Computing the exact (I think) padding size
[libopusenc.git] / src / opusenc.c
1 /* Copyright (C)2002-2017 Jean-Marc Valin
2    Copyright (C)2007-2013 Xiph.Org Foundation
3    Copyright (C)2008-2013 Gregory Maxwell
4    File: opusenc.c
5
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions
8    are met:
9
10    - Redistributions of source code must retain the above copyright
11    notice, this list of conditions and the following disclaimer.
12
13    - Redistributions in binary form must reproduce the above copyright
14    notice, this list of conditions and the following disclaimer in the
15    documentation and/or other materials provided with the distribution.
16
17    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include <stdarg.h>
35 #include <time.h>
36 #include <unistd.h>
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <string.h>
40 #include <assert.h>
41 #include <opus_multistream.h>
42 #include "opusenc.h"
43 #include "opus_header.h"
44 #include "speex_resampler.h"
45 #include "picture.h"
46 #include "ogg_packer.h"
47
48 #define MAX_CHANNELS 8
49
50 #define LPC_PADDING 120
51 #define LPC_ORDER 24
52 #define LPC_INPUT 480
53 /* Make the following constant always equal to 2*cos(M_PI/LPC_PADDING) */
54 #define LPC_GOERTZEL_CONST 1.99931465f
55
56 /* Allow up to 2 seconds for delayed decision. */
57 #define MAX_LOOKAHEAD 96000
58 /* We can't have a circular buffer (because of delayed decision), so let's not copy too often. */
59 #define BUFFER_EXTRA 24000
60
61 #define BUFFER_SAMPLES (MAX_LOOKAHEAD + BUFFER_EXTRA)
62
63 #define MIN(a,b) ((a) < (b) ? (a) : (b))
64 #define MAX(a,b) ((a) > (b) ? (a) : (b))
65
66 #define MAX_PACKET_SIZE (1276*8)
67
68 #define USE_OGGP
69
70 struct StdioObject {
71   FILE *file;
72 };
73
74 typedef struct EncStream EncStream;
75
76 struct EncStream {
77   void *user_data;
78 #ifndef USE_OGGP
79   ogg_stream_state os;
80 #endif
81   int serialno_is_set;
82   int serialno;
83   int stream_is_init;
84   int packetno;
85   char *comment;
86   int comment_length;
87   int seen_file_icons;
88   int close_at_end;
89   int header_is_frozen;
90   ogg_int64_t end_granule;
91   ogg_int64_t granule_offset;
92   EncStream *next;
93 };
94
95 struct OggOpusEnc {
96   OpusMSEncoder *st;
97 #ifdef USE_OGGP
98   oggpacker *oggp;
99 #endif
100   int unrecoverable;
101   int pull_api;
102   int rate;
103   int channels;
104   float *buffer;
105   int buffer_start;
106   int buffer_end;
107   SpeexResamplerState *re;
108   int frame_size;
109   int decision_delay;
110   int max_ogg_delay;
111   int global_granule_offset;
112   ogg_int64_t curr_granule;
113   ogg_int64_t write_granule;
114   ogg_int64_t last_page_granule;
115   unsigned char *chaining_keyframe;
116   int chaining_keyframe_length;
117   OpusEncCallbacks callbacks;
118   ope_packet_func packet_callback;
119   OpusHeader header;
120   int comment_padding;
121   EncStream *streams;
122   EncStream *last_stream;
123 };
124
125 #ifdef USE_OGGP
126 static void output_pages(OggOpusEnc *enc) {
127   unsigned char *page;
128   int len;
129   while (oggp_get_next_page(enc->oggp, &page, &len)) {
130     enc->callbacks.write(enc->streams->user_data, page, len);
131   }
132 }
133 static void oe_flush_page(OggOpusEnc *enc) {
134   oggp_flush_page(enc->oggp);
135   if (!enc->pull_api) output_pages(enc);
136 }
137
138 #else
139
140 static int oe_write_page(OggOpusEnc *enc, ogg_page *page, void *user_data)
141 {
142   int length;
143   int err;
144   err = enc->callbacks.write(user_data, page->header, page->header_len);
145   if (err) return -1;
146   err = enc->callbacks.write(user_data, page->body, page->body_len);
147   if (err) return -1;
148   length = page->header_len+page->body_len;
149   return length;
150 }
151
152 static void oe_flush_page(OggOpusEnc *enc) {
153   ogg_page og;
154   int ret;
155
156   while ( (ret = ogg_stream_flush_fill(&enc->streams->os, &og, 255*255))) {
157     if (ogg_page_packets(&og) != 0) enc->last_page_granule = ogg_page_granulepos(&og) + enc->streams->granule_offset;
158     ret = oe_write_page(enc, &og, enc->streams->user_data);
159     if (ret == -1) {
160       return;
161     }
162   }
163 }
164 #endif
165
166
167 int stdio_write(void *user_data, const unsigned char *ptr, int len) {
168   struct StdioObject *obj = (struct StdioObject*)user_data;
169   return fwrite(ptr, 1, len, obj->file) != (size_t)len;
170 }
171
172 int stdio_close(void *user_data) {
173   struct StdioObject *obj = (struct StdioObject*)user_data;
174   int ret = 0;
175   if (obj->file) ret = fclose(obj->file);
176   free(obj);
177   return ret;
178 }
179
180 static const OpusEncCallbacks stdio_callbacks = {
181   stdio_write,
182   stdio_close
183 };
184
185 /* Create a new OggOpus file. */
186 OggOpusEnc *ope_create_file(const char *path, int rate, int channels, int family, int *error) {
187   OggOpusEnc *enc;
188   struct StdioObject *obj;
189   obj = malloc(sizeof(*obj));
190   enc = ope_create_callbacks(&stdio_callbacks, obj, rate, channels, family, error);
191   if (enc == NULL || (error && *error)) {
192     return NULL;
193   }
194   obj->file = fopen(path, "wb");
195   if (!obj->file) {
196     if (error) *error = OPE_CANNOT_OPEN;
197     ope_destroy(enc);
198     return NULL;
199   }
200   return enc;
201 }
202
203 EncStream *stream_create() {
204   EncStream *stream;
205   stream = malloc(sizeof(*stream));
206   if (!stream) return NULL;
207   stream->next = NULL;
208   stream->close_at_end = 1;
209   stream->serialno_is_set = 0;
210   stream->seen_file_icons = 0;
211   stream->stream_is_init = 0;
212   stream->header_is_frozen = 0;
213   stream->granule_offset = 0;
214   stream->comment = NULL;
215   comment_init(&stream->comment, &stream->comment_length, opus_get_version_string());
216   if (!stream->comment) goto fail;
217   {
218     char encoder_string[1024];
219     snprintf(encoder_string, sizeof(encoder_string), "%s version %s", PACKAGE_NAME, PACKAGE_VERSION);
220     comment_add(&stream->comment, &stream->comment_length, "ENCODER", encoder_string);
221   }
222   return stream;
223 fail:
224   if (stream->comment) free(stream->comment);
225   free(stream);
226   return NULL;
227 }
228
229 static void stream_destroy(EncStream *stream) {
230   if (stream->comment) free(stream->comment);
231 #ifndef USE_OGGP
232   if (stream->stream_is_init) ogg_stream_clear(&stream->os);
233 #endif
234   free(stream);
235 }
236
237 /* Create a new OggOpus file (callback-based). */
238 OggOpusEnc *ope_create_callbacks(const OpusEncCallbacks *callbacks, void *user_data,
239     int rate, int channels, int family, int *error) {
240   OpusMSEncoder *st=NULL;
241   OggOpusEnc *enc=NULL;
242   int ret;
243   if (family != 0 && family != 1 && family != 255) {
244     if (error) *error = OPE_UNIMPLEMENTED;
245     return NULL;
246   }
247   if (channels <= 0 || channels > 255) {
248     if (error) *error = OPE_BAD_ARG;
249     return NULL;
250   }
251   if (rate <= 0) {
252     if (error) *error = OPE_BAD_ARG;
253     return NULL;
254   }
255
256   if ( (enc = malloc(sizeof(*enc))) == NULL) goto fail;
257   enc->streams = NULL;
258   if ( (enc->streams = stream_create()) == NULL) goto fail;
259   enc->streams->next = NULL;
260   enc->last_stream = enc->streams;
261 #ifdef USE_OGGP
262   enc->oggp = NULL;
263 #endif
264   enc->unrecoverable = 0;
265   enc->pull_api = 0;
266   enc->packet_callback = NULL;
267   enc->rate = rate;
268   enc->channels = channels;
269   enc->frame_size = 960;
270   enc->decision_delay = 96000;
271   enc->max_ogg_delay = 48000;
272   enc->chaining_keyframe = NULL;
273   enc->chaining_keyframe_length = -1;
274   enc->comment_padding = 512;
275   enc->header.channels=channels;
276   enc->header.channel_mapping=family;
277   enc->header.input_sample_rate=rate;
278   enc->header.gain=0;
279   st=opus_multistream_surround_encoder_create(48000, channels, enc->header.channel_mapping,
280       &enc->header.nb_streams, &enc->header.nb_coupled,
281       enc->header.stream_map, OPUS_APPLICATION_AUDIO, &ret);
282   if (! (ret == OPUS_OK && st != NULL) ) {
283     goto fail;
284   }
285   if (rate != 48000) {
286     enc->re = speex_resampler_init(channels, rate, 48000, 5, NULL);
287     if (enc->re == NULL) goto fail;
288     speex_resampler_skip_zeros(enc->re);
289   } else {
290     enc->re = NULL;
291   }
292   opus_multistream_encoder_ctl(st, OPUS_SET_EXPERT_FRAME_DURATION(OPUS_FRAMESIZE_20_MS));
293   {
294     opus_int32 tmp;
295     int ret;
296     ret = opus_multistream_encoder_ctl(st, OPUS_GET_LOOKAHEAD(&tmp));
297     if (ret == OPUS_OK) enc->header.preskip = tmp;
298     else enc->header.preskip = 0;
299     enc->global_granule_offset = enc->header.preskip;
300   }
301   enc->curr_granule = 0;
302   enc->write_granule = 0;
303   enc->last_page_granule = 0;
304   if ( (enc->buffer = malloc(sizeof(*enc->buffer)*BUFFER_SAMPLES*channels)) == NULL) goto fail;
305   enc->buffer_start = enc->buffer_end = 0;
306   enc->st = st;
307   enc->callbacks = *callbacks;
308   enc->streams->user_data = user_data;
309   if (error) *error = OPE_OK;
310   return enc;
311 fail:
312   if (enc) {
313     free(enc);
314     if (enc->buffer) free(enc->buffer);
315     if (enc->streams) stream_destroy(enc->streams);
316   }
317   if (st) {
318     opus_multistream_encoder_destroy(st);
319   }
320   if (error) *error = OPE_ALLOC_FAIL;
321   return NULL;
322 }
323
324 /* Create a new OggOpus stream, pulling one page at a time. */
325 OPE_EXPORT OggOpusEnc *ope_create_pull(int rate, int channels, int family, int *error) {
326   OggOpusEnc *enc = ope_create_callbacks(NULL, NULL, rate, channels, family, error);
327   enc->pull_api = 1;
328   return enc;
329 }
330
331 static void init_stream(OggOpusEnc *enc) {
332   assert(!enc->streams->stream_is_init);
333   if (!enc->streams->serialno_is_set) {
334     enc->streams->serialno = rand();
335   }
336
337 #ifdef USE_OGGP
338   if (enc->oggp != NULL) oggp_chain(enc->oggp, enc->streams->serialno);
339   else {
340     enc->oggp = oggp_create(enc->streams->serialno);
341     if (enc->oggp == NULL) {
342       enc->unrecoverable = 1;
343       return;
344     }
345     oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
346   }
347 #else
348   if (ogg_stream_init(&enc->streams->os, enc->streams->serialno) == -1) {
349     enc->unrecoverable = 1;
350     return;
351   }
352 #endif
353   comment_pad(&enc->streams->comment, &enc->streams->comment_length, enc->comment_padding);
354
355   /*Write header*/
356   {
357 #ifdef USE_OGGP
358     unsigned char *p;
359     p = oggp_get_packet_buffer(enc->oggp, 276);
360     int packet_size = opus_header_to_packet(&enc->header, p, 276);
361     oggp_commit_packet(enc->oggp, packet_size, 0, 0);
362     oe_flush_page(enc);
363     p = oggp_get_packet_buffer(enc->oggp, enc->streams->comment_length);
364     memcpy(p, enc->streams->comment, enc->streams->comment_length);
365     oggp_commit_packet(enc->oggp, enc->streams->comment_length, 0, 0);
366     oe_flush_page(enc);
367
368 #else
369
370     ogg_packet op;
371     /*The Identification Header is 19 bytes, plus a Channel Mapping Table for
372       mapping families other than 0. The Channel Mapping Table is 2 bytes +
373       1 byte per channel. Because the maximum number of channels is 255, the
374       maximum size of this header is 19 + 2 + 255 = 276 bytes.*/
375     unsigned char header_data[276];
376     int packet_size = opus_header_to_packet(&enc->header, header_data, sizeof(header_data));
377     op.packet=header_data;
378     op.bytes=packet_size;
379     op.b_o_s=1;
380     op.e_o_s=0;
381     op.granulepos=0;
382     op.packetno=0;
383     ogg_stream_packetin(&enc->streams->os, &op);
384     oe_flush_page(enc);
385
386     op.packet = (unsigned char *)enc->streams->comment;
387     op.bytes = enc->streams->comment_length;
388     op.b_o_s = 0;
389     op.e_o_s = 0;
390     op.granulepos = 0;
391     op.packetno = 1;
392     ogg_stream_packetin(&enc->streams->os, &op);
393     oe_flush_page(enc);
394 #endif
395   }
396   enc->streams->stream_is_init = 1;
397   enc->streams->packetno = 2;
398 }
399
400 static void shift_buffer(OggOpusEnc *enc) {
401   /* Leaving enough in the buffer to do LPC extension if needed. */
402   if (enc->buffer_start > LPC_INPUT) {
403     memmove(&enc->buffer[enc->channels*LPC_INPUT], &enc->buffer[enc->channels*enc->buffer_start], enc->channels*(enc->buffer_end-enc->buffer_start)*sizeof(*enc->buffer));
404     enc->buffer_end -= enc->buffer_start-LPC_INPUT;
405     enc->buffer_start = LPC_INPUT;
406   }
407 }
408
409 static void encode_buffer(OggOpusEnc *enc) {
410   /* Round up when converting the granule pos because the decoder will round down. */
411   ogg_int64_t end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
412   while (enc->buffer_end-enc->buffer_start > enc->frame_size + enc->decision_delay) {
413     int cont;
414     opus_int32 pred;
415     int flush_needed;
416     ogg_packet op;
417 #ifndef USE_OGGP
418     ogg_page og;
419 #endif
420     int nbBytes;
421     unsigned char packet[MAX_PACKET_SIZE];
422     int is_keyframe=0;
423     if (enc->unrecoverable) return;
424     opus_multistream_encoder_ctl(enc->st, OPUS_GET_PREDICTION_DISABLED(&pred));
425     /* FIXME: a frame that follows a keyframe generally doesn't need to be a keyframe
426        unless there's two consecutive stream boundaries. */
427     if (enc->curr_granule + 2*enc->frame_size>= end_granule48k && enc->streams->next) {
428       opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(1));
429       is_keyframe = 1;
430     }
431     nbBytes = opus_multistream_encode_float(enc->st, &enc->buffer[enc->channels*enc->buffer_start],
432         enc->buffer_end-enc->buffer_start, packet, MAX_PACKET_SIZE);
433     if (nbBytes < 0) {
434       /* Anything better we can do here? */
435       enc->unrecoverable = 1;
436       return;
437     }
438     opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(pred));
439     assert(nbBytes > 0);
440     enc->curr_granule += enc->frame_size;
441     op.packet=packet;
442     op.bytes=nbBytes;
443     op.b_o_s=0;
444     op.packetno=enc->streams->packetno++;
445     do {
446       op.granulepos=enc->curr_granule-enc->streams->granule_offset;
447       op.e_o_s=enc->curr_granule >= end_granule48k;
448       cont = 0;
449       if (op.e_o_s) op.granulepos=end_granule48k-enc->streams->granule_offset;
450 #ifdef USE_OGGP
451       {
452         unsigned char *p;
453         p = oggp_get_packet_buffer(enc->oggp, MAX_PACKET_SIZE);
454         memcpy(p, packet, nbBytes);
455         oggp_commit_packet(enc->oggp, nbBytes, op.granulepos, op.e_o_s);
456       }
457 #else
458       ogg_stream_packetin(&enc->streams->os, &op);
459 #endif
460       if (enc->packet_callback) enc->packet_callback(enc->streams->user_data, op.packet, op.bytes, 0);
461       /* FIXME: Also flush on too many segments. */
462 #ifdef USE_OGGP
463       flush_needed = op.e_o_s;
464       if (flush_needed) oe_flush_page(enc);
465       else if (!enc->pull_api) output_pages(enc);
466 #else
467       flush_needed = op.e_o_s || enc->curr_granule - enc->last_page_granule >= enc->max_ogg_delay;
468       if (flush_needed) {
469         oe_flush_page(enc);
470       } else {
471         while (ogg_stream_pageout_fill(&enc->streams->os, &og, 255*255)) {
472           if (ogg_page_packets(&og) != 0) enc->last_page_granule = ogg_page_granulepos(&og) + enc->streams->granule_offset;
473           int ret = oe_write_page(enc, &og, enc->streams->user_data);
474           /* FIXME: what do we do if this fails? */
475           assert(ret != -1);
476         }
477       }
478 #endif
479       if (op.e_o_s) {
480         EncStream *tmp;
481         tmp = enc->streams->next;
482         if (enc->streams->close_at_end) enc->callbacks.close(enc->streams->user_data);
483         stream_destroy(enc->streams);
484         enc->streams = tmp;
485         if (!tmp) enc->last_stream = NULL;
486         if (enc->last_stream == NULL) return;
487         /* We're done with this stream, start the next one. */
488         enc->header.preskip = end_granule48k + enc->frame_size - enc->curr_granule;
489         enc->streams->granule_offset = enc->curr_granule - enc->frame_size;
490         if (enc->chaining_keyframe) {
491           enc->header.preskip += enc->frame_size;
492           enc->streams->granule_offset -= enc->frame_size;
493         }
494         init_stream(enc);
495         if (enc->chaining_keyframe) {
496           ogg_packet op2;
497           op2.packet = enc->chaining_keyframe;
498           op2.bytes = enc->chaining_keyframe_length;
499           op2.b_o_s = 0;
500           op2.e_o_s = 0;
501           op2.packetno=enc->streams->packetno++;
502           op2.granulepos=enc->curr_granule - enc->streams->granule_offset - enc->frame_size;
503 #ifdef USE_OGGP
504           {
505             unsigned char *p;
506             p = oggp_get_packet_buffer(enc->oggp, MAX_PACKET_SIZE);
507             memcpy(p, enc->chaining_keyframe, enc->chaining_keyframe_length);
508             oggp_commit_packet(enc->oggp, enc->chaining_keyframe_length, op2.granulepos, 0);
509           }
510 #else
511           ogg_stream_packetin(&enc->streams->os, &op2);
512 #endif
513           if (enc->packet_callback) enc->packet_callback(enc->streams->user_data, op2.packet, op2.bytes, 0);
514         }
515         end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
516         cont = 1;
517       }
518     } while (cont);
519     if (enc->chaining_keyframe) free(enc->chaining_keyframe);
520     if (is_keyframe) {
521       enc->chaining_keyframe = malloc(nbBytes);
522       enc->chaining_keyframe_length = nbBytes;
523       memcpy(enc->chaining_keyframe, packet, nbBytes);
524     } else {
525       enc->chaining_keyframe = NULL;
526       enc->chaining_keyframe_length = -1;
527     }
528     enc->buffer_start += enc->frame_size;
529   }
530   /* If we've reached the end of the buffer, move everything back to the front. */
531   if (enc->buffer_end == BUFFER_SAMPLES) {
532     shift_buffer(enc);
533   }
534   /* This function must never leave the buffer full. */
535   assert(enc->buffer_end < BUFFER_SAMPLES);
536 }
537
538 /* Add/encode any number of float samples to the file. */
539 int ope_write_float(OggOpusEnc *enc, const float *pcm, int samples_per_channel) {
540   int channels = enc->channels;
541   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
542   enc->last_stream->header_is_frozen = 1;
543   if (!enc->streams->stream_is_init) init_stream(enc);
544   if (samples_per_channel < 0) return OPE_BAD_ARG;
545   enc->write_granule += samples_per_channel;
546   enc->last_stream->end_granule = enc->write_granule;
547   do {
548     int i;
549     spx_uint32_t in_samples, out_samples;
550     out_samples = BUFFER_SAMPLES-enc->buffer_end;
551     if (enc->re != NULL) {
552       in_samples = samples_per_channel;
553       speex_resampler_process_interleaved_float(enc->re, pcm, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
554     } else {
555       int curr;
556       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
557       for (i=0;i<channels*curr;i++) {
558       enc->buffer[channels*enc->buffer_end+i] = pcm[i];
559       }
560       in_samples = out_samples = curr;
561     }
562     enc->buffer_end += out_samples;
563     pcm += in_samples*channels;
564     samples_per_channel -= in_samples;
565     encode_buffer(enc);
566     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
567   } while (samples_per_channel > 0);
568   return OPE_OK;
569 }
570
571 #define CONVERT_BUFFER 256
572
573 /* Add/encode any number of int16 samples to the file. */
574 int ope_write(OggOpusEnc *enc, const opus_int16 *pcm, int samples_per_channel) {
575   int channels = enc->channels;
576   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
577   enc->last_stream->header_is_frozen = 1;
578   if (!enc->streams->stream_is_init) init_stream(enc);
579   if (samples_per_channel < 0) return OPE_BAD_ARG;
580   enc->write_granule += samples_per_channel;
581   enc->last_stream->end_granule = enc->write_granule;
582   do {
583     int i;
584     spx_uint32_t in_samples, out_samples;
585     out_samples = BUFFER_SAMPLES-enc->buffer_end;
586     if (enc->re != NULL) {
587       float buf[CONVERT_BUFFER*MAX_CHANNELS];
588       in_samples = MIN(CONVERT_BUFFER, samples_per_channel);
589       for (i=0;i<channels*(int)in_samples;i++) {
590         buf[i] = (1.f/32768)*pcm[i];
591       }
592       speex_resampler_process_interleaved_float(enc->re, buf, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
593     } else {
594       int curr;
595       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
596       for (i=0;i<channels*curr;i++) {
597         enc->buffer[channels*enc->buffer_end+i] = (1.f/32768)*pcm[i];
598       }
599       in_samples = out_samples = curr;
600     }
601     enc->buffer_end += out_samples;
602     pcm += in_samples*channels;
603     samples_per_channel -= in_samples;
604     encode_buffer(enc);
605     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
606   } while (samples_per_channel > 0);
607   return OPE_OK;
608 }
609
610 /* Get the next page from the stream. Returns 1 if there is a page available, 0 if not. */
611 OPE_EXPORT int ope_get_page(OggOpusEnc *enc, unsigned char **page, int *len, int flush) {
612   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
613   if (!enc->pull_api) return 0;
614   else {
615     if (flush) oggp_flush_page(enc->oggp);
616     return oggp_get_next_page(enc->oggp, page, len);
617   }
618 }
619
620 static void extend_signal(float *x, int before, int after, int channels);
621
622 int ope_drain(OggOpusEnc *enc) {
623   int pad_samples;
624   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
625   /* Check if it's already been drained. */
626   if (enc->streams == NULL) return OPE_TOO_LATE;
627   pad_samples = MAX(LPC_PADDING, enc->global_granule_offset + enc->frame_size);
628   if (!enc->streams->stream_is_init) init_stream(enc);
629   shift_buffer(enc);
630   assert(enc->buffer_end + pad_samples <= BUFFER_SAMPLES);
631   memset(&enc->buffer[enc->channels*enc->buffer_end], 0, pad_samples*enc->channels*sizeof(enc->buffer[0]));
632   extend_signal(&enc->buffer[enc->channels*enc->buffer_end], enc->buffer_end, LPC_PADDING, enc->channels);
633   enc->decision_delay = 0;
634   enc->buffer_end += pad_samples;
635   assert(enc->buffer_end <= BUFFER_SAMPLES);
636   encode_buffer(enc);
637   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
638   /* Draining should have called all the streams to complete. */
639   assert(enc->streams == NULL);
640   return OPE_OK;
641 }
642
643 void ope_destroy(OggOpusEnc *enc) {
644   EncStream *stream;
645   stream = enc->streams;
646   while (stream != NULL) {
647     EncStream *tmp = stream;
648     stream = stream->next;
649     if (tmp->close_at_end) enc->callbacks.close(tmp->user_data);
650     stream_destroy(tmp);
651   }
652   if (enc->chaining_keyframe) free(enc->chaining_keyframe);
653   free(enc->buffer);
654 #ifdef USE_OGGP
655   if (enc->oggp) oggp_destroy(enc->oggp);
656 #endif
657   opus_multistream_encoder_destroy(enc->st);
658   if (enc->re) speex_resampler_destroy(enc->re);
659   free(enc);
660 }
661
662 /* Ends the stream and create a new stream within the same file. */
663 int ope_chain_current(OggOpusEnc *enc) {
664   enc->last_stream->close_at_end = 0;
665   return ope_continue_new_callbacks(enc, enc->last_stream->user_data);
666 }
667
668 /* Ends the stream and create a new file. */
669 int ope_continue_new_file(OggOpusEnc *enc, const char *path) {
670   int ret;
671   struct StdioObject *obj;
672   if (!(obj = malloc(sizeof(*obj)))) return OPE_ALLOC_FAIL;
673   obj->file = fopen(path, "wb");
674   if (!obj->file) {
675     free(obj);
676     /* By trying to open the file first, we can recover if we can't open it. */
677     return OPE_CANNOT_OPEN;
678   }
679   ret = ope_continue_new_callbacks(enc, obj);
680   if (ret == OPE_OK) return ret;
681   fclose(obj->file);
682   free(obj);
683   return ret;
684 }
685
686 /* Ends the stream and create a new file (callback-based). */
687 int ope_continue_new_callbacks(OggOpusEnc *enc, void *user_data) {
688   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
689   EncStream *new_stream;
690   assert(enc->streams);
691   assert(enc->last_stream);
692   new_stream = stream_create();
693   if (!new_stream) return OPE_ALLOC_FAIL;
694   new_stream->user_data = user_data;
695   enc->last_stream->next = new_stream;
696   enc->last_stream = new_stream;
697   return OPE_OK;
698 }
699
700 /* Add a comment to the file (can only be called before encoding samples). */
701 int ope_add_comment(OggOpusEnc *enc, const char *tag, const char *val) {
702   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
703   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
704   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
705   if (comment_add(&enc->last_stream->comment, &enc->last_stream->comment_length, tag, val)) return OPE_ALLOC_FAIL;
706   return OPE_OK;
707 }
708
709 int ope_add_picture(OggOpusEnc *enc, const char *spec) {
710   const char *error_message;
711   char *picture_data;
712   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
713   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
714   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
715   picture_data = parse_picture_specification(spec, &error_message, &enc->last_stream->seen_file_icons);
716   if(picture_data==NULL){
717     /* FIXME: return proper errors rather than printing a message. */
718     fprintf(stderr,"Error parsing picture option: %s\n",error_message);
719     return OPE_BAD_ARG;
720   }
721   comment_add(&enc->last_stream->comment, &enc->last_stream->comment_length, "METADATA_BLOCK_PICTURE", picture_data);
722   free(picture_data);
723   return OPE_OK;
724 }
725
726 /* Sets the Opus comment vendor string (optional, defaults to library info). */
727 int ope_set_vendor_string(OggOpusEnc *enc, const char *vendor) {
728   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
729   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
730   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
731   if (comment_replace_vendor_string(&enc->last_stream->comment, &enc->last_stream->comment_length, vendor)) return OPE_ALLOC_FAIL;
732   return OPE_OK;
733 }
734
735 int ope_flush_header(OggOpusEnc *enc) {
736   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
737   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
738   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
739   else init_stream(enc);
740   return OPE_OK;
741 }
742
743 /* Goes straight to the libopus ctl() functions. */
744 int ope_encoder_ctl(OggOpusEnc *enc, int request, ...) {
745   int ret;
746   int translate;
747   va_list ap;
748   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
749   va_start(ap, request);
750   switch (request) {
751     case OPUS_SET_APPLICATION_REQUEST:
752     case OPUS_SET_BITRATE_REQUEST:
753     case OPUS_SET_MAX_BANDWIDTH_REQUEST:
754     case OPUS_SET_VBR_REQUEST:
755     case OPUS_SET_BANDWIDTH_REQUEST:
756     case OPUS_SET_COMPLEXITY_REQUEST:
757     case OPUS_SET_INBAND_FEC_REQUEST:
758     case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
759     case OPUS_SET_DTX_REQUEST:
760     case OPUS_SET_VBR_CONSTRAINT_REQUEST:
761     case OPUS_SET_FORCE_CHANNELS_REQUEST:
762     case OPUS_SET_SIGNAL_REQUEST:
763     case OPUS_SET_LSB_DEPTH_REQUEST:
764     case OPUS_SET_PREDICTION_DISABLED_REQUEST:
765 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
766     case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
767 #endif
768     {
769       opus_int32 value = va_arg(ap, opus_int32);
770       ret = opus_multistream_encoder_ctl(enc->st, request, value);
771     }
772     break;
773     case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
774     {
775       opus_int32 value = va_arg(ap, opus_int32);
776       int max_supported = OPUS_FRAMESIZE_60_MS;
777 #ifdef OPUS_FRAMESIZE_120_MS
778       max_supported = OPUS_FRAMESIZE_120_MS;
779 #endif
780       if (value < OPUS_FRAMESIZE_2_5_MS || value > max_supported) {
781         ret = OPUS_UNIMPLEMENTED;
782         break;
783       }
784       ret = opus_multistream_encoder_ctl(enc->st, request, value);
785       if (ret == OPUS_OK) {
786         if (value <= OPUS_FRAMESIZE_40_MS)
787           enc->frame_size = 120<<(value-OPUS_FRAMESIZE_2_5_MS);
788         else
789           enc->frame_size = (value-OPUS_FRAMESIZE_2_5_MS-2)*960;
790       }
791     }
792     break;
793     case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
794     {
795       opus_int32 stream_id;
796       OpusEncoder **value;
797       stream_id = va_arg(ap, opus_int32);
798       value = va_arg(ap, OpusEncoder**);
799       ret = opus_multistream_encoder_ctl(enc->st, request, stream_id, value);
800     }
801     break;
802
803     /* ****************** libopusenc-specific requests. ********************** */
804     case OPE_SET_DECISION_DELAY_REQUEST:
805     {
806       opus_int32 value = va_arg(ap, opus_int32);
807       if (value < 0) {
808         ret = OPE_BAD_ARG;
809         break;
810       }
811       enc->decision_delay = value;
812       ret = OPE_OK;
813     }
814     break;
815     case OPE_SET_MUXING_DELAY_REQUEST:
816     {
817       opus_int32 value = va_arg(ap, opus_int32);
818       if (value < 0) {
819         ret = OPE_BAD_ARG;
820         break;
821       }
822       enc->max_ogg_delay = value;
823 #ifdef USE_OGGP
824       oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
825 #endif
826       ret = OPE_OK;
827     }
828     break;
829     case OPE_SET_COMMENT_PADDING_REQUEST:
830     {
831       opus_int32 value = va_arg(ap, opus_int32);
832       if (value < 0) {
833         ret = OPE_BAD_ARG;
834         break;
835       }
836       enc->comment_padding = value;
837       ret = OPE_OK;
838     }
839     break;
840     case OPE_SET_SERIALNO_REQUEST:
841     {
842       opus_int32 value = va_arg(ap, opus_int32);
843       if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
844       enc->last_stream->serialno = value;
845       enc->last_stream->serialno_is_set = 1;
846       ret = OPE_OK;
847     }
848     case OPE_SET_PACKET_CALLBACK_REQUEST:
849     {
850       ope_packet_func value = va_arg(ap, ope_packet_func);
851       enc->packet_callback = value;
852       ret = OPE_OK;
853     }
854     break;
855     default:
856       return OPE_UNIMPLEMENTED;
857   }
858   va_end(ap);
859   translate = request < 14000 || (ret < 0 && ret >= -10);
860   if (translate) {
861     if (ret == OPUS_BAD_ARG) ret = OPE_BAD_ARG;
862     else if (ret == OPUS_INTERNAL_ERROR) ret = OPE_INTERNAL_ERROR;
863     else if (ret == OPUS_UNIMPLEMENTED) ret = OPE_UNIMPLEMENTED;
864     else if (ret == OPUS_ALLOC_FAIL) ret = OPE_ALLOC_FAIL;
865     else ret = OPE_INTERNAL_ERROR;
866   }
867   assert(ret == 0 || ret < -10);
868   return ret;
869 }
870
871
872 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride);
873
874 static void extend_signal(float *x, int before, int after, int channels) {
875   int c;
876   int i;
877   float window[LPC_PADDING];
878   if (after==0) return;
879   before = MIN(before, LPC_INPUT);
880   if (before < 4*LPC_ORDER) {
881     int i;
882     for (i=0;i<after*channels;i++) x[i] = 0;
883     return;
884   }
885   {
886     /* Generate Window using a resonating IIR aka Goertzel's algorithm. */
887     float m0=1, m1=1;
888     float a1 = LPC_GOERTZEL_CONST;
889     window[0] = 1;
890     for (i=1;i<LPC_PADDING;i++) {
891       window[i] = a1*m0 - m1;
892       m1 = m0;
893       m0 = window[i];
894     }
895     for (i=0;i<LPC_PADDING;i++) window[i] = .5+.5*window[i];
896   }
897   for (c=0;c<channels;c++) {
898     float lpc[LPC_ORDER];
899     vorbis_lpc_from_data(x-channels*before+c, lpc, before, channels);
900     for (i=0;i<after;i++) {
901       float sum;
902       int j;
903       sum = 0;
904       for (j=0;j<LPC_ORDER;j++) sum -= x[(i-j-1)*channels + c]*lpc[j];
905       x[i*channels + c] = sum;
906     }
907     for (i=0;i<after;i++) x[i*channels + c] *= window[i];
908   }
909 }
910
911 /* Some of these routines (autocorrelator, LPC coefficient estimator)
912    are derived from code written by Jutta Degener and Carsten Bormann;
913    thus we include their copyright below.  The entirety of this file
914    is freely redistributable on the condition that both of these
915    copyright notices are preserved without modification.  */
916
917 /* Preserved Copyright: *********************************************/
918
919 /* Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
920 Technische Universita"t Berlin
921
922 Any use of this software is permitted provided that this notice is not
923 removed and that neither the authors nor the Technische Universita"t
924 Berlin are deemed to have made any representations as to the
925 suitability of this software for any purpose nor are held responsible
926 for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR
927 THIS SOFTWARE.
928
929 As a matter of courtesy, the authors request to be informed about uses
930 this software has found, about bugs in this software, and about any
931 improvements that may be of general interest.
932
933 Berlin, 28.11.1994
934 Jutta Degener
935 Carsten Bormann
936
937 *********************************************************************/
938
939 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride) {
940   double aut[LPC_ORDER+1];
941   double lpc[LPC_ORDER];
942   double error;
943   double epsilon;
944   int i,j;
945
946   /* FIXME: Apply a window to the input. */
947   /* autocorrelation, p+1 lag coefficients */
948   j=LPC_ORDER+1;
949   while(j--){
950     double d=0; /* double needed for accumulator depth */
951     for(i=j;i<n;i++)d+=(double)data[i*stride]*data[(i-j)*stride];
952     aut[j]=d;
953   }
954
955   /* Apply lag windowing (better than bandwidth expansion) */
956   if (LPC_ORDER <= 64) {
957     for (i=1;i<=LPC_ORDER;i++) {
958       /* Approximate this gaussian for low enough order. */
959       /* aut[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
960       aut[i] -= aut[i]*(0.008f*0.008f)*i*i;
961     }
962   }
963   /* Generate lpc coefficients from autocorr values */
964
965   /* set our noise floor to about -100dB */
966   error=aut[0] * (1. + 1e-7);
967   epsilon=1e-6*aut[0]+1e-7;
968
969   for(i=0;i<LPC_ORDER;i++){
970     double r= -aut[i+1];
971
972     if(error<epsilon){
973       memset(lpc+i,0,(LPC_ORDER-i)*sizeof(*lpc));
974       goto done;
975     }
976
977     /* Sum up this iteration's reflection coefficient; note that in
978        Vorbis we don't save it.  If anyone wants to recycle this code
979        and needs reflection coefficients, save the results of 'r' from
980        each iteration. */
981
982     for(j=0;j<i;j++)r-=lpc[j]*aut[i-j];
983     r/=error;
984
985     /* Update LPC coefficients and total error */
986
987     lpc[i]=r;
988     for(j=0;j<i/2;j++){
989       double tmp=lpc[j];
990
991       lpc[j]+=r*lpc[i-1-j];
992       lpc[i-1-j]+=r*tmp;
993     }
994     if(i&1)lpc[j]+=lpc[j]*r;
995
996     error*=1.-r*r;
997
998   }
999
1000  done:
1001
1002   /* slightly damp the filter */
1003   {
1004     double g = .999;
1005     double damp = g;
1006     for(j=0;j<LPC_ORDER;j++){
1007       lpc[j]*=damp;
1008       damp*=g;
1009     }
1010   }
1011
1012   for(j=0;j<LPC_ORDER;j++)lpci[j]=(float)lpc[j];
1013 }
1014