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