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