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