seek_to_sample_coarse()

static int32_t fl::third_party::vorbis::seek_to_sample_coarse ( stb_vorbis * f, uint32 sample_number )

static

Definition at line 4458 of file stb_vorbis.cpp.hpp.

{
   ProbedPage left, right, mid;
   int32_t i, start_seg_with_known_loc, end_pos, page_start;
   uint32 delta, stream_length, padding, last_sample_limit;
   double offset = 0.0, bytes_per_sample = 0.0;
   int32_t probe = 0;
 
   // find the last page and validate the target sample
   stream_length = stb_vorbis_stream_length_in_samples(f);
   if (stream_length == 0)            return error(f, VORBIS_seek_without_length);
   if (sample_number > stream_length) return error(f, VORBIS_seek_invalid);
 
   // this is the maximum difference between the window-center (which is the
   // actual granule position value), and the right-start (which the spec
   // indicates should be the granule position (give or take one)).
   padding = ((f->blocksize_1 - f->blocksize_0) >> 2);
   if (sample_number < padding)
      last_sample_limit = 0;
   else
      last_sample_limit = sample_number - padding;
 
   left = f->p_first;
   while (left.last_decoded_sample == ~0U) {
      // (untested) the first page does not have a 'last_decoded_sample'
      set_file_offset(f, left.page_end);
      if (!get_seek_page_info(f, &left)) goto error;
   }
 
   right = f->p_last;
   FL_ASSERT(right.last_decoded_sample != ~0U, "right sample must be decoded");
 
   // starting from the start is handled differently
   if (last_sample_limit <= left.last_decoded_sample) {
      if (stb_vorbis_seek_start(f)) {
         if (f->current_loc > sample_number)
            return error(f, VORBIS_seek_failed);
         return 1;
      }
      return 0;
   }
 
   while (left.page_end != right.page_start) {
      FL_ASSERT(left.page_end < right.page_start, "left page_end must be < right page_start");
      // search range in bytes
      delta = right.page_start - left.page_end;
      if (delta <= 65536) {
         // there's only 64K left to search - handle it linearly
         set_file_offset(f, left.page_end);
      } else {
         if (probe < 2) {
            if (probe == 0) {
               // first probe (interpolate)
               double data_bytes = right.page_end - left.page_start;
               bytes_per_sample = data_bytes / right.last_decoded_sample;
               offset = left.page_start + bytes_per_sample * (last_sample_limit - left.last_decoded_sample);
            } else {
               // second probe (try to bound the other side)
               double error = ((double) last_sample_limit - mid.last_decoded_sample) * bytes_per_sample;
               if (error >= 0 && error <  8000) error =  8000;
               if (error <  0 && error > -8000) error = -8000;
               offset += error * 2;
            }
 
            // ensure the offset is valid
            if (offset < left.page_end)
               offset = left.page_end;
            if (offset > right.page_start - 65536)
               offset = right.page_start - 65536;
 
            set_file_offset(f, (uint32_t) offset);
         } else {
            // binary search for large ranges (offset by 32K to ensure
            // we don't hit the right page)
            set_file_offset(f, left.page_end + (delta / 2) - 32768);
         }
 
         if (!vorbis_find_page(f, nullptr, nullptr)) goto error;
      }
 
      for (;;) {
         if (!get_seek_page_info(f, &mid)) goto error;
         if (mid.last_decoded_sample != ~0U) break;
         // (untested) no frames end on this page
         set_file_offset(f, mid.page_end);
         FL_ASSERT(mid.page_start < right.page_start, "mid page_start must be < right page_start");
      }
 
      // if we've just found the last page again then we're in a tricky file,
      // and we're close enough (if it wasn't an interpolation probe).
      if (mid.page_start == right.page_start) {
         if (probe >= 2 || delta <= 65536)
            break;
      } else {
         if (last_sample_limit < mid.last_decoded_sample)
            right = mid;
         else
            left = mid;
      }
 
      ++probe;
   }
 
   // seek back to start of the last packet
   page_start = left.page_start;
   set_file_offset(f, page_start);
   if (!start_page(f)) return error(f, VORBIS_seek_failed);
   end_pos = f->end_seg_with_known_loc;
   FL_ASSERT(end_pos >= 0, "end_pos must be >= 0");
 
   for (;;) {
      for (i = end_pos; i > 0; --i)
         if (f->segments[i-1] != 255)
            break;
 
      start_seg_with_known_loc = i;
 
      if (start_seg_with_known_loc > 0 || !(f->page_flag & PAGEFLAG_continued_packet))
         break;
 
      // (untested) the final packet begins on an earlier page
      if (!go_to_page_before(f, page_start))
         goto error;
 
      page_start = stb_vorbis_get_file_offset(f);
      if (!start_page(f)) goto error;
      end_pos = f->segment_count - 1;
   }
 
   // prepare to start decoding
   f->current_loc_valid = false;
   f->last_seg = false;
   f->valid_bits = 0;
   f->packet_bytes = 0;
   f->bytes_in_seg = 0;
   f->previous_length = 0;
   f->next_seg = start_seg_with_known_loc;
 
   for (i = 0; i < start_seg_with_known_loc; i++)
      skip(f, f->segments[i]);
 
   // start decoding (optimizable - this frame is generally discarded)
   if (!vorbis_pump_first_frame(f))
      return 0;
   if (f->current_loc > sample_number)
      return error(f, VORBIS_seek_failed);
   return 1;
 
error:
   // try to restore the file to a valid state
   stb_vorbis_seek_start(f);
   return error(f, VORBIS_seek_failed);
}

References error(), FL_ASSERT, FL_NOEXCEPT, get_seek_page_info(), go_to_page_before(), fl::third_party::vorbis::ProbedPage::last_decoded_sample, offset(), fl::third_party::vorbis::ProbedPage::page_end, fl::third_party::vorbis::ProbedPage::page_start, PAGEFLAG_continued_packet, set_file_offset(), skip(), start_page(), stb_vorbis_get_file_offset(), stb_vorbis_seek_start(), stb_vorbis_stream_length_in_samples(), vorbis_find_page(), vorbis_pump_first_frame(), VORBIS_seek_failed, VORBIS_seek_invalid, and VORBIS_seek_without_length.

Referenced by stb_vorbis_seek_frame().

Here is the call graph for this function:

Here is the caller graph for this function: