Don't discard timestamps from invalid packets.
[opusfile.git] / src / opusfile.c
1 /********************************************************************
2  *                                                                  *
3  * THIS FILE IS PART OF THE libopusfile SOFTWARE CODEC SOURCE CODE. *
4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
7  *                                                                  *
8  * THE libopusfile SOURCE CODE IS (C) COPYRIGHT 1994-2012           *
9  * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
10  *                                                                  *
11  ********************************************************************
12
13  function: stdio-based convenience library for opening/seeking/decoding
14  last mod: $Id: vorbisfile.c 17573 2010-10-27 14:53:59Z xiphmont $
15
16  ********************************************************************/
17 #include "internal.h"
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <errno.h>
21 #include <limits.h>
22 #include <string.h>
23 #include <math.h>
24
25 #include "opusfile.h"
26
27 /*This implementation is largely based off of libvorbisfile.
28   All of the Ogg bits work roughly the same, though I have made some
29    "improvements" that have not been folded back there, yet.*/
30
31 /*A 'chained bitstream' is an Ogg Opus bitstream that contains more than one
32    logical bitstream arranged end to end (the only form of Ogg multiplexing
33    supported by this library.
34   Grouping (parallel multiplexing) is not supported, except to the extent that
35    if there are multiple logical Ogg streams in a single link of the chain, we
36    will ignore all but the first Opus stream we find.*/
37
38 /*An Ogg Opus file can be played beginning to end (streamed) without worrying
39    ahead of time about chaining (see opusdec from the opus-tools package).
40   If we have the whole file, however, and want random access
41    (seeking/scrubbing) or desire to know the total length/time of a file, we
42    need to account for the possibility of chaining.*/
43
44 /*We can handle things a number of ways.
45   We can determine the entire bitstream structure right off the bat, or find
46    pieces on demand.
47   This library determines and caches structure for the entire bitstream, but
48    builds a virtual decoder on the fly when moving between links in the chain.*/
49
50 /*There are also different ways to implement seeking.
51   Enough information exists in an Ogg bitstream to seek to sample-granularity
52    positions in the output.
53   Or, one can seek by picking some portion of the stream roughly in the desired
54    area if we only want coarse navigation through the stream.
55   We implement and expose both strategies.*/
56
57 /*The maximum number of bytes in a page (including the page headers).*/
58 #define OP_PAGE_SIZE_MAX  (65307)
59 /*The default amount to seek backwards per step when trying to find the
60    previous page.
61   This must be at least as large as the maximum size of a page.*/
62 #define OP_CHUNK_SIZE     (65536)
63 /*The maximum amount to seek backwards per step when trying to find the
64    previous page.*/
65 #define OP_CHUNK_SIZE_MAX (1024*(opus_int32)1024)
66 /*A smaller read size is needed for low-rate streaming.*/
67 #define OP_READ_SIZE      (2048)
68
69 int op_test(OpusHead *_head,
70  const unsigned char *_initial_data,size_t _initial_bytes){
71   ogg_sync_state  oy;
72   char           *data;
73   int             err;
74   /*The first page of a normal Opus file will be at most 57 bytes (27 Ogg
75      page header bytes + 1 lacing value + 21 Opus header bytes + 8 channel
76      mapping bytes).
77     It will be at least 47 bytes (27 Ogg page header bytes + 1 lacing value +
78      19 Opus header bytes using channel mapping family 0).
79     If we don't have at least that much data, give up now.*/
80   if(_initial_bytes<47)return OP_FALSE;
81   /*Only proceed if we start with the magic OggS string.
82     This is to prevent us spending a lot of time allocating memory and looking
83      for Ogg pages in non-Ogg files.*/
84   if(memcmp(_initial_data,"OggS",4)!=0)return OP_ENOTFORMAT;
85   ogg_sync_init(&oy);
86   data=ogg_sync_buffer(&oy,_initial_bytes);
87   if(data!=NULL){
88     ogg_stream_state os;
89     ogg_page         og;
90     int              ret;
91     memcpy(data,_initial_data,_initial_bytes);
92     ogg_sync_wrote(&oy,_initial_bytes);
93     ogg_stream_init(&os,-1);
94     err=OP_FALSE;
95     do{
96       ogg_packet op;
97       ret=ogg_sync_pageout(&oy,&og);
98       /*Ignore holes.*/
99       if(ret<0)continue;
100       /*Stop if we run out of data.*/
101       if(!ret)break;
102       ogg_stream_reset_serialno(&os,ogg_page_serialno(&og));
103       ogg_stream_pagein(&os,&og);
104       /*Only process the first packet on this page (if it's a BOS packet,
105          it's required to be the only one).*/
106       if(ogg_stream_packetout(&os,&op)==1){
107         if(op.b_o_s){
108           ret=opus_head_parse(_head,op.packet,op.bytes);
109           /*If this didn't look like Opus, keep going.*/
110           if(ret==OP_ENOTFORMAT)continue;
111           /*Otherwise we're done, one way or another.*/
112           err=ret;
113         }
114         /*We finished parsing the headers.
115           There is no Opus to be found.*/
116         else err=OP_ENOTFORMAT;
117       }
118     }
119     while(err==OP_FALSE);
120     ogg_stream_clear(&os);
121   }
122   else err=OP_EFAULT;
123   ogg_sync_clear(&oy);
124   return err;
125 }
126
127 /*Many, many internal helpers.
128   The intention is not to be confusing.
129   Rampant duplication and monolithic function implementation (though we do have
130    some large, omnibus functions still) would be harder to understand anyway.
131   The high level functions are last.
132   Begin grokking near the end of the file if you prefer to read things
133    top-down.*/
134
135 /*The read/seek functions track absolute position within the stream.*/
136
137 /*Read a little more data from the file/pipe into the ogg_sync framer.
138   _nbytes: The maximum number of bytes to read.
139   Return: A positive number of bytes read on success, 0 on end-of-file, or a
140            negative value on failure.*/
141 static int op_get_data(OggOpusFile *_of,int _nbytes){
142   unsigned char *buffer;
143   int            nbytes;
144   OP_ASSERT(_nbytes>0);
145   buffer=(unsigned char *)ogg_sync_buffer(&_of->oy,_nbytes);
146   nbytes=(int)(*_of->callbacks.read)(_of->source,buffer,_nbytes);
147   OP_ASSERT(nbytes<=_nbytes);
148   if(OP_LIKELY(nbytes>0))ogg_sync_wrote(&_of->oy,nbytes);
149   return nbytes;
150 }
151
152 /*Save a tiny smidge of verbosity to make the code more readable.*/
153 static int op_seek_helper(OggOpusFile *_of,opus_int64 _offset){
154   if(_offset==_of->offset)return 0;
155   if(_of->callbacks.seek==NULL||
156    (*_of->callbacks.seek)(_of->source,_offset,SEEK_SET)){
157     return OP_EREAD;
158   }
159   _of->offset=_offset;
160   ogg_sync_reset(&_of->oy);
161   return 0;
162 }
163
164 /*Get the current position indicator of the underlying source.
165   This should be the same as the value reported by tell().*/
166 static opus_int64 op_position(OggOpusFile *_of){
167   /*The current position indicator is _not_ simply offset.
168     We may also have unprocessed, buffered data in the sync state.*/
169   return _of->offset+_of->oy.fill-_of->oy.returned;
170 }
171
172 /*From the head of the stream, get the next page.
173   _boundary specifies if the function is allowed to fetch more data from the
174    stream (and how much) or only use internally buffered data.
175   _boundary: -1: Unbounded search.
176               0: Read no additional data.
177                  Use only cached data.
178               n: Search for the start of a new page up to file position n.
179   Return: n>=0:       Found a page at absolute offset n.
180           OP_FALSE:   Hit the _boundary limit.
181           OP_EREAD:   An underlying read operation failed.
182           OP_BADLINK: We hit end-of-file before reaching _boundary.*/
183 static opus_int64 op_get_next_page(OggOpusFile *_of,ogg_page *_og,
184  opus_int64 _boundary){
185   for(;;){
186     int more;
187     if(_boundary>0&&_of->offset>=_boundary)return OP_FALSE;
188     more=ogg_sync_pageseek(&_of->oy,_og);
189     /*Skipped (-more) bytes.*/
190     if(OP_UNLIKELY(more<0))_of->offset-=more;
191     else if(more==0){
192       int read_nbytes;
193       int ret;
194       /*Send more paramedics.*/
195       if(!_boundary)return OP_FALSE;
196       if(_boundary<0)read_nbytes=OP_READ_SIZE;
197       else{
198         opus_int64 position;
199         position=op_position(_of);
200         if(position>=_boundary)return OP_FALSE;
201         read_nbytes=(int)OP_MIN(_boundary-position,OP_READ_SIZE);
202       }
203       ret=op_get_data(_of,read_nbytes);
204       if(OP_UNLIKELY(ret<0))return OP_EREAD;
205       if(OP_UNLIKELY(ret==0)){
206         /*Only fail cleanly on EOF if we didn't have a known boundary.
207           Otherwise, we should have been able to reach that boundary, and this
208            is a fatal error.*/
209         return OP_UNLIKELY(_boundary<0)?OP_FALSE:OP_EBADLINK;
210       }
211     }
212     else{
213       /*Got a page.
214         Return the offset at the page beginning, advance the internal offset
215          past the page end.*/
216       opus_int64 page_offset;
217       page_offset=_of->offset;
218       _of->offset+=more;
219       return page_offset;
220     }
221   }
222 }
223
224 static int op_add_serialno(ogg_page *_og,
225  ogg_uint32_t **_serialnos,int *_nserialnos,int *_cserialnos){
226   ogg_uint32_t *serialnos;
227   int           nserialnos;
228   int           cserialnos;
229   ogg_uint32_t s;
230   s=ogg_page_serialno(_og);
231   serialnos=*_serialnos;
232   nserialnos=*_nserialnos;
233   cserialnos=*_cserialnos;
234   if(OP_UNLIKELY(nserialnos>=cserialnos)){
235     if(OP_UNLIKELY(cserialnos>INT_MAX-1>>1))return OP_EFAULT;
236     cserialnos=2*cserialnos+1;
237     OP_ASSERT(nserialnos<cserialnos);
238     serialnos=_ogg_realloc(serialnos,sizeof(*serialnos)*cserialnos);
239     if(OP_UNLIKELY(serialnos==NULL))return OP_EFAULT;
240   }
241   serialnos[nserialnos++]=s;
242   *_serialnos=serialnos;
243   *_nserialnos=nserialnos;
244   *_cserialnos=cserialnos;
245   return 0;
246 }
247
248 /*Returns nonzero if found.*/
249 static int op_lookup_serialno(ogg_uint32_t _s,
250  const ogg_uint32_t *_serialnos,int _nserialnos){
251   int i;
252   for(i=0;i<_nserialnos&&_serialnos[i]!=_s;i++);
253   return i<_nserialnos;
254 }
255
256 static int op_lookup_page_serialno(ogg_page *_og,
257  const ogg_uint32_t *_serialnos,int _nserialnos){
258   return op_lookup_serialno(ogg_page_serialno(_og),_serialnos,_nserialnos);
259 }
260
261 typedef struct OpusSeekRecord OpusSeekRecord;
262
263 /*We use this to remember the pages we found while enumerating the links of a
264    chained stream.
265   We only need to know the starting and ending byte offsets and the serial
266    number, so we can tell if the page belonged to the current chain or not,
267    and where to bisect.*/
268 struct OpusSeekRecord{
269   /*The earliest byte we know of such that reading forward from it causes
270      capture to be regained at this page.*/
271   opus_int64   search_start;
272   /*The offset of this page.*/
273   opus_int64   offset;
274   /*The size of this page.*/
275   opus_int32   size;
276   /*The serial number of this page.*/
277   ogg_uint32_t serialno;
278   /*The granule position of this page.*/
279   ogg_int64_t  gp;
280 };
281
282 /*Find the last page beginning before _offset with a valid granule position.
283   There is no '_boundary' parameter as it will always have to read more data.
284   This is much dirtier than the above, as Ogg doesn't have any backward search
285    linkage.
286   This search prefers pages of the specified serial number.
287   If a page of the specified serial number is spotted during the
288    seek-back-and-read-forward, it will return the info of last page of the
289    matching serial number, instead of the very last page.
290   If no page of the specified serial number is seen, it will return the info of
291    the last page and update *_serialno.
292   Return: 0 on success, or a negative value on failure.
293           OP_EREAD:    Failed to read more data (error or EOF).
294           OP_EBADLINK: We couldn't find a page even after seeking back to the
295                         start of the stream.*/
296 static int op_get_prev_page_serial(OggOpusFile *_of,
297  OpusSeekRecord *_sr,opus_int32 *_chunk_size,opus_int64 _offset,
298  ogg_uint32_t _serialno,const ogg_uint32_t *_serialnos,int _nserialnos){
299   OpusSeekRecord preferred_sr;
300   ogg_page       og;
301   opus_int64     begin;
302   opus_int64     end;
303   opus_int64     original_end;
304   opus_int32     chunk_size;
305   int            preferred_found;
306   original_end=end=begin=_offset;
307   preferred_found=0;
308   _offset=-1;
309   chunk_size=_chunk_size==NULL?OP_CHUNK_SIZE:*_chunk_size;
310   do{
311     opus_int64 search_start;
312     int        ret;
313     OP_ASSERT(chunk_size>=OP_PAGE_SIZE_MAX);
314     begin=OP_MAX(begin-chunk_size,0);
315     ret=op_seek_helper(_of,begin);
316     if(OP_UNLIKELY(ret<0))return ret;
317     search_start=begin;
318     while(_of->offset<end){
319       opus_int64   llret;
320       ogg_uint32_t serialno;
321       llret=op_get_next_page(_of,&og,end);
322       if(OP_UNLIKELY(llret<OP_FALSE))return (int)llret;
323       else if(llret==OP_FALSE)break;
324       serialno=ogg_page_serialno(&og);
325       /*Save the information for this page.
326         We're not interested in the page itself... just the serial number, byte
327          offset, page size, and granule position.*/
328       _sr->search_start=search_start;
329       _sr->offset=_offset=llret;
330       _sr->serialno=serialno;
331       OP_ASSERT(_of->offset-_offset>=0);
332       OP_ASSERT(_of->offset-_offset<=OP_PAGE_SIZE_MAX);
333       _sr->size=(opus_int32)(_of->offset-_offset);
334       _sr->gp=ogg_page_granulepos(&og);
335       /*If this page is from the stream we're looking for, remember it.*/
336       if(serialno==_serialno){
337         preferred_found=1;
338         *&preferred_sr=*_sr;
339       }
340       if(!op_lookup_serialno(serialno,_serialnos,_nserialnos)){
341         /*We fell off the end of the link, which means we seeked back too far
342            and shouldn't have been looking in that link to begin with.
343           If we found the preferred serial number, forget that we saw it.*/
344         preferred_found=0;
345       }
346       search_start=llret+1;
347     }
348     /*We started from the beginning of the stream and found nothing.
349       This should be impossible unless the contents of the source changed out
350        from under us after we read from it.*/
351     if(OP_UNLIKELY(!begin)&&OP_UNLIKELY(_offset<0))return OP_EBADLINK;
352     /*Bump up the chunk size.
353       This is mildly helpful when seeks are very expensive (http).*/
354     chunk_size=OP_MIN(2*chunk_size,OP_CHUNK_SIZE_MAX);
355     /*Avoid quadratic complexity if we hit an invalid patch of the file.*/
356     end=OP_MIN(begin+OP_PAGE_SIZE_MAX-1,original_end);
357   }
358   while(_offset<0);
359   if(_chunk_size!=NULL)*_chunk_size=chunk_size;
360   if(preferred_found)*_sr=*&preferred_sr;
361   return 0;
362 }
363
364 /*Uses the local ogg_stream storage in _of.
365   This is important for non-streaming input sources.*/
366 static int op_fetch_headers_impl(OggOpusFile *_of,OpusHead *_head,
367  OpusTags *_tags,ogg_uint32_t **_serialnos,int *_nserialnos,
368  int *_cserialnos,ogg_page *_og){
369   ogg_packet op;
370   int        ret;
371   if(_serialnos!=NULL)*_nserialnos=0;
372   /*Extract the serialnos of all BOS pages plus the first set of Opus headers
373      we see in the link.*/
374   while(ogg_page_bos(_og)){
375     if(_serialnos!=NULL){
376       if(OP_UNLIKELY(op_lookup_page_serialno(_og,*_serialnos,*_nserialnos))){
377         /*A dupe serialnumber in an initial header packet set==invalid stream.*/
378         return OP_EBADHEADER;
379       }
380       ret=op_add_serialno(_og,_serialnos,_nserialnos,_cserialnos);
381       if(OP_UNLIKELY(ret<0))return ret;
382     }
383     if(_of->ready_state<OP_STREAMSET){
384       /*We don't have an Opus stream in this link yet, so begin prospective
385          stream setup.
386         We need a stream to get packets.*/
387       ogg_stream_reset_serialno(&_of->os,ogg_page_serialno(_og));
388       ogg_stream_pagein(&_of->os,_og);
389       if(OP_LIKELY(ogg_stream_packetout(&_of->os,&op)>0)){
390         ret=opus_head_parse(_head,op.packet,op.bytes);
391         /*If it's just a stream type we don't recognize, ignore it.*/
392         if(ret==OP_ENOTFORMAT)continue;
393         /*Everything else is fatal.*/
394         if(OP_UNLIKELY(ret<0))return ret;
395         /*Found a valid Opus header.
396           Continue setup.*/
397         _of->ready_state=OP_STREAMSET;
398       }
399     }
400     /*Get the next page.
401       No need to clamp the boundary offset against _of->end, as all errors
402        become OP_ENOTFORMAT.*/
403     if(OP_UNLIKELY(op_get_next_page(_of,_og,
404      OP_ADV_OFFSET(_of->offset,OP_CHUNK_SIZE))<0)){
405       return OP_ENOTFORMAT;
406     }
407     /*If this page also belongs to our Opus stream, submit it and break.*/
408     if(_of->ready_state==OP_STREAMSET
409      &&_of->os.serialno==ogg_page_serialno(_og)){
410       ogg_stream_pagein(&_of->os,_og);
411       break;
412     }
413   }
414   if(OP_UNLIKELY(_of->ready_state!=OP_STREAMSET))return OP_ENOTFORMAT;
415   /*Loop getting packets.*/
416   for(;;){
417     switch(ogg_stream_packetout(&_of->os,&op)){
418       case 0:{
419         /*Loop getting pages.*/
420         for(;;){
421           /*No need to clamp the boundary offset against _of->end, as all
422              errors become OP_EBADHEADER.*/
423           if(OP_UNLIKELY(op_get_next_page(_of,_og,
424            OP_ADV_OFFSET(_of->offset,OP_CHUNK_SIZE))<0)){
425             return OP_EBADHEADER;
426           }
427           /*If this page belongs to the correct stream, go parse it.*/
428           if(_of->os.serialno==ogg_page_serialno(_og)){
429             ogg_stream_pagein(&_of->os,_og);
430             break;
431           }
432           /*If the link ends before we see the Opus comment header, abort.*/
433           if(OP_UNLIKELY(ogg_page_bos(_og)))return OP_EBADHEADER;
434           /*Otherwise, keep looking.*/
435         }
436       }break;
437       /*We shouldn't get a hole in the headers!*/
438       case -1:return OP_EBADHEADER;
439       default:{
440         /*Got a packet.
441           It should be the comment header.*/
442         ret=opus_tags_parse(_tags,op.packet,op.bytes);
443         if(OP_UNLIKELY(ret<0))return ret;
444         /*Make sure the page terminated at the end of the comment header.
445           If there is another packet on the page, or part of a packet, then
446            reject the stream.
447           Otherwise seekable sources won't be able to seek back to the start
448            properly.*/
449         ret=ogg_stream_packetout(&_of->os,&op);
450         if(OP_UNLIKELY(ret!=0)
451          ||OP_UNLIKELY(_og->header[_og->header_len-1]==255)){
452           /*If we fail, the caller assumes our tags are uninitialized.*/
453           opus_tags_clear(_tags);
454           return OP_EBADHEADER;
455         }
456         return 0;
457       }
458     }
459   }
460 }
461
462 static int op_fetch_headers(OggOpusFile *_of,OpusHead *_head,
463  OpusTags *_tags,ogg_uint32_t **_serialnos,int *_nserialnos,
464  int *_cserialnos,ogg_page *_og){
465   ogg_page og;
466   int      ret;
467   if(!_og){
468     /*No need to clamp the boundary offset against _of->end, as all errors
469        become OP_ENOTFORMAT.*/
470     if(OP_UNLIKELY(op_get_next_page(_of,&og,
471      OP_ADV_OFFSET(_of->offset,OP_CHUNK_SIZE))<0)){
472       return OP_ENOTFORMAT;
473     }
474     _og=&og;
475   }
476   _of->ready_state=OP_OPENED;
477   ret=op_fetch_headers_impl(_of,_head,_tags,_serialnos,_nserialnos,
478    _cserialnos,_og);
479   /*Revert back from OP_STREAMSET to OP_OPENED on failure, to prevent
480      double-free of the tags in an unseekable stream.*/
481   if(OP_UNLIKELY(ret<0))_of->ready_state=OP_OPENED;
482   return ret;
483 }
484
485 /*Granule position manipulation routines.
486   A granule position is defined to be an unsigned 64-bit integer, with the
487    special value -1 in two's complement indicating an unset or invalid granule
488    position.
489   We are not guaranteed to have an unsigned 64-bit type, so we construct the
490    following routines that
491    a) Properly order negative numbers as larger than positive numbers, and
492    b) Check for underflow or overflow past the special -1 value.
493   This lets us operate on the full, valid range of granule positions in a
494    consistent and safe manner.
495   This full range is organized into distinct regions:
496    [ -1 (invalid) ][ 0 ... OP_INT64_MAX ][ OP_INT64_MIN ... -2 ][-1 (invalid) ]
497
498   No one should actually use granule positions so large that they're negative,
499    even if they are technically valid, as very little software handles them
500    correctly (including most of Xiph.Org's).
501   This library also refuses to support durations so large they won't fit in a
502    signed 64-bit integer (to avoid exposing this mess to the application, and
503    to simplify a good deal of internal arithmetic), so the only way to use them
504    successfully is if pcm_start is very large.
505   This means there isn't anything you can do with negative granule positions
506    that you couldn't have done with purely non-negative ones.
507   The main purpose of these routines is to allow us to think very explicitly
508    about the possible failure cases of all granule position manipulations.*/
509
510 /*Safely adds a small signed integer to a valid (not -1) granule position.
511   The result can use the full 64-bit range of values (both positive and
512    negative), but will fail on overflow (wrapping past -1; wrapping past
513    OP_INT64_MAX is explicitly okay).
514   [out] _dst_gp: The resulting granule position.
515                  Only modified on success.
516   _src_gp:       The granule position to add to.
517                  This must not be -1.
518   _delta:        The amount to add.
519                  This is allowed to be up to 32 bits to support the maximum
520                   duration of a single Ogg page (255 packets * 120 ms per
521                   packet == 1,468,800 samples at 48 kHz).
522   Return: 0 on success, or OP_EINVAL if the result would wrap around past -1.*/
523 static int op_granpos_add(ogg_int64_t *_dst_gp,ogg_int64_t _src_gp,
524  opus_int32 _delta){
525   /*The code below handles this case correctly, but there's no reason we
526      should ever be called with these values, so make sure we aren't.*/
527   OP_ASSERT(_src_gp!=-1);
528   if(_delta>0){
529     /*Adding this amount to the granule position would overflow its 64-bit
530        range.*/
531     if(OP_UNLIKELY(_src_gp<0)&&OP_UNLIKELY(_src_gp>=-1-_delta))return OP_EINVAL;
532     if(OP_UNLIKELY(_src_gp>OP_INT64_MAX-_delta)){
533       /*Adding this amount to the granule position would overflow the positive
534          half of its 64-bit range.
535         Since signed overflow is undefined in C, do it in a way the compiler
536          isn't allowed to screw up.*/
537       _delta-=(opus_int32)(OP_INT64_MAX-_src_gp)+1;
538       _src_gp=OP_INT64_MIN;
539     }
540   }
541   else if(_delta<0){
542     /*Subtracting this amount from the granule position would underflow its
543        64-bit range.*/
544     if(_src_gp>=0&&OP_UNLIKELY(_src_gp<-_delta))return OP_EINVAL;
545     if(OP_UNLIKELY(_src_gp<OP_INT64_MIN-_delta)){
546       /*Subtracting this amount from the granule position would underflow the
547          negative half of its 64-bit range.
548         Since signed underflow is undefined in C, do it in a way the compiler
549          isn't allowed to screw up.*/
550       _delta+=(opus_int32)(_src_gp-OP_INT64_MIN)+1;
551       _src_gp=OP_INT64_MAX;
552     }
553   }
554   *_dst_gp=_src_gp+_delta;
555   return 0;
556 }
557
558 /*Safely computes the difference between two granule positions.
559   The difference must fit in a signed 64-bit integer, or the function fails.
560   It correctly handles the case where the granule position has wrapped around
561    from positive values to negative ones.
562   [out] _delta: The difference between the granule positions.
563                 Only modified on success.
564   _gp_a:        The granule position to subtract from.
565                 This must not be -1.
566   _gp_b:        The granule position to subtract.
567                 This must not be -1.
568   Return: 0 on success, or OP_EINVAL if the result would not fit in a signed
569            64-bit integer.*/
570 static int op_granpos_diff(ogg_int64_t *_delta,
571  ogg_int64_t _gp_a,ogg_int64_t _gp_b){
572   int gp_a_negative;
573   int gp_b_negative;
574   /*The code below handles these cases correctly, but there's no reason we
575      should ever be called with these values, so make sure we aren't.*/
576   OP_ASSERT(_gp_a!=-1);
577   OP_ASSERT(_gp_b!=-1);
578   gp_a_negative=OP_UNLIKELY(_gp_a<0);
579   gp_b_negative=OP_UNLIKELY(_gp_b<0);
580   if(OP_UNLIKELY(gp_a_negative^gp_b_negative)){
581     ogg_int64_t da;
582     ogg_int64_t db;
583     if(gp_a_negative){
584       /*_gp_a has wrapped to a negative value but _gp_b hasn't: the difference
585          should be positive.*/
586       /*Step 1: Handle wrapping.*/
587       /*_gp_a < 0 => da < 0.*/
588       da=(OP_INT64_MIN-_gp_a)-1;
589       /*_gp_b >= 0  => db >= 0.*/
590       db=OP_INT64_MAX-_gp_b;
591       /*Step 2: Check for overflow.*/
592       if(OP_UNLIKELY(OP_INT64_MAX+da<db))return OP_EINVAL;
593       *_delta=db-da;
594     }
595     else{
596       /*_gp_b has wrapped to a negative value but _gp_a hasn't: the difference
597          should be negative.*/
598       /*Step 1: Handle wrapping.*/
599       /*_gp_a >= 0 => da <= 0*/
600       da=_gp_a+OP_INT64_MIN;
601       /*_gp_b < 0 => db <= 0*/
602       db=OP_INT64_MIN-_gp_b;
603       /*Step 2: Check for overflow.*/
604       if(OP_UNLIKELY(da<OP_INT64_MIN-db))return OP_EINVAL;
605       *_delta=da+db;
606     }
607   }
608   else *_delta=_gp_a-_gp_b;
609   return 0;
610 }
611
612 static int op_granpos_cmp(ogg_int64_t _gp_a,ogg_int64_t _gp_b){
613   /*The invalid granule position -1 should behave like NaN: neither greater
614      than nor less than any other granule position, nor equal to any other
615      granule position, including itself.
616     However, that means there isn't anything we could sensibly return from this
617      function for it.*/
618   OP_ASSERT(_gp_a!=-1);
619   OP_ASSERT(_gp_b!=-1);
620   /*Handle the wrapping cases.*/
621   if(OP_UNLIKELY(_gp_a<0)){
622     if(_gp_b>=0)return 1;
623     /*Else fall through.*/
624   }
625   else if(OP_UNLIKELY(_gp_b<0))return -1;
626   /*No wrapping case.*/
627   return (_gp_a>_gp_b)-(_gp_b>_gp_a);
628 }
629
630 /*Returns the duration of the packet (in samples at 48 kHz), or a negative
631    value on error.*/
632 static int op_get_packet_duration(const unsigned char *_data,int _len){
633   int nframes;
634   int frame_size;
635   int nsamples;
636   nframes=opus_packet_get_nb_frames(_data,_len);
637   if(OP_UNLIKELY(nframes<0))return OP_EBADPACKET;
638   frame_size=opus_packet_get_samples_per_frame(_data,48000);
639   nsamples=nframes*frame_size;
640   if(OP_UNLIKELY(nsamples>120*48))return OP_EBADPACKET;
641   return nsamples;
642 }
643
644 /*This function more properly belongs in info.c, but we define it here to allow
645    the static granule position manipulation functions to remain static.*/
646 ogg_int64_t opus_granule_sample(const OpusHead *_head,ogg_int64_t _gp){
647   opus_int32 pre_skip;
648   pre_skip=_head->pre_skip;
649   if(_gp!=-1&&op_granpos_add(&_gp,_gp,-pre_skip))_gp=-1;
650   return _gp;
651 }
652
653 /*Grab all the packets currently in the stream state, and compute their
654    durations.
655   _of->op_count is set to the number of packets collected.
656   [out] _durations: Returns the durations of the individual packets.
657   Return: The total duration of all packets, or OP_HOLE if there was a hole.*/
658 static opus_int32 op_collect_audio_packets(OggOpusFile *_of,
659  int _durations[255]){
660   opus_int32 total_duration;
661   int        op_count;
662   /*Count the durations of all packets in the page.*/
663   op_count=0;
664   total_duration=0;
665   for(;;){
666     int ret;
667     /*Unless libogg is broken, we can't get more than 255 packets from a
668        single page.*/
669     OP_ASSERT(op_count<255);
670     /*This takes advantage of undocumented libogg behavior that returned
671        ogg_packet buffers are valid at least until the next page is
672        submitted.
673       Relying on this is not too terrible, as _none_ of the Ogg memory
674        ownership/lifetime rules are well-documented.
675       But I can read its code and know this will work.*/
676     ret=ogg_stream_packetout(&_of->os,_of->op+op_count);
677     if(!ret)break;
678     if(OP_UNLIKELY(ret<0)){
679       /*We shouldn't get holes in the middle of pages.*/
680       OP_ASSERT(op_count==0);
681       return OP_HOLE;
682     }
683     _durations[op_count]=op_get_packet_duration(_of->op[op_count].packet,
684      _of->op[op_count].bytes);
685     if(OP_LIKELY(_durations[op_count]>0)){
686       /*With at most 255 packets on a page, this can't overflow.*/
687       total_duration+=_durations[op_count++];
688     }
689     /*Ignore packets with an invalid TOC sequence.*/
690     else if(op_count>0){
691       /*But save the granule position, if there was one.*/
692       _of->op[op_count-1].granulepos=_of->op[op_count].granulepos;
693     }
694   }
695   _of->op_pos=0;
696   _of->op_count=op_count;
697   return total_duration;
698 }
699
700 /*Starting from current cursor position, get the initial PCM offset of the next
701    page.
702   This also validates the granule position on the first page with a completed
703    audio data packet, as required by the spec.
704   If this link is completely empty (no pages with completed packets), then this
705    function sets pcm_start=pcm_end=0 and returns the BOS page of the next link
706    (if any).
707   In the seekable case, we initialize pcm_end=-1 before calling this function,
708    so that later we can detect that the link was empty before calling
709    op_find_final_pcm_offset().
710   [inout] _link: The link for which to find pcm_start.
711   [out] _og:     Returns the BOS page of the next link if this link was empty.
712                  In the unseekable case, we can then feed this to
713                   op_fetch_headers() to start the next link.
714                  The caller may pass NULL (e.g., for seekable streams), in
715                   which case this page will be discarded.
716   Return: 0 on success, 1 if there is a buffered BOS page available, or a
717            negative value on unrecoverable error.*/
718 static int op_find_initial_pcm_offset(OggOpusFile *_of,
719  OggOpusLink *_link,ogg_page *_og){
720   ogg_page     og;
721   ogg_int64_t  pcm_start;
722   ogg_int64_t  prev_packet_gp;
723   ogg_int64_t  cur_page_gp;
724   ogg_uint32_t serialno;
725   opus_int32   total_duration;
726   int          durations[255];
727   int          cur_page_eos;
728   int          op_count;
729   int          pi;
730   if(_og==NULL)_og=&og;
731   serialno=_of->os.serialno;
732   op_count=0;
733   /*We shouldn't have to initialize total_duration, but gcc is too dumb to
734      figure out that op_count>0 implies we've been through the whole loop at
735      least once.*/
736   total_duration=0;
737   do{
738     opus_int64 llret;
739     llret=op_get_next_page(_of,_og,_of->end);
740     /*We should get a page unless the file is truncated or mangled.
741       Otherwise there are no audio data packets in the whole logical stream.*/
742     if(OP_UNLIKELY(llret<0)){
743       /*Fail if there was a read error.*/
744       if(llret<OP_FALSE)return (int)llret;
745       /*Fail if the pre-skip is non-zero, since it's asking us to skip more
746          samples than exist.*/
747       if(_link->head.pre_skip>0)return OP_EBADTIMESTAMP;
748       /*Set pcm_end and end_offset so we can skip the call to
749          op_find_final_pcm_offset().*/
750       _link->pcm_start=_link->pcm_end=0;
751       _link->end_offset=_link->data_offset;
752       return 0;
753     }
754     /*Similarly, if we hit the next link in the chain, we've gone too far.*/
755     if(OP_UNLIKELY(ogg_page_bos(_og))){
756       if(_link->head.pre_skip>0)return OP_EBADTIMESTAMP;
757       /*Set pcm_end and end_offset so we can skip the call to
758          op_find_final_pcm_offset().*/
759       _link->pcm_end=_link->pcm_start=0;
760       _link->end_offset=_link->data_offset;
761       /*Tell the caller we've got a buffered page for them.*/
762       return 1;
763     }
764     /*Ignore pages from other streams (not strictly necessary, because of the
765        checks in ogg_stream_pagein(), but saves some work).*/
766     if(serialno!=(ogg_uint32_t)ogg_page_serialno(_og))continue;
767     ogg_stream_pagein(&_of->os,_og);
768     /*Bitrate tracking: add the header's bytes here.
769       The body bytes are counted when we consume the packets.*/
770     _of->bytes_tracked+=_og->header_len;
771     /*Count the durations of all packets in the page.*/
772     do total_duration=op_collect_audio_packets(_of,durations);
773     /*Ignore holes.*/
774     while(OP_UNLIKELY(total_duration<0));
775     op_count=_of->op_count;
776   }
777   while(op_count<=0);
778   /*We found the first page with a completed audio data packet: actually look
779      at the granule position.
780     RFC 3533 says, "A special value of -1 (in two's complement) indicates that
781      no packets finish on this page," which does not say that a granule
782      position that is NOT -1 indicates that some packets DO finish on that page
783      (even though this was the intention, libogg itself violated this intention
784      for years before we fixed it).
785     The Ogg Opus specification only imposes its start-time requirements
786      on the granule position of the first page with completed packets,
787      so we ignore any set granule positions until then.*/
788   cur_page_gp=_of->op[op_count-1].granulepos;
789   /*But getting a packet without a valid granule position on the page is not
790      okay.*/
791   if(cur_page_gp==-1)return OP_EBADTIMESTAMP;
792   cur_page_eos=_of->op[op_count-1].e_o_s;
793   if(OP_LIKELY(!cur_page_eos)){
794     /*The EOS flag wasn't set.
795       Work backwards from the provided granule position to get the starting PCM
796        offset.*/
797     if(OP_UNLIKELY(op_granpos_add(&pcm_start,cur_page_gp,-total_duration)<0)){
798       /*The starting granule position MUST not be smaller than the amount of
799          audio on the first page with completed packets.*/
800       return OP_EBADTIMESTAMP;
801     }
802   }
803   else{
804     /*The first page with completed packets was also the last.*/
805     if(OP_LIKELY(op_granpos_add(&pcm_start,cur_page_gp,-total_duration)<0)){
806       /*If there's less audio on the page than indicated by the granule
807          position, then we're doing end-trimming, and the starting PCM offset
808          is zero by spec mandate.*/
809       pcm_start=0;
810       /*However, the end-trimming MUST not ask us to trim more samples than
811          exist after applying the pre-skip.*/
812       if(OP_UNLIKELY(op_granpos_cmp(cur_page_gp,_link->head.pre_skip)<0)){
813         return OP_EBADTIMESTAMP;
814       }
815     }
816   }
817   /*Timestamp the individual packets.*/
818   prev_packet_gp=pcm_start;
819   for(pi=0;pi<op_count;pi++){
820     int ret;
821     if(cur_page_eos){
822       ogg_int64_t diff;
823       ret=op_granpos_diff(&diff,cur_page_gp,prev_packet_gp);
824       OP_ASSERT(!ret);
825       diff=durations[pi]-diff;
826       /*If we have samples to trim...*/
827       if(diff>0){
828         /*If we trimmed the entire packet, stop (the spec says encoders
829            shouldn't do this, but we support it anyway).*/
830         if(OP_UNLIKELY(diff>durations[pi]))break;
831         _of->op[pi].granulepos=prev_packet_gp=cur_page_gp;
832         /*Move the EOS flag to this packet, if necessary, so we'll trim the
833            samples.*/
834         _of->op[pi].e_o_s=1;
835         continue;
836       }
837     }
838     /*Update the granule position as normal.*/
839     ret=op_granpos_add(&_of->op[pi].granulepos,
840      prev_packet_gp,durations[pi]);
841     OP_ASSERT(!ret);
842     prev_packet_gp=_of->op[pi].granulepos;
843   }
844   /*Update the packet count after end-trimming.*/
845   _of->op_count=pi;
846   _of->cur_discard_count=_link->head.pre_skip;
847   _of->prev_packet_gp=_link->pcm_start=pcm_start;
848   return 0;
849 }
850
851 /*Starting from current cursor position, get the final PCM offset of the
852    previous page.
853   This also validates the duration of the link, which, while not strictly
854    required by the spec, we need to ensure duration calculations don't
855    overflow.
856   This is only done for seekable sources.
857   We must validate that op_find_initial_pcm_offset() succeeded for this link
858    before calling this function, otherwise it will scan the entire stream
859    backwards until it reaches the start, and then fail.*/
860 static int op_find_final_pcm_offset(OggOpusFile *_of,
861  const ogg_uint32_t *_serialnos,int _nserialnos,OggOpusLink *_link,
862  opus_int64 _offset,ogg_uint32_t _end_serialno,ogg_int64_t _end_gp,
863  ogg_int64_t *_total_duration){
864   OpusSeekRecord sr;
865   ogg_int64_t    total_duration;
866   ogg_int64_t    duration;
867   ogg_uint32_t   cur_serialno;
868   opus_int32     chunk_size;
869   /*For the time being, fetch end PCM offset the simple way.*/
870   cur_serialno=_link->serialno;
871   sr.offset=_offset;
872   sr.serialno=_end_serialno;
873   sr.gp=_end_gp;
874   /*Keep track of the growing chunk size to better handle being multiplexed
875      with another high-bitrate stream.*/
876   chunk_size=OP_CHUNK_SIZE;
877   while(sr.gp==-1||sr.serialno!=cur_serialno){
878     int ret;
879     ret=op_get_prev_page_serial(_of,&sr,&chunk_size,sr.offset,
880      cur_serialno,_serialnos,_nserialnos);
881     if(OP_UNLIKELY(ret<0))return ret;
882   }
883   /*This implementation requires that the difference between the first and last
884      granule positions in each link be representable in a signed, 64-bit
885      number, and that each link also have at least as many samples as the
886      pre-skip requires.*/
887   if(OP_UNLIKELY(op_granpos_diff(&duration,sr.gp,_link->pcm_start)<0)
888    ||OP_UNLIKELY(duration<_link->head.pre_skip)){
889     return OP_EBADTIMESTAMP;
890   }
891   /*We also require that the total duration be representable in a signed,
892      64-bit number.*/
893   duration-=_link->head.pre_skip;
894   total_duration=*_total_duration;
895   if(OP_UNLIKELY(OP_INT64_MAX-duration<total_duration))return OP_EBADTIMESTAMP;
896   *_total_duration=total_duration+duration;
897   _link->pcm_end=sr.gp;
898   _link->end_offset=sr.offset;
899   return 0;
900 }
901
902 /*Rescale the number _x from the range [0,_from] to [0,_to].
903   _from and _to must be positive.*/
904 opus_int64 op_rescale64(opus_int64 _x,opus_int64 _from,opus_int64 _to){
905   opus_int64 frac;
906   opus_int64 ret;
907   int        i;
908   if(_x>=_from)return _to;
909   if(_x<=0)return 0;
910   frac=0;
911   for(i=0;i<63;i++){
912     frac<<=1;
913     OP_ASSERT(_x<=_from);
914     if(_x>=_from>>1){
915       _x-=_from-_x;
916       frac|=1;
917     }
918     else _x<<=1;
919   }
920   ret=0;
921   for(i=0;i<63;i++){
922     if(frac&1)ret=(ret&_to&1)+(ret>>1)+(_to>>1);
923     else ret>>=1;
924     frac>>=1;
925   }
926   return ret;
927 }
928
929 /*The minimum granule position spacing allowed for making predictions.
930   This corresponds to about 1 second of audio at 48 kHz for both Opus and
931    Vorbis, or one keyframe interval in Theora with the default keyframe spacing
932    of 256.*/
933 #define OP_GP_SPACING_MIN (48000)
934
935 /*Try to estimate the location of the next link using the current seek
936    records, assuming the initial granule position of any streams we've found is
937    0.*/
938 static opus_int64 op_predict_link_start(const OpusSeekRecord *_sr,int _nsr,
939  opus_int64 _searched,opus_int64 _end_searched,opus_int32 _bias){
940   opus_int64 bisect;
941   int        sri;
942   int        srj;
943   /*Require that we be at least OP_CHUNK_SIZE from the end.
944     We don't require that we be at least OP_CHUNK_SIZE from the beginning,
945      because if we are we'll just scan forward without seeking.*/
946   _end_searched-=OP_CHUNK_SIZE;
947   if(_searched>=_end_searched)return -1;
948   bisect=_end_searched;
949   for(sri=0;sri<_nsr;sri++){
950     ogg_int64_t  gp1;
951     ogg_int64_t  gp2_min;
952     ogg_uint32_t serialno1;
953     opus_int64   offset1;
954     /*If the granule position is negative, either it's invalid or we'd cause
955        overflow.*/
956     gp1=_sr[sri].gp;
957     if(gp1<0)continue;
958     /*We require some minimum distance between granule positions to make an
959        estimate.
960       We don't actually know what granule position scheme is being used,
961        because we have no idea what kind of stream these came from.
962       Therefore we require a minimum spacing between them, with the
963        expectation that while bitrates and granule position increments might
964        vary locally in quite complex ways, they are globally smooth.*/
965     if(OP_UNLIKELY(op_granpos_add(&gp2_min,gp1,OP_GP_SPACING_MIN)<0)){
966       /*No granule position would satisfy us.*/
967       continue;
968     }
969     offset1=_sr[sri].offset;
970     serialno1=_sr[sri].serialno;
971     for(srj=sri;srj-->0;){
972       ogg_int64_t gp2;
973       opus_int64  offset2;
974       opus_int64  num;
975       ogg_int64_t den;
976       ogg_int64_t ipart;
977       gp2=_sr[srj].gp;
978       if(gp2<gp2_min)continue;
979       /*Oh, and also make sure these came from the same stream.*/
980       if(_sr[srj].serialno!=serialno1)continue;
981       offset2=_sr[srj].offset;
982       /*For once, we can subtract with impunity.*/
983       den=gp2-gp1;
984       ipart=gp2/den;
985       num=offset2-offset1;
986       OP_ASSERT(num>0);
987       if(ipart>0&&(offset2-_searched)/ipart<num)continue;
988       offset2-=ipart*num;
989       gp2-=ipart*den;
990       offset2-=op_rescale64(gp2,den,num)-_bias;
991       if(offset2<_searched)continue;
992       bisect=OP_MIN(bisect,offset2);
993       break;
994     }
995   }
996   return bisect>=_end_searched?-1:bisect;
997 }
998
999 /*Finds each bitstream link, one at a time, using a bisection search.
1000   This has to begin by knowing the offset of the first link's initial page.*/
1001 static int op_bisect_forward_serialno(OggOpusFile *_of,
1002  opus_int64 _searched,OpusSeekRecord *_sr,int _csr,
1003  ogg_uint32_t **_serialnos,int *_nserialnos,int *_cserialnos){
1004   ogg_page      og;
1005   OggOpusLink  *links;
1006   int           nlinks;
1007   int           clinks;
1008   ogg_uint32_t *serialnos;
1009   int           nserialnos;
1010   ogg_int64_t   total_duration;
1011   int           nsr;
1012   int           ret;
1013   links=_of->links;
1014   nlinks=clinks=_of->nlinks;
1015   total_duration=0;
1016   /*We start with one seek record, for the last page in the file.
1017     We build up a list of records for places we seek to during link
1018      enumeration.
1019     This list is kept sorted in reverse order.
1020     We only care about seek locations that were _not_ in the current link,
1021      therefore we can add them one at a time to the end of the list as we
1022      improve the lower bound on the location where the next link starts.*/
1023   nsr=1;
1024   for(;;){
1025     opus_int64  end_searched;
1026     opus_int64  bisect;
1027     opus_int64  next;
1028     opus_int64  last;
1029     ogg_int64_t end_offset;
1030     ogg_int64_t end_gp;
1031     int         sri;
1032     serialnos=*_serialnos;
1033     nserialnos=*_nserialnos;
1034     if(OP_UNLIKELY(nlinks>=clinks)){
1035       if(OP_UNLIKELY(clinks>INT_MAX-1>>1))return OP_EFAULT;
1036       clinks=2*clinks+1;
1037       OP_ASSERT(nlinks<clinks);
1038       links=_ogg_realloc(links,sizeof(*links)*clinks);
1039       if(OP_UNLIKELY(links==NULL))return OP_EFAULT;
1040       _of->links=links;
1041     }
1042     /*Invariants:
1043       We have the headers and serial numbers for the link beginning at 'begin'.
1044       We have the offset and granule position of the last page in the file
1045        (potentially not a page we care about).*/
1046     /*Scan the seek records we already have to save us some bisection.*/
1047     for(sri=0;sri<nsr;sri++){
1048       if(op_lookup_serialno(_sr[sri].serialno,*_serialnos,*_nserialnos))break;
1049     }
1050     /*Is the last page in our current list of serial numbers?*/
1051     if(sri<=0)break;
1052     /*Last page wasn't found.
1053       We have at least one more link.*/
1054     last=-1;
1055     end_searched=_sr[sri-1].search_start;
1056     next=_sr[sri-1].offset;
1057     end_gp=-1;
1058     if(sri<nsr){
1059       _searched=_sr[sri].offset+_sr[sri].size;
1060       if(_sr[sri].serialno==links[nlinks-1].serialno){
1061         end_gp=_sr[sri].gp;
1062         end_offset=_sr[sri].offset;
1063       }
1064     }
1065     nsr=sri;
1066     bisect=-1;
1067     /*If we've already found the end of at least one link, try to pick the
1068        first bisection point at twice the average link size.
1069       This is a good choice for files with lots of links that are all about the
1070        same size.*/
1071     if(nlinks>1){
1072       opus_int64 last_offset;
1073       opus_int64 avg_link_size;
1074       opus_int64 upper_limit;
1075       last_offset=links[nlinks-1].offset;
1076       avg_link_size=last_offset/(nlinks-1);
1077       upper_limit=end_searched-OP_CHUNK_SIZE-avg_link_size;
1078       if(OP_LIKELY(last_offset>_searched-avg_link_size)
1079        &&OP_LIKELY(last_offset<upper_limit)){
1080         bisect=last_offset+avg_link_size;
1081         if(OP_LIKELY(bisect<upper_limit))bisect+=avg_link_size;
1082       }
1083     }
1084     /*We guard against garbage separating the last and first pages of two
1085        links below.*/
1086     while(_searched<end_searched){
1087       opus_int32 next_bias;
1088       /*If we don't have a better estimate, use simple bisection.*/
1089       if(bisect==-1)bisect=_searched+(end_searched-_searched>>1);
1090       /*If we're within OP_CHUNK_SIZE of the start, scan forward.*/
1091       if(bisect-_searched<OP_CHUNK_SIZE)bisect=_searched;
1092       /*Otherwise we're skipping data.
1093         Forget the end page, if we saw one, as we might miss a later one.*/
1094       else end_gp=-1;
1095       ret=op_seek_helper(_of,bisect);
1096       if(OP_UNLIKELY(ret<0))return ret;
1097       last=op_get_next_page(_of,&og,_sr[nsr-1].offset);
1098       if(OP_UNLIKELY(last<OP_FALSE))return (int)last;
1099       next_bias=0;
1100       if(last==OP_FALSE)end_searched=bisect;
1101       else{
1102         ogg_uint32_t serialno;
1103         ogg_int64_t  gp;
1104         serialno=ogg_page_serialno(&og);
1105         gp=ogg_page_granulepos(&og);
1106         if(!op_lookup_serialno(serialno,serialnos,nserialnos)){
1107           end_searched=bisect;
1108           next=last;
1109           /*In reality we should always have enough room, but be paranoid.*/
1110           if(OP_LIKELY(nsr<_csr)){
1111             _sr[nsr].search_start=bisect;
1112             _sr[nsr].offset=last;
1113             OP_ASSERT(_of->offset-last>=0);
1114             OP_ASSERT(_of->offset-last<=OP_PAGE_SIZE_MAX);
1115             _sr[nsr].size=(opus_int32)(_of->offset-last);
1116             _sr[nsr].serialno=serialno;
1117             _sr[nsr].gp=gp;
1118             nsr++;
1119           }
1120         }
1121         else{
1122           _searched=_of->offset;
1123           next_bias=OP_CHUNK_SIZE;
1124           if(serialno==links[nlinks-1].serialno){
1125             /*This page was from the stream we want, remember it.
1126               If it's the last such page in the link, we won't have to go back
1127                looking for it later.*/
1128             end_gp=gp;
1129             end_offset=last;
1130           }
1131         }
1132       }
1133       bisect=op_predict_link_start(_sr,nsr,_searched,end_searched,next_bias);
1134     }
1135     /*Bisection point found.
1136       Get the final granule position of the previous link, assuming
1137        op_find_initial_pcm_offset() didn't already determine the link was
1138        empty.*/
1139     if(OP_LIKELY(links[nlinks-1].pcm_end==-1)){
1140       if(end_gp==-1){
1141         /*If we don't know where the end page is, we'll have to seek back and
1142            look for it, starting from the end of the link.*/
1143         end_offset=next;
1144         /*Also forget the last page we read.
1145           It won't be available after the seek.*/
1146         last=-1;
1147       }
1148       ret=op_find_final_pcm_offset(_of,serialnos,nserialnos,
1149        links+nlinks-1,end_offset,links[nlinks-1].serialno,end_gp,
1150        &total_duration);
1151       if(OP_UNLIKELY(ret<0))return ret;
1152     }
1153     if(last!=next){
1154       /*The last page we read was not the first page the next link.
1155         Move the cursor position to the offset of that first page.
1156         This only performs an actual seek if the first page of the next link
1157          does not start at the end of the last page from the current Opus
1158          stream with a valid granule position.*/
1159       ret=op_seek_helper(_of,next);
1160       if(OP_UNLIKELY(ret<0))return ret;
1161     }
1162     ret=op_fetch_headers(_of,&links[nlinks].head,&links[nlinks].tags,
1163      _serialnos,_nserialnos,_cserialnos,last!=next?NULL:&og);
1164     if(OP_UNLIKELY(ret<0))return ret;
1165     links[nlinks].offset=next;
1166     links[nlinks].data_offset=_of->offset;
1167     links[nlinks].serialno=_of->os.serialno;
1168     links[nlinks].pcm_end=-1;
1169     /*This might consume a page from the next link, however the next bisection
1170        always starts with a seek.*/
1171     ret=op_find_initial_pcm_offset(_of,links+nlinks,NULL);
1172     if(OP_UNLIKELY(ret<0))return ret;
1173     _searched=_of->offset;
1174     /*Mark the current link count so it can be cleaned up on error.*/
1175     _of->nlinks=++nlinks;
1176   }
1177   /*Last page is in the starting serialno list, so we've reached the last link.
1178     Now find the last granule position for it (if we didn't the first time we
1179      looked at the end of the stream, and if op_find_initial_pcm_offset()
1180      didn't already determine the link was empty).*/
1181   if(OP_LIKELY(links[nlinks-1].pcm_end==-1)){
1182     ret=op_find_final_pcm_offset(_of,serialnos,nserialnos,
1183      links+nlinks-1,_sr[0].offset,_sr[0].serialno,_sr[0].gp,&total_duration);
1184     if(OP_UNLIKELY(ret<0))return ret;
1185   }
1186   /*Trim back the links array if necessary.*/
1187   links=_ogg_realloc(links,sizeof(*links)*nlinks);
1188   if(OP_LIKELY(links!=NULL))_of->links=links;
1189   /*We also don't need these anymore.*/
1190   _ogg_free(*_serialnos);
1191   *_serialnos=NULL;
1192   *_cserialnos=*_nserialnos=0;
1193   return 0;
1194 }
1195
1196 static int op_make_decode_ready(OggOpusFile *_of){
1197   OpusHead *head;
1198   int       li;
1199   int       stream_count;
1200   int       coupled_count;
1201   int       channel_count;
1202   if(_of->ready_state>OP_STREAMSET)return 0;
1203   if(OP_UNLIKELY(_of->ready_state<OP_STREAMSET))return OP_EFAULT;
1204   li=_of->seekable?_of->cur_link:0;
1205   head=&_of->links[li].head;
1206   stream_count=head->stream_count;
1207   coupled_count=head->coupled_count;
1208   channel_count=head->channel_count;
1209   /*Check to see if the current decoder is compatible with the current link.*/
1210   if(_of->od!=NULL&&_of->od_stream_count==stream_count
1211    &&_of->od_coupled_count==coupled_count&&_of->od_channel_count==channel_count
1212    &&memcmp(_of->od_mapping,head->mapping,
1213    sizeof(*head->mapping)*channel_count)==0){
1214     opus_multistream_decoder_ctl(_of->od,OPUS_RESET_STATE);
1215   }
1216   else{
1217     int err;
1218     opus_multistream_decoder_destroy(_of->od);
1219     _of->od=opus_multistream_decoder_create(48000,channel_count,
1220      stream_count,coupled_count,head->mapping,&err);
1221     if(_of->od==NULL)return OP_EFAULT;
1222     _of->od_stream_count=stream_count;
1223     _of->od_coupled_count=coupled_count;
1224     _of->od_channel_count=channel_count;
1225     memcpy(_of->od_mapping,head->mapping,sizeof(*head->mapping)*channel_count);
1226   }
1227 #if defined(OPUS_SET_GAIN)
1228   opus_multistream_decoder_ctl(_of->od,OPUS_SET_GAIN(head->output_gain));
1229 #else
1230 /*A fallback that works with both float and fixed-point is a bunch of work,
1231    so just force people to use a sufficiently new version.
1232   This is deployed well enough at this point that this shouldn't be a burden.*/
1233 # error "libopus 1.0.1 or later required"
1234 #endif
1235   _of->ready_state=OP_INITSET;
1236   _of->bytes_tracked=0;
1237   _of->samples_tracked=0;
1238 #if !defined(OP_FIXED_POINT)
1239   _of->dither_mute=65;
1240   /*Use the serial number for the PRNG seed to get repeatable output for
1241      straight play-throughs.*/
1242   _of->dither_seed=_of->links[li].serialno;
1243 #endif
1244   return 0;
1245 }
1246
1247 static int op_open_seekable2_impl(OggOpusFile *_of){
1248   /*64 seek records should be enough for anybody.
1249     Actually, with a bisection search in a 63-bit range down to OP_CHUNK_SIZE
1250      granularity, much more than enough.*/
1251   OpusSeekRecord sr[64];
1252   opus_int64     data_offset;
1253   int            ret;
1254   /*We can seek, so set out learning all about this file.*/
1255   (*_of->callbacks.seek)(_of->source,0,SEEK_END);
1256   _of->offset=_of->end=(*_of->callbacks.tell)(_of->source);
1257   if(OP_UNLIKELY(_of->end<0))return OP_EREAD;
1258   data_offset=_of->links[0].data_offset;
1259   if(OP_UNLIKELY(_of->end<data_offset))return OP_EBADLINK;
1260   /*Get the offset of the last page of the physical bitstream, or, if we're
1261      lucky, the last Opus page of the first link, as most Ogg Opus files will
1262      contain a single logical bitstream.*/
1263   ret=op_get_prev_page_serial(_of,sr,NULL,_of->end,
1264    _of->links[0].serialno,_of->serialnos,_of->nserialnos);
1265   if(OP_UNLIKELY(ret<0))return ret;
1266   /*If there's any trailing junk, forget about it.*/
1267   _of->end=sr[0].offset+sr[0].size;
1268   if(OP_UNLIKELY(_of->end<data_offset))return OP_EBADLINK;
1269   /*Now enumerate the bitstream structure.*/
1270   return op_bisect_forward_serialno(_of,data_offset,sr,sizeof(sr)/sizeof(*sr),
1271    &_of->serialnos,&_of->nserialnos,&_of->cserialnos);
1272 }
1273
1274 static int op_open_seekable2(OggOpusFile *_of){
1275   ogg_sync_state    oy_start;
1276   ogg_stream_state  os_start;
1277   ogg_packet       *op_start;
1278   opus_int64        start_offset;
1279   int               start_op_count;
1280   int               ret;
1281   /*We're partially open and have a first link header state in storage in _of.
1282     Save off that stream state so we can come back to it.*/
1283   start_op_count=_of->op_count;
1284   /*This is a bit too large to put on the stack unconditionally.*/
1285   op_start=(ogg_packet *)_ogg_malloc(sizeof(*op_start)*start_op_count);
1286   if(op_start==NULL)return OP_EFAULT;
1287   *&oy_start=_of->oy;
1288   *&os_start=_of->os;
1289   start_offset=_of->offset;
1290   memcpy(op_start,_of->op,sizeof(*op_start)*start_op_count);
1291   OP_ASSERT((*_of->callbacks.tell)(_of->source)==op_position(_of));
1292   ogg_sync_init(&_of->oy);
1293   ogg_stream_init(&_of->os,-1);
1294   ret=op_open_seekable2_impl(_of);
1295   /*Restore the old stream state.*/
1296   ogg_stream_clear(&_of->os);
1297   ogg_sync_clear(&_of->oy);
1298   *&_of->oy=*&oy_start;
1299   *&_of->os=*&os_start;
1300   _of->offset=start_offset;
1301   _of->op_count=start_op_count;
1302   memcpy(_of->op,op_start,sizeof(*_of->op)*start_op_count);
1303   _ogg_free(op_start);
1304   _of->prev_packet_gp=_of->links[0].pcm_start;
1305   _of->cur_discard_count=_of->links[0].head.pre_skip;
1306   if(OP_UNLIKELY(ret<0))return ret;
1307   /*And restore the position indicator.*/
1308   ret=(*_of->callbacks.seek)(_of->source,op_position(_of),SEEK_SET);
1309   return OP_UNLIKELY(ret<0)?OP_EREAD:0;
1310 }
1311
1312 /*Clear out the current logical bitstream decoder.*/
1313 static void op_decode_clear(OggOpusFile *_of){
1314   /*We don't actually free the decoder.
1315     We might be able to re-use it for the next link.*/
1316   _of->op_count=0;
1317   _of->od_buffer_size=0;
1318   _of->prev_packet_gp=-1;
1319   if(!_of->seekable){
1320     OP_ASSERT(_of->ready_state>=OP_INITSET);
1321     opus_tags_clear(&_of->links[0].tags);
1322   }
1323   _of->ready_state=OP_OPENED;
1324 }
1325
1326 static void op_clear(OggOpusFile *_of){
1327   OggOpusLink *links;
1328   _ogg_free(_of->od_buffer);
1329   if(_of->od!=NULL)opus_multistream_decoder_destroy(_of->od);
1330   links=_of->links;
1331   if(!_of->seekable){
1332     if(_of->ready_state>OP_OPENED||_of->ready_state==OP_PARTOPEN){
1333       opus_tags_clear(&links[0].tags);
1334     }
1335   }
1336   else if(OP_LIKELY(links!=NULL)){
1337     int nlinks;
1338     int link;
1339     nlinks=_of->nlinks;
1340     for(link=0;link<nlinks;link++)opus_tags_clear(&links[link].tags);
1341   }
1342   _ogg_free(links);
1343   _ogg_free(_of->serialnos);
1344   ogg_stream_clear(&_of->os);
1345   ogg_sync_clear(&_of->oy);
1346   if(_of->callbacks.close!=NULL)(*_of->callbacks.close)(_of->source);
1347 }
1348
1349 static int op_open1(OggOpusFile *_of,
1350  void *_source,const OpusFileCallbacks *_cb,
1351  const unsigned char *_initial_data,size_t _initial_bytes){
1352   ogg_page  og;
1353   ogg_page *pog;
1354   int       seekable;
1355   int       ret;
1356   memset(_of,0,sizeof(*_of));
1357   _of->end=-1;
1358   _of->source=_source;
1359   *&_of->callbacks=*_cb;
1360   /*At a minimum, we need to be able to read data.*/
1361   if(OP_UNLIKELY(_of->callbacks.read==NULL))return OP_EREAD;
1362   /*Initialize the framing state.*/
1363   ogg_sync_init(&_of->oy);
1364   /*Perhaps some data was previously read into a buffer for testing against
1365      other stream types.
1366     Allow initialization from this previously read data (especially as we may
1367      be reading from a non-seekable stream).
1368     This requires copying it into a buffer allocated by ogg_sync_buffer() and
1369      doesn't support seeking, so this is not a good mechanism to use for
1370      decoding entire files from RAM.*/
1371   if(_initial_bytes>0){
1372     char *buffer;
1373     buffer=ogg_sync_buffer(&_of->oy,_initial_bytes);
1374     memcpy(buffer,_initial_data,_initial_bytes*sizeof(*buffer));
1375     ogg_sync_wrote(&_of->oy,_initial_bytes);
1376   }
1377   /*Can we seek?
1378     Stevens suggests the seek test is portable.*/
1379   seekable=_cb->seek!=NULL&&(*_cb->seek)(_source,0,SEEK_CUR)!=-1;
1380   /*If seek is implemented, tell must also be implemented.*/
1381   if(seekable){
1382     if(OP_UNLIKELY(_of->callbacks.tell==NULL))return OP_EINVAL;
1383     else{
1384       opus_int64 pos;
1385       pos=(*_of->callbacks.tell)(_of->source);
1386       /*If the current position is not equal to the initial bytes consumed,
1387          absolute seeking will not work.*/
1388       if(OP_UNLIKELY(pos!=(opus_int64)_initial_bytes))return OP_EINVAL;
1389     }
1390   }
1391   _of->seekable=seekable;
1392   /*Don't seek yet.
1393     Set up a 'single' (current) logical bitstream entry for partial open.*/
1394   _of->links=(OggOpusLink *)_ogg_malloc(sizeof(*_of->links));
1395   /*The serialno gets filled in later by op_fetch_headers().*/
1396   ogg_stream_init(&_of->os,-1);
1397   pog=NULL;
1398   for(;;){
1399     /*Fetch all BOS pages, store the Opus header and all seen serial numbers,
1400       and load subsequent Opus setup headers.*/
1401     ret=op_fetch_headers(_of,&_of->links[0].head,&_of->links[0].tags,
1402      &_of->serialnos,&_of->nserialnos,&_of->cserialnos,pog);
1403     if(OP_UNLIKELY(ret<0))break;
1404     _of->nlinks=1;
1405     _of->links[0].offset=0;
1406     _of->links[0].data_offset=_of->offset;
1407     _of->links[0].pcm_end=-1;
1408     _of->links[0].serialno=_of->os.serialno;
1409     /*Fetch the initial PCM offset.*/
1410     ret=op_find_initial_pcm_offset(_of,_of->links,&og);
1411     if(seekable||OP_LIKELY(ret<=0))break;
1412     /*This link was empty, but we already have the BOS page for the next one in
1413        og.
1414       We can't seek, so start processing the next link right now.*/
1415     opus_tags_clear(&_of->links[0].tags);
1416     _of->nlinks=0;
1417     if(!seekable)_of->cur_link++;
1418     pog=&og;
1419   }
1420   if(OP_UNLIKELY(ret<0)){
1421     /*Don't auto-close the stream on failure.*/
1422     _of->callbacks.close=NULL;
1423     op_clear(_of);
1424   }
1425   else _of->ready_state=OP_PARTOPEN;
1426   return ret;
1427 }
1428
1429 static int op_open2(OggOpusFile *_of){
1430   int ret;
1431   OP_ASSERT(_of->ready_state==OP_PARTOPEN);
1432   if(_of->seekable){
1433     _of->ready_state=OP_OPENED;
1434     ret=op_open_seekable2(_of);
1435   }
1436   else ret=0;
1437   if(OP_LIKELY(ret>=0)){
1438     /*We have buffered packets from op_find_initial_pcm_offset().
1439       Move to OP_INITSET so we can use them.*/
1440     _of->ready_state=OP_STREAMSET;
1441     ret=op_make_decode_ready(_of);
1442     if(OP_LIKELY(ret>=0))return 0;
1443   }
1444   /*Don't auto-close the stream on failure.*/
1445   _of->callbacks.close=NULL;
1446   op_clear(_of);
1447   return ret;
1448 }
1449
1450 OggOpusFile *op_test_callbacks(void *_source,const OpusFileCallbacks *_cb,
1451  const unsigned char *_initial_data,size_t _initial_bytes,int *_error){
1452   OggOpusFile *of;
1453   int          ret;
1454   of=(OggOpusFile *)_ogg_malloc(sizeof(*of));
1455   ret=OP_EFAULT;
1456   if(OP_LIKELY(of!=NULL)){
1457     ret=op_open1(of,_source,_cb,_initial_data,_initial_bytes);
1458     if(OP_LIKELY(ret>=0)){
1459       if(_error!=NULL)*_error=0;
1460       return of;
1461     }
1462     _ogg_free(of);
1463   }
1464   if(_error!=NULL)*_error=ret;
1465   return NULL;
1466 }
1467
1468 OggOpusFile *op_open_callbacks(void *_source,const OpusFileCallbacks *_cb,
1469  const unsigned char *_initial_data,size_t _initial_bytes,int *_error){
1470   OggOpusFile *of;
1471   of=op_test_callbacks(_source,_cb,_initial_data,_initial_bytes,_error);
1472   if(OP_LIKELY(of!=NULL)){
1473     int ret;
1474     ret=op_open2(of);
1475     if(OP_LIKELY(ret>=0))return of;
1476     if(_error!=NULL)*_error=ret;
1477     _ogg_free(of);
1478   }
1479   return NULL;
1480 }
1481
1482 /*Convenience routine to clean up from failure for the open functions that
1483    create their own streams.*/
1484 static OggOpusFile *op_open_close_on_failure(void *_source,
1485  const OpusFileCallbacks *_cb,int *_error){
1486   OggOpusFile *of;
1487   if(OP_UNLIKELY(_source==NULL)){
1488     if(_error!=NULL)*_error=OP_EFAULT;
1489     return NULL;
1490   }
1491   of=op_open_callbacks(_source,_cb,NULL,0,_error);
1492   if(OP_UNLIKELY(of==NULL))(*_cb->close)(_source);
1493   return of;
1494 }
1495
1496 OggOpusFile *op_open_file(const char *_path,int *_error){
1497   OpusFileCallbacks cb;
1498   return op_open_close_on_failure(op_fopen(&cb,_path,"rb"),&cb,_error);
1499 }
1500
1501 OggOpusFile *op_open_memory(const unsigned char *_data,size_t _size,
1502  int *_error){
1503   OpusFileCallbacks cb;
1504   return op_open_close_on_failure(op_mem_stream_create(&cb,_data,_size),&cb,
1505    _error);
1506 }
1507
1508 OggOpusFile *op_vopen_url(const char *_url,int *_error,va_list _ap){
1509   OpusFileCallbacks cb;
1510   return op_open_close_on_failure(op_url_stream_vcreate(&cb,_url,_ap),&cb,
1511    _error);
1512 }
1513
1514 OggOpusFile *op_open_url(const char *_url,int *_error,...){
1515   va_list ap;
1516   va_start(ap,_error);
1517   return op_vopen_url(_url,_error,ap);
1518 }
1519
1520 /*Convenience routine to clean up from failure for the open functions that
1521    create their own streams.*/
1522 static OggOpusFile *op_test_close_on_failure(void *_source,
1523  const OpusFileCallbacks *_cb,int *_error){
1524   OggOpusFile *of;
1525   if(OP_UNLIKELY(_source==NULL)){
1526     if(_error!=NULL)*_error=OP_EFAULT;
1527     return NULL;
1528   }
1529   of=op_test_callbacks(_source,_cb,NULL,0,_error);
1530   if(OP_UNLIKELY(of==NULL))(*_cb->close)(_source);
1531   return of;
1532 }
1533
1534 OggOpusFile *op_test_file(const char *_path,int *_error){
1535   OpusFileCallbacks cb;
1536   return op_test_close_on_failure(op_fopen(&cb,_path,"rb"),&cb,_error);
1537 }
1538
1539 OggOpusFile *op_test_memory(const unsigned char *_data,size_t _size,
1540  int *_error){
1541   OpusFileCallbacks cb;
1542   return op_test_close_on_failure(op_mem_stream_create(&cb,_data,_size),&cb,
1543    _error);
1544 }
1545
1546 OggOpusFile *op_vtest_url(const char *_url,int *_error,va_list _ap){
1547   OpusFileCallbacks cb;
1548   return op_test_close_on_failure(op_url_stream_vcreate(&cb,_url,_ap),&cb,
1549    _error);
1550 }
1551
1552 OggOpusFile *op_test_url(const char *_url,int *_error,...){
1553   va_list ap;
1554   va_start(ap,_error);
1555   return op_vtest_url(_url,_error,ap);
1556 }
1557
1558 int op_test_open(OggOpusFile *_of){
1559   int ret;
1560   if(OP_UNLIKELY(_of->ready_state!=OP_PARTOPEN))return OP_EINVAL;
1561   ret=op_open2(_of);
1562   /*op_open2() will clear this structure on failure.
1563     Reset its contents to prevent double-frees in op_free().*/
1564   if(OP_UNLIKELY(ret<0))memset(_of,0,sizeof(*_of));
1565   return ret;
1566 }
1567
1568 void op_free(OggOpusFile *_of){
1569   if(OP_LIKELY(_of!=NULL)){
1570     op_clear(_of);
1571     _ogg_free(_of);
1572   }
1573 }
1574
1575 int op_seekable(OggOpusFile *_of){
1576   return _of->seekable;
1577 }
1578
1579 int op_link_count(OggOpusFile *_of){
1580   return _of->nlinks;
1581 }
1582
1583 ogg_uint32_t op_serialno(OggOpusFile *_of,int _li){
1584   if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
1585   if(!_of->seekable)_li=0;
1586   return _of->links[_li<0?_of->cur_link:_li].serialno;
1587 }
1588
1589 int op_channel_count(OggOpusFile *_of,int _li){
1590   return op_head(_of,_li)->channel_count;
1591 }
1592
1593 opus_int64 op_raw_total(OggOpusFile *_of,int _li){
1594   if(OP_UNLIKELY(_of->ready_state<OP_OPENED)
1595    ||OP_UNLIKELY(!_of->seekable)
1596    ||OP_UNLIKELY(_li>=_of->nlinks)){
1597     return OP_EINVAL;
1598   }
1599   if(_li<0)return _of->end-_of->links[0].offset;
1600   return (_li+1>=_of->nlinks?_of->end:_of->links[_li+1].offset)
1601    -_of->links[_li].offset;
1602 }
1603
1604 ogg_int64_t op_pcm_total(OggOpusFile *_of,int _li){
1605   OggOpusLink *links;
1606   ogg_int64_t  diff;
1607   int          ret;
1608   int          nlinks;
1609   nlinks=_of->nlinks;
1610   if(OP_UNLIKELY(_of->ready_state<OP_OPENED)
1611    ||OP_UNLIKELY(!_of->seekable)
1612    ||OP_UNLIKELY(_li>=nlinks)){
1613     return OP_EINVAL;
1614   }
1615   links=_of->links;
1616   /*We verify that the granule position differences are larger than the
1617      pre-skip and that the total duration does not overflow during link
1618      enumeration, so we don't have to check here.*/
1619   if(_li<0){
1620     ogg_int64_t pcm_total;
1621     int         li;
1622     pcm_total=0;
1623     for(li=0;li<nlinks;li++){
1624       ret=op_granpos_diff(&diff,links[li].pcm_end,links[li].pcm_start);
1625       OP_ASSERT(!ret);
1626       pcm_total+=diff-links[li].head.pre_skip;
1627     }
1628     return pcm_total;
1629   }
1630   ret=op_granpos_diff(&diff,links[_li].pcm_end,links[_li].pcm_start);
1631   OP_ASSERT(!ret);
1632   return diff-links[_li].head.pre_skip;
1633 }
1634
1635 const OpusHead *op_head(OggOpusFile *_of,int _li){
1636   if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
1637   if(!_of->seekable)_li=0;
1638   return &_of->links[_li<0?_of->cur_link:_li].head;
1639 }
1640
1641 const OpusTags *op_tags(OggOpusFile *_of,int _li){
1642   if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
1643   if(!_of->seekable){
1644     if(_of->ready_state<OP_STREAMSET&&_of->ready_state!=OP_PARTOPEN){
1645       return NULL;
1646     }
1647     _li=0;
1648   }
1649   else if(_li<0)_li=_of->ready_state>=OP_STREAMSET?_of->cur_link:0;
1650   return &_of->links[_li].tags;
1651 }
1652
1653 int op_current_link(OggOpusFile *_of){
1654   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
1655   return _of->cur_link;
1656 }
1657
1658 /*Compute an average bitrate given a byte and sample count.
1659   Return: The bitrate in bits per second.*/
1660 static opus_int32 op_calc_bitrate(opus_int64 _bytes,ogg_int64_t _samples){
1661   /*These rates are absurd, but let's handle them anyway.*/
1662   if(OP_UNLIKELY(_bytes>(OP_INT64_MAX-(_samples>>1))/(48000*8))){
1663     ogg_int64_t den;
1664     if(OP_UNLIKELY(_bytes/(0x7FFFFFFFF/(48000*8))>=_samples))return 0x7FFFFFFF;
1665     den=_samples/(48000*8);
1666     return (opus_int32)((_bytes+(den>>1))/den);
1667   }
1668   if(OP_UNLIKELY(_samples<=0))return 0x7FFFFFFF;
1669   /*This can't actually overflow in normal operation: even with a pre-skip of
1670      545 2.5 ms frames with 8 streams running at 1282*8+1 bytes per packet
1671      (1275 byte frames + Opus framing overhead + Ogg lacing values), that all
1672      produce a single sample of decoded output, we still don't top 45 Mbps.
1673     The only way to get bitrates larger than that is with excessive Opus
1674      padding, more encoded streams than output channels, or lots and lots of
1675      Ogg pages with no packets on them.*/
1676   return (opus_int32)OP_MIN((_bytes*48000*8+(_samples>>1))/_samples,0x7FFFFFFF);
1677 }
1678
1679 opus_int32 op_bitrate(OggOpusFile *_of,int _li){
1680   if(OP_UNLIKELY(_of->ready_state<OP_OPENED)||OP_UNLIKELY(!_of->seekable)
1681    ||OP_UNLIKELY(_li>=_of->nlinks)){
1682     return OP_EINVAL;
1683   }
1684   return op_calc_bitrate(op_raw_total(_of,_li),op_pcm_total(_of,_li));
1685 }
1686
1687 opus_int32 op_bitrate_instant(OggOpusFile *_of){
1688   ogg_int64_t samples_tracked;
1689   opus_int32  ret;
1690   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
1691   samples_tracked=_of->samples_tracked;
1692   if(OP_UNLIKELY(samples_tracked==0))return OP_FALSE;
1693   ret=op_calc_bitrate(_of->bytes_tracked,samples_tracked);
1694   _of->bytes_tracked=0;
1695   _of->samples_tracked=0;
1696   return ret;
1697 }
1698
1699 /*Fetch and process a page.
1700   This handles the case where we're at a bitstream boundary and dumps the
1701    decoding machine.
1702   If the decoding machine is unloaded, it loads it.
1703   It also keeps prev_packet_gp up to date (seek and read both use this; seek
1704    uses a special hack with _readp).
1705   Return: <0) Error, OP_HOLE (lost packet), or OP_EOF.
1706            0) Need more data (only if _readp==0).
1707            1) Got at least one audio data packet.*/
1708 static int op_fetch_and_process_page(OggOpusFile *_of,
1709  ogg_page *_og,opus_int64 _page_pos,int _readp,int _spanp,int _ignore_holes){
1710   OggOpusLink  *links;
1711   ogg_uint32_t  cur_serialno;
1712   int           seekable;
1713   int           cur_link;
1714   int           ret;
1715   if(OP_LIKELY(_of->ready_state>=OP_INITSET)
1716    &&OP_LIKELY(_of->op_pos<_of->op_count)){
1717     /*We're ready to decode and have at least one packet available already.*/
1718     return 1;
1719   }
1720   if(!_readp)return 0;
1721   seekable=_of->seekable;
1722   links=_of->links;
1723   cur_link=seekable?_of->cur_link:0;
1724   cur_serialno=links[cur_link].serialno;
1725   /*Handle one page.*/
1726   for(;;){
1727     ogg_page og;
1728     OP_ASSERT(_of->ready_state>=OP_OPENED);
1729     /*This loop is not strictly necessary, but there's no sense in doing the
1730        extra checks of the larger loop for the common case in a multiplexed
1731        bistream where the page is simply part of a different logical
1732        bitstream.*/
1733     do{
1734       /*If we were given a page to use, use it.*/
1735       if(_og!=NULL){
1736         *&og=*_og;
1737         _og=NULL;
1738       }
1739       /*Keep reading until we get a page with the correct serialno.*/
1740       else _page_pos=op_get_next_page(_of,&og,_of->end);
1741       /*EOF: Leave uninitialized.*/
1742       if(_page_pos<0)return _page_pos<OP_FALSE?(int)_page_pos:OP_EOF;
1743       if(OP_LIKELY(_of->ready_state>=OP_STREAMSET)){
1744         if(cur_serialno!=(ogg_uint32_t)ogg_page_serialno(&og)){
1745           /*Two possibilities:
1746              1) Another stream is multiplexed into this logical section, or*/
1747           if(OP_LIKELY(!ogg_page_bos(&og)))continue;
1748           /* 2) Our decoding just traversed a bitstream boundary.*/
1749           if(!_spanp)return OP_EOF;
1750           if(OP_LIKELY(_of->ready_state>=OP_INITSET))op_decode_clear(_of);
1751           break;
1752         }
1753       }
1754       /*Bitrate tracking: add the header's bytes here.
1755         The body bytes are counted when we consume the packets.*/
1756       _of->bytes_tracked+=og.header_len;
1757     }
1758     while(0);
1759     /*Do we need to load a new machine before submitting the page?
1760       This is different in the seekable and non-seekable cases.
1761       In the seekable case, we already have all the header information loaded
1762        and cached.
1763       We just initialize the machine with it and continue on our merry way.
1764       In the non-seekable (streaming) case, we'll only be at a boundary if we
1765        just left the previous logical bitstream, and we're now nominally at the
1766        header of the next bitstream.*/
1767     if(OP_UNLIKELY(_of->ready_state<OP_STREAMSET)){
1768       if(seekable){
1769         ogg_uint32_t serialno;
1770         int          nlinks;
1771         int          li;
1772         serialno=ogg_page_serialno(&og);
1773         /*Match the serialno to bitstream section.
1774           We use this rather than offset positions to avoid problems near
1775            logical bitstream boundaries.*/
1776         nlinks=_of->nlinks;
1777         for(li=0;li<nlinks&&links[li].serialno!=serialno;li++);
1778         /*Not a desired Opus bitstream section.
1779           Keep trying.*/
1780         if(li>=nlinks)continue;
1781         cur_serialno=serialno;
1782         _of->cur_link=cur_link=li;
1783         ogg_stream_reset_serialno(&_of->os,serialno);
1784         _of->ready_state=OP_STREAMSET;
1785         /*If we're at the start of this link, initialize the granule position
1786            and pre-skip tracking.*/
1787         if(_page_pos<=links[cur_link].data_offset){
1788           _of->prev_packet_gp=links[cur_link].pcm_start;
1789           _of->cur_discard_count=links[cur_link].head.pre_skip;
1790           /*Ignore a hole at the start of a new link (this is common for
1791              streams joined in the middle) or after seeking.*/
1792           _ignore_holes=1;
1793         }
1794       }
1795       else{
1796         do{
1797           /*We're streaming.
1798             Fetch the two header packets, build the info struct.*/
1799           ret=op_fetch_headers(_of,&links[0].head,&links[0].tags,
1800            NULL,NULL,NULL,&og);
1801           if(OP_UNLIKELY(ret<0))return ret;
1802           /*op_find_initial_pcm_offset() will suppress any initial hole for us,
1803              so no need to set _ignore_holes.*/
1804           ret=op_find_initial_pcm_offset(_of,links,&og);
1805           if(OP_UNLIKELY(ret<0))return ret;
1806           _of->links[0].serialno=cur_serialno=_of->os.serialno;
1807           _of->cur_link++;
1808         }
1809         /*If the link was empty, keep going, because we already have the
1810            BOS page of the next one in og.*/
1811         while(OP_UNLIKELY(ret>0));
1812         /*If we didn't get any packets out of op_find_initial_pcm_offset(),
1813            keep going (this is possible if end-trimming trimmed them all).*/
1814         if(_of->op_count<=0)continue;
1815         /*Otherwise, we're done.*/
1816         ret=op_make_decode_ready(_of);
1817         if(OP_UNLIKELY(ret<0))return ret;
1818         return 1;
1819       }
1820     }
1821     /*The buffered page is the data we want, and we're ready for it.
1822       Add it to the stream state.*/
1823     if(OP_UNLIKELY(_of->ready_state==OP_STREAMSET)){
1824       ret=op_make_decode_ready(_of);
1825       if(OP_UNLIKELY(ret<0))return ret;
1826     }
1827     /*Extract all the packets from the current page.*/
1828     ogg_stream_pagein(&_of->os,&og);
1829     if(OP_LIKELY(_of->ready_state>=OP_INITSET)){
1830       opus_int32 total_duration;
1831       int        durations[255];
1832       int        op_count;
1833       total_duration=op_collect_audio_packets(_of,durations);
1834       if(OP_UNLIKELY(total_duration<0)){
1835         /*Drain the packets from the page anyway.*/
1836         total_duration=op_collect_audio_packets(_of,durations);
1837         OP_ASSERT(total_duration>=0);
1838         /*Report holes to the caller.*/
1839         if(!_ignore_holes)return OP_HOLE;
1840       }
1841       op_count=_of->op_count;
1842       /*If we found at least one audio data packet, compute per-packet granule
1843          positions for them.*/
1844       if(op_count>0){
1845         ogg_int64_t diff;
1846         ogg_int64_t prev_packet_gp;
1847         ogg_int64_t cur_packet_gp;
1848         ogg_int64_t cur_page_gp;
1849         int         cur_page_eos;
1850         int         pi;
1851         cur_page_gp=_of->op[op_count-1].granulepos;
1852         cur_page_eos=_of->op[op_count-1].e_o_s;
1853         prev_packet_gp=_of->prev_packet_gp;
1854         if(OP_UNLIKELY(prev_packet_gp==-1)){
1855           opus_int32 cur_discard_count;
1856           /*This is the first call after a raw seek.
1857             Try to reconstruct prev_packet_gp from scratch.*/
1858           OP_ASSERT(seekable);
1859           if(OP_UNLIKELY(cur_page_eos)){
1860             /*If the first page we hit after our seek was the EOS page, and
1861                we didn't start from data_offset or before, we don't have
1862                enough information to do end-trimming.
1863               Proceed to the next link, rather than risk playing back some
1864                samples that shouldn't have been played.*/
1865             _of->op_count=0;
1866             continue;
1867           }
1868           /*By default discard 80 ms of data after a seek, unless we seek
1869              into the pre-skip region.*/
1870           cur_discard_count=80*48;
1871           cur_page_gp=_of->op[op_count-1].granulepos;
1872           /*Try to initialize prev_packet_gp.
1873             If the current page had packets but didn't have a granule
1874              position, or the granule position it had was too small (both
1875              illegal), just use the starting granule position for the link.*/
1876           prev_packet_gp=links[cur_link].pcm_start;
1877           if(OP_LIKELY(cur_page_gp!=-1)){
1878             op_granpos_add(&prev_packet_gp,cur_page_gp,-total_duration);
1879           }
1880           if(OP_LIKELY(!op_granpos_diff(&diff,
1881            prev_packet_gp,links[cur_link].pcm_start))){
1882             opus_int32 pre_skip;
1883             /*If we start at the beginning of the pre-skip region, or we're
1884                at least 80 ms from the end of the pre-skip region, we discard
1885                to the end of the pre-skip region.
1886               Otherwise, we still use the 80 ms default, which will discard
1887                past the end of the pre-skip region.*/
1888             pre_skip=links[cur_link].head.pre_skip;
1889             if(diff>=0&&diff<=OP_MAX(0,pre_skip-80*48)){
1890               cur_discard_count=pre_skip-(int)diff;
1891             }
1892           }
1893           _of->cur_discard_count=cur_discard_count;
1894         }
1895         if(OP_UNLIKELY(cur_page_gp==-1)){
1896           /*This page had completed packets but didn't have a valid granule
1897              position.
1898             This is illegal, but we'll try to handle it by continuing to count
1899              forwards from the previous page.*/
1900           if(op_granpos_add(&cur_page_gp,prev_packet_gp,total_duration)<0){
1901             /*The timestamp for this page overflowed.*/
1902             cur_page_gp=links[cur_link].pcm_end;
1903           }
1904         }
1905         /*If we hit the last page, handle end-trimming.*/
1906         if(OP_UNLIKELY(cur_page_eos)
1907          &&OP_LIKELY(!op_granpos_diff(&diff,cur_page_gp,prev_packet_gp))
1908          &&OP_LIKELY(diff<total_duration)){
1909           cur_packet_gp=prev_packet_gp;
1910           for(pi=0;pi<op_count;pi++){
1911             diff=durations[pi]-diff;
1912             /*If we have samples to trim...*/
1913             if(diff>0){
1914               /*If we trimmed the entire packet, stop (the spec says encoders
1915                  shouldn't do this, but we support it anyway).*/
1916               if(OP_UNLIKELY(diff>durations[pi]))break;
1917               cur_packet_gp=cur_page_gp;
1918               /*Move the EOS flag to this packet, if necessary, so we'll trim
1919                  the samples during decode.*/
1920               _of->op[pi].e_o_s=1;
1921             }
1922             else{
1923               /*Update the granule position as normal.*/
1924               ret=op_granpos_add(&cur_packet_gp,cur_packet_gp,durations[pi]);
1925               OP_ASSERT(!ret);
1926             }
1927             _of->op[pi].granulepos=cur_packet_gp;
1928             ret=op_granpos_diff(&diff,cur_page_gp,cur_packet_gp);
1929             OP_ASSERT(!ret);
1930           }
1931         }
1932         else{
1933           /*Propagate timestamps to earlier packets.
1934             op_granpos_add(&prev_packet_gp,prev_packet_gp,total_duration)
1935              should succeed and give prev_packet_gp==cur_page_gp.
1936             But we don't bother to check that, as there isn't much we can do
1937              if it's not true.
1938             The only thing we guarantee is that the start and end granule
1939              positions of the packets are valid, and that they are monotonic
1940              within a page.
1941             They might be completely out of range for this link (we'll check
1942              that elsewhere), or non-monotonic between pages.*/
1943           if(OP_UNLIKELY(op_granpos_add(&prev_packet_gp,
1944            cur_page_gp,-total_duration)<0)){
1945             /*The starting timestamp for the first packet on this page
1946                underflowed.
1947               This is illegal, but we ignore it.*/
1948             prev_packet_gp=0;
1949           }
1950           for(pi=0;pi<op_count;pi++){
1951             if(OP_UNLIKELY(op_granpos_add(&cur_packet_gp,
1952              cur_page_gp,-total_duration)<0)){
1953               /*The start timestamp for this packet underflowed.
1954                 This is illegal, but we ignore it.*/
1955               cur_packet_gp=0;
1956             }
1957             total_duration-=durations[pi];
1958             OP_ASSERT(total_duration>=0);
1959             ret=op_granpos_add(&cur_packet_gp,cur_packet_gp,durations[pi]);
1960             OP_ASSERT(!ret);
1961             _of->op[pi].granulepos=cur_packet_gp;
1962           }
1963           OP_ASSERT(total_duration==0);
1964         }
1965         _of->prev_packet_gp=prev_packet_gp;
1966         _of->op_count=pi;
1967         /*If end-trimming didn't trim all the packets, we're done.*/
1968         if(OP_LIKELY(pi>0))return 1;
1969       }
1970     }
1971   }
1972 }
1973
1974 int op_raw_seek(OggOpusFile *_of,opus_int64 _pos){
1975   int          ret;
1976   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
1977   /*Don't dump the decoder state if we can't seek.*/
1978   if(OP_UNLIKELY(!_of->seekable))return OP_ENOSEEK;
1979   if(OP_UNLIKELY(_pos<0)||OP_UNLIKELY(_pos>_of->end))return OP_EINVAL;
1980   /*Clear out any buffered, decoded data.*/
1981   op_decode_clear(_of);
1982   _of->bytes_tracked=0;
1983   _of->samples_tracked=0;
1984   ret=op_seek_helper(_of,_pos);
1985   if(OP_UNLIKELY(ret<0))return OP_EREAD;
1986   ret=op_fetch_and_process_page(_of,NULL,-1,1,1,1);
1987   /*If we hit EOF, op_fetch_and_process_page() leaves us uninitialized.
1988     Instead, jump to the end.*/
1989   if(ret==OP_EOF){
1990     int cur_link;
1991     op_decode_clear(_of);
1992     cur_link=_of->nlinks-1;
1993     _of->cur_link=cur_link;
1994     _of->prev_packet_gp=_of->links[cur_link].pcm_end;
1995     _of->cur_discard_count=0;
1996     ret=0;
1997   }
1998   else if(ret>0)ret=0;
1999   return ret;
2000 }
2001
2002 /*Convert a PCM offset relative to the start of the whole stream to a granule
2003    position in an individual link.*/
2004 static ogg_int64_t op_get_granulepos(const OggOpusFile *_of,
2005  ogg_int64_t _pcm_offset,int *_li){
2006   OggOpusLink *links;
2007   ogg_int64_t  duration;
2008   int          nlinks;
2009   int          li;
2010   int          ret;
2011   OP_ASSERT(_pcm_offset>=0);
2012   nlinks=_of->nlinks;
2013   links=_of->links;
2014   for(li=0;OP_LIKELY(li<nlinks);li++){
2015     ogg_int64_t pcm_start;
2016     opus_int32  pre_skip;
2017     pcm_start=links[li].pcm_start;
2018     pre_skip=links[li].head.pre_skip;
2019     ret=op_granpos_diff(&duration,links[li].pcm_end,pcm_start);
2020     OP_ASSERT(!ret);
2021     duration-=pre_skip;
2022     if(_pcm_offset<duration){
2023       _pcm_offset+=pre_skip;
2024       if(OP_UNLIKELY(pcm_start>OP_INT64_MAX-_pcm_offset)){
2025         /*Adding this amount to the granule position would overflow the positive
2026            half of its 64-bit range.
2027           Since signed overflow is undefined in C, do it in a way the compiler
2028            isn't allowed to screw up.*/
2029         _pcm_offset-=OP_INT64_MAX-pcm_start+1;
2030         pcm_start=OP_INT64_MIN;
2031       }
2032       pcm_start+=_pcm_offset;
2033       *_li=li;
2034       return pcm_start;
2035     }
2036     _pcm_offset-=duration;
2037   }
2038   return -1;
2039 }
2040
2041 /*This controls how close the target has to be to use the current stream
2042    position to subdivide the initial range.
2043   Two minutes seems to be a good default.*/
2044 #define OP_CUR_TIME_THRESH (120*48*(opus_int32)1000)
2045
2046 /*Search within link _li for the page with the highest granule position
2047    preceding (or equal to) _target_gp.
2048   There is a danger here: missing pages or incorrect frame number information
2049    in the bitstream could make our task impossible.
2050   Account for that (and report it as an error condition).*/
2051 static int op_pcm_seek_page(OggOpusFile *_of,
2052  ogg_int64_t _target_gp,int _li){
2053   OggOpusLink  *link;
2054   ogg_page      og;
2055   ogg_int64_t   pcm_pre_skip;
2056   ogg_int64_t   pcm_start;
2057   ogg_int64_t   pcm_end;
2058   ogg_int64_t   best_gp;
2059   ogg_int64_t   diff;
2060   ogg_uint32_t  serialno;
2061   opus_int32    pre_skip;
2062   opus_int32    cur_discard_count;
2063   opus_int64    begin;
2064   opus_int64    end;
2065   opus_int64    boundary;
2066   opus_int64    best;
2067   opus_int64    page_offset;
2068   opus_int64    d[3];
2069   int           force_bisect;
2070   int           ret;
2071   _of->bytes_tracked=0;
2072   _of->samples_tracked=0;
2073   /*New search algorithm by HB (Nicholas Vinen).*/
2074   link=_of->links+_li;
2075   best_gp=pcm_start=link->pcm_start;
2076   pcm_end=link->pcm_end;
2077   serialno=link->serialno;
2078   best=begin=link->data_offset;
2079   page_offset=-1;
2080   /*We discard the first 80 ms of data after a seek, so seek back that much
2081      farther.
2082     If we can't, simply seek to the beginning of the link.*/
2083   if(OP_UNLIKELY(op_granpos_add(&_target_gp,_target_gp,-80*48)<0)){
2084     _target_gp=pcm_start;
2085   }
2086   /*Special case seeking to the start of the link.*/
2087   pre_skip=link->head.pre_skip;
2088   ret=op_granpos_add(&pcm_pre_skip,pcm_start,pre_skip);
2089   OP_ASSERT(!ret);
2090   if(op_granpos_cmp(_target_gp,pcm_pre_skip)<0)end=boundary=begin;
2091   else{
2092     end=boundary=link->end_offset;
2093     /*If we were decoding from this link, we can narrow the range a bit.*/
2094     if(_li==_of->cur_link&&_of->ready_state>=OP_INITSET){
2095       opus_int64 offset;
2096       int        op_count;
2097       op_count=_of->op_count;
2098       /*The only way the offset can be invalid _and_ we can fail the granule
2099          position checks below is if someone changed the contents of the last
2100          page since we read it.
2101         We'd be within our rights to just return OP_EBADLINK in that case, but
2102          we'll simply ignore the current position instead.*/
2103       offset=_of->offset;
2104       if(op_count>0&&OP_LIKELY(offset<=end)){
2105         ogg_int64_t gp;
2106         gp=_of->op[op_count-1].granulepos;
2107         /*Make sure the timestamp is valid.
2108           The granule position might be -1 if we collected the packets from a
2109            page without a granule position after reporting a hole.*/
2110         if(OP_LIKELY(gp!=-1)&&OP_LIKELY(op_granpos_cmp(pcm_start,gp)<0)
2111          &&OP_LIKELY(op_granpos_cmp(pcm_end,gp)>0)){
2112           ret=op_granpos_diff(&diff,gp,_target_gp);
2113           OP_ASSERT(!ret);
2114           /*We only actually use the current time if either
2115             a) We can cut off more than half the range, or
2116             b) We're seeking sufficiently close to the current position that
2117                 it's likely to be informative.
2118             Otherwise it appears using the whole link range to estimate the
2119              first seek location gives better results, on average.*/
2120           if(diff<0){
2121             OP_ASSERT(offset>=begin);
2122             if(offset-begin>=end-begin>>1||diff>-OP_CUR_TIME_THRESH){
2123               best=begin=offset;
2124               best_gp=pcm_start=gp;
2125             }
2126           }
2127           else if(offset-begin<=end-begin>>1||diff<OP_CUR_TIME_THRESH){
2128             /*We really want the page start here, but this will do.*/
2129             end=boundary=offset;
2130             pcm_end=gp;
2131           }
2132         }
2133       }
2134     }
2135   }
2136   op_decode_clear(_of);
2137   /*Initialize the interval size history.*/
2138   d[2]=d[1]=d[0]=end-begin;
2139   force_bisect=0;
2140   while(begin<end){
2141     opus_int64 bisect;
2142     opus_int64 next_boundary;
2143     opus_int32 chunk_size;
2144     if(end-begin<OP_CHUNK_SIZE)bisect=begin;
2145     else{
2146       /*Update the interval size history.*/
2147       d[0]=d[1]>>1;
2148       d[1]=d[2]>>1;
2149       d[2]=end-begin>>1;
2150       if(force_bisect)bisect=begin+(end-begin>>1);
2151       else{
2152         ogg_int64_t diff2;
2153         ret=op_granpos_diff(&diff,_target_gp,pcm_start);
2154         OP_ASSERT(!ret);
2155         ret=op_granpos_diff(&diff2,pcm_end,pcm_start);
2156         OP_ASSERT(!ret);
2157         /*Take a (pretty decent) guess.*/
2158         bisect=begin+op_rescale64(diff,diff2,end-begin)-OP_CHUNK_SIZE;
2159       }
2160       if(bisect-OP_CHUNK_SIZE<begin)bisect=begin;
2161       force_bisect=0;
2162     }
2163     if(bisect!=_of->offset){
2164       page_offset=-1;
2165       ret=op_seek_helper(_of,bisect);
2166       if(OP_UNLIKELY(ret<0))return ret;
2167     }
2168     chunk_size=OP_CHUNK_SIZE;
2169     next_boundary=boundary;
2170     while(begin<end){
2171       page_offset=op_get_next_page(_of,&og,boundary);
2172       if(page_offset<0){
2173         if(page_offset<OP_FALSE)return (int)page_offset;
2174         /*There are no more pages in our interval from our stream with a valid
2175            timestamp that start at position bisect or later.*/
2176         /*If we scanned the whole interval, we're done.*/
2177         if(bisect<=begin+1)end=begin;
2178         else{
2179           /*Otherwise, back up one chunk.*/
2180           bisect=OP_MAX(bisect-chunk_size,begin);
2181           ret=op_seek_helper(_of,bisect);
2182           if(OP_UNLIKELY(ret<0))return ret;
2183           /*Bump up the chunk size.*/
2184           chunk_size=OP_MIN(2*chunk_size,OP_CHUNK_SIZE_MAX);
2185           /*If we did find a page from another stream or without a timestamp,
2186              don't read past it.*/
2187           boundary=next_boundary;
2188         }
2189       }
2190       else{
2191         ogg_int64_t gp;
2192         /*Save the offset of the first page we found after the seek, regardless
2193            of the stream it came from or whether or not it has a timestamp.*/
2194         next_boundary=OP_MIN(page_offset,next_boundary);
2195         if(serialno!=(ogg_uint32_t)ogg_page_serialno(&og))continue;
2196         gp=ogg_page_granulepos(&og);
2197         if(gp==-1)continue;
2198         if(op_granpos_cmp(gp,_target_gp)<0){
2199           /*We found a page that ends before our target.
2200             Advance to the raw offset of the next page.*/
2201           begin=_of->offset;
2202           if(OP_UNLIKELY(op_granpos_cmp(pcm_start,gp)>0)
2203            ||OP_UNLIKELY(op_granpos_cmp(pcm_end,gp)<0)){
2204             /*Don't let pcm_start get out of range!
2205               That could happen with an invalid timestamp.*/
2206             break;
2207           }
2208           /*Save the byte offset of the end of the page with this granule
2209              position.*/
2210           best=begin;
2211           best_gp=pcm_start=gp;
2212           ret=op_granpos_diff(&diff,_target_gp,pcm_start);
2213           OP_ASSERT(!ret);
2214           /*If we're more than a second away from our target, break out and
2215              do another bisection.*/
2216           if(diff>48000)break;
2217           /*Otherwise, keep scanning forward (do NOT use begin+1).*/
2218           bisect=begin;
2219         }
2220         else{
2221           /*We found a page that ends after our target.*/
2222           /*If we scanned the whole interval before we found it, we're done.*/
2223           if(bisect<=begin+1)end=begin;
2224           else{
2225             end=bisect;
2226             /*In later iterations, don't read past the first page we found.*/
2227             boundary=next_boundary;
2228             /*If we're not making much progress shrinking the interval size,
2229                start forcing straight bisection to limit the worst case.*/
2230             force_bisect=end-begin>d[0]*2;
2231             /*Don't let pcm_end get out of range!
2232               That could happen with an invalid timestamp.*/
2233             if(OP_LIKELY(op_granpos_cmp(pcm_end,gp)>0)
2234              &&OP_LIKELY(op_granpos_cmp(pcm_start,gp)<=0)){
2235               pcm_end=gp;
2236             }
2237             break;
2238           }
2239         }
2240       }
2241     }
2242   }
2243   /*Found our page.
2244     Seek right after it and update prev_packet_gp and cur_discard_count.
2245     This is an easier case than op_raw_seek(), as we don't need to keep any
2246      packets from the page we found.*/
2247   /*Seek, if necessary.*/
2248   if(best!=page_offset){
2249     page_offset=-1;
2250     ret=op_seek_helper(_of,best);
2251     if(OP_UNLIKELY(ret<0))return ret;
2252   }
2253   /*By default, discard 80 ms of data after a seek, unless we seek
2254      into the pre-skip region.*/
2255   cur_discard_count=80*48;
2256   ret=op_granpos_diff(&diff,best_gp,pcm_start);
2257   OP_ASSERT(!ret);
2258   OP_ASSERT(diff>=0);
2259   /*If we start at the beginning of the pre-skip region, or we're at least
2260      80 ms from the end of the pre-skip region, we discard to the end of the
2261      pre-skip region.
2262     Otherwise, we still use the 80 ms default, which will discard past the end
2263      of the pre-skip region.*/
2264   if(diff<=OP_MAX(0,pre_skip-80*48))cur_discard_count=pre_skip-(int)diff;
2265   _of->cur_link=_li;
2266   _of->ready_state=OP_STREAMSET;
2267   _of->prev_packet_gp=best_gp;
2268   _of->cur_discard_count=cur_discard_count;
2269   ogg_stream_reset_serialno(&_of->os,serialno);
2270   ret=op_fetch_and_process_page(_of,page_offset<0?NULL:&og,page_offset,1,0,1);
2271   if(OP_UNLIKELY(ret<=0))return OP_EBADLINK;
2272   /*Verify result.*/
2273   if(OP_UNLIKELY(op_granpos_cmp(_of->prev_packet_gp,_target_gp)>0)){
2274     return OP_EBADLINK;
2275   }
2276   return 0;
2277 }
2278
2279 int op_pcm_seek(OggOpusFile *_of,ogg_int64_t _pcm_offset){
2280   OggOpusLink *link;
2281   ogg_int64_t  pcm_start;
2282   ogg_int64_t  target_gp;
2283   ogg_int64_t  prev_packet_gp;
2284   ogg_int64_t  skip;
2285   ogg_int64_t  diff;
2286   int          op_count;
2287   int          op_pos;
2288   int          ret;
2289   int          li;
2290   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2291   if(OP_UNLIKELY(!_of->seekable))return OP_ENOSEEK;
2292   if(OP_UNLIKELY(_pcm_offset<0))return OP_EINVAL;
2293   target_gp=op_get_granulepos(_of,_pcm_offset,&li);
2294   if(OP_UNLIKELY(target_gp==-1))return OP_EINVAL;
2295   ret=op_pcm_seek_page(_of,target_gp,li);
2296   /*Now skip samples until we actually get to our target.*/
2297   link=_of->links+li;
2298   pcm_start=link->pcm_start;
2299   ret=op_granpos_diff(&_pcm_offset,target_gp,pcm_start);
2300   OP_ASSERT(!ret);
2301   /*Figure out where we should skip to.*/
2302   if(_pcm_offset<=link->head.pre_skip)skip=0;
2303   else skip=OP_MAX(_pcm_offset-80*48,0);
2304   OP_ASSERT(_pcm_offset-skip>=0);
2305   OP_ASSERT(_pcm_offset-skip<0x7FFFFFFF-120*48);
2306   /*Skip packets until we find one with samples past our skip target.*/
2307   for(;;){
2308     op_count=_of->op_count;
2309     prev_packet_gp=_of->prev_packet_gp;
2310     for(op_pos=_of->op_pos;op_pos<op_count;op_pos++){
2311       ogg_int64_t cur_packet_gp;
2312       cur_packet_gp=_of->op[op_pos].granulepos;
2313       if(OP_LIKELY(!op_granpos_diff(&diff,cur_packet_gp,pcm_start))
2314        &&diff>skip){
2315         break;
2316       }
2317       prev_packet_gp=cur_packet_gp;
2318     }
2319     _of->prev_packet_gp=prev_packet_gp;
2320     _of->op_pos=op_pos;
2321     if(op_pos<op_count)break;
2322     /*We skipped all the packets on this page.
2323       Fetch another.*/
2324     ret=op_fetch_and_process_page(_of,NULL,-1,1,0,1);
2325     if(OP_UNLIKELY(ret<=0))return OP_EBADLINK;
2326   }
2327   ret=op_granpos_diff(&diff,prev_packet_gp,pcm_start);
2328   OP_ASSERT(!ret);
2329   /*We skipped too far.
2330     Either the timestamps were illegal or there was a hole in the data.*/
2331   if(diff>skip)return OP_EBADLINK;
2332   OP_ASSERT(_pcm_offset-diff<0x7FFFFFFF);
2333   /*TODO: If there are further holes/illegal timestamps, we still won't decode
2334      to the correct sample.
2335     However, at least op_pcm_tell() will report the correct value immediately
2336      after returning.*/
2337   _of->cur_discard_count=(opus_int32)(_pcm_offset-diff);
2338   return 0;
2339 }
2340
2341 opus_int64 op_raw_tell(OggOpusFile *_of){
2342   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2343   return _of->offset;
2344 }
2345
2346 /*Convert a granule position from a given link to a PCM offset relative to the
2347    start of the whole stream.
2348   For unseekable sources, this gets reset to 0 at the beginning of each link.*/
2349 static ogg_int64_t op_get_pcm_offset(const OggOpusFile *_of,
2350  ogg_int64_t _gp,int _li){
2351   OggOpusLink *links;
2352   ogg_int64_t  pcm_offset;
2353   ogg_int64_t  delta;
2354   int          ret;
2355   int          li;
2356   links=_of->links;
2357   pcm_offset=0;
2358   OP_ASSERT(_li<_of->nlinks);
2359   for(li=0;li<_li;li++){
2360     ret=op_granpos_diff(&delta,links[li].pcm_end,links[li].pcm_start);
2361     OP_ASSERT(!ret);
2362     delta-=links[li].head.pre_skip;
2363     pcm_offset+=delta;
2364   }
2365   OP_ASSERT(_li>=0);
2366   if(_of->seekable&&OP_UNLIKELY(op_granpos_cmp(_gp,links[_li].pcm_end)>0)){
2367     _gp=links[_li].pcm_end;
2368   }
2369   if(OP_LIKELY(op_granpos_cmp(_gp,links[_li].pcm_start)>0)){
2370     ret=op_granpos_diff(&delta,_gp,links[_li].pcm_start);
2371     OP_ASSERT(!ret);
2372     if(delta<links[_li].head.pre_skip)delta=0;
2373     else delta-=links[_li].head.pre_skip;
2374     pcm_offset+=delta;
2375   }
2376   return pcm_offset;
2377 }
2378
2379 ogg_int64_t op_pcm_tell(OggOpusFile *_of){
2380   ogg_int64_t gp;
2381   int         nbuffered;
2382   int         ret;
2383   int         li;
2384   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2385   gp=_of->prev_packet_gp;
2386   if(gp==-1)return 0;
2387   nbuffered=OP_MAX(_of->od_buffer_size-_of->od_buffer_pos,0);
2388   ret=op_granpos_add(&gp,gp,-nbuffered);
2389   OP_ASSERT(!ret);
2390   li=_of->seekable?_of->cur_link:0;
2391   if(op_granpos_add(&gp,gp,_of->cur_discard_count)<0){
2392     gp=_of->links[li].pcm_end;
2393   }
2394   return op_get_pcm_offset(_of,gp,li);
2395 }
2396
2397 /*Allocate the decoder scratch buffer.
2398   This is done lazily, since if the user provides large enough buffers, we'll
2399    never need it.*/
2400 static int op_init_buffer(OggOpusFile *_of){
2401   int nchannels_max;
2402   if(_of->seekable){
2403     OggOpusLink *links;
2404     int          nlinks;
2405     int          li;
2406     links=_of->links;
2407     nlinks=_of->nlinks;
2408     nchannels_max=1;
2409     for(li=0;li<nlinks;li++){
2410       nchannels_max=OP_MAX(nchannels_max,links[li].head.channel_count);
2411     }
2412   }
2413   else nchannels_max=OP_NCHANNELS_MAX;
2414   _of->od_buffer=(op_sample *)_ogg_malloc(
2415    sizeof(*_of->od_buffer)*nchannels_max*120*48);
2416   if(_of->od_buffer==NULL)return OP_EFAULT;
2417   return 0;
2418 }
2419
2420 /*Read more samples from the stream, using the same API as op_read() or
2421    op_read_float().*/
2422 static int op_read_native(OggOpusFile *_of,
2423  op_sample *_pcm,int _buf_size,int *_li){
2424   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2425   for(;;){
2426     int ret;
2427     if(OP_LIKELY(_of->ready_state>=OP_INITSET)){
2428       int nchannels;
2429       int od_buffer_pos;
2430       int nsamples;
2431       int op_pos;
2432       nchannels=_of->links[_of->seekable?_of->cur_link:0].head.channel_count;
2433       od_buffer_pos=_of->od_buffer_pos;
2434       nsamples=_of->od_buffer_size-od_buffer_pos;
2435       /*If we have buffered samples, return them.*/
2436       if(OP_UNLIKELY(nsamples>0)){
2437         if(OP_UNLIKELY(nsamples*nchannels>_buf_size)){
2438           nsamples=_buf_size/nchannels;
2439         }
2440         memcpy(_pcm,_of->od_buffer+nchannels*od_buffer_pos,
2441          sizeof(*_pcm)*nchannels*nsamples);
2442         od_buffer_pos+=nsamples;
2443         _of->od_buffer_pos=od_buffer_pos;
2444         if(_li!=NULL)*_li=_of->cur_link;
2445         return nsamples;
2446       }
2447       /*If we have buffered packets, decode one.*/
2448       op_pos=_of->op_pos;
2449       if(OP_LIKELY(op_pos<_of->op_count)){
2450         ogg_packet  *pop;
2451         ogg_int64_t  diff;
2452         opus_int32   cur_discard_count;
2453         int          duration;
2454         int          trimmed_duration;
2455         pop=_of->op+op_pos++;
2456         _of->op_pos=op_pos;
2457         cur_discard_count=_of->cur_discard_count;
2458         duration=op_get_packet_duration(pop->packet,pop->bytes);
2459         /*We don't buffer packets with an invalid TOC sequence.*/
2460         OP_ASSERT(duration>0);
2461         trimmed_duration=duration;
2462         /*Perform end-trimming.*/
2463         if(OP_UNLIKELY(pop->e_o_s)){
2464           if(OP_UNLIKELY(op_granpos_cmp(pop->granulepos,
2465            _of->prev_packet_gp)<=0)){
2466             trimmed_duration=0;
2467           }
2468           else if(OP_LIKELY(!op_granpos_diff(&diff,
2469            pop->granulepos,_of->prev_packet_gp))){
2470             trimmed_duration=(int)OP_MIN(diff,trimmed_duration);
2471           }
2472         }
2473         _of->prev_packet_gp=pop->granulepos;
2474         if(OP_UNLIKELY(duration*nchannels>_buf_size)){
2475           op_sample *buf;
2476           /*If the user's buffer is too small, decode into a scratch buffer.*/
2477           buf=_of->od_buffer;
2478           if(OP_UNLIKELY(buf==NULL)){
2479             ret=op_init_buffer(_of);
2480             if(OP_UNLIKELY(ret<0))return ret;
2481             buf=_of->od_buffer;
2482           }
2483 #if defined(OP_FIXED_POINT)
2484           ret=opus_multistream_decode(_of->od,
2485            pop->packet,pop->bytes,buf,120*48,0);
2486 #else
2487           ret=opus_multistream_decode_float(_of->od,
2488            pop->packet,pop->bytes,buf,120*48,0);
2489 #endif
2490           if(OP_UNLIKELY(ret<0))return OP_EBADPACKET;
2491           OP_ASSERT(ret==duration);
2492           /*Perform pre-skip/pre-roll.*/
2493           od_buffer_pos=(int)OP_MIN(trimmed_duration,cur_discard_count);
2494           cur_discard_count-=od_buffer_pos;
2495           _of->cur_discard_count=cur_discard_count;
2496           _of->od_buffer_pos=od_buffer_pos;
2497           _of->od_buffer_size=trimmed_duration;
2498           /*Update bitrate tracking based on the actual samples we used from
2499              what was decoded.*/
2500           _of->bytes_tracked+=pop->bytes;
2501           _of->samples_tracked+=trimmed_duration-od_buffer_pos;
2502           /*Don't grab another page yet.*/
2503           if(OP_LIKELY(od_buffer_pos<trimmed_duration))continue;
2504         }
2505         else{
2506           /*Otherwise decode directly into the user's buffer.*/
2507 #if defined(OP_FIXED_POINT)
2508           ret=opus_multistream_decode(_of->od,pop->packet,pop->bytes,
2509            _pcm,_buf_size/nchannels,0);
2510 #else
2511           ret=opus_multistream_decode_float(_of->od,pop->packet,pop->bytes,
2512            _pcm,_buf_size/nchannels,0);
2513 #endif
2514           if(OP_UNLIKELY(ret<0))return OP_EBADPACKET;
2515           OP_ASSERT(ret==duration);
2516           if(OP_LIKELY(trimmed_duration>0)){
2517             /*Perform pre-skip/pre-roll.*/
2518             od_buffer_pos=(int)OP_MIN(trimmed_duration,cur_discard_count);
2519             cur_discard_count-=od_buffer_pos;
2520             _of->cur_discard_count=cur_discard_count;
2521             if(OP_UNLIKELY(od_buffer_pos>0)
2522              &&OP_LIKELY(od_buffer_pos<trimmed_duration)){
2523               memmove(_pcm,_pcm+od_buffer_pos*nchannels,
2524                sizeof(*_pcm)*(trimmed_duration-od_buffer_pos)*nchannels);
2525             }
2526             trimmed_duration-=od_buffer_pos;
2527             /*Update bitrate tracking based on the actual samples we used from
2528                what was decoded.*/
2529             _of->bytes_tracked+=pop->bytes;
2530             _of->samples_tracked+=trimmed_duration;
2531             if(OP_LIKELY(trimmed_duration>0)){
2532               if(_li!=NULL)*_li=_of->cur_link;
2533               return trimmed_duration;
2534             }
2535           }
2536         }
2537       }
2538     }
2539     /*Suck in another page.*/
2540     ret=op_fetch_and_process_page(_of,NULL,-1,1,1,0);
2541     if(OP_UNLIKELY(ret==OP_EOF)){
2542       if(_li!=NULL)*_li=_of->cur_link;
2543       return 0;
2544     }
2545     if(OP_UNLIKELY(ret<0))return ret;
2546   }
2547 }
2548
2549 typedef int (*op_read_filter_func)(OggOpusFile *_of,void *_dst,int _dst_sz,
2550  op_sample *_src,int _nsamples,int _nchannels);
2551
2552 /*Decode some samples and then apply a custom filter to them.
2553   This is used to convert to different output formats.*/
2554 static int op_read_native_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2555  op_read_filter_func _filter,int *_li){
2556   int ret;
2557   /*Ensure we have some decoded samples in our buffer.*/
2558   ret=op_read_native(_of,NULL,0,_li);
2559   /*Now apply the filter to them.*/
2560   if(OP_LIKELY(ret>=0)&&OP_LIKELY(_of->ready_state>=OP_INITSET)){
2561     int od_buffer_pos;
2562     od_buffer_pos=_of->od_buffer_pos;
2563     ret=_of->od_buffer_size-od_buffer_pos;
2564     if(OP_LIKELY(ret>0)){
2565       int nchannels;
2566       nchannels=_of->links[_of->seekable?_of->cur_link:0].head.channel_count;
2567       ret=(*_filter)(_of,_dst,_dst_sz,
2568        _of->od_buffer+nchannels*od_buffer_pos,ret,nchannels);
2569       OP_ASSERT(ret>=0);
2570       OP_ASSERT(ret<=_of->od_buffer_size-od_buffer_pos);
2571       od_buffer_pos+=ret;
2572       _of->od_buffer_pos=od_buffer_pos;
2573     }
2574   }
2575   return ret;
2576 }
2577
2578 #if defined(OP_FIXED_POINT)
2579
2580 int op_read(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size,int *_li){
2581   return op_read_native(_of,_pcm,_buf_size,_li);
2582 }
2583
2584 /*Matrices for downmixing from the supported channel counts to stereo.
2585   The matrices with 5 or more channels are normalized to a total volume of 2.0,
2586    since most mixes sound too quiet if normalized to 1.0 (as there is generally
2587    little volume in the side/rear channels).
2588   Hence we keep the coefficients in Q14, so the downmix values won't overflow a
2589    32-bit number.*/
2590 static const opus_int16 OP_STEREO_DOWNMIX_Q14
2591  [OP_NCHANNELS_MAX-2][OP_NCHANNELS_MAX][2]={
2592   /*3.0*/
2593   {
2594     {9598,0},{6786,6786},{0,9598}
2595   },
2596   /*quadrophonic*/
2597   {
2598     {6924,0},{0,6924},{5996,3464},{3464,5996}
2599   },
2600   /*5.0*/
2601   {
2602     {10666,0},{7537,7537},{0,10666},{9234,5331},{5331,9234}
2603   },
2604   /*5.1*/
2605   {
2606     {8668,0},{6129,6129},{0,8668},{7507,4335},{4335,7507},{6129,6129}
2607   },
2608   /*6.1*/
2609   {
2610     {7459,0},{5275,5275},{0,7459},{6460,3731},{3731,6460},{4568,4568},
2611     {5275,5275}
2612   },
2613   /*7.1*/
2614   {
2615     {6368,0},{4502,4502},{0,6368},{5515,3183},{3183,5515},{5515,3183},
2616     {3183,5515},{4502,4502}
2617   }
2618 };
2619
2620 static int op_stereo_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2621  op_sample *_src,int _nsamples,int _nchannels){
2622   _of=_of;
2623   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2624   if(_nchannels==2)memcpy(_dst,_src,_nsamples*2*sizeof(*_src));
2625   else{
2626     opus_int16 *dst;
2627     int         i;
2628     dst=(opus_int16 *)_dst;
2629     if(_nchannels==1){
2630       for(i=0;i<_nsamples;i++)dst[2*i+0]=dst[2*i+1]=_src[i];
2631     }
2632     else{
2633       for(i=0;i<_nsamples;i++){
2634         opus_int32 l;
2635         opus_int32 r;
2636         int        ci;
2637         l=r=0;
2638         for(ci=0;ci<_nchannels;ci++){
2639           opus_int32 s;
2640           s=_src[_nchannels*i+ci];
2641           l+=OP_STEREO_DOWNMIX_Q14[_nchannels-3][ci][0]*s;
2642           r+=OP_STEREO_DOWNMIX_Q14[_nchannels-3][ci][1]*s;
2643         }
2644         dst[2*i+0]=(opus_int16)OP_CLAMP(-32768,l+8192>>14,32767);
2645         dst[2*i+1]=(opus_int16)OP_CLAMP(-32768,r+8192>>14,32767);
2646       }
2647     }
2648   }
2649   return _nsamples;
2650 }
2651
2652 int op_read_stereo(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size){
2653   return op_read_native_filter(_of,_pcm,_buf_size,op_stereo_filter,NULL);
2654 }
2655
2656 # if !defined(OP_DISABLE_FLOAT_API)
2657
2658 static int op_short2float_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2659  op_sample *_src,int _nsamples,int _nchannels){
2660   float *dst;
2661   int    i;
2662   _of=_of;
2663   dst=(float *)_dst;
2664   if(OP_UNLIKELY(_nsamples*_nchannels>_dst_sz))_nsamples=_dst_sz/_nchannels;
2665   _dst_sz=_nsamples*_nchannels;
2666   for(i=0;i<_dst_sz;i++)dst[i]=(1.0F/32768)*_src[i];
2667   return _nsamples;
2668 }
2669
2670 int op_read_float(OggOpusFile *_of,float *_pcm,int _buf_size,int *_li){
2671   return op_read_native_filter(_of,_pcm,_buf_size,op_short2float_filter,_li);
2672 }
2673
2674 static int op_short2float_stereo_filter(OggOpusFile *_of,
2675  void *_dst,int _dst_sz,op_sample *_src,int _nsamples,int _nchannels){
2676   float *dst;
2677   dst=(float *)_dst;
2678   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2679   if(_nchannels==1){
2680     int i;
2681     _nsamples=op_short2float_filter(_of,dst,_nsamples,_src,_nsamples,1);
2682     for(i=_nsamples;i-->0;)dst[2*i+0]=dst[2*i+1]=dst[i];
2683     return _nsamples;
2684   }
2685   /*It would be better to convert to floats and then downmix (so that we don't
2686      risk clipping with more than 5 channels), but that would require a large
2687      stack buffer, which is probably not a good idea if you're using the
2688      fixed-point build.*/
2689   if(_nchannels>2){
2690     _nsamples=op_stereo_filter(_of,_src,_nsamples*2,
2691      _src,_nsamples,_nchannels);
2692   }
2693   return op_short2float_filter(_of,dst,_dst_sz,_src,_nsamples,2);
2694 }
2695
2696 int op_read_float_stereo(OggOpusFile *_of,float *_pcm,int _buf_size){
2697   return op_read_native_filter(_of,_pcm,_buf_size,
2698    op_short2float_stereo_filter,NULL);
2699 }
2700
2701 # endif
2702
2703 #else
2704
2705 # if defined(OP_HAVE_LRINTF)
2706 #  include <math.h>
2707 #  define op_float2int(_x) (lrintf(_x))
2708 # else
2709 #  define op_float2int(_x) ((int)((_x)+((_x)<0?-0.5F:0.5F)))
2710 # endif
2711
2712 /*The dithering code here is adapted from opusdec, part of opus-tools.
2713   It was originally written by Greg Maxwell.*/
2714
2715 static opus_uint32 op_rand(opus_uint32 _seed){
2716   return _seed*96314165+907633515&0xFFFFFFFFU;
2717 }
2718
2719 /*This implements 16-bit quantization with full triangular dither and IIR noise
2720    shaping.
2721   The noise shaping filters were designed by Sebastian Gesemann, and are based
2722    on the LAME ATH curves with flattening to limite their peak gain to 20 dB.
2723   Everyone else's noise shaping filters are mildly crazy.
2724   The 48 kHz version of this filter is just a warped version of the 44.1 kHz
2725    filter and probably could be improved by shifting the HF shelf up in
2726    frequency a little bit, since 48 kHz has a bit more room and being more
2727    conservative against bat-ears is probably more important than more noise
2728    suppression.
2729   This process can increase the peak level of the signal (in theory by the peak
2730    error of 1.5 +20 dB, though that is unobservably rare).
2731   To avoid clipping, the signal is attenuated by a couple thousands of a dB.
2732   Initially, the approach taken here was to only attenuate by the 99.9th
2733    percentile, making clipping rare but not impossible (like SoX), but the
2734    limited gain of the filter means that the worst case was only two
2735    thousandths of a dB more, so this just uses the worst case.
2736   The attenuation is probably also helpful to prevent clipping in the DAC
2737    reconstruction filters or downstream resampling, in any case.*/
2738
2739 #define OP_GAIN (32753.0F)
2740
2741 #define OP_PRNG_GAIN (1.0F/0xFFFFFFFF)
2742
2743 /*48 kHz noise shaping filter, sd=2.34.*/
2744
2745 static const float OP_FCOEF_B[4]={
2746   2.2374F,-0.7339F,-0.1251F,-0.6033F
2747 };
2748
2749 static const float OP_FCOEF_A[4]={
2750   0.9030F,0.0116F,-0.5853F,-0.2571F
2751 };
2752
2753 static void op_shaped_dither16(OggOpusFile *_of,opus_int16 *_dst,
2754  const float *_src,int _nsamples,int _nchannels){
2755   opus_uint32 seed;
2756   int         mute;
2757   int         i;
2758   mute=_of->dither_mute;
2759   seed=_of->dither_seed;
2760   /*In order to avoid replacing digital silence with quiet dither noise, we
2761      mute if the output has been silent for a while.*/
2762   if(mute>64)memset(_of->dither_a,0,sizeof(*_of->dither_a)*4*_nchannels);
2763   for(i=0;i<_nsamples;i++){
2764     int silent;
2765     int ci;
2766     silent=1;
2767     for(ci=0;ci<_nchannels;ci++){
2768       float r;
2769       float s;
2770       float err;
2771       int   si;
2772       int   j;
2773       s=_src[_nchannels*i+ci];
2774       silent&=s==0;
2775       s*=OP_GAIN;
2776       err=0;
2777       for(j=0;j<4;j++){
2778         err+=OP_FCOEF_B[j]*_of->dither_b[ci*4+j]
2779          -OP_FCOEF_A[j]*_of->dither_a[ci*4+j];
2780       }
2781       for(j=3;j-->0;)_of->dither_a[ci*4+j+1]=_of->dither_a[ci*4+j];
2782       for(j=3;j-->0;)_of->dither_b[ci*4+j+1]=_of->dither_b[ci*4+j];
2783       _of->dither_a[ci*4]=err;
2784       s-=err;
2785       if(mute>16)r=0;
2786       else{
2787         seed=op_rand(seed);
2788         r=seed*OP_PRNG_GAIN;
2789         seed=op_rand(seed);
2790         r-=seed*OP_PRNG_GAIN;
2791       }
2792       /*Clamp in float out of paranoia that the input will be > 96 dBFS and
2793          wrap if the integer is clamped.*/
2794       si=op_float2int(OP_CLAMP(-32768,s+r,32767));
2795       _dst[_nchannels*i+ci]=(opus_int16)si;
2796       /*Including clipping in the noise shaping is generally disastrous: the
2797          futile effort to restore the clipped energy results in more clipping.
2798         However, small amounts---at the level which could normally be created
2799          by dither and rounding---are harmless and can even reduce clipping
2800          somewhat due to the clipping sometimes reducing the dither + rounding
2801          error.*/
2802       _of->dither_b[ci*4]=mute>16?0:OP_CLAMP(-1.5F,si-s,1.5F);
2803     }
2804     mute++;
2805     if(!silent)mute=0;
2806   }
2807   _of->dither_mute=OP_MIN(mute,65);
2808   _of->dither_seed=seed;
2809 }
2810
2811 static int op_float2short_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2812  op_sample *_src,int _nsamples,int _nchannels){
2813   opus_int16 *dst;
2814   dst=(opus_int16 *)_dst;
2815   if(OP_UNLIKELY(_nsamples*_nchannels>_dst_sz))_nsamples=_dst_sz/_nchannels;
2816   op_shaped_dither16(_of,dst,_src,_nsamples,_nchannels);
2817   return _nsamples;
2818 }
2819
2820 int op_read(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size,int *_li){
2821   return op_read_native_filter(_of,_pcm,_buf_size,op_float2short_filter,_li);
2822 }
2823
2824 int op_read_float(OggOpusFile *_of,float *_pcm,int _buf_size,int *_li){
2825   return op_read_native(_of,_pcm,_buf_size,_li);
2826 }
2827
2828 /*Matrices for downmixing from the supported channel counts to stereo.
2829   The matrices with 5 or more channels are normalized to a total volume of 2.0,
2830    since most mixes sound too quiet if normalized to 1.0 (as there is generally
2831    little volume in the side/rear channels).*/
2832 static const float OP_STEREO_DOWNMIX[OP_NCHANNELS_MAX-2][OP_NCHANNELS_MAX][2]={
2833   /*3.0*/
2834   {
2835     {0.5858F,0.0F},{0.4142F,0.4142F},{0.0F,0.5858F}
2836   },
2837   /*quadrophonic*/
2838   {
2839     {0.4226F,0.0F},{0.0F,0.4226F},{0.366F,0.2114F},{0.2114F,0.336F}
2840   },
2841   /*5.0*/
2842   {
2843     {0.651F,0.0F},{0.46F,0.46F},{0.0F,0.651F},{0.5636F,0.3254F},
2844     {0.3254F,0.5636F}
2845   },
2846   /*5.1*/
2847   {
2848     {0.529F,0.0F},{0.3741F,0.3741F},{0.0F,0.529F},{0.4582F,0.2645F},
2849     {0.2645F,0.4582F},{0.3741F,0.3741F}
2850   },
2851   /*6.1*/
2852   {
2853     {0.4553F,0.0F},{0.322F,0.322F},{0.0F,0.4553F},{0.3943F,0.2277F},
2854     {0.2277F,0.3943F},{0.2788F,0.2788F},{0.322F,0.322F}
2855   },
2856   /*7.1*/
2857   {
2858     {0.3886F,0.0F},{0.2748F,0.2748F},{0.0F,0.3886F},{0.3366F,0.1943F},
2859     {0.1943F,0.3366F},{0.3366F,0.1943F},{0.1943F,0.3366F},{0.2748F,0.2748F}
2860   }
2861 };
2862
2863 static int op_stereo_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2864  op_sample *_src,int _nsamples,int _nchannels){
2865   _of=_of;
2866   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2867   if(_nchannels==2)memcpy(_dst,_src,_nsamples*2*sizeof(*_src));
2868   else{
2869     float *dst;
2870     int    i;
2871     dst=(float *)_dst;
2872     if(_nchannels==1){
2873       for(i=0;i<_nsamples;i++)dst[2*i+0]=dst[2*i+1]=_src[i];
2874     }
2875     else{
2876       for(i=0;i<_nsamples;i++){
2877         float l;
2878         float r;
2879         int   ci;
2880         l=r=0;
2881         for(ci=0;ci<_nchannels;ci++){
2882           l+=OP_STEREO_DOWNMIX[_nchannels-3][ci][0]*_src[_nchannels*i+ci];
2883           r+=OP_STEREO_DOWNMIX[_nchannels-3][ci][1]*_src[_nchannels*i+ci];
2884         }
2885         dst[2*i+0]=l;
2886         dst[2*i+1]=r;
2887       }
2888     }
2889   }
2890   return _nsamples;
2891 }
2892
2893 static int op_float2short_stereo_filter(OggOpusFile *_of,
2894  void *_dst,int _dst_sz,op_sample *_src,int _nsamples,int _nchannels){
2895   opus_int16 *dst;
2896   dst=(opus_int16 *)_dst;
2897   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2898   if(_nchannels==1){
2899     int i;
2900     op_shaped_dither16(_of,dst,_src,_nsamples,1);
2901     for(i=_nsamples;i-->0;)dst[2*i+0]=dst[2*i+1]=dst[i];
2902   }
2903   else{
2904     if(_nchannels>2){
2905       _nsamples=op_stereo_filter(_of,_src,_nsamples*2,
2906        _src,_nsamples,_nchannels);
2907     }
2908     op_shaped_dither16(_of,dst,_src,_nsamples,_nchannels);
2909   }
2910   return _nsamples;
2911 }
2912
2913 int op_read_stereo(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size){
2914   return op_read_native_filter(_of,_pcm,_buf_size,
2915    op_float2short_stereo_filter,NULL);
2916 }
2917
2918 int op_read_float_stereo(OggOpusFile *_of,float *_pcm,int _buf_size){
2919   return op_read_native_filter(_of,_pcm,_buf_size,op_stereo_filter,NULL);
2920 }
2921
2922 #endif