Remove unused vorbis_analyze_page

Author: LibretroAdmin

libretro-common/formats/vorbis/rvorbis.c

@@ -5010,148 +5010,6 @@ static uint32_t vorbis_find_page(rvorbis *f, uint32_t *end, uint32_t *last)
 
 #define SAMPLE_unknown  0xffffffff
 
-/* ogg vorbis, in its insane infinite wisdom, only provides
- * information about the sample at the END of the page.
- * therefore we COULD have the data we need in the current
- * page, and not know it. we could just use the end location
- * as our only knowledge for bounds, seek back, and eventually
- * the binary search finds it. or we can try to be smart and
- * not waste time trying to locate more pages. we try to be
- * smart, since this data is already in memory anyway, so
- * doing needless I/O would be crazy!
- */
-static int vorbis_analyze_page(rvorbis *f, ProbedPage *z)
-{
-   uint8_t lacing[255];
-   uint8_t packet_type[255];
-   int num_packet, packet_start;
-   int i,len;
-   uint32_t samples;
-   uint8_t header[27] = {0};
-
-   /* record where the page starts */
-   z->page_start = (unsigned int)(f->stream - f->stream_start);
-
-   /* parse the header */
-   getn(f, header, 27);
-   assert(header[0] == 'O' && header[1] == 'g' && header[2] == 'g' && header[3] == 'S');
-   getn(f, lacing, header[26]);
-
-   /* determine the length of the payload */
-   len = 0;
-   for (i=0; i < header[26]; ++i)
-      len += lacing[i];
-
-   /* this implies where the page ends */
-   z->page_end = z->page_start + 27 + header[26] + len;
-
-   /* read the last-decoded sample out of the data */
-   z->last_decoded_sample = header[6] + (header[7] << 8) + (header[8] << 16) + (header[9] << 24);
-
-   if (header[5] & 4)
-   {
-      /* if this is the last page, it's not possible to work
-       * backwards to figure out the first sample! whoops! fuck. */
-      z->first_decoded_sample = SAMPLE_unknown;
-      set_file_offset(f, z->page_start);
-      return 1;
-   }
-
-   /* scan through the frames to determine the sample-count of each one...
-    * our goal is the sample # of the first fully-decoded sample on the
-    * page, which is the first decoded sample of the 2nd packet */
-
-   num_packet=0;
-
-   packet_start = ((header[5] & 1) == 0);
-
-   for (i=0; i < header[26]; ++i)
-   {
-      if (packet_start)
-      {
-         uint8_t n,b;
-         if (lacing[i] == 0)
-            goto bail; /* trying to read from zero-length packet */
-         n = get8(f);
-         /* if bottom bit is non-zero, we've got corruption */
-         if (n & 1)
-            goto bail;
-         n >>= 1;
-         b = ilog(f->mode_count-1);
-         n &= (1 << b)-1;
-         if (n >= f->mode_count)
-            goto bail;
-         packet_type[num_packet++] = f->mode_config[n].blockflag;
-         skip(f, lacing[i]-1);
-      }
-      else
-         skip(f, lacing[i]);
-      packet_start = (lacing[i] < 255);
-   }
-
-   /* now that we know the sizes of all the pages, we can start determining
-    * how much sample data there is. */
-
-   samples = 0;
-
-   /* for the last packet, we step by its whole length, because the definition
-    * is that we encoded the end sample loc of the 'last packet completed',
-    * where 'completed' refers to packets being split, and we are left to guess
-    * what 'end sample loc' means. we assume it means ignoring the fact that
-    * the last half of the data is useless without windowing against the next
-    * packet... (so it's not REALLY complete in that sense)
-    */
-   if (num_packet > 1)
-      samples += f->blocksize[packet_type[num_packet-1]];
-
-   for (i=num_packet-2; i >= 1; --i)
-   {
-      /* now, for this packet, how many samples do we have that
-       * do not overlap the following packet? */
-      if (packet_type[i] == 1)
-         if (packet_type[i+1] == 1)
-            samples += f->blocksize_1 >> 1;
-         else
-            samples += ((f->blocksize_1 - f->blocksize_0) >> 2) + (f->blocksize_0 >> 1);
-      else
-         samples += f->blocksize_0 >> 1;
-   }
-   /* now, at this point, we've rewound to the very beginning of the
-    * _second_ packet. if we entirely discard the first packet after
-    * a seek, this will be exactly the right sample number. HOWEVER!
-    * we can't as easily compute this number for the LAST page. The
-    * only way to get the sample offset of the LAST page is to use
-    * the end loc from the previous page. But what that returns us
-    * is _exactly_ the place where we get our first non-overlapped
-    * sample. (I think. Stupid spec for being ambiguous.) So for
-    * consistency it's better to do that here, too. However, that
-    * will then require us to NOT discard all of the first frame we
-    * decode, in some cases, which means an even weirder frame size
-    * and extra code. what a fucking pain.
-
-    * we're going to discard the first packet if we
-    * start the seek here, so we don't care about it. (we could actually
-    * do better; if the first packet is long, and the previous packet
-    * is short, there's actually data in the first half of the first
-    * packet that doesn't need discarding... but not worth paying the
-    * effort of tracking that of that here and in the seeking logic)
-    * except crap, if we infer it from the _previous_ packet's end
-    * location, we DO need to use that definition... and we HAVE to
-    * infer the start loc of the LAST packet from the previous packet's
-    * end location. fuck you, ogg vorbis. */
-
-   z->first_decoded_sample = z->last_decoded_sample - samples;
-
-   /* restore file state to where we were */
-   set_file_offset(f, z->page_start);
-   return 1;
-
-   /* restore file state to where we were */
-  bail:
-   set_file_offset(f, z->page_start);
-   return 0;
-}
-
 /* Latch the output pipeline (0 = float, 1 = fixed-point s16).  In
  * normal mixer use this runs once, on the first read; a mid-stream
  * switch converts the persistent overlap state and any undelivered