When I was trying to find yesterday's xmms-plugin bug, i have noticed
that seeking in stream without seek-table isn't very good. With
attached patch it is much better.
--
Miroslav Lichvar
--- src/libFLAC/seekable_stream_decoder.c.orig 2003-02-26 19:41:51.000000000 +0100
+++ src/libFLAC/seekable_stream_decoder.c 2003-07-09 23:49:35.000000000 +0200
@@ -816,11 +816,11 @@
FLAC__bool seek_to_absolute_sample_(FLAC__SeekableStreamDecoder *decoder,
FLAC__uint64 stream_length, FLAC__uint64 target_sample)
{
- FLAC__uint64 first_frame_offset, lower_bound, upper_bound;
- FLAC__int64 pos = -1, last_pos = -1;
- int i, lower_seek_point = -1, upper_seek_point = -1;
+ FLAC__uint64 first_frame_offset, lower_bound, upper_bound, lower_bound_sample,
upper_bound_sample;
+ FLAC__int64 pos, last_pos = -1;
+ int i;
unsigned approx_bytes_per_frame;
- FLAC__uint64 last_frame_sample = 0xffffffffffffffff;
+ FLAC__uint64 last_frame_sample = 0xffffffffffffffff, this_frame_sample;
FLAC__bool needs_seek;
const FLAC__uint64 total_samples =
decoder->private_->stream_info.total_samples;
const unsigned min_blocksize = decoder->private_->stream_info.min_blocksize;
@@ -862,12 +862,14 @@
* the first and last frames.
*/
lower_bound = first_frame_offset;
+ lower_bound_sample = 0;
/* calc the upper_bound, beyond which we never want to seek */
if(max_framesize > 0)
upper_bound = stream_length - (max_framesize + 128 + 2); /* 128 for a
possible ID3V1 tag, 2 for indexing differences */
else
upper_bound = stream_length - ((channels * bps * FLAC__MAX_BLOCK_SIZE)
/ 8 + 128 + 2);
+ upper_bound_sample = total_samples;
/*
* Now we refine the bounds if we have a seektable with
@@ -882,7 +884,7 @@
}
if(i >= 0) { /* i.e. we found a suitable seek point... */
lower_bound = first_frame_offset +
decoder->private_->seek_table->points[i].stream_offset;
- lower_seek_point = i;
+ lower_bound_sample =
decoder->private_->seek_table->points[i].sample_number;
}
/* find the closest seek point > target_sample, if it exists */
@@ -892,76 +894,25 @@
}
if(i < (int)decoder->private_->seek_table->num_points) { /* i.e. we
found a suitable seek point... */
upper_bound = first_frame_offset +
decoder->private_->seek_table->points[i].stream_offset;
- upper_seek_point = i;
+ upper_bound_sample =
decoder->private_->seek_table->points[i].sample_number;
}
}
- /*
- * Now guess at where within those bounds our target
- * sample will be.
- */
- if(lower_seek_point >= 0) {
- /* first see if our sample is within a few frames of the lower
seekpoint */
-
if(decoder->private_->seek_table->points[lower_seek_point].sample_number <=
target_sample && target_sample <
decoder->private_->seek_table->points[lower_seek_point].sample_number +
(decoder->private_->seek_table->points[lower_seek_point].frame_samples * 4)) {
- pos = (FLAC__int64)lower_bound;
- }
- else if(upper_seek_point >= 0) {
- const FLAC__uint64 target_offset = target_sample -
decoder->private_->seek_table->points[lower_seek_point].sample_number;
- const FLAC__uint64 range_samples =
decoder->private_->seek_table->points[upper_seek_point].sample_number -
decoder->private_->seek_table->points[lower_seek_point].sample_number;
- const FLAC__uint64 range_bytes = upper_bound - lower_bound;
-#if defined _MSC_VER || defined __MINGW32__
- /* with VC++ you have to spoon feed it the casting */
- pos = (FLAC__int64)lower_bound +
(FLAC__int64)((double)(FLAC__int64)target_offset / (double)(FLAC__int64)range_samples
* (double)(FLAC__int64)(range_bytes-1)) - approx_bytes_per_frame;
-#else
- pos = (FLAC__int64)lower_bound +
(FLAC__int64)((double)target_offset / (double)range_samples * (double)(range_bytes-1))
- approx_bytes_per_frame;
-#endif
- }
- }
+ decoder->private_->target_sample = target_sample;
- /*
- * If there's no seek table, we need to use the metadata (if we
- * have it) and the filelength to estimate the position of the
- * frame with the correct sample.
- */
- if(pos < 0 && total_samples > 0) {
+ needs_seek = (total_samples > 0) ? true : false;
+ while(1) {
+ if(needs_seek) {
#if defined _MSC_VER || defined __MINGW32__
- /* with VC++ you have to spoon feed it the casting */
- pos = (FLAC__int64)first_frame_offset +
(FLAC__int64)((double)(FLAC__int64)target_sample / (double)(FLAC__int64)total_samples
* (double)(FLAC__int64)(stream_length-first_frame_offset-1)) - approx_bytes_per_frame;
+ /* with VC++ you have to spoon feed it the casting */
+ pos = (FLAC__int64)lower_bound +
(FLAC__int64)((double)(FLAC__int64)(target_sample - lower_bound_sample) /
(double)(FLAC__int64)(upper_bound_sample - lower_bound_sample) *
(double)(FLAC__int64)(upper_bound - lower_bound)) - approx_bytes_per_frame;
#else
- pos = (FLAC__int64)first_frame_offset +
(FLAC__int64)((double)target_sample / (double)total_samples *
(double)(stream_length-first_frame_offset-1)) - approx_bytes_per_frame;
+ pos = (FLAC__int64)lower_bound +
(FLAC__int64)((double)(target_sample - lower_bound_sample) /
(double)(upper_bound_sample - lower_bound_sample) * (double)(upper_bound -
lower_bound)) - approx_bytes_per_frame;
#endif
- }
-
- /*
- * If there's no seek table and total_samples is unknown, we
- * don't even bother trying to figure out a target, we just use
- * our current position.
- */
- if(pos < 0) {
- FLAC__uint64 upos;
- if(decoder->private_->tell_callback(decoder, &upos,
decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK) {
- decoder->protected_->state =
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- pos = (FLAC__int32)upos;
- needs_seek = false;
- }
- else
- needs_seek = true;
-
- /* clip the position to the bounds, lower bound takes precedence */
- if(pos >= (FLAC__int64)upper_bound) {
- pos = (FLAC__int64)upper_bound-1;
- needs_seek = true;
- }
- if(pos < (FLAC__int64)lower_bound) {
- pos = (FLAC__int64)lower_bound;
- needs_seek = true;
- }
-
- decoder->private_->target_sample = target_sample;
- while(1) {
- if(needs_seek) {
+ if(pos >= (FLAC__int64)upper_bound)
+ pos = (FLAC__int64)upper_bound - 1;
+ if(pos < (FLAC__int64)lower_bound)
+ pos = (FLAC__int64)lower_bound;
if(decoder->private_->seek_callback(decoder,
(FLAC__uint64)pos, decoder->private_->client_data) !=
FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK) {
decoder->protected_->state =
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
return false;
@@ -979,45 +930,43 @@
if(decoder->protected_->state !=
FLAC__SEEKABLE_STREAM_DECODER_SEEKING) {
break;
}
- else { /* we need to narrow the search */
- FLAC__uint64 this_frame_sample =
decoder->private_->last_frame.header.number.sample_number;
- FLAC__ASSERT(decoder->private_->last_frame.header.number_type
== FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
- if(this_frame_sample == last_frame_sample && pos < last_pos) {
- /* our last move backwards wasn't big enough, double
it */
- pos -= (last_pos - pos);
- needs_seek = true;
+ /* we need to narrow the search */
+ this_frame_sample =
decoder->private_->last_frame.header.number.sample_number;
+ FLAC__ASSERT(decoder->private_->last_frame.header.number_type ==
FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
+
+ approx_bytes_per_frame =
decoder->private_->last_frame.header.blocksize * channels * bps/8 + 64;
+
+ if(target_sample < this_frame_sample) {
+ if(this_frame_sample == last_frame_sample) {
+ /* our last move backwards wasn't big enough */
+ upper_bound -= approx_bytes_per_frame;
}
else {
- if(target_sample < this_frame_sample) {
- last_pos = pos;
- approx_bytes_per_frame =
decoder->private_->last_frame.header.blocksize * channels * bps/8 + 64;
- pos -= approx_bytes_per_frame;
- needs_seek = true;
- }
- else { /* target_sample >= this_frame_sample + this
frame's blocksize */
- FLAC__uint64 upos;
- if(decoder->private_->tell_callback(decoder,
&upos, decoder->private_->client_data) !=
FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK) {
- decoder->protected_->state =
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- last_pos = pos;
- pos = (FLAC__int32)upos;
- pos -=
FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private_->stream_decoder);
- needs_seek = false;
- /*
- * if we haven't hit the target frame yet and
our position hasn't changed,
- * it means we're at the end of the stream and
the seek target does not exist.
- */
- if(last_pos == pos) {
- decoder->protected_->state =
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
- return false;
- }
+ upper_bound_sample = this_frame_sample +
decoder->private_->last_frame.header.blocksize;
+
if(!FLAC__seekable_stream_decoder_get_decode_position(decoder, &upper_bound)) {
+ decoder->protected_->state =
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
+ return false;
}
}
- if(pos < (FLAC__int64)lower_bound)
- pos = (FLAC__int64)lower_bound;
- last_frame_sample = this_frame_sample;
}
+ else {
+ /* target_sample >= this_frame_sample + this frame's blocksize
*/
+
+ if(target_sample < this_frame_sample + 4 *
decoder->private_->last_frame.header.blocksize)
+ needs_seek = false;
+
+ lower_bound_sample = this_frame_sample +
decoder->private_->last_frame.header.blocksize;
+ if(!FLAC__seekable_stream_decoder_get_decode_position(decoder,
&lower_bound)) {
+ decoder->protected_->state =
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
+ return false;
+ }
+ if(last_pos == (FLAC__int64)lower_bound) {
+ decoder->protected_->state =
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
+ return false;
+ }
+ last_pos = lower_bound;
+ }
+ last_frame_sample = this_frame_sample;
}
return true;
