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