bemoody
commented
4 months ago Here's the tool I'm using to search for these examples:
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <sys/stat.h>
#include <FLAC/stream_decoder.h>
struct filehandle {
const char *filename;
int fd;
long long read_pos;
struct stat st;
int nseeks;
int abort_nseeks;
long long seek_pos;
struct {
long long t;
long long seek_pos;
long long read_pos;
int status;
int nseeks;
} results_cache[64];
};
static FLAC__StreamDecoderReadStatus
read_cb(const FLAC__StreamDecoder *dec, FLAC__byte buffer[],
size_t *bytes, void *client_data)
{
struct filehandle *fh = client_data;
ssize_t n;
size_t max = *bytes;
*bytes = 0;
while (*bytes < max) {
n = pread(fh->fd, buffer, max - *bytes, fh->read_pos);
if (n < 0)
return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
buffer += n;
*bytes += n;
fh->read_pos += n;
if (n == 0)
return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
}
return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}
static FLAC__StreamDecoderSeekStatus
seek_cb(const FLAC__StreamDecoder *dec, FLAC__uint64 pos, void *client_data)
{
struct filehandle *fh = client_data;
if (++fh->nseeks == fh->abort_nseeks)
return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
fh->seek_pos = pos;
fh->read_pos = pos;
return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
}
static FLAC__StreamDecoderTellStatus
tell_cb(const FLAC__StreamDecoder *dec, FLAC__uint64 *pos, void *client_data)
{
struct filehandle *fh = client_data;
*pos = fh->read_pos;
return FLAC__STREAM_DECODER_TELL_STATUS_OK;
}
static FLAC__StreamDecoderLengthStatus
length_cb(const FLAC__StreamDecoder *dec, FLAC__uint64 *len, void *client_data)
{
struct filehandle *fh = client_data;
*len = fh->st.st_size;
return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
}
static FLAC__bool eof_cb(const FLAC__StreamDecoder *dec, void *client_data)
{
struct filehandle *fh = client_data;
return (fh->read_pos >= fh->st.st_size);
}
static FLAC__StreamDecoderWriteStatus
write_cb(const FLAC__StreamDecoder *dec, const FLAC__Frame *frame,
const FLAC__int32 *const buf[], void *client_data)
{
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
static void
error_cb(const FLAC__StreamDecoder *decoder,
FLAC__StreamDecoderErrorStatus status,
void *client_data)
{
}
static FLAC__StreamDecoder *init_decoder(struct filehandle *fh)
{
FLAC__StreamDecoder *dec;
fh->read_pos = 0;
fh->seek_pos = 0;
fh->nseeks = 0;
fh->abort_nseeks = -1;
if (!(dec = FLAC__stream_decoder_new())) {
printf("%s: stream_decoder_new failed\n", fh->filename);
return NULL;
} else if (FLAC__stream_decoder_init_stream(dec, &read_cb,
&seek_cb, &tell_cb,
&length_cb, &eof_cb,
&write_cb, NULL,
&error_cb, fh)) {
printf("%s: stream_decoder_init_stream failed\n", fh->filename);
FLAC__stream_decoder_delete(dec);
return NULL;
} else if (!FLAC__stream_decoder_process_until_end_of_metadata(dec)) {
printf("%s: stream_decoder_process_until_end_of_metadata failed\n",
fh->filename);
FLAC__stream_decoder_delete(dec);
return NULL;
} else {
return dec;
}
}
static int try_seek(struct filehandle *fh, int depth, long long t,
long long *seek_pos, long long *read_pos, int *nseeks)
{
FLAC__StreamDecoder *dec;
int status;
if (t == fh->results_cache[depth].t) {
*seek_pos = fh->results_cache[depth].seek_pos;
*read_pos = fh->results_cache[depth].read_pos;
*nseeks = fh->results_cache[depth].nseeks;
return fh->results_cache[depth].status;
}
if (!(dec = init_decoder(fh)))
return 2;
fh->nseeks = 0;
fh->abort_nseeks = 2;
fh->seek_pos = 0;
status = !!FLAC__stream_decoder_seek_absolute(dec, t);
FLAC__stream_decoder_delete(dec);
fh->results_cache[depth].t = t;
fh->results_cache[depth].status = status;
fh->results_cache[depth].seek_pos = *seek_pos = fh->seek_pos;
fh->results_cache[depth].read_pos = *read_pos = fh->read_pos;
fh->results_cache[depth].nseeks = *nseeks = fh->nseeks;
return status;
}
static int probe_bad_seek(struct filehandle *fh, long long total_samples,
long long sync_pos)
{
long long a, b, t, seek_pos, read_pos,
best_seek_pos = -1, best_read_pos = -1, best_t = -1;
int depth = 0, status, nseeks, best_status = 0, best_nseeks = -1;
a = 0;
b = total_samples;
/* Try to pick a sample number such that seek_absolute's first
seek lands at or before sync_pos, as close as possible. */
while (a < b) {
t = (a + b) / 2;
status = try_seek(fh, depth, t, &seek_pos, &read_pos, &nseeks);
if (status > 1)
return status;
if (seek_pos > sync_pos)
b = t;
else {
if (seek_pos > best_seek_pos) {
best_seek_pos = seek_pos;
best_read_pos = read_pos;
best_t = t;
best_status = status;
best_nseeks = nseeks;
}
a = t + 1;
}
depth++;
}
if (best_seek_pos > sync_pos || best_read_pos < sync_pos + 2) {
printf("%s: unable to force seeking to %lld\n",
fh->filename, sync_pos);
return 2;
} else if (best_status != 0) {
/* libFLAC successfully parsed the given frame header
(or skipped a fake frame header and parsed the next
real frame header), and continued reading */
return 0;
} else if (best_nseeks > 1) {
/* libFLAC successfully parsed the given frame header (or
skipped a fake frame header and parsed the next real frame
header), and decided to seek somewhere else */
return 0;
} else {
/* libFLAC threw an error after reading the data at sync_pos,
without trying to perform another seek */
printf("%s: FAILED at t=%lld (bytes %lld to %lld)\n",
fh->filename, best_t, best_seek_pos, best_read_pos);
return 1;
}
}
int main(int argc, char **argv)
{
struct filehandle fh;
FLAC__StreamDecoder *dec;
FILE *fp;
long long pos, npos = 0, total_samples;
int status, failed = 0, c;
if (argc != 2) {
printf("usage: %s file.flac\n", argv[0]);
return 2;
}
fh.filename = argv[1];
if (!(fp = fopen(fh.filename, "r"))) {
printf("%s: open failed: %s\n", fh.filename, strerror(errno));
return 2;
}
fh.fd = fileno(fp);
if (fstat(fh.fd, &fh.st)) {
printf("%s: fstat failed: %s\n", fh.filename, strerror(errno));
return 2;
}
if (!(dec = init_decoder(&fh)))
return 2;
total_samples = FLAC__stream_decoder_get_total_samples(dec);
FLAC__stream_decoder_delete(dec);
fseeko(fp, fh.read_pos, SEEK_SET);
while ((c = fgetc(fp)) != EOF) {
if (c == 0xff) {
c = fgetc(fp);
if (c == 0xf8 || c == 0xf9) {
pos = ftello(fp) - 2;
if (pos > npos) {
fprintf(stderr, "%15lld/%15lld (%.0f%%)\r",
pos, (long long) fh.st.st_size,
(pos * 100.0 / fh.st.st_size));
npos = pos + 500000;
}
status = probe_bad_seek(&fh, total_samples, pos);
if (status == 1)
failed = 1;
else if (status != 0)
return status;
}
}
}
fprintf(stderr, "\n");
return failed;
}(My first attempt took 5 hours to run on a 300 MB file, this one takes 4 minutes.)
tompollard
eagomez2
Some versions of libFLAC report an error when we try to seek to particular sample numbers:
(All tested only on Linux amd64.)
In the case of wfdb-python, this manifests as an exception "internal psf_fseek() failed" (but see also issue #486, which appears to be something different.)
Some examples from
mimic4wdb/0.1.0:It'd be good to figure out why these examples are broken, and find a minimal example that we can use as a test case (and also share with the upstream flac and soundfile developers.)