41263043de31c832225b102f1661438fd7aa2b34
[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   }
691   _of->op_pos=0;
692   _of->op_count=op_count;
693   return total_duration;
694 }
695
696 /*Starting from current cursor position, get the initial PCM offset of the next
697    page.
698   This also validates the granule position on the first page with a completed
699    audio data packet, as required by the spec.
700   If this link is completely empty (no pages with completed packets), then this
701    function sets pcm_start=pcm_end=0 and returns the BOS page of the next link
702    (if any).
703   In the seekable case, we initialize pcm_end=-1 before calling this function,
704    so that later we can detect that the link was empty before calling
705    op_find_final_pcm_offset().
706   [inout] _link: The link for which to find pcm_start.
707   [out] _og:     Returns the BOS page of the next link if this link was empty.
708                  In the unseekable case, we can then feed this to
709                   op_fetch_headers() to start the next link.
710                  The caller may pass NULL (e.g., for seekable streams), in
711                   which case this page will be discarded.
712   Return: 0 on success, 1 if there is a buffered BOS page available, or a
713            negative value on unrecoverable error.*/
714 static int op_find_initial_pcm_offset(OggOpusFile *_of,
715  OggOpusLink *_link,ogg_page *_og){
716   ogg_page     og;
717   ogg_int64_t  pcm_start;
718   ogg_int64_t  prev_packet_gp;
719   ogg_int64_t  cur_page_gp;
720   ogg_uint32_t serialno;
721   opus_int32   total_duration;
722   int          durations[255];
723   int          cur_page_eos;
724   int          op_count;
725   int          pi;
726   if(_og==NULL)_og=&og;
727   serialno=_of->os.serialno;
728   op_count=0;
729   /*We shouldn't have to initialize total_duration, but gcc is too dumb to
730      figure out that op_count>0 implies we've been through the whole loop at
731      least once.*/
732   total_duration=0;
733   do{
734     opus_int64 llret;
735     llret=op_get_next_page(_of,_og,_of->end);
736     /*We should get a page unless the file is truncated or mangled.
737       Otherwise there are no audio data packets in the whole logical stream.*/
738     if(OP_UNLIKELY(llret<0)){
739       /*Fail if there was a read error.*/
740       if(llret<OP_FALSE)return (int)llret;
741       /*Fail if the pre-skip is non-zero, since it's asking us to skip more
742          samples than exist.*/
743       if(_link->head.pre_skip>0)return OP_EBADTIMESTAMP;
744       /*Set pcm_end and end_offset so we can skip the call to
745          op_find_final_pcm_offset().*/
746       _link->pcm_start=_link->pcm_end=0;
747       _link->end_offset=_link->data_offset;
748       return 0;
749     }
750     /*Similarly, if we hit the next link in the chain, we've gone too far.*/
751     if(OP_UNLIKELY(ogg_page_bos(_og))){
752       if(_link->head.pre_skip>0)return OP_EBADTIMESTAMP;
753       /*Set pcm_end and end_offset so we can skip the call to
754          op_find_final_pcm_offset().*/
755       _link->pcm_end=_link->pcm_start=0;
756       _link->end_offset=_link->data_offset;
757       /*Tell the caller we've got a buffered page for them.*/
758       return 1;
759     }
760     /*Ignore pages from other streams (not strictly necessary, because of the
761        checks in ogg_stream_pagein(), but saves some work).*/
762     if(serialno!=(ogg_uint32_t)ogg_page_serialno(_og))continue;
763     ogg_stream_pagein(&_of->os,_og);
764     /*Bitrate tracking: add the header's bytes here.
765       The body bytes are counted when we consume the packets.*/
766     _of->bytes_tracked+=_og->header_len;
767     /*Count the durations of all packets in the page.*/
768     do total_duration=op_collect_audio_packets(_of,durations);
769     /*Ignore holes.*/
770     while(OP_UNLIKELY(total_duration<0));
771     op_count=_of->op_count;
772   }
773   while(op_count<=0);
774   /*We found the first page with a completed audio data packet: actually look
775      at the granule position.
776     RFC 3533 says, "A special value of -1 (in two's complement) indicates that
777      no packets finish on this page," which does not say that a granule
778      position that is NOT -1 indicates that some packets DO finish on that page
779      (even though this was the intention, libogg itself violated this intention
780      for years before we fixed it).
781     The Ogg Opus specification only imposes its start-time requirements
782      on the granule position of the first page with completed packets,
783      so we ignore any set granule positions until then.*/
784   cur_page_gp=_of->op[op_count-1].granulepos;
785   /*But getting a packet without a valid granule position on the page is not
786      okay.*/
787   if(cur_page_gp==-1)return OP_EBADTIMESTAMP;
788   cur_page_eos=_of->op[op_count-1].e_o_s;
789   if(OP_LIKELY(!cur_page_eos)){
790     /*The EOS flag wasn't set.
791       Work backwards from the provided granule position to get the starting PCM
792        offset.*/
793     if(OP_UNLIKELY(op_granpos_add(&pcm_start,cur_page_gp,-total_duration)<0)){
794       /*The starting granule position MUST not be smaller than the amount of
795          audio on the first page with completed packets.*/
796       return OP_EBADTIMESTAMP;
797     }
798   }
799   else{
800     /*The first page with completed packets was also the last.*/
801     if(OP_LIKELY(op_granpos_add(&pcm_start,cur_page_gp,-total_duration)<0)){
802       /*If there's less audio on the page than indicated by the granule
803          position, then we're doing end-trimming, and the starting PCM offset
804          is zero by spec mandate.*/
805       pcm_start=0;
806       /*However, the end-trimming MUST not ask us to trim more samples than
807          exist after applying the pre-skip.*/
808       if(OP_UNLIKELY(op_granpos_cmp(cur_page_gp,_link->head.pre_skip)<0)){
809         return OP_EBADTIMESTAMP;
810       }
811     }
812   }
813   /*Timestamp the individual packets.*/
814   prev_packet_gp=pcm_start;
815   for(pi=0;pi<op_count;pi++){
816     int ret;
817     if(cur_page_eos){
818       ogg_int64_t diff;
819       ret=op_granpos_diff(&diff,cur_page_gp,prev_packet_gp);
820       OP_ASSERT(!ret);
821       diff=durations[pi]-diff;
822       /*If we have samples to trim...*/
823       if(diff>0){
824         /*If we trimmed the entire packet, stop (the spec says encoders
825            shouldn't do this, but we support it anyway).*/
826         if(OP_UNLIKELY(diff>durations[pi]))break;
827         _of->op[pi].granulepos=prev_packet_gp=cur_page_gp;
828         /*Move the EOS flag to this packet, if necessary, so we'll trim the
829            samples.*/
830         _of->op[pi].e_o_s=1;
831         continue;
832       }
833     }
834     /*Update the granule position as normal.*/
835     ret=op_granpos_add(&_of->op[pi].granulepos,
836      prev_packet_gp,durations[pi]);
837     OP_ASSERT(!ret);
838     prev_packet_gp=_of->op[pi].granulepos;
839   }
840   /*Update the packet count after end-trimming.*/
841   _of->op_count=pi;
842   _of->cur_discard_count=_link->head.pre_skip;
843   _of->prev_packet_gp=_link->pcm_start=pcm_start;
844   return 0;
845 }
846
847 /*Starting from current cursor position, get the final PCM offset of the
848    previous page.
849   This also validates the duration of the link, which, while not strictly
850    required by the spec, we need to ensure duration calculations don't
851    overflow.
852   This is only done for seekable sources.
853   We must validate that op_find_initial_pcm_offset() succeeded for this link
854    before calling this function, otherwise it will scan the entire stream
855    backwards until it reaches the start, and then fail.*/
856 static int op_find_final_pcm_offset(OggOpusFile *_of,
857  const ogg_uint32_t *_serialnos,int _nserialnos,OggOpusLink *_link,
858  opus_int64 _offset,ogg_uint32_t _end_serialno,ogg_int64_t _end_gp,
859  ogg_int64_t *_total_duration){
860   OpusSeekRecord sr;
861   ogg_int64_t    total_duration;
862   ogg_int64_t    duration;
863   ogg_uint32_t   cur_serialno;
864   opus_int32     chunk_size;
865   /*For the time being, fetch end PCM offset the simple way.*/
866   cur_serialno=_link->serialno;
867   sr.offset=_offset;
868   sr.serialno=_end_serialno;
869   sr.gp=_end_gp;
870   /*Keep track of the growing chunk size to better handle being multiplexed
871      with another high-bitrate stream.*/
872   chunk_size=OP_CHUNK_SIZE;
873   while(sr.gp==-1||sr.serialno!=cur_serialno){
874     int ret;
875     ret=op_get_prev_page_serial(_of,&sr,&chunk_size,sr.offset,
876      cur_serialno,_serialnos,_nserialnos);
877     if(OP_UNLIKELY(ret<0))return ret;
878   }
879   /*This implementation requires that the difference between the first and last
880      granule positions in each link be representable in a signed, 64-bit
881      number, and that each link also have at least as many samples as the
882      pre-skip requires.*/
883   if(OP_UNLIKELY(op_granpos_diff(&duration,sr.gp,_link->pcm_start)<0)
884    ||OP_UNLIKELY(duration<_link->head.pre_skip)){
885     return OP_EBADTIMESTAMP;
886   }
887   /*We also require that the total duration be representable in a signed,
888      64-bit number.*/
889   duration-=_link->head.pre_skip;
890   total_duration=*_total_duration;
891   if(OP_UNLIKELY(OP_INT64_MAX-duration<total_duration))return OP_EBADTIMESTAMP;
892   *_total_duration=total_duration+duration;
893   _link->pcm_end=sr.gp;
894   _link->end_offset=sr.offset;
895   return 0;
896 }
897
898 /*Rescale the number _x from the range [0,_from] to [0,_to].
899   _from and _to must be positive.*/
900 opus_int64 op_rescale64(opus_int64 _x,opus_int64 _from,opus_int64 _to){
901   opus_int64 frac;
902   opus_int64 ret;
903   int        i;
904   if(_x>=_from)return _to;
905   if(_x<=0)return 0;
906   frac=0;
907   for(i=0;i<63;i++){
908     frac<<=1;
909     OP_ASSERT(_x<=_from);
910     if(_x>=_from>>1){
911       _x-=_from-_x;
912       frac|=1;
913     }
914     else _x<<=1;
915   }
916   ret=0;
917   for(i=0;i<63;i++){
918     if(frac&1)ret=(ret&_to&1)+(ret>>1)+(_to>>1);
919     else ret>>=1;
920     frac>>=1;
921   }
922   return ret;
923 }
924
925 /*The minimum granule position spacing allowed for making predictions.
926   This corresponds to about 1 second of audio at 48 kHz for both Opus and
927    Vorbis, or one keyframe interval in Theora with the default keyframe spacing
928    of 256.*/
929 #define OP_GP_SPACING_MIN (48000)
930
931 /*Try to estimate the location of the next link using the current seek
932    records, assuming the initial granule position of any streams we've found is
933    0.*/
934 static opus_int64 op_predict_link_start(const OpusSeekRecord *_sr,int _nsr,
935  opus_int64 _searched,opus_int64 _end_searched,opus_int32 _bias){
936   opus_int64 bisect;
937   int        sri;
938   int        srj;
939   /*Require that we be at least OP_CHUNK_SIZE from the end.
940     We don't require that we be at least OP_CHUNK_SIZE from the beginning,
941      because if we are we'll just scan forward without seeking.*/
942   _end_searched-=OP_CHUNK_SIZE;
943   if(_searched>=_end_searched)return -1;
944   bisect=_end_searched;
945   for(sri=0;sri<_nsr;sri++){
946     ogg_int64_t  gp1;
947     ogg_int64_t  gp2_min;
948     ogg_uint32_t serialno1;
949     opus_int64   offset1;
950     /*If the granule position is negative, either it's invalid or we'd cause
951        overflow.*/
952     gp1=_sr[sri].gp;
953     if(gp1<0)continue;
954     /*We require some minimum distance between granule positions to make an
955        estimate.
956       We don't actually know what granule position scheme is being used,
957        because we have no idea what kind of stream these came from.
958       Therefore we require a minimum spacing between them, with the
959        expectation that while bitrates and granule position increments might
960        vary locally in quite complex ways, they are globally smooth.*/
961     if(OP_UNLIKELY(op_granpos_add(&gp2_min,gp1,OP_GP_SPACING_MIN)<0)){
962       /*No granule position would satisfy us.*/
963       continue;
964     }
965     offset1=_sr[sri].offset;
966     serialno1=_sr[sri].serialno;
967     for(srj=sri;srj-->0;){
968       ogg_int64_t gp2;
969       opus_int64  offset2;
970       opus_int64  num;
971       ogg_int64_t den;
972       ogg_int64_t ipart;
973       gp2=_sr[srj].gp;
974       if(gp2<gp2_min)continue;
975       /*Oh, and also make sure these came from the same stream.*/
976       if(_sr[srj].serialno!=serialno1)continue;
977       offset2=_sr[srj].offset;
978       /*For once, we can subtract with impunity.*/
979       den=gp2-gp1;
980       ipart=gp2/den;
981       num=offset2-offset1;
982       OP_ASSERT(num>0);
983       if(ipart>0&&(offset2-_searched)/ipart<num)continue;
984       offset2-=ipart*num;
985       gp2-=ipart*den;
986       offset2-=op_rescale64(gp2,den,num)-_bias;
987       if(offset2<_searched)continue;
988       bisect=OP_MIN(bisect,offset2);
989       break;
990     }
991   }
992   return bisect>=_end_searched?-1:bisect;
993 }
994
995 /*Finds each bitstream link, one at a time, using a bisection search.
996   This has to begin by knowing the offset of the first link's initial page.*/
997 static int op_bisect_forward_serialno(OggOpusFile *_of,
998  opus_int64 _searched,OpusSeekRecord *_sr,int _csr,
999  ogg_uint32_t **_serialnos,int *_nserialnos,int *_cserialnos){
1000   ogg_page      og;
1001   OggOpusLink  *links;
1002   int           nlinks;
1003   int           clinks;
1004   ogg_uint32_t *serialnos;
1005   int           nserialnos;
1006   ogg_int64_t   total_duration;
1007   int           nsr;
1008   int           ret;
1009   links=_of->links;
1010   nlinks=clinks=_of->nlinks;
1011   total_duration=0;
1012   /*We start with one seek record, for the last page in the file.
1013     We build up a list of records for places we seek to during link
1014      enumeration.
1015     This list is kept sorted in reverse order.
1016     We only care about seek locations that were _not_ in the current link,
1017      therefore we can add them one at a time to the end of the list as we
1018      improve the lower bound on the location where the next link starts.*/
1019   nsr=1;
1020   for(;;){
1021     opus_int64  end_searched;
1022     opus_int64  bisect;
1023     opus_int64  next;
1024     opus_int64  last;
1025     ogg_int64_t end_offset;
1026     ogg_int64_t end_gp;
1027     int         sri;
1028     serialnos=*_serialnos;
1029     nserialnos=*_nserialnos;
1030     if(OP_UNLIKELY(nlinks>=clinks)){
1031       if(OP_UNLIKELY(clinks>INT_MAX-1>>1))return OP_EFAULT;
1032       clinks=2*clinks+1;
1033       OP_ASSERT(nlinks<clinks);
1034       links=_ogg_realloc(links,sizeof(*links)*clinks);
1035       if(OP_UNLIKELY(links==NULL))return OP_EFAULT;
1036       _of->links=links;
1037     }
1038     /*Invariants:
1039       We have the headers and serial numbers for the link beginning at 'begin'.
1040       We have the offset and granule position of the last page in the file
1041        (potentially not a page we care about).*/
1042     /*Scan the seek records we already have to save us some bisection.*/
1043     for(sri=0;sri<nsr;sri++){
1044       if(op_lookup_serialno(_sr[sri].serialno,*_serialnos,*_nserialnos))break;
1045     }
1046     /*Is the last page in our current list of serial numbers?*/
1047     if(sri<=0)break;
1048     /*Last page wasn't found.
1049       We have at least one more link.*/
1050     last=-1;
1051     end_searched=_sr[sri-1].search_start;
1052     next=_sr[sri-1].offset;
1053     end_gp=-1;
1054     if(sri<nsr){
1055       _searched=_sr[sri].offset+_sr[sri].size;
1056       if(_sr[sri].serialno==links[nlinks-1].serialno){
1057         end_gp=_sr[sri].gp;
1058         end_offset=_sr[sri].offset;
1059       }
1060     }
1061     nsr=sri;
1062     bisect=-1;
1063     /*If we've already found the end of at least one link, try to pick the
1064        first bisection point at twice the average link size.
1065       This is a good choice for files with lots of links that are all about the
1066        same size.*/
1067     if(nlinks>1){
1068       opus_int64 last_offset;
1069       opus_int64 avg_link_size;
1070       opus_int64 upper_limit;
1071       last_offset=links[nlinks-1].offset;
1072       avg_link_size=last_offset/(nlinks-1);
1073       upper_limit=end_searched-OP_CHUNK_SIZE-avg_link_size;
1074       if(OP_LIKELY(last_offset>_searched-avg_link_size)
1075        &&OP_LIKELY(last_offset<upper_limit)){
1076         bisect=last_offset+avg_link_size;
1077         if(OP_LIKELY(bisect<upper_limit))bisect+=avg_link_size;
1078       }
1079     }
1080     /*We guard against garbage separating the last and first pages of two
1081        links below.*/
1082     while(_searched<end_searched){
1083       opus_int32 next_bias;
1084       /*If we don't have a better estimate, use simple bisection.*/
1085       if(bisect==-1)bisect=_searched+(end_searched-_searched>>1);
1086       /*If we're within OP_CHUNK_SIZE of the start, scan forward.*/
1087       if(bisect-_searched<OP_CHUNK_SIZE)bisect=_searched;
1088       /*Otherwise we're skipping data.
1089         Forget the end page, if we saw one, as we might miss a later one.*/
1090       else end_gp=-1;
1091       ret=op_seek_helper(_of,bisect);
1092       if(OP_UNLIKELY(ret<0))return ret;
1093       last=op_get_next_page(_of,&og,_sr[nsr-1].offset);
1094       if(OP_UNLIKELY(last<OP_FALSE))return (int)last;
1095       next_bias=0;
1096       if(last==OP_FALSE)end_searched=bisect;
1097       else{
1098         ogg_uint32_t serialno;
1099         ogg_int64_t  gp;
1100         serialno=ogg_page_serialno(&og);
1101         gp=ogg_page_granulepos(&og);
1102         if(!op_lookup_serialno(serialno,serialnos,nserialnos)){
1103           end_searched=bisect;
1104           next=last;
1105           /*In reality we should always have enough room, but be paranoid.*/
1106           if(OP_LIKELY(nsr<_csr)){
1107             _sr[nsr].search_start=bisect;
1108             _sr[nsr].offset=last;
1109             OP_ASSERT(_of->offset-last>=0);
1110             OP_ASSERT(_of->offset-last<=OP_PAGE_SIZE_MAX);
1111             _sr[nsr].size=(opus_int32)(_of->offset-last);
1112             _sr[nsr].serialno=serialno;
1113             _sr[nsr].gp=gp;
1114             nsr++;
1115           }
1116         }
1117         else{
1118           _searched=_of->offset;
1119           next_bias=OP_CHUNK_SIZE;
1120           if(serialno==links[nlinks-1].serialno){
1121             /*This page was from the stream we want, remember it.
1122               If it's the last such page in the link, we won't have to go back
1123                looking for it later.*/
1124             end_gp=gp;
1125             end_offset=last;
1126           }
1127         }
1128       }
1129       bisect=op_predict_link_start(_sr,nsr,_searched,end_searched,next_bias);
1130     }
1131     /*Bisection point found.
1132       Get the final granule position of the previous link, assuming
1133        op_find_initial_pcm_offset() didn't already determine the link was
1134        empty.*/
1135     if(OP_LIKELY(links[nlinks-1].pcm_end==-1)){
1136       if(end_gp==-1){
1137         /*If we don't know where the end page is, we'll have to seek back and
1138            look for it, starting from the end of the link.*/
1139         end_offset=next;
1140         /*Also forget the last page we read.
1141           It won't be available after the seek.*/
1142         last=-1;
1143       }
1144       ret=op_find_final_pcm_offset(_of,serialnos,nserialnos,
1145        links+nlinks-1,end_offset,links[nlinks-1].serialno,end_gp,
1146        &total_duration);
1147       if(OP_UNLIKELY(ret<0))return ret;
1148     }
1149     if(last!=next){
1150       /*The last page we read was not the first page the next link.
1151         Move the cursor position to the offset of that first page.
1152         This only performs an actual seek if the first page of the next link
1153          does not start at the end of the last page from the current Opus
1154          stream with a valid granule position.*/
1155       ret=op_seek_helper(_of,next);
1156       if(OP_UNLIKELY(ret<0))return ret;
1157     }
1158     ret=op_fetch_headers(_of,&links[nlinks].head,&links[nlinks].tags,
1159      _serialnos,_nserialnos,_cserialnos,last!=next?NULL:&og);
1160     if(OP_UNLIKELY(ret<0))return ret;
1161     links[nlinks].offset=next;
1162     links[nlinks].data_offset=_of->offset;
1163     links[nlinks].serialno=_of->os.serialno;
1164     links[nlinks].pcm_end=-1;
1165     /*This might consume a page from the next link, however the next bisection
1166        always starts with a seek.*/
1167     ret=op_find_initial_pcm_offset(_of,links+nlinks,NULL);
1168     if(OP_UNLIKELY(ret<0))return ret;
1169     _searched=_of->offset;
1170     /*Mark the current link count so it can be cleaned up on error.*/
1171     _of->nlinks=++nlinks;
1172   }
1173   /*Last page is in the starting serialno list, so we've reached the last link.
1174     Now find the last granule position for it (if we didn't the first time we
1175      looked at the end of the stream, and if op_find_initial_pcm_offset()
1176      didn't already determine the link was empty).*/
1177   if(OP_LIKELY(links[nlinks-1].pcm_end==-1)){
1178     ret=op_find_final_pcm_offset(_of,serialnos,nserialnos,
1179      links+nlinks-1,_sr[0].offset,_sr[0].serialno,_sr[0].gp,&total_duration);
1180     if(OP_UNLIKELY(ret<0))return ret;
1181   }
1182   /*Trim back the links array if necessary.*/
1183   links=_ogg_realloc(links,sizeof(*links)*nlinks);
1184   if(OP_LIKELY(links!=NULL))_of->links=links;
1185   /*We also don't need these anymore.*/
1186   _ogg_free(*_serialnos);
1187   *_serialnos=NULL;
1188   *_cserialnos=*_nserialnos=0;
1189   return 0;
1190 }
1191
1192 static int op_make_decode_ready(OggOpusFile *_of){
1193   OpusHead *head;
1194   int       li;
1195   int       stream_count;
1196   int       coupled_count;
1197   int       channel_count;
1198   if(_of->ready_state>OP_STREAMSET)return 0;
1199   if(OP_UNLIKELY(_of->ready_state<OP_STREAMSET))return OP_EFAULT;
1200   li=_of->seekable?_of->cur_link:0;
1201   head=&_of->links[li].head;
1202   stream_count=head->stream_count;
1203   coupled_count=head->coupled_count;
1204   channel_count=head->channel_count;
1205   /*Check to see if the current decoder is compatible with the current link.*/
1206   if(_of->od!=NULL&&_of->od_stream_count==stream_count
1207    &&_of->od_coupled_count==coupled_count&&_of->od_channel_count==channel_count
1208    &&memcmp(_of->od_mapping,head->mapping,
1209    sizeof(*head->mapping)*channel_count)==0){
1210     opus_multistream_decoder_ctl(_of->od,OPUS_RESET_STATE);
1211   }
1212   else{
1213     int err;
1214     opus_multistream_decoder_destroy(_of->od);
1215     _of->od=opus_multistream_decoder_create(48000,channel_count,
1216      stream_count,coupled_count,head->mapping,&err);
1217     if(_of->od==NULL)return OP_EFAULT;
1218     _of->od_stream_count=stream_count;
1219     _of->od_coupled_count=coupled_count;
1220     _of->od_channel_count=channel_count;
1221     memcpy(_of->od_mapping,head->mapping,sizeof(*head->mapping)*channel_count);
1222   }
1223 #if defined(OPUS_SET_GAIN)
1224   opus_multistream_decoder_ctl(_of->od,OPUS_SET_GAIN(head->output_gain));
1225 #else
1226 /*A fallback that works with both float and fixed-point is a bunch of work,
1227    so just force people to use a sufficiently new version.
1228   This is deployed well enough at this point that this shouldn't be a burden.*/
1229 # error "libopus 1.0.1 or later required"
1230 #endif
1231   _of->ready_state=OP_INITSET;
1232   _of->bytes_tracked=0;
1233   _of->samples_tracked=0;
1234 #if !defined(OP_FIXED_POINT)
1235   _of->dither_mute=65;
1236   /*Use the serial number for the PRNG seed to get repeatable output for
1237      straight play-throughs.*/
1238   _of->dither_seed=_of->links[li].serialno;
1239 #endif
1240   return 0;
1241 }
1242
1243 static int op_open_seekable2_impl(OggOpusFile *_of){
1244   /*64 seek records should be enough for anybody.
1245     Actually, with a bisection search in a 63-bit range down to OP_CHUNK_SIZE
1246      granularity, much more than enough.*/
1247   OpusSeekRecord sr[64];
1248   opus_int64     data_offset;
1249   int            ret;
1250   /*We can seek, so set out learning all about this file.*/
1251   (*_of->callbacks.seek)(_of->source,0,SEEK_END);
1252   _of->offset=_of->end=(*_of->callbacks.tell)(_of->source);
1253   if(OP_UNLIKELY(_of->end<0))return OP_EREAD;
1254   data_offset=_of->links[0].data_offset;
1255   if(OP_UNLIKELY(_of->end<data_offset))return OP_EBADLINK;
1256   /*Get the offset of the last page of the physical bitstream, or, if we're
1257      lucky, the last Opus page of the first link, as most Ogg Opus files will
1258      contain a single logical bitstream.*/
1259   ret=op_get_prev_page_serial(_of,sr,NULL,_of->end,
1260    _of->links[0].serialno,_of->serialnos,_of->nserialnos);
1261   if(OP_UNLIKELY(ret<0))return ret;
1262   /*If there's any trailing junk, forget about it.*/
1263   _of->end=sr[0].offset+sr[0].size;
1264   if(OP_UNLIKELY(_of->end<data_offset))return OP_EBADLINK;
1265   /*Now enumerate the bitstream structure.*/
1266   return op_bisect_forward_serialno(_of,data_offset,sr,sizeof(sr)/sizeof(*sr),
1267    &_of->serialnos,&_of->nserialnos,&_of->cserialnos);
1268 }
1269
1270 static int op_open_seekable2(OggOpusFile *_of){
1271   ogg_sync_state    oy_start;
1272   ogg_stream_state  os_start;
1273   ogg_packet       *op_start;
1274   opus_int64        start_offset;
1275   int               start_op_count;
1276   int               ret;
1277   /*We're partially open and have a first link header state in storage in _of.
1278     Save off that stream state so we can come back to it.*/
1279   start_op_count=_of->op_count;
1280   /*This is a bit too large to put on the stack unconditionally.*/
1281   op_start=(ogg_packet *)_ogg_malloc(sizeof(*op_start)*start_op_count);
1282   if(op_start==NULL)return OP_EFAULT;
1283   *&oy_start=_of->oy;
1284   *&os_start=_of->os;
1285   start_offset=_of->offset;
1286   memcpy(op_start,_of->op,sizeof(*op_start)*start_op_count);
1287   OP_ASSERT((*_of->callbacks.tell)(_of->source)==op_position(_of));
1288   ogg_sync_init(&_of->oy);
1289   ogg_stream_init(&_of->os,-1);
1290   ret=op_open_seekable2_impl(_of);
1291   /*Restore the old stream state.*/
1292   ogg_stream_clear(&_of->os);
1293   ogg_sync_clear(&_of->oy);
1294   *&_of->oy=*&oy_start;
1295   *&_of->os=*&os_start;
1296   _of->offset=start_offset;
1297   _of->op_count=start_op_count;
1298   memcpy(_of->op,op_start,sizeof(*_of->op)*start_op_count);
1299   _ogg_free(op_start);
1300   _of->prev_packet_gp=_of->links[0].pcm_start;
1301   _of->cur_discard_count=_of->links[0].head.pre_skip;
1302   if(OP_UNLIKELY(ret<0))return ret;
1303   /*And restore the position indicator.*/
1304   ret=(*_of->callbacks.seek)(_of->source,op_position(_of),SEEK_SET);
1305   return OP_UNLIKELY(ret<0)?OP_EREAD:0;
1306 }
1307
1308 /*Clear out the current logical bitstream decoder.*/
1309 static void op_decode_clear(OggOpusFile *_of){
1310   /*We don't actually free the decoder.
1311     We might be able to re-use it for the next link.*/
1312   _of->op_count=0;
1313   _of->od_buffer_size=0;
1314   _of->prev_packet_gp=-1;
1315   if(!_of->seekable){
1316     OP_ASSERT(_of->ready_state>=OP_INITSET);
1317     opus_tags_clear(&_of->links[0].tags);
1318   }
1319   _of->ready_state=OP_OPENED;
1320 }
1321
1322 static void op_clear(OggOpusFile *_of){
1323   OggOpusLink *links;
1324   _ogg_free(_of->od_buffer);
1325   if(_of->od!=NULL)opus_multistream_decoder_destroy(_of->od);
1326   links=_of->links;
1327   if(!_of->seekable){
1328     if(_of->ready_state>OP_OPENED||_of->ready_state==OP_PARTOPEN){
1329       opus_tags_clear(&links[0].tags);
1330     }
1331   }
1332   else if(OP_LIKELY(links!=NULL)){
1333     int nlinks;
1334     int link;
1335     nlinks=_of->nlinks;
1336     for(link=0;link<nlinks;link++)opus_tags_clear(&links[link].tags);
1337   }
1338   _ogg_free(links);
1339   _ogg_free(_of->serialnos);
1340   ogg_stream_clear(&_of->os);
1341   ogg_sync_clear(&_of->oy);
1342   if(_of->callbacks.close!=NULL)(*_of->callbacks.close)(_of->source);
1343 }
1344
1345 static int op_open1(OggOpusFile *_of,
1346  void *_source,const OpusFileCallbacks *_cb,
1347  const unsigned char *_initial_data,size_t _initial_bytes){
1348   ogg_page  og;
1349   ogg_page *pog;
1350   int       seekable;
1351   int       ret;
1352   memset(_of,0,sizeof(*_of));
1353   _of->end=-1;
1354   _of->source=_source;
1355   *&_of->callbacks=*_cb;
1356   /*At a minimum, we need to be able to read data.*/
1357   if(OP_UNLIKELY(_of->callbacks.read==NULL))return OP_EREAD;
1358   /*Initialize the framing state.*/
1359   ogg_sync_init(&_of->oy);
1360   /*Perhaps some data was previously read into a buffer for testing against
1361      other stream types.
1362     Allow initialization from this previously read data (especially as we may
1363      be reading from a non-seekable stream).
1364     This requires copying it into a buffer allocated by ogg_sync_buffer() and
1365      doesn't support seeking, so this is not a good mechanism to use for
1366      decoding entire files from RAM.*/
1367   if(_initial_bytes>0){
1368     char *buffer;
1369     buffer=ogg_sync_buffer(&_of->oy,_initial_bytes);
1370     memcpy(buffer,_initial_data,_initial_bytes*sizeof(*buffer));
1371     ogg_sync_wrote(&_of->oy,_initial_bytes);
1372   }
1373   /*Can we seek?
1374     Stevens suggests the seek test is portable.*/
1375   seekable=_cb->seek!=NULL&&(*_cb->seek)(_source,0,SEEK_CUR)!=-1;
1376   /*If seek is implemented, tell must also be implemented.*/
1377   if(seekable){
1378     if(OP_UNLIKELY(_of->callbacks.tell==NULL))return OP_EINVAL;
1379     else{
1380       opus_int64 pos;
1381       pos=(*_of->callbacks.tell)(_of->source);
1382       /*If the current position is not equal to the initial bytes consumed,
1383          absolute seeking will not work.*/
1384       if(OP_UNLIKELY(pos!=(opus_int64)_initial_bytes))return OP_EINVAL;
1385     }
1386   }
1387   _of->seekable=seekable;
1388   /*Don't seek yet.
1389     Set up a 'single' (current) logical bitstream entry for partial open.*/
1390   _of->links=(OggOpusLink *)_ogg_malloc(sizeof(*_of->links));
1391   /*The serialno gets filled in later by op_fetch_headers().*/
1392   ogg_stream_init(&_of->os,-1);
1393   pog=NULL;
1394   for(;;){
1395     /*Fetch all BOS pages, store the Opus header and all seen serial numbers,
1396       and load subsequent Opus setup headers.*/
1397     ret=op_fetch_headers(_of,&_of->links[0].head,&_of->links[0].tags,
1398      &_of->serialnos,&_of->nserialnos,&_of->cserialnos,pog);
1399     if(OP_UNLIKELY(ret<0))break;
1400     _of->nlinks=1;
1401     _of->links[0].offset=0;
1402     _of->links[0].data_offset=_of->offset;
1403     _of->links[0].pcm_end=-1;
1404     _of->links[0].serialno=_of->os.serialno;
1405     /*Fetch the initial PCM offset.*/
1406     ret=op_find_initial_pcm_offset(_of,_of->links,&og);
1407     if(seekable||OP_LIKELY(ret<=0))break;
1408     /*This link was empty, but we already have the BOS page for the next one in
1409        og.
1410       We can't seek, so start processing the next link right now.*/
1411     opus_tags_clear(&_of->links[0].tags);
1412     _of->nlinks=0;
1413     if(!seekable)_of->cur_link++;
1414     pog=&og;
1415   }
1416   if(OP_UNLIKELY(ret<0)){
1417     /*Don't auto-close the stream on failure.*/
1418     _of->callbacks.close=NULL;
1419     op_clear(_of);
1420   }
1421   else _of->ready_state=OP_PARTOPEN;
1422   return ret;
1423 }
1424
1425 static int op_open2(OggOpusFile *_of){
1426   int ret;
1427   OP_ASSERT(_of->ready_state==OP_PARTOPEN);
1428   if(_of->seekable){
1429     _of->ready_state=OP_OPENED;
1430     ret=op_open_seekable2(_of);
1431   }
1432   else ret=0;
1433   if(OP_LIKELY(ret>=0)){
1434     /*We have buffered packets from op_find_initial_pcm_offset().
1435       Move to OP_INITSET so we can use them.*/
1436     _of->ready_state=OP_STREAMSET;
1437     ret=op_make_decode_ready(_of);
1438     if(OP_LIKELY(ret>=0))return 0;
1439   }
1440   /*Don't auto-close the stream on failure.*/
1441   _of->callbacks.close=NULL;
1442   op_clear(_of);
1443   return ret;
1444 }
1445
1446 OggOpusFile *op_test_callbacks(void *_source,const OpusFileCallbacks *_cb,
1447  const unsigned char *_initial_data,size_t _initial_bytes,int *_error){
1448   OggOpusFile *of;
1449   int          ret;
1450   of=(OggOpusFile *)_ogg_malloc(sizeof(*of));
1451   ret=OP_EFAULT;
1452   if(OP_LIKELY(of!=NULL)){
1453     ret=op_open1(of,_source,_cb,_initial_data,_initial_bytes);
1454     if(OP_LIKELY(ret>=0)){
1455       if(_error!=NULL)*_error=0;
1456       return of;
1457     }
1458     _ogg_free(of);
1459   }
1460   if(_error!=NULL)*_error=ret;
1461   return NULL;
1462 }
1463
1464 OggOpusFile *op_open_callbacks(void *_source,const OpusFileCallbacks *_cb,
1465  const unsigned char *_initial_data,size_t _initial_bytes,int *_error){
1466   OggOpusFile *of;
1467   of=op_test_callbacks(_source,_cb,_initial_data,_initial_bytes,_error);
1468   if(OP_LIKELY(of!=NULL)){
1469     int ret;
1470     ret=op_open2(of);
1471     if(OP_LIKELY(ret>=0))return of;
1472     if(_error!=NULL)*_error=ret;
1473     _ogg_free(of);
1474   }
1475   return NULL;
1476 }
1477
1478 /*Convenience routine to clean up from failure for the open functions that
1479    create their own streams.*/
1480 static OggOpusFile *op_open_close_on_failure(void *_source,
1481  const OpusFileCallbacks *_cb,int *_error){
1482   OggOpusFile *of;
1483   if(OP_UNLIKELY(_source==NULL)){
1484     if(_error!=NULL)*_error=OP_EFAULT;
1485     return NULL;
1486   }
1487   of=op_open_callbacks(_source,_cb,NULL,0,_error);
1488   if(OP_UNLIKELY(of==NULL))(*_cb->close)(_source);
1489   return of;
1490 }
1491
1492 OggOpusFile *op_open_file(const char *_path,int *_error){
1493   OpusFileCallbacks cb;
1494   return op_open_close_on_failure(op_fopen(&cb,_path,"rb"),&cb,_error);
1495 }
1496
1497 OggOpusFile *op_open_memory(const unsigned char *_data,size_t _size,
1498  int *_error){
1499   OpusFileCallbacks cb;
1500   return op_open_close_on_failure(op_mem_stream_create(&cb,_data,_size),&cb,
1501    _error);
1502 }
1503
1504 OggOpusFile *op_vopen_url(const char *_url,int *_error,va_list _ap){
1505   OpusFileCallbacks cb;
1506   return op_open_close_on_failure(op_url_stream_vcreate(&cb,_url,_ap),&cb,
1507    _error);
1508 }
1509
1510 OggOpusFile *op_open_url(const char *_url,int *_error,...){
1511   va_list ap;
1512   va_start(ap,_error);
1513   return op_vopen_url(_url,_error,ap);
1514 }
1515
1516 /*Convenience routine to clean up from failure for the open functions that
1517    create their own streams.*/
1518 static OggOpusFile *op_test_close_on_failure(void *_source,
1519  const OpusFileCallbacks *_cb,int *_error){
1520   OggOpusFile *of;
1521   if(OP_UNLIKELY(_source==NULL)){
1522     if(_error!=NULL)*_error=OP_EFAULT;
1523     return NULL;
1524   }
1525   of=op_test_callbacks(_source,_cb,NULL,0,_error);
1526   if(OP_UNLIKELY(of==NULL))(*_cb->close)(_source);
1527   return of;
1528 }
1529
1530 OggOpusFile *op_test_file(const char *_path,int *_error){
1531   OpusFileCallbacks cb;
1532   return op_test_close_on_failure(op_fopen(&cb,_path,"rb"),&cb,_error);
1533 }
1534
1535 OggOpusFile *op_test_memory(const unsigned char *_data,size_t _size,
1536  int *_error){
1537   OpusFileCallbacks cb;
1538   return op_test_close_on_failure(op_mem_stream_create(&cb,_data,_size),&cb,
1539    _error);
1540 }
1541
1542 OggOpusFile *op_vtest_url(const char *_url,int *_error,va_list _ap){
1543   OpusFileCallbacks cb;
1544   return op_test_close_on_failure(op_url_stream_vcreate(&cb,_url,_ap),&cb,
1545    _error);
1546 }
1547
1548 OggOpusFile *op_test_url(const char *_url,int *_error,...){
1549   va_list ap;
1550   va_start(ap,_error);
1551   return op_vtest_url(_url,_error,ap);
1552 }
1553
1554 int op_test_open(OggOpusFile *_of){
1555   int ret;
1556   if(OP_UNLIKELY(_of->ready_state!=OP_PARTOPEN))return OP_EINVAL;
1557   ret=op_open2(_of);
1558   /*op_open2() will clear this structure on failure.
1559     Reset its contents to prevent double-frees in op_free().*/
1560   if(OP_UNLIKELY(ret<0))memset(_of,0,sizeof(*_of));
1561   return ret;
1562 }
1563
1564 void op_free(OggOpusFile *_of){
1565   if(OP_LIKELY(_of!=NULL)){
1566     op_clear(_of);
1567     _ogg_free(_of);
1568   }
1569 }
1570
1571 int op_seekable(OggOpusFile *_of){
1572   return _of->seekable;
1573 }
1574
1575 int op_link_count(OggOpusFile *_of){
1576   return _of->nlinks;
1577 }
1578
1579 ogg_uint32_t op_serialno(OggOpusFile *_of,int _li){
1580   if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
1581   if(!_of->seekable)_li=0;
1582   return _of->links[_li<0?_of->cur_link:_li].serialno;
1583 }
1584
1585 int op_channel_count(OggOpusFile *_of,int _li){
1586   return op_head(_of,_li)->channel_count;
1587 }
1588
1589 opus_int64 op_raw_total(OggOpusFile *_of,int _li){
1590   if(OP_UNLIKELY(_of->ready_state<OP_OPENED)
1591    ||OP_UNLIKELY(!_of->seekable)
1592    ||OP_UNLIKELY(_li>=_of->nlinks)){
1593     return OP_EINVAL;
1594   }
1595   if(_li<0)return _of->end-_of->links[0].offset;
1596   return (_li+1>=_of->nlinks?_of->end:_of->links[_li+1].offset)
1597    -_of->links[_li].offset;
1598 }
1599
1600 ogg_int64_t op_pcm_total(OggOpusFile *_of,int _li){
1601   OggOpusLink *links;
1602   ogg_int64_t  diff;
1603   int          ret;
1604   int          nlinks;
1605   nlinks=_of->nlinks;
1606   if(OP_UNLIKELY(_of->ready_state<OP_OPENED)
1607    ||OP_UNLIKELY(!_of->seekable)
1608    ||OP_UNLIKELY(_li>=nlinks)){
1609     return OP_EINVAL;
1610   }
1611   links=_of->links;
1612   /*We verify that the granule position differences are larger than the
1613      pre-skip and that the total duration does not overflow during link
1614      enumeration, so we don't have to check here.*/
1615   if(_li<0){
1616     ogg_int64_t pcm_total;
1617     int         li;
1618     pcm_total=0;
1619     for(li=0;li<nlinks;li++){
1620       ret=op_granpos_diff(&diff,links[li].pcm_end,links[li].pcm_start);
1621       OP_ASSERT(!ret);
1622       pcm_total+=diff-links[li].head.pre_skip;
1623     }
1624     return pcm_total;
1625   }
1626   ret=op_granpos_diff(&diff,links[_li].pcm_end,links[_li].pcm_start);
1627   OP_ASSERT(!ret);
1628   return diff-links[_li].head.pre_skip;
1629 }
1630
1631 const OpusHead *op_head(OggOpusFile *_of,int _li){
1632   if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
1633   if(!_of->seekable)_li=0;
1634   return &_of->links[_li<0?_of->cur_link:_li].head;
1635 }
1636
1637 const OpusTags *op_tags(OggOpusFile *_of,int _li){
1638   if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
1639   if(!_of->seekable){
1640     if(_of->ready_state<OP_STREAMSET&&_of->ready_state!=OP_PARTOPEN){
1641       return NULL;
1642     }
1643     _li=0;
1644   }
1645   else if(_li<0)_li=_of->ready_state>=OP_STREAMSET?_of->cur_link:0;
1646   return &_of->links[_li].tags;
1647 }
1648
1649 int op_current_link(OggOpusFile *_of){
1650   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
1651   return _of->cur_link;
1652 }
1653
1654 /*Compute an average bitrate given a byte and sample count.
1655   Return: The bitrate in bits per second.*/
1656 static opus_int32 op_calc_bitrate(opus_int64 _bytes,ogg_int64_t _samples){
1657   /*These rates are absurd, but let's handle them anyway.*/
1658   if(OP_UNLIKELY(_bytes>(OP_INT64_MAX-(_samples>>1))/(48000*8))){
1659     ogg_int64_t den;
1660     if(OP_UNLIKELY(_bytes/(0x7FFFFFFFF/(48000*8))>=_samples))return 0x7FFFFFFF;
1661     den=_samples/(48000*8);
1662     return (opus_int32)((_bytes+(den>>1))/den);
1663   }
1664   if(OP_UNLIKELY(_samples<=0))return 0x7FFFFFFF;
1665   /*This can't actually overflow in normal operation: even with a pre-skip of
1666      545 2.5 ms frames with 8 streams running at 1282*8+1 bytes per packet
1667      (1275 byte frames + Opus framing overhead + Ogg lacing values), that all
1668      produce a single sample of decoded output, we still don't top 45 Mbps.
1669     The only way to get bitrates larger than that is with excessive Opus
1670      padding, more encoded streams than output channels, or lots and lots of
1671      Ogg pages with no packets on them.*/
1672   return (opus_int32)OP_MIN((_bytes*48000*8+(_samples>>1))/_samples,0x7FFFFFFF);
1673 }
1674
1675 opus_int32 op_bitrate(OggOpusFile *_of,int _li){
1676   if(OP_UNLIKELY(_of->ready_state<OP_OPENED)||OP_UNLIKELY(!_of->seekable)
1677    ||OP_UNLIKELY(_li>=_of->nlinks)){
1678     return OP_EINVAL;
1679   }
1680   return op_calc_bitrate(op_raw_total(_of,_li),op_pcm_total(_of,_li));
1681 }
1682
1683 opus_int32 op_bitrate_instant(OggOpusFile *_of){
1684   ogg_int64_t samples_tracked;
1685   opus_int32  ret;
1686   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
1687   samples_tracked=_of->samples_tracked;
1688   if(OP_UNLIKELY(samples_tracked==0))return OP_FALSE;
1689   ret=op_calc_bitrate(_of->bytes_tracked,samples_tracked);
1690   _of->bytes_tracked=0;
1691   _of->samples_tracked=0;
1692   return ret;
1693 }
1694
1695 /*Fetch and process a page.
1696   This handles the case where we're at a bitstream boundary and dumps the
1697    decoding machine.
1698   If the decoding machine is unloaded, it loads it.
1699   It also keeps prev_packet_gp up to date (seek and read both use this; seek
1700    uses a special hack with _readp).
1701   Return: <0) Error, OP_HOLE (lost packet), or OP_EOF.
1702            0) Need more data (only if _readp==0).
1703            1) Got at least one audio data packet.*/
1704 static int op_fetch_and_process_page(OggOpusFile *_of,
1705  ogg_page *_og,opus_int64 _page_pos,int _readp,int _spanp,int _ignore_holes){
1706   OggOpusLink  *links;
1707   ogg_uint32_t  cur_serialno;
1708   int           seekable;
1709   int           cur_link;
1710   int           ret;
1711   if(OP_LIKELY(_of->ready_state>=OP_INITSET)
1712    &&OP_LIKELY(_of->op_pos<_of->op_count)){
1713     /*We're ready to decode and have at least one packet available already.*/
1714     return 1;
1715   }
1716   if(!_readp)return 0;
1717   seekable=_of->seekable;
1718   links=_of->links;
1719   cur_link=seekable?_of->cur_link:0;
1720   cur_serialno=links[cur_link].serialno;
1721   /*Handle one page.*/
1722   for(;;){
1723     ogg_page og;
1724     OP_ASSERT(_of->ready_state>=OP_OPENED);
1725     /*This loop is not strictly necessary, but there's no sense in doing the
1726        extra checks of the larger loop for the common case in a multiplexed
1727        bistream where the page is simply part of a different logical
1728        bitstream.*/
1729     do{
1730       /*If we were given a page to use, use it.*/
1731       if(_og!=NULL){
1732         *&og=*_og;
1733         _og=NULL;
1734       }
1735       /*Keep reading until we get a page with the correct serialno.*/
1736       else _page_pos=op_get_next_page(_of,&og,_of->end);
1737       /*EOF: Leave uninitialized.*/
1738       if(_page_pos<0)return _page_pos<OP_FALSE?(int)_page_pos:OP_EOF;
1739       if(OP_LIKELY(_of->ready_state>=OP_STREAMSET)){
1740         if(cur_serialno!=(ogg_uint32_t)ogg_page_serialno(&og)){
1741           /*Two possibilities:
1742              1) Another stream is multiplexed into this logical section, or*/
1743           if(OP_LIKELY(!ogg_page_bos(&og)))continue;
1744           /* 2) Our decoding just traversed a bitstream boundary.*/
1745           if(!_spanp)return OP_EOF;
1746           if(OP_LIKELY(_of->ready_state>=OP_INITSET))op_decode_clear(_of);
1747           break;
1748         }
1749       }
1750       /*Bitrate tracking: add the header's bytes here.
1751         The body bytes are counted when we consume the packets.*/
1752       _of->bytes_tracked+=og.header_len;
1753     }
1754     while(0);
1755     /*Do we need to load a new machine before submitting the page?
1756       This is different in the seekable and non-seekable cases.
1757       In the seekable case, we already have all the header information loaded
1758        and cached.
1759       We just initialize the machine with it and continue on our merry way.
1760       In the non-seekable (streaming) case, we'll only be at a boundary if we
1761        just left the previous logical bitstream, and we're now nominally at the
1762        header of the next bitstream.*/
1763     if(OP_UNLIKELY(_of->ready_state<OP_STREAMSET)){
1764       if(seekable){
1765         ogg_uint32_t serialno;
1766         int          nlinks;
1767         int          li;
1768         serialno=ogg_page_serialno(&og);
1769         /*Match the serialno to bitstream section.
1770           We use this rather than offset positions to avoid problems near
1771            logical bitstream boundaries.*/
1772         nlinks=_of->nlinks;
1773         for(li=0;li<nlinks&&links[li].serialno!=serialno;li++);
1774         /*Not a desired Opus bitstream section.
1775           Keep trying.*/
1776         if(li>=nlinks)continue;
1777         cur_serialno=serialno;
1778         _of->cur_link=cur_link=li;
1779         ogg_stream_reset_serialno(&_of->os,serialno);
1780         _of->ready_state=OP_STREAMSET;
1781         /*If we're at the start of this link, initialize the granule position
1782            and pre-skip tracking.*/
1783         if(_page_pos<=links[cur_link].data_offset){
1784           _of->prev_packet_gp=links[cur_link].pcm_start;
1785           _of->cur_discard_count=links[cur_link].head.pre_skip;
1786           /*Ignore a hole at the start of a new link (this is common for
1787              streams joined in the middle) or after seeking.*/
1788           _ignore_holes=1;
1789         }
1790       }
1791       else{
1792         do{
1793           /*We're streaming.
1794             Fetch the two header packets, build the info struct.*/
1795           ret=op_fetch_headers(_of,&links[0].head,&links[0].tags,
1796            NULL,NULL,NULL,&og);
1797           if(OP_UNLIKELY(ret<0))return ret;
1798           /*op_find_initial_pcm_offset() will suppress any initial hole for us,
1799              so no need to set _ignore_holes.*/
1800           ret=op_find_initial_pcm_offset(_of,links,&og);
1801           if(OP_UNLIKELY(ret<0))return ret;
1802           _of->links[0].serialno=cur_serialno=_of->os.serialno;
1803           _of->cur_link++;
1804         }
1805         /*If the link was empty, keep going, because we already have the
1806            BOS page of the next one in og.*/
1807         while(OP_UNLIKELY(ret>0));
1808         /*If we didn't get any packets out of op_find_initial_pcm_offset(),
1809            keep going (this is possible if end-trimming trimmed them all).*/
1810         if(_of->op_count<=0)continue;
1811         /*Otherwise, we're done.*/
1812         ret=op_make_decode_ready(_of);
1813         if(OP_UNLIKELY(ret<0))return ret;
1814         return 1;
1815       }
1816     }
1817     /*The buffered page is the data we want, and we're ready for it.
1818       Add it to the stream state.*/
1819     if(OP_UNLIKELY(_of->ready_state==OP_STREAMSET)){
1820       ret=op_make_decode_ready(_of);
1821       if(OP_UNLIKELY(ret<0))return ret;
1822     }
1823     /*Extract all the packets from the current page.*/
1824     ogg_stream_pagein(&_of->os,&og);
1825     if(OP_LIKELY(_of->ready_state>=OP_INITSET)){
1826       opus_int32 total_duration;
1827       int        durations[255];
1828       int        op_count;
1829       total_duration=op_collect_audio_packets(_of,durations);
1830       if(OP_UNLIKELY(total_duration<0)){
1831         /*Drain the packets from the page anyway.*/
1832         total_duration=op_collect_audio_packets(_of,durations);
1833         OP_ASSERT(total_duration>=0);
1834         /*Report holes to the caller.*/
1835         if(!_ignore_holes)return OP_HOLE;
1836       }
1837       op_count=_of->op_count;
1838       /*If we found at least one audio data packet, compute per-packet granule
1839          positions for them.*/
1840       if(op_count>0){
1841         ogg_int64_t diff;
1842         ogg_int64_t prev_packet_gp;
1843         ogg_int64_t cur_packet_gp;
1844         ogg_int64_t cur_page_gp;
1845         int         cur_page_eos;
1846         int         pi;
1847         cur_page_gp=_of->op[op_count-1].granulepos;
1848         cur_page_eos=_of->op[op_count-1].e_o_s;
1849         prev_packet_gp=_of->prev_packet_gp;
1850         if(OP_UNLIKELY(prev_packet_gp==-1)){
1851           opus_int32 cur_discard_count;
1852           /*This is the first call after a raw seek.
1853             Try to reconstruct prev_packet_gp from scratch.*/
1854           OP_ASSERT(seekable);
1855           if(OP_UNLIKELY(cur_page_eos)){
1856             /*If the first page we hit after our seek was the EOS page, and
1857                we didn't start from data_offset or before, we don't have
1858                enough information to do end-trimming.
1859               Proceed to the next link, rather than risk playing back some
1860                samples that shouldn't have been played.*/
1861             _of->op_count=0;
1862             continue;
1863           }
1864           /*By default discard 80 ms of data after a seek, unless we seek
1865              into the pre-skip region.*/
1866           cur_discard_count=80*48;
1867           cur_page_gp=_of->op[op_count-1].granulepos;
1868           /*Try to initialize prev_packet_gp.
1869             If the current page had packets but didn't have a granule
1870              position, or the granule position it had was too small (both
1871              illegal), just use the starting granule position for the link.*/
1872           prev_packet_gp=links[cur_link].pcm_start;
1873           if(OP_LIKELY(cur_page_gp!=-1)){
1874             op_granpos_add(&prev_packet_gp,cur_page_gp,-total_duration);
1875           }
1876           if(OP_LIKELY(!op_granpos_diff(&diff,
1877            prev_packet_gp,links[cur_link].pcm_start))){
1878             opus_int32 pre_skip;
1879             /*If we start at the beginning of the pre-skip region, or we're
1880                at least 80 ms from the end of the pre-skip region, we discard
1881                to the end of the pre-skip region.
1882               Otherwise, we still use the 80 ms default, which will discard
1883                past the end of the pre-skip region.*/
1884             pre_skip=links[cur_link].head.pre_skip;
1885             if(diff>=0&&diff<=OP_MAX(0,pre_skip-80*48)){
1886               cur_discard_count=pre_skip-(int)diff;
1887             }
1888           }
1889           _of->cur_discard_count=cur_discard_count;
1890         }
1891         if(OP_UNLIKELY(cur_page_gp==-1)){
1892           /*This page had completed packets but didn't have a valid granule
1893              position.
1894             This is illegal, but we'll try to handle it by continuing to count
1895              forwards from the previous page.*/
1896           if(op_granpos_add(&cur_page_gp,prev_packet_gp,total_duration)<0){
1897             /*The timestamp for this page overflowed.*/
1898             cur_page_gp=links[cur_link].pcm_end;
1899           }
1900         }
1901         /*If we hit the last page, handle end-trimming.*/
1902         if(OP_UNLIKELY(cur_page_eos)
1903          &&OP_LIKELY(!op_granpos_diff(&diff,cur_page_gp,prev_packet_gp))
1904          &&OP_LIKELY(diff<total_duration)){
1905           cur_packet_gp=prev_packet_gp;
1906           for(pi=0;pi<op_count;pi++){
1907             diff=durations[pi]-diff;
1908             /*If we have samples to trim...*/
1909             if(diff>0){
1910               /*If we trimmed the entire packet, stop (the spec says encoders
1911                  shouldn't do this, but we support it anyway).*/
1912               if(OP_UNLIKELY(diff>durations[pi]))break;
1913               cur_packet_gp=cur_page_gp;
1914               /*Move the EOS flag to this packet, if necessary, so we'll trim
1915                  the samples during decode.*/
1916               _of->op[pi].e_o_s=1;
1917             }
1918             else{
1919               /*Update the granule position as normal.*/
1920               ret=op_granpos_add(&cur_packet_gp,cur_packet_gp,durations[pi]);
1921               OP_ASSERT(!ret);
1922             }
1923             _of->op[pi].granulepos=cur_packet_gp;
1924             ret=op_granpos_diff(&diff,cur_page_gp,cur_packet_gp);
1925             OP_ASSERT(!ret);
1926           }
1927         }
1928         else{
1929           /*Propagate timestamps to earlier packets.
1930             op_granpos_add(&prev_packet_gp,prev_packet_gp,total_duration)
1931              should succeed and give prev_packet_gp==cur_page_gp.
1932             But we don't bother to check that, as there isn't much we can do
1933              if it's not true.
1934             The only thing we guarantee is that the start and end granule
1935              positions of the packets are valid, and that they are monotonic
1936              within a page.
1937             They might be completely out of range for this link (we'll check
1938              that elsewhere), or non-monotonic between pages.*/
1939           if(OP_UNLIKELY(op_granpos_add(&prev_packet_gp,
1940            cur_page_gp,-total_duration)<0)){
1941             /*The starting timestamp for the first packet on this page
1942                underflowed.
1943               This is illegal, but we ignore it.*/
1944             prev_packet_gp=0;
1945           }
1946           for(pi=0;pi<op_count;pi++){
1947             if(OP_UNLIKELY(op_granpos_add(&cur_packet_gp,
1948              cur_page_gp,-total_duration)<0)){
1949               /*The start timestamp for this packet underflowed.
1950                 This is illegal, but we ignore it.*/
1951               cur_packet_gp=0;
1952             }
1953             total_duration-=durations[pi];
1954             OP_ASSERT(total_duration>=0);
1955             ret=op_granpos_add(&cur_packet_gp,cur_packet_gp,durations[pi]);
1956             OP_ASSERT(!ret);
1957             _of->op[pi].granulepos=cur_packet_gp;
1958           }
1959           OP_ASSERT(total_duration==0);
1960         }
1961         _of->prev_packet_gp=prev_packet_gp;
1962         _of->op_count=pi;
1963         /*If end-trimming didn't trim all the packets, we're done.*/
1964         if(OP_LIKELY(pi>0))return 1;
1965       }
1966     }
1967   }
1968 }
1969
1970 int op_raw_seek(OggOpusFile *_of,opus_int64 _pos){
1971   int          ret;
1972   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
1973   /*Don't dump the decoder state if we can't seek.*/
1974   if(OP_UNLIKELY(!_of->seekable))return OP_ENOSEEK;
1975   if(OP_UNLIKELY(_pos<0)||OP_UNLIKELY(_pos>_of->end))return OP_EINVAL;
1976   /*Clear out any buffered, decoded data.*/
1977   op_decode_clear(_of);
1978   _of->bytes_tracked=0;
1979   _of->samples_tracked=0;
1980   ret=op_seek_helper(_of,_pos);
1981   if(OP_UNLIKELY(ret<0))return OP_EREAD;
1982   ret=op_fetch_and_process_page(_of,NULL,-1,1,1,1);
1983   /*If we hit EOF, op_fetch_and_process_page() leaves us uninitialized.
1984     Instead, jump to the end.*/
1985   if(ret==OP_EOF){
1986     int cur_link;
1987     op_decode_clear(_of);
1988     cur_link=_of->nlinks-1;
1989     _of->cur_link=cur_link;
1990     _of->prev_packet_gp=_of->links[cur_link].pcm_end;
1991     _of->cur_discard_count=0;
1992     ret=0;
1993   }
1994   else if(ret>0)ret=0;
1995   return ret;
1996 }
1997
1998 /*Convert a PCM offset relative to the start of the whole stream to a granule
1999    position in an individual link.*/
2000 static ogg_int64_t op_get_granulepos(const OggOpusFile *_of,
2001  ogg_int64_t _pcm_offset,int *_li){
2002   OggOpusLink *links;
2003   ogg_int64_t  duration;
2004   int          nlinks;
2005   int          li;
2006   int          ret;
2007   OP_ASSERT(_pcm_offset>=0);
2008   nlinks=_of->nlinks;
2009   links=_of->links;
2010   for(li=0;OP_LIKELY(li<nlinks);li++){
2011     ogg_int64_t pcm_start;
2012     opus_int32  pre_skip;
2013     pcm_start=links[li].pcm_start;
2014     pre_skip=links[li].head.pre_skip;
2015     ret=op_granpos_diff(&duration,links[li].pcm_end,pcm_start);
2016     OP_ASSERT(!ret);
2017     duration-=pre_skip;
2018     if(_pcm_offset<duration){
2019       _pcm_offset+=pre_skip;
2020       if(OP_UNLIKELY(pcm_start>OP_INT64_MAX-_pcm_offset)){
2021         /*Adding this amount to the granule position would overflow the positive
2022            half of its 64-bit range.
2023           Since signed overflow is undefined in C, do it in a way the compiler
2024            isn't allowed to screw up.*/
2025         _pcm_offset-=OP_INT64_MAX-pcm_start+1;
2026         pcm_start=OP_INT64_MIN;
2027       }
2028       pcm_start+=_pcm_offset;
2029       *_li=li;
2030       return pcm_start;
2031     }
2032     _pcm_offset-=duration;
2033   }
2034   return -1;
2035 }
2036
2037 /*This controls how close the target has to be to use the current stream
2038    position to subdivide the initial range.
2039   Two minutes seems to be a good default.*/
2040 #define OP_CUR_TIME_THRESH (120*48*(opus_int32)1000)
2041
2042 /*Search within link _li for the page with the highest granule position
2043    preceding (or equal to) _target_gp.
2044   There is a danger here: missing pages or incorrect frame number information
2045    in the bitstream could make our task impossible.
2046   Account for that (and report it as an error condition).*/
2047 static int op_pcm_seek_page(OggOpusFile *_of,
2048  ogg_int64_t _target_gp,int _li){
2049   OggOpusLink  *link;
2050   ogg_page      og;
2051   ogg_int64_t   pcm_pre_skip;
2052   ogg_int64_t   pcm_start;
2053   ogg_int64_t   pcm_end;
2054   ogg_int64_t   best_gp;
2055   ogg_int64_t   diff;
2056   ogg_uint32_t  serialno;
2057   opus_int32    pre_skip;
2058   opus_int32    cur_discard_count;
2059   opus_int64    begin;
2060   opus_int64    end;
2061   opus_int64    boundary;
2062   opus_int64    best;
2063   opus_int64    page_offset;
2064   opus_int64    d[3];
2065   int           force_bisect;
2066   int           ret;
2067   _of->bytes_tracked=0;
2068   _of->samples_tracked=0;
2069   /*New search algorithm by HB (Nicholas Vinen).*/
2070   link=_of->links+_li;
2071   best_gp=pcm_start=link->pcm_start;
2072   pcm_end=link->pcm_end;
2073   serialno=link->serialno;
2074   best=begin=link->data_offset;
2075   page_offset=-1;
2076   /*We discard the first 80 ms of data after a seek, so seek back that much
2077      farther.
2078     If we can't, simply seek to the beginning of the link.*/
2079   if(OP_UNLIKELY(op_granpos_add(&_target_gp,_target_gp,-80*48)<0)){
2080     _target_gp=pcm_start;
2081   }
2082   /*Special case seeking to the start of the link.*/
2083   pre_skip=link->head.pre_skip;
2084   ret=op_granpos_add(&pcm_pre_skip,pcm_start,pre_skip);
2085   OP_ASSERT(!ret);
2086   if(op_granpos_cmp(_target_gp,pcm_pre_skip)<0)end=boundary=begin;
2087   else{
2088     end=boundary=link->end_offset;
2089     /*If we were decoding from this link, we can narrow the range a bit.*/
2090     if(_li==_of->cur_link&&_of->ready_state>=OP_INITSET){
2091       int op_count;
2092       op_count=_of->op_count;
2093       if(op_count>0){
2094         ogg_int64_t gp;
2095         gp=_of->op[op_count-1].granulepos;
2096         /*Make sure the timestamp is valid.
2097           The granule position might be -1 if we collected the packets from a
2098            page without a granule position after reporting a hole.
2099           The comparison with pcm_end must be strictly greater than, otherwise
2100            we might include the last page (where _of->offset>end).*/
2101         if(OP_LIKELY(gp!=-1)&&OP_LIKELY(op_granpos_cmp(pcm_start,gp)<=0)
2102          &&OP_LIKELY(op_granpos_cmp(pcm_end,gp)>0)){
2103           OP_ASSERT(_of->offset<=end);
2104           ret=op_granpos_diff(&diff,gp,_target_gp);
2105           OP_ASSERT(!ret);
2106           /*We only actually use the current time if either
2107             a) We can cut off more than half the range, or
2108             b) We're seeking sufficiently close to the current position that
2109                 it's likely to be informative.
2110             Otherwise it appears using the whole link range to estimate the
2111              first seek location gives better results, on average.*/
2112           if(diff<0){
2113             OP_ASSERT(_of->offset>=begin);
2114             if(_of->offset-begin>=end-begin>>1||diff>-OP_CUR_TIME_THRESH){
2115               best=begin=_of->offset;
2116               best_gp=pcm_start=gp;
2117             }
2118           }
2119           else if(_of->offset-begin<=end-begin>>1||diff<OP_CUR_TIME_THRESH){
2120             /*We really want the page start here, but this will do.*/
2121             end=boundary=_of->offset;
2122             pcm_end=gp;
2123           }
2124         }
2125       }
2126     }
2127   }
2128   op_decode_clear(_of);
2129   /*Initialize the interval size history.*/
2130   d[2]=d[1]=d[0]=end-begin;
2131   force_bisect=0;
2132   while(begin<end){
2133     opus_int64 bisect;
2134     opus_int64 next_boundary;
2135     opus_int32 chunk_size;
2136     if(end-begin<OP_CHUNK_SIZE)bisect=begin;
2137     else{
2138       /*Update the interval size history.*/
2139       d[0]=d[1]>>1;
2140       d[1]=d[2]>>1;
2141       d[2]=end-begin>>1;
2142       if(force_bisect)bisect=begin+(end-begin>>1);
2143       else{
2144         ogg_int64_t diff2;
2145         ret=op_granpos_diff(&diff,_target_gp,pcm_start);
2146         OP_ASSERT(!ret);
2147         ret=op_granpos_diff(&diff2,pcm_end,pcm_start);
2148         OP_ASSERT(!ret);
2149         /*Take a (pretty decent) guess.*/
2150         bisect=begin+op_rescale64(diff,diff2,end-begin)-OP_CHUNK_SIZE;
2151       }
2152       if(bisect-OP_CHUNK_SIZE<begin)bisect=begin;
2153       force_bisect=0;
2154     }
2155     if(bisect!=_of->offset){
2156       page_offset=-1;
2157       ret=op_seek_helper(_of,bisect);
2158       if(OP_UNLIKELY(ret<0))return ret;
2159     }
2160     chunk_size=OP_CHUNK_SIZE;
2161     next_boundary=boundary;
2162     while(begin<end){
2163       page_offset=op_get_next_page(_of,&og,boundary);
2164       if(page_offset<0){
2165         if(page_offset<OP_FALSE)return (int)page_offset;
2166         /*There are no more pages in our interval from our stream with a valid
2167            timestamp that start at position bisect or later.*/
2168         /*If we scanned the whole interval, we're done.*/
2169         if(bisect<=begin+1)end=begin;
2170         else{
2171           /*Otherwise, back up one chunk.*/
2172           bisect=OP_MAX(bisect-chunk_size,begin);
2173           ret=op_seek_helper(_of,bisect);
2174           if(OP_UNLIKELY(ret<0))return ret;
2175           /*Bump up the chunk size.*/
2176           chunk_size=OP_MIN(2*chunk_size,OP_CHUNK_SIZE_MAX);
2177           /*If we did find a page from another stream or without a timestamp,
2178              don't read past it.*/
2179           boundary=next_boundary;
2180         }
2181       }
2182       else{
2183         ogg_int64_t gp;
2184         /*Save the offset of the first page we found after the seek, regardless
2185            of the stream it came from or whether or not it has a timestamp.*/
2186         next_boundary=OP_MIN(page_offset,next_boundary);
2187         if(serialno!=(ogg_uint32_t)ogg_page_serialno(&og))continue;
2188         gp=ogg_page_granulepos(&og);
2189         if(gp==-1)continue;
2190         if(op_granpos_cmp(gp,_target_gp)<0){
2191           /*We found a page that ends before our target.
2192             Advance to the raw offset of the next page.*/
2193           begin=_of->offset;
2194           if(OP_UNLIKELY(op_granpos_cmp(pcm_start,gp)>0)
2195            ||OP_UNLIKELY(op_granpos_cmp(pcm_end,gp)<0)){
2196             /*Don't let pcm_start get out of range!
2197               That could happen with an invalid timestamp.*/
2198             break;
2199           }
2200           /*Save the byte offset of the end of the page with this granule
2201              position.*/
2202           best=begin;
2203           best_gp=pcm_start=gp;
2204           ret=op_granpos_diff(&diff,_target_gp,pcm_start);
2205           OP_ASSERT(!ret);
2206           /*If we're more than a second away from our target, break out and
2207              do another bisection.*/
2208           if(diff>48000)break;
2209           /*Otherwise, keep scanning forward (do NOT use begin+1).*/
2210           bisect=begin;
2211         }
2212         else{
2213           /*We found a page that ends after our target.*/
2214           /*If we scanned the whole interval before we found it, we're done.*/
2215           if(bisect<=begin+1)end=begin;
2216           else{
2217             end=bisect;
2218             /*In later iterations, don't read past the first page we found.*/
2219             boundary=next_boundary;
2220             /*If we're not making much progress shrinking the interval size,
2221                start forcing straight bisection to limit the worst case.*/
2222             force_bisect=end-begin>d[0]*2;
2223             /*Don't let pcm_end get out of range!
2224               That could happen with an invalid timestamp.*/
2225             if(OP_LIKELY(op_granpos_cmp(pcm_end,gp)>0)
2226              &&OP_LIKELY(op_granpos_cmp(pcm_start,gp)<=0)){
2227               pcm_end=gp;
2228             }
2229             break;
2230           }
2231         }
2232       }
2233     }
2234   }
2235   /*Found our page.
2236     Seek right after it and update prev_packet_gp and cur_discard_count.
2237     This is an easier case than op_raw_seek(), as we don't need to keep any
2238      packets from the page we found.*/
2239   /*Seek, if necessary.*/
2240   if(best!=page_offset){
2241     page_offset=-1;
2242     ret=op_seek_helper(_of,best);
2243     if(OP_UNLIKELY(ret<0))return ret;
2244   }
2245   /*By default, discard 80 ms of data after a seek, unless we seek
2246      into the pre-skip region.*/
2247   cur_discard_count=80*48;
2248   ret=op_granpos_diff(&diff,best_gp,pcm_start);
2249   OP_ASSERT(!ret);
2250   OP_ASSERT(diff>=0);
2251   /*If we start at the beginning of the pre-skip region, or we're at least
2252      80 ms from the end of the pre-skip region, we discard to the end of the
2253      pre-skip region.
2254     Otherwise, we still use the 80 ms default, which will discard past the end
2255      of the pre-skip region.*/
2256   if(diff<=OP_MAX(0,pre_skip-80*48))cur_discard_count=pre_skip-(int)diff;
2257   _of->cur_link=_li;
2258   _of->ready_state=OP_STREAMSET;
2259   _of->prev_packet_gp=best_gp;
2260   _of->cur_discard_count=cur_discard_count;
2261   ogg_stream_reset_serialno(&_of->os,serialno);
2262   ret=op_fetch_and_process_page(_of,page_offset<0?NULL:&og,page_offset,1,0,1);
2263   if(OP_UNLIKELY(ret<=0))return OP_EBADLINK;
2264   /*Verify result.*/
2265   if(OP_UNLIKELY(op_granpos_cmp(_of->prev_packet_gp,_target_gp)>0)){
2266     return OP_EBADLINK;
2267   }
2268   return 0;
2269 }
2270
2271 int op_pcm_seek(OggOpusFile *_of,ogg_int64_t _pcm_offset){
2272   OggOpusLink *link;
2273   ogg_int64_t  pcm_start;
2274   ogg_int64_t  target_gp;
2275   ogg_int64_t  prev_packet_gp;
2276   ogg_int64_t  skip;
2277   ogg_int64_t  diff;
2278   int          op_count;
2279   int          op_pos;
2280   int          ret;
2281   int          li;
2282   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2283   if(OP_UNLIKELY(!_of->seekable))return OP_ENOSEEK;
2284   if(OP_UNLIKELY(_pcm_offset<0))return OP_EINVAL;
2285   target_gp=op_get_granulepos(_of,_pcm_offset,&li);
2286   if(OP_UNLIKELY(target_gp==-1))return OP_EINVAL;
2287   ret=op_pcm_seek_page(_of,target_gp,li);
2288   /*Now skip samples until we actually get to our target.*/
2289   link=_of->links+li;
2290   pcm_start=link->pcm_start;
2291   ret=op_granpos_diff(&_pcm_offset,target_gp,pcm_start);
2292   OP_ASSERT(!ret);
2293   /*Figure out where we should skip to.*/
2294   if(_pcm_offset<=link->head.pre_skip)skip=0;
2295   else skip=OP_MAX(_pcm_offset-80*48,0);
2296   OP_ASSERT(_pcm_offset-skip>=0);
2297   OP_ASSERT(_pcm_offset-skip<0x7FFFFFFF-120*48);
2298   /*Skip packets until we find one with samples past our skip target.*/
2299   for(;;){
2300     op_count=_of->op_count;
2301     prev_packet_gp=_of->prev_packet_gp;
2302     for(op_pos=_of->op_pos;op_pos<op_count;op_pos++){
2303       ogg_int64_t cur_packet_gp;
2304       cur_packet_gp=_of->op[op_pos].granulepos;
2305       if(OP_LIKELY(!op_granpos_diff(&diff,cur_packet_gp,pcm_start))
2306        &&diff>skip){
2307         break;
2308       }
2309       prev_packet_gp=cur_packet_gp;
2310     }
2311     _of->prev_packet_gp=prev_packet_gp;
2312     _of->op_pos=op_pos;
2313     if(op_pos<op_count)break;
2314     /*We skipped all the packets on this page.
2315       Fetch another.*/
2316     ret=op_fetch_and_process_page(_of,NULL,-1,1,0,1);
2317     if(OP_UNLIKELY(ret<=0))return OP_EBADLINK;
2318   }
2319   ret=op_granpos_diff(&diff,prev_packet_gp,pcm_start);
2320   OP_ASSERT(!ret);
2321   /*We skipped too far.
2322     Either the timestamps were illegal or there was a hole in the data.*/
2323   if(diff>skip)return OP_EBADLINK;
2324   OP_ASSERT(_pcm_offset-diff<0x7FFFFFFF);
2325   /*TODO: If there are further holes/illegal timestamps, we still won't decode
2326      to the correct sample.
2327     However, at least op_pcm_tell() will report the correct value immediately
2328      after returning.*/
2329   _of->cur_discard_count=(opus_int32)(_pcm_offset-diff);
2330   return 0;
2331 }
2332
2333 opus_int64 op_raw_tell(OggOpusFile *_of){
2334   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2335   return _of->offset;
2336 }
2337
2338 /*Convert a granule position from a given link to a PCM offset relative to the
2339    start of the whole stream.
2340   For unseekable sources, this gets reset to 0 at the beginning of each link.*/
2341 static ogg_int64_t op_get_pcm_offset(const OggOpusFile *_of,
2342  ogg_int64_t _gp,int _li){
2343   OggOpusLink *links;
2344   ogg_int64_t  pcm_offset;
2345   ogg_int64_t  delta;
2346   int          ret;
2347   int          li;
2348   links=_of->links;
2349   pcm_offset=0;
2350   OP_ASSERT(_li<_of->nlinks);
2351   for(li=0;li<_li;li++){
2352     ret=op_granpos_diff(&delta,links[li].pcm_end,links[li].pcm_start);
2353     OP_ASSERT(!ret);
2354     delta-=links[li].head.pre_skip;
2355     pcm_offset+=delta;
2356   }
2357   OP_ASSERT(_li>=0);
2358   if(_of->seekable&&OP_UNLIKELY(op_granpos_cmp(_gp,links[_li].pcm_end)>0)){
2359     _gp=links[_li].pcm_end;
2360   }
2361   if(OP_LIKELY(op_granpos_cmp(_gp,links[_li].pcm_start)>0)){
2362     ret=op_granpos_diff(&delta,_gp,links[_li].pcm_start);
2363     OP_ASSERT(!ret);
2364     if(delta<links[_li].head.pre_skip)delta=0;
2365     else delta-=links[_li].head.pre_skip;
2366     pcm_offset+=delta;
2367   }
2368   return pcm_offset;
2369 }
2370
2371 ogg_int64_t op_pcm_tell(OggOpusFile *_of){
2372   ogg_int64_t gp;
2373   int         nbuffered;
2374   int         ret;
2375   int         li;
2376   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2377   gp=_of->prev_packet_gp;
2378   if(gp==-1)return 0;
2379   nbuffered=OP_MAX(_of->od_buffer_size-_of->od_buffer_pos,0);
2380   ret=op_granpos_add(&gp,gp,-nbuffered);
2381   OP_ASSERT(!ret);
2382   li=_of->seekable?_of->cur_link:0;
2383   if(op_granpos_add(&gp,gp,_of->cur_discard_count)<0){
2384     gp=_of->links[li].pcm_end;
2385   }
2386   return op_get_pcm_offset(_of,gp,li);
2387 }
2388
2389 /*Allocate the decoder scratch buffer.
2390   This is done lazily, since if the user provides large enough buffers, we'll
2391    never need it.*/
2392 static int op_init_buffer(OggOpusFile *_of){
2393   int nchannels_max;
2394   if(_of->seekable){
2395     OggOpusLink *links;
2396     int          nlinks;
2397     int          li;
2398     links=_of->links;
2399     nlinks=_of->nlinks;
2400     nchannels_max=1;
2401     for(li=0;li<nlinks;li++){
2402       nchannels_max=OP_MAX(nchannels_max,links[li].head.channel_count);
2403     }
2404   }
2405   else nchannels_max=OP_NCHANNELS_MAX;
2406   _of->od_buffer=(op_sample *)_ogg_malloc(
2407    sizeof(*_of->od_buffer)*nchannels_max*120*48);
2408   if(_of->od_buffer==NULL)return OP_EFAULT;
2409   return 0;
2410 }
2411
2412 /*Read more samples from the stream, using the same API as op_read() or
2413    op_read_float().*/
2414 static int op_read_native(OggOpusFile *_of,
2415  op_sample *_pcm,int _buf_size,int *_li){
2416   if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
2417   for(;;){
2418     int ret;
2419     if(OP_LIKELY(_of->ready_state>=OP_INITSET)){
2420       int nchannels;
2421       int od_buffer_pos;
2422       int nsamples;
2423       int op_pos;
2424       nchannels=_of->links[_of->seekable?_of->cur_link:0].head.channel_count;
2425       od_buffer_pos=_of->od_buffer_pos;
2426       nsamples=_of->od_buffer_size-od_buffer_pos;
2427       /*If we have buffered samples, return them.*/
2428       if(OP_UNLIKELY(nsamples>0)){
2429         if(OP_UNLIKELY(nsamples*nchannels>_buf_size)){
2430           nsamples=_buf_size/nchannels;
2431         }
2432         memcpy(_pcm,_of->od_buffer+nchannels*od_buffer_pos,
2433          sizeof(*_pcm)*nchannels*nsamples);
2434         od_buffer_pos+=nsamples;
2435         _of->od_buffer_pos=od_buffer_pos;
2436         if(_li!=NULL)*_li=_of->cur_link;
2437         return nsamples;
2438       }
2439       /*If we have buffered packets, decode one.*/
2440       op_pos=_of->op_pos;
2441       if(OP_LIKELY(op_pos<_of->op_count)){
2442         ogg_packet  *pop;
2443         ogg_int64_t  diff;
2444         opus_int32   cur_discard_count;
2445         int          duration;
2446         int          trimmed_duration;
2447         pop=_of->op+op_pos++;
2448         _of->op_pos=op_pos;
2449         cur_discard_count=_of->cur_discard_count;
2450         duration=op_get_packet_duration(pop->packet,pop->bytes);
2451         /*We don't buffer packets with an invalid TOC sequence.*/
2452         OP_ASSERT(duration>0);
2453         trimmed_duration=duration;
2454         /*Perform end-trimming.*/
2455         if(OP_UNLIKELY(pop->e_o_s)){
2456           if(OP_UNLIKELY(op_granpos_cmp(pop->granulepos,
2457            _of->prev_packet_gp)<=0)){
2458             trimmed_duration=0;
2459           }
2460           else if(OP_LIKELY(!op_granpos_diff(&diff,
2461            pop->granulepos,_of->prev_packet_gp))){
2462             trimmed_duration=(int)OP_MIN(diff,trimmed_duration);
2463           }
2464         }
2465         _of->prev_packet_gp=pop->granulepos;
2466         if(OP_UNLIKELY(duration*nchannels>_buf_size)){
2467           op_sample *buf;
2468           /*If the user's buffer is too small, decode into a scratch buffer.*/
2469           buf=_of->od_buffer;
2470           if(OP_UNLIKELY(buf==NULL)){
2471             ret=op_init_buffer(_of);
2472             if(OP_UNLIKELY(ret<0))return ret;
2473             buf=_of->od_buffer;
2474           }
2475 #if defined(OP_FIXED_POINT)
2476           ret=opus_multistream_decode(_of->od,
2477            pop->packet,pop->bytes,buf,120*48,0);
2478 #else
2479           ret=opus_multistream_decode_float(_of->od,
2480            pop->packet,pop->bytes,buf,120*48,0);
2481 #endif
2482           if(OP_UNLIKELY(ret<0))return OP_EBADPACKET;
2483           OP_ASSERT(ret==duration);
2484           /*Perform pre-skip/pre-roll.*/
2485           od_buffer_pos=(int)OP_MIN(trimmed_duration,cur_discard_count);
2486           cur_discard_count-=od_buffer_pos;
2487           _of->cur_discard_count=cur_discard_count;
2488           _of->od_buffer_pos=od_buffer_pos;
2489           _of->od_buffer_size=trimmed_duration;
2490           /*Update bitrate tracking based on the actual samples we used from
2491              what was decoded.*/
2492           _of->bytes_tracked+=pop->bytes;
2493           _of->samples_tracked+=trimmed_duration-od_buffer_pos;
2494           /*Don't grab another page yet.*/
2495           if(OP_LIKELY(od_buffer_pos<trimmed_duration))continue;
2496         }
2497         else{
2498           /*Otherwise decode directly into the user's buffer.*/
2499 #if defined(OP_FIXED_POINT)
2500           ret=opus_multistream_decode(_of->od,pop->packet,pop->bytes,
2501            _pcm,_buf_size/nchannels,0);
2502 #else
2503           ret=opus_multistream_decode_float(_of->od,pop->packet,pop->bytes,
2504            _pcm,_buf_size/nchannels,0);
2505 #endif
2506           if(OP_UNLIKELY(ret<0))return OP_EBADPACKET;
2507           OP_ASSERT(ret==duration);
2508           if(OP_LIKELY(trimmed_duration>0)){
2509             /*Perform pre-skip/pre-roll.*/
2510             od_buffer_pos=(int)OP_MIN(trimmed_duration,cur_discard_count);
2511             cur_discard_count-=od_buffer_pos;
2512             _of->cur_discard_count=cur_discard_count;
2513             if(OP_UNLIKELY(od_buffer_pos>0)
2514              &&OP_LIKELY(od_buffer_pos<trimmed_duration)){
2515               memmove(_pcm,_pcm+od_buffer_pos*nchannels,
2516                sizeof(*_pcm)*(trimmed_duration-od_buffer_pos)*nchannels);
2517             }
2518             trimmed_duration-=od_buffer_pos;
2519             /*Update bitrate tracking based on the actual samples we used from
2520                what was decoded.*/
2521             _of->bytes_tracked+=pop->bytes;
2522             _of->samples_tracked+=trimmed_duration;
2523             if(OP_LIKELY(trimmed_duration>0)){
2524               if(_li!=NULL)*_li=_of->cur_link;
2525               return trimmed_duration;
2526             }
2527           }
2528         }
2529       }
2530     }
2531     /*Suck in another page.*/
2532     ret=op_fetch_and_process_page(_of,NULL,-1,1,1,0);
2533     if(OP_UNLIKELY(ret==OP_EOF)){
2534       if(_li!=NULL)*_li=_of->cur_link;
2535       return 0;
2536     }
2537     if(OP_UNLIKELY(ret<0))return ret;
2538   }
2539 }
2540
2541 typedef int (*op_read_filter_func)(OggOpusFile *_of,void *_dst,int _dst_sz,
2542  op_sample *_src,int _nsamples,int _nchannels);
2543
2544 /*Decode some samples and then apply a custom filter to them.
2545   This is used to convert to different output formats.*/
2546 static int op_read_native_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2547  op_read_filter_func _filter,int *_li){
2548   int ret;
2549   /*Ensure we have some decoded samples in our buffer.*/
2550   ret=op_read_native(_of,NULL,0,_li);
2551   /*Now apply the filter to them.*/
2552   if(OP_LIKELY(ret>=0)&&OP_LIKELY(_of->ready_state>=OP_INITSET)){
2553     int od_buffer_pos;
2554     od_buffer_pos=_of->od_buffer_pos;
2555     ret=_of->od_buffer_size-od_buffer_pos;
2556     if(OP_LIKELY(ret>0)){
2557       int nchannels;
2558       nchannels=_of->links[_of->seekable?_of->cur_link:0].head.channel_count;
2559       ret=(*_filter)(_of,_dst,_dst_sz,
2560        _of->od_buffer+nchannels*od_buffer_pos,ret,nchannels);
2561       OP_ASSERT(ret>=0);
2562       OP_ASSERT(ret<=_of->od_buffer_size-od_buffer_pos);
2563       od_buffer_pos+=ret;
2564       _of->od_buffer_pos=od_buffer_pos;
2565     }
2566   }
2567   return ret;
2568 }
2569
2570 #if defined(OP_FIXED_POINT)
2571
2572 int op_read(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size,int *_li){
2573   return op_read_native(_of,_pcm,_buf_size,_li);
2574 }
2575
2576 /*Matrices for downmixing from the supported channel counts to stereo.
2577   The matrices with 5 or more channels are normalized to a total volume of 2.0,
2578    since most mixes sound too quiet if normalized to 1.0 (as there is generally
2579    little volume in the side/rear channels).
2580   Hence we keep the coefficients in Q14, so the downmix values won't overflow a
2581    32-bit number.*/
2582 static const opus_int16 OP_STEREO_DOWNMIX_Q14
2583  [OP_NCHANNELS_MAX-2][OP_NCHANNELS_MAX][2]={
2584   /*3.0*/
2585   {
2586     {9598,0},{6786,6786},{0,9598}
2587   },
2588   /*quadrophonic*/
2589   {
2590     {6924,0},{0,6924},{5996,3464},{3464,5996}
2591   },
2592   /*5.0*/
2593   {
2594     {10666,0},{7537,7537},{0,10666},{9234,5331},{5331,9234}
2595   },
2596   /*5.1*/
2597   {
2598     {8668,0},{6129,6129},{0,8668},{7507,4335},{4335,7507},{6129,6129}
2599   },
2600   /*6.1*/
2601   {
2602     {7459,0},{5275,5275},{0,7459},{6460,3731},{3731,6460},{4568,4568},
2603     {5275,5275}
2604   },
2605   /*7.1*/
2606   {
2607     {6368,0},{4502,4502},{0,6368},{5515,3183},{3183,5515},{5515,3183},
2608     {3183,5515},{4502,4502}
2609   }
2610 };
2611
2612 static int op_stereo_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2613  op_sample *_src,int _nsamples,int _nchannels){
2614   _of=_of;
2615   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2616   if(_nchannels==2)memcpy(_dst,_src,_nsamples*2*sizeof(*_src));
2617   else{
2618     opus_int16 *dst;
2619     int         i;
2620     dst=(opus_int16 *)_dst;
2621     if(_nchannels==1){
2622       for(i=0;i<_nsamples;i++)dst[2*i+0]=dst[2*i+1]=_src[i];
2623     }
2624     else{
2625       for(i=0;i<_nsamples;i++){
2626         opus_int32 l;
2627         opus_int32 r;
2628         int        ci;
2629         l=r=0;
2630         for(ci=0;ci<_nchannels;ci++){
2631           opus_int32 s;
2632           s=_src[_nchannels*i+ci];
2633           l+=OP_STEREO_DOWNMIX_Q14[_nchannels-3][ci][0]*s;
2634           r+=OP_STEREO_DOWNMIX_Q14[_nchannels-3][ci][1]*s;
2635         }
2636         dst[2*i+0]=(opus_int16)OP_CLAMP(-32768,l+8192>>14,32767);
2637         dst[2*i+1]=(opus_int16)OP_CLAMP(-32768,r+8192>>14,32767);
2638       }
2639     }
2640   }
2641   return _nsamples;
2642 }
2643
2644 int op_read_stereo(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size){
2645   return op_read_native_filter(_of,_pcm,_buf_size,op_stereo_filter,NULL);
2646 }
2647
2648 # if !defined(OP_DISABLE_FLOAT_API)
2649
2650 static int op_short2float_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2651  op_sample *_src,int _nsamples,int _nchannels){
2652   float *dst;
2653   int    i;
2654   _of=_of;
2655   dst=(float *)_dst;
2656   if(OP_UNLIKELY(_nsamples*_nchannels>_dst_sz))_nsamples=_dst_sz/_nchannels;
2657   _dst_sz=_nsamples*_nchannels;
2658   for(i=0;i<_dst_sz;i++)dst[i]=(1.0F/32768)*_src[i];
2659   return _nsamples;
2660 }
2661
2662 int op_read_float(OggOpusFile *_of,float *_pcm,int _buf_size,int *_li){
2663   return op_read_native_filter(_of,_pcm,_buf_size,op_short2float_filter,_li);
2664 }
2665
2666 static int op_short2float_stereo_filter(OggOpusFile *_of,
2667  void *_dst,int _dst_sz,op_sample *_src,int _nsamples,int _nchannels){
2668   float *dst;
2669   dst=(float *)_dst;
2670   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2671   if(_nchannels==1){
2672     int i;
2673     _nsamples=op_short2float_filter(_of,dst,_nsamples,_src,_nsamples,1);
2674     for(i=_nsamples;i-->0;)dst[2*i+0]=dst[2*i+1]=dst[i];
2675     return _nsamples;
2676   }
2677   /*It would be better to convert to floats and then downmix (so that we don't
2678      risk clipping with more than 5 channels), but that would require a large
2679      stack buffer, which is probably not a good idea if you're using the
2680      fixed-point build.*/
2681   if(_nchannels>2){
2682     _nsamples=op_stereo_filter(_of,_src,_nsamples*2,
2683      _src,_nsamples,_nchannels);
2684   }
2685   return op_short2float_filter(_of,dst,_dst_sz,_src,_nsamples,2);
2686 }
2687
2688 int op_read_float_stereo(OggOpusFile *_of,float *_pcm,int _buf_size){
2689   return op_read_native_filter(_of,_pcm,_buf_size,
2690    op_short2float_stereo_filter,NULL);
2691 }
2692
2693 # endif
2694
2695 #else
2696
2697 # if defined(OP_HAVE_LRINTF)
2698 #  include <math.h>
2699 #  define op_float2int(_x) (lrintf(_x))
2700 # else
2701 #  define op_float2int(_x) ((int)((_x)+((_x)<0?-0.5F:0.5F)))
2702 # endif
2703
2704 /*The dithering code here is adapted from opusdec, part of opus-tools.
2705   It was originally written by Greg Maxwell.*/
2706
2707 static opus_uint32 op_rand(opus_uint32 _seed){
2708   return _seed*96314165+907633515&0xFFFFFFFFU;
2709 }
2710
2711 /*This implements 16-bit quantization with full triangular dither and IIR noise
2712    shaping.
2713   The noise shaping filters were designed by Sebastian Gesemann, and are based
2714    on the LAME ATH curves with flattening to limite their peak gain to 20 dB.
2715   Everyone else's noise shaping filters are mildly crazy.
2716   The 48 kHz version of this filter is just a warped version of the 44.1 kHz
2717    filter and probably could be improved by shifting the HF shelf up in
2718    frequency a little bit, since 48 kHz has a bit more room and being more
2719    conservative against bat-ears is probably more important than more noise
2720    suppression.
2721   This process can increase the peak level of the signal (in theory by the peak
2722    error of 1.5 +20 dB, though that is unobservably rare).
2723   To avoid clipping, the signal is attenuated by a couple thousands of a dB.
2724   Initially, the approach taken here was to only attenuate by the 99.9th
2725    percentile, making clipping rare but not impossible (like SoX), but the
2726    limited gain of the filter means that the worst case was only two
2727    thousandths of a dB more, so this just uses the worst case.
2728   The attenuation is probably also helpful to prevent clipping in the DAC
2729    reconstruction filters or downstream resampling, in any case.*/
2730
2731 #define OP_GAIN (32753.0F)
2732
2733 #define OP_PRNG_GAIN (1.0F/0xFFFFFFFF)
2734
2735 /*48 kHz noise shaping filter, sd=2.34.*/
2736
2737 static const float OP_FCOEF_B[4]={
2738   2.2374F,-0.7339F,-0.1251F,-0.6033F
2739 };
2740
2741 static const float OP_FCOEF_A[4]={
2742   0.9030F,0.0116F,-0.5853F,-0.2571F
2743 };
2744
2745 static void op_shaped_dither16(OggOpusFile *_of,opus_int16 *_dst,
2746  const float *_src,int _nsamples,int _nchannels){
2747   opus_uint32 seed;
2748   int         mute;
2749   int         i;
2750   mute=_of->dither_mute;
2751   seed=_of->dither_seed;
2752   /*In order to avoid replacing digital silence with quiet dither noise, we
2753      mute if the output has been silent for a while.*/
2754   if(mute>64)memset(_of->dither_a,0,sizeof(*_of->dither_a)*4*_nchannels);
2755   for(i=0;i<_nsamples;i++){
2756     int silent;
2757     int ci;
2758     silent=1;
2759     for(ci=0;ci<_nchannels;ci++){
2760       float r;
2761       float s;
2762       float err;
2763       int   si;
2764       int   j;
2765       s=_src[_nchannels*i+ci];
2766       silent&=s==0;
2767       s*=OP_GAIN;
2768       err=0;
2769       for(j=0;j<4;j++){
2770         err+=OP_FCOEF_B[j]*_of->dither_b[ci*4+j]
2771          -OP_FCOEF_A[j]*_of->dither_a[ci*4+j];
2772       }
2773       for(j=3;j-->0;)_of->dither_a[ci*4+j+1]=_of->dither_a[ci*4+j];
2774       for(j=3;j-->0;)_of->dither_b[ci*4+j+1]=_of->dither_b[ci*4+j];
2775       _of->dither_a[ci*4]=err;
2776       s-=err;
2777       if(mute>16)r=0;
2778       else{
2779         seed=op_rand(seed);
2780         r=seed*OP_PRNG_GAIN;
2781         seed=op_rand(seed);
2782         r-=seed*OP_PRNG_GAIN;
2783       }
2784       /*Clamp in float out of paranoia that the input will be > 96 dBFS and
2785          wrap if the integer is clamped.*/
2786       si=op_float2int(OP_CLAMP(-32768,s+r,32767));
2787       _dst[_nchannels*i+ci]=(opus_int16)si;
2788       /*Including clipping in the noise shaping is generally disastrous: the
2789          futile effort to restore the clipped energy results in more clipping.
2790         However, small amounts---at the level which could normally be created
2791          by dither and rounding---are harmless and can even reduce clipping
2792          somewhat due to the clipping sometimes reducing the dither + rounding
2793          error.*/
2794       _of->dither_b[ci*4]=mute>16?0:OP_CLAMP(-1.5F,si-s,1.5F);
2795     }
2796     mute++;
2797     if(!silent)mute=0;
2798   }
2799   _of->dither_mute=OP_MIN(mute,65);
2800   _of->dither_seed=seed;
2801 }
2802
2803 static int op_float2short_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2804  op_sample *_src,int _nsamples,int _nchannels){
2805   opus_int16 *dst;
2806   dst=(opus_int16 *)_dst;
2807   if(OP_UNLIKELY(_nsamples*_nchannels>_dst_sz))_nsamples=_dst_sz/_nchannels;
2808   op_shaped_dither16(_of,dst,_src,_nsamples,_nchannels);
2809   return _nsamples;
2810 }
2811
2812 int op_read(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size,int *_li){
2813   return op_read_native_filter(_of,_pcm,_buf_size,op_float2short_filter,_li);
2814 }
2815
2816 int op_read_float(OggOpusFile *_of,float *_pcm,int _buf_size,int *_li){
2817   return op_read_native(_of,_pcm,_buf_size,_li);
2818 }
2819
2820 /*Matrices for downmixing from the supported channel counts to stereo.
2821   The matrices with 5 or more channels are normalized to a total volume of 2.0,
2822    since most mixes sound too quiet if normalized to 1.0 (as there is generally
2823    little volume in the side/rear channels).*/
2824 static const float OP_STEREO_DOWNMIX[OP_NCHANNELS_MAX-2][OP_NCHANNELS_MAX][2]={
2825   /*3.0*/
2826   {
2827     {0.5858F,0.0F},{0.4142F,0.4142F},{0.0F,0.5858F}
2828   },
2829   /*quadrophonic*/
2830   {
2831     {0.4226F,0.0F},{0.0F,0.4226F},{0.366F,0.2114F},{0.2114F,0.336F}
2832   },
2833   /*5.0*/
2834   {
2835     {0.651F,0.0F},{0.46F,0.46F},{0.0F,0.651F},{0.5636F,0.3254F},
2836     {0.3254F,0.5636F}
2837   },
2838   /*5.1*/
2839   {
2840     {0.529F,0.0F},{0.3741F,0.3741F},{0.0F,0.529F},{0.4582F,0.2645F},
2841     {0.2645F,0.4582F},{0.3741F,0.3741F}
2842   },
2843   /*6.1*/
2844   {
2845     {0.4553F,0.0F},{0.322F,0.322F},{0.0F,0.4553F},{0.3943F,0.2277F},
2846     {0.2277F,0.3943F},{0.2788F,0.2788F},{0.322F,0.322F}
2847   },
2848   /*7.1*/
2849   {
2850     {0.3886F,0.0F},{0.2748F,0.2748F},{0.0F,0.3886F},{0.3366F,0.1943F},
2851     {0.1943F,0.3366F},{0.3366F,0.1943F},{0.1943F,0.3366F},{0.2748F,0.2748F}
2852   }
2853 };
2854
2855 static int op_stereo_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
2856  op_sample *_src,int _nsamples,int _nchannels){
2857   _of=_of;
2858   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2859   if(_nchannels==2)memcpy(_dst,_src,_nsamples*2*sizeof(*_src));
2860   else{
2861     float *dst;
2862     int    i;
2863     dst=(float *)_dst;
2864     if(_nchannels==1){
2865       for(i=0;i<_nsamples;i++)dst[2*i+0]=dst[2*i+1]=_src[i];
2866     }
2867     else{
2868       for(i=0;i<_nsamples;i++){
2869         float l;
2870         float r;
2871         int   ci;
2872         l=r=0;
2873         for(ci=0;ci<_nchannels;ci++){
2874           l+=OP_STEREO_DOWNMIX[_nchannels-3][ci][0]*_src[_nchannels*i+ci];
2875           r+=OP_STEREO_DOWNMIX[_nchannels-3][ci][1]*_src[_nchannels*i+ci];
2876         }
2877         dst[2*i+0]=l;
2878         dst[2*i+1]=r;
2879       }
2880     }
2881   }
2882   return _nsamples;
2883 }
2884
2885 static int op_float2short_stereo_filter(OggOpusFile *_of,
2886  void *_dst,int _dst_sz,op_sample *_src,int _nsamples,int _nchannels){
2887   opus_int16 *dst;
2888   dst=(opus_int16 *)_dst;
2889   _nsamples=OP_MIN(_nsamples,_dst_sz>>1);
2890   if(_nchannels==1){
2891     int i;
2892     op_shaped_dither16(_of,dst,_src,_nsamples,1);
2893     for(i=_nsamples;i-->0;)dst[2*i+0]=dst[2*i+1]=dst[i];
2894   }
2895   else{
2896     if(_nchannels>2){
2897       _nsamples=op_stereo_filter(_of,_src,_nsamples*2,
2898        _src,_nsamples,_nchannels);
2899     }
2900     op_shaped_dither16(_of,dst,_src,_nsamples,_nchannels);
2901   }
2902   return _nsamples;
2903 }
2904
2905 int op_read_stereo(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size){
2906   return op_read_native_filter(_of,_pcm,_buf_size,
2907    op_float2short_stereo_filter,NULL);
2908 }
2909
2910 int op_read_float_stereo(OggOpusFile *_of,float *_pcm,int _buf_size){
2911   return op_read_native_filter(_of,_pcm,_buf_size,op_stereo_filter,NULL);
2912 }
2913
2914 #endif