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