Properly support > 8 channels
[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       /* FIXME: Also flush on too many segments. */
447       if (e_o_s) oe_flush_page(enc);
448       else if (!enc->pull_api) output_pages(enc);
449       if (e_o_s) {
450         EncStream *tmp;
451         tmp = enc->streams->next;
452         if (enc->streams->close_at_end) enc->callbacks.close(enc->streams->user_data);
453         stream_destroy(enc->streams);
454         enc->streams = tmp;
455         if (!tmp) enc->last_stream = NULL;
456         if (enc->last_stream == NULL) return;
457         /* We're done with this stream, start the next one. */
458         enc->header.preskip = end_granule48k + enc->frame_size - enc->curr_granule;
459         enc->streams->granule_offset = enc->curr_granule - enc->frame_size;
460         if (enc->chaining_keyframe) {
461           enc->header.preskip += enc->frame_size;
462           enc->streams->granule_offset -= enc->frame_size;
463         }
464         init_stream(enc);
465         if (enc->chaining_keyframe) {
466           opus_int64 granulepos2=enc->curr_granule - enc->streams->granule_offset - enc->frame_size;
467           p = oggp_get_packet_buffer(enc->oggp, MAX_PACKET_SIZE);
468           memcpy(p, enc->chaining_keyframe, enc->chaining_keyframe_length);
469           oggp_commit_packet(enc->oggp, enc->chaining_keyframe_length, granulepos2, 0);
470           if (enc->packet_callback) enc->packet_callback(enc->packet_callback_data, enc->chaining_keyframe, enc->chaining_keyframe_length, 0);
471         }
472         end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
473         cont = 1;
474       }
475     } while (cont);
476     if (enc->chaining_keyframe) free(enc->chaining_keyframe);
477     if (is_keyframe) {
478       enc->chaining_keyframe = malloc(nbBytes);
479       enc->chaining_keyframe_length = nbBytes;
480       memcpy(enc->chaining_keyframe, packet, nbBytes);
481     } else {
482       enc->chaining_keyframe = NULL;
483       enc->chaining_keyframe_length = -1;
484     }
485     enc->buffer_start += enc->frame_size;
486   }
487   /* If we've reached the end of the buffer, move everything back to the front. */
488   if (enc->buffer_end == BUFFER_SAMPLES) {
489     shift_buffer(enc);
490   }
491   /* This function must never leave the buffer full. */
492   assert(enc->buffer_end < BUFFER_SAMPLES);
493 }
494
495 /* Add/encode any number of float samples to the file. */
496 int ope_encoder_write_float(OggOpusEnc *enc, const float *pcm, int samples_per_channel) {
497   int channels = enc->channels;
498   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
499   enc->last_stream->header_is_frozen = 1;
500   if (!enc->streams->stream_is_init) init_stream(enc);
501   if (samples_per_channel < 0) return OPE_BAD_ARG;
502   enc->write_granule += samples_per_channel;
503   enc->last_stream->end_granule = enc->write_granule;
504   do {
505     int i;
506     spx_uint32_t in_samples, out_samples;
507     out_samples = BUFFER_SAMPLES-enc->buffer_end;
508     if (enc->re != NULL) {
509       in_samples = samples_per_channel;
510       speex_resampler_process_interleaved_float(enc->re, pcm, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
511     } else {
512       int curr;
513       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
514       for (i=0;i<channels*curr;i++) {
515       enc->buffer[channels*enc->buffer_end+i] = pcm[i];
516       }
517       in_samples = out_samples = curr;
518     }
519     enc->buffer_end += out_samples;
520     pcm += in_samples*channels;
521     samples_per_channel -= in_samples;
522     encode_buffer(enc);
523     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
524   } while (samples_per_channel > 0);
525   return OPE_OK;
526 }
527
528 #define CONVERT_BUFFER 4096
529
530 /* Add/encode any number of int16 samples to the file. */
531 int ope_encoder_write(OggOpusEnc *enc, const opus_int16 *pcm, int samples_per_channel) {
532   int channels = enc->channels;
533   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
534   enc->last_stream->header_is_frozen = 1;
535   if (!enc->streams->stream_is_init) init_stream(enc);
536   if (samples_per_channel < 0) return OPE_BAD_ARG;
537   enc->write_granule += samples_per_channel;
538   enc->last_stream->end_granule = enc->write_granule;
539   do {
540     int i;
541     spx_uint32_t in_samples, out_samples;
542     out_samples = BUFFER_SAMPLES-enc->buffer_end;
543     if (enc->re != NULL) {
544       float buf[CONVERT_BUFFER];
545       in_samples = MIN(CONVERT_BUFFER/channels, samples_per_channel);
546       for (i=0;i<channels*(int)in_samples;i++) {
547         buf[i] = (1.f/32768)*pcm[i];
548       }
549       speex_resampler_process_interleaved_float(enc->re, buf, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
550     } else {
551       int curr;
552       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
553       for (i=0;i<channels*curr;i++) {
554         enc->buffer[channels*enc->buffer_end+i] = (1.f/32768)*pcm[i];
555       }
556       in_samples = out_samples = curr;
557     }
558     enc->buffer_end += out_samples;
559     pcm += in_samples*channels;
560     samples_per_channel -= in_samples;
561     encode_buffer(enc);
562     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
563   } while (samples_per_channel > 0);
564   return OPE_OK;
565 }
566
567 /* Get the next page from the stream. Returns 1 if there is a page available, 0 if not. */
568 OPE_EXPORT int ope_encoder_get_page(OggOpusEnc *enc, unsigned char **page, opus_int32 *len, int flush) {
569   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
570   if (!enc->pull_api) return 0;
571   else {
572     if (flush) oggp_flush_page(enc->oggp);
573     return oggp_get_next_page(enc->oggp, page, len);
574   }
575 }
576
577 static void extend_signal(float *x, int before, int after, int channels);
578
579 int ope_encoder_drain(OggOpusEnc *enc) {
580   int pad_samples;
581   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
582   /* Check if it's already been drained. */
583   if (enc->streams == NULL) return OPE_TOO_LATE;
584   pad_samples = MAX(LPC_PADDING, enc->global_granule_offset + enc->frame_size);
585   if (!enc->streams->stream_is_init) init_stream(enc);
586   shift_buffer(enc);
587   assert(enc->buffer_end + pad_samples <= BUFFER_SAMPLES);
588   memset(&enc->buffer[enc->channels*enc->buffer_end], 0, pad_samples*enc->channels*sizeof(enc->buffer[0]));
589   extend_signal(&enc->buffer[enc->channels*enc->buffer_end], enc->buffer_end, LPC_PADDING, enc->channels);
590   enc->decision_delay = 0;
591   enc->buffer_end += pad_samples;
592   assert(enc->buffer_end <= BUFFER_SAMPLES);
593   encode_buffer(enc);
594   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
595   /* Draining should have called all the streams to complete. */
596   assert(enc->streams == NULL);
597   return OPE_OK;
598 }
599
600 void ope_encoder_destroy(OggOpusEnc *enc) {
601   EncStream *stream;
602   stream = enc->streams;
603   while (stream != NULL) {
604     EncStream *tmp = stream;
605     stream = stream->next;
606     if (tmp->close_at_end) enc->callbacks.close(tmp->user_data);
607     stream_destroy(tmp);
608   }
609   if (enc->chaining_keyframe) free(enc->chaining_keyframe);
610   free(enc->buffer);
611   if (enc->oggp) oggp_destroy(enc->oggp);
612   opus_multistream_encoder_destroy(enc->st);
613   if (enc->re) speex_resampler_destroy(enc->re);
614   free(enc);
615 }
616
617 /* Ends the stream and create a new stream within the same file. */
618 int ope_encoder_chain_current(OggOpusEnc *enc, const OggOpusComments *comments) {
619   enc->last_stream->close_at_end = 0;
620   return ope_encoder_continue_new_callbacks(enc, enc->last_stream->user_data, comments);
621 }
622
623 /* Ends the stream and create a new file. */
624 int ope_encoder_continue_new_file(OggOpusEnc *enc, const char *path, const OggOpusComments *comments) {
625   int ret;
626   struct StdioObject *obj;
627   if (!(obj = malloc(sizeof(*obj)))) return OPE_ALLOC_FAIL;
628   obj->file = fopen(path, "wb");
629   if (!obj->file) {
630     free(obj);
631     /* By trying to open the file first, we can recover if we can't open it. */
632     return OPE_CANNOT_OPEN;
633   }
634   ret = ope_encoder_continue_new_callbacks(enc, obj, comments);
635   if (ret == OPE_OK) return ret;
636   fclose(obj->file);
637   free(obj);
638   return ret;
639 }
640
641 /* Ends the stream and create a new file (callback-based). */
642 int ope_encoder_continue_new_callbacks(OggOpusEnc *enc, void *user_data, const OggOpusComments *comments) {
643   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
644   EncStream *new_stream;
645   assert(enc->streams);
646   assert(enc->last_stream);
647   new_stream = stream_create(comments);
648   if (!new_stream) return OPE_ALLOC_FAIL;
649   new_stream->user_data = user_data;
650   new_stream->end_granule = enc->write_granule;
651   enc->last_stream->next = new_stream;
652   enc->last_stream = new_stream;
653   return OPE_OK;
654 }
655
656 int ope_encoder_flush_header(OggOpusEnc *enc) {
657   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
658   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
659   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
660   else init_stream(enc);
661   return OPE_OK;
662 }
663
664 /* Goes straight to the libopus ctl() functions. */
665 int ope_encoder_ctl(OggOpusEnc *enc, int request, ...) {
666   int ret;
667   int translate;
668   va_list ap;
669   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
670   va_start(ap, request);
671   switch (request) {
672     case OPUS_SET_APPLICATION_REQUEST:
673     case OPUS_SET_BITRATE_REQUEST:
674     case OPUS_SET_MAX_BANDWIDTH_REQUEST:
675     case OPUS_SET_VBR_REQUEST:
676     case OPUS_SET_BANDWIDTH_REQUEST:
677     case OPUS_SET_COMPLEXITY_REQUEST:
678     case OPUS_SET_INBAND_FEC_REQUEST:
679     case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
680     case OPUS_SET_DTX_REQUEST:
681     case OPUS_SET_VBR_CONSTRAINT_REQUEST:
682     case OPUS_SET_FORCE_CHANNELS_REQUEST:
683     case OPUS_SET_SIGNAL_REQUEST:
684     case OPUS_SET_LSB_DEPTH_REQUEST:
685     case OPUS_SET_PREDICTION_DISABLED_REQUEST:
686 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
687     case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
688 #endif
689     {
690       opus_int32 value = va_arg(ap, opus_int32);
691       ret = opus_multistream_encoder_ctl(enc->st, request, value);
692     }
693     break;
694     case OPUS_GET_LOOKAHEAD_REQUEST:
695     {
696       opus_int32 *value = va_arg(ap, opus_int32*);
697       ret = opus_multistream_encoder_ctl(enc->st, request, value);
698     }
699     break;
700     case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
701     {
702       opus_int32 value = va_arg(ap, opus_int32);
703       int max_supported = OPUS_FRAMESIZE_60_MS;
704 #ifdef OPUS_FRAMESIZE_120_MS
705       max_supported = OPUS_FRAMESIZE_120_MS;
706 #endif
707       if (value < OPUS_FRAMESIZE_2_5_MS || value > max_supported) {
708         ret = OPUS_UNIMPLEMENTED;
709         break;
710       }
711       ret = opus_multistream_encoder_ctl(enc->st, request, value);
712       if (ret == OPUS_OK) {
713         if (value <= OPUS_FRAMESIZE_40_MS)
714           enc->frame_size = 120<<(value-OPUS_FRAMESIZE_2_5_MS);
715         else
716           enc->frame_size = (value-OPUS_FRAMESIZE_2_5_MS-2)*960;
717       }
718     }
719     break;
720     case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
721     {
722       opus_int32 stream_id;
723       OpusEncoder **value;
724       stream_id = va_arg(ap, opus_int32);
725       value = va_arg(ap, OpusEncoder**);
726       ret = opus_multistream_encoder_ctl(enc->st, request, stream_id, value);
727     }
728     break;
729
730     /* ****************** libopusenc-specific requests. ********************** */
731     case OPE_SET_DECISION_DELAY_REQUEST:
732     {
733       opus_int32 value = va_arg(ap, opus_int32);
734       if (value < 0) {
735         ret = OPE_BAD_ARG;
736         break;
737       }
738       enc->decision_delay = value;
739       ret = OPE_OK;
740     }
741     break;
742     case OPE_SET_MUXING_DELAY_REQUEST:
743     {
744       opus_int32 value = va_arg(ap, opus_int32);
745       if (value < 0) {
746         ret = OPE_BAD_ARG;
747         break;
748       }
749       enc->max_ogg_delay = value;
750       oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
751       ret = OPE_OK;
752     }
753     break;
754     case OPE_SET_COMMENT_PADDING_REQUEST:
755     {
756       opus_int32 value = va_arg(ap, opus_int32);
757       if (value < 0) {
758         ret = OPE_BAD_ARG;
759         break;
760       }
761       enc->comment_padding = value;
762       ret = OPE_OK;
763     }
764     break;
765     case OPE_SET_SERIALNO_REQUEST:
766     {
767       opus_int32 value = va_arg(ap, opus_int32);
768       if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
769       enc->last_stream->serialno = value;
770       enc->last_stream->serialno_is_set = 1;
771       ret = OPE_OK;
772     }
773     break;
774     case OPE_SET_PACKET_CALLBACK_REQUEST:
775     {
776       ope_packet_func value = va_arg(ap, ope_packet_func);
777       void *data = va_arg(ap, void *);
778       enc->packet_callback = value;
779       enc->packet_callback_data = data;
780       ret = OPE_OK;
781     }
782     break;
783     default:
784       return OPE_UNIMPLEMENTED;
785   }
786   va_end(ap);
787   translate = ret != 0 && (request < 14000 || (ret < 0 && ret >= -10));
788   if (translate) {
789     if (ret == OPUS_BAD_ARG) ret = OPE_BAD_ARG;
790     else if (ret == OPUS_INTERNAL_ERROR) ret = OPE_INTERNAL_ERROR;
791     else if (ret == OPUS_UNIMPLEMENTED) ret = OPE_UNIMPLEMENTED;
792     else if (ret == OPUS_ALLOC_FAIL) ret = OPE_ALLOC_FAIL;
793     else ret = OPE_INTERNAL_ERROR;
794   }
795   assert(ret == 0 || ret < -10);
796   return ret;
797 }
798
799 const char *ope_get_version_string(void)
800 {
801   return "libopusenc " PACKAGE_VERSION;
802 }
803
804 int ope_get_abi_version(void) {
805   return OPE_ABI_VERSION;
806 }
807
808 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride);
809
810 static void extend_signal(float *x, int before, int after, int channels) {
811   int c;
812   int i;
813   float window[LPC_PADDING];
814   if (after==0) return;
815   before = MIN(before, LPC_INPUT);
816   if (before < 4*LPC_ORDER) {
817     int i;
818     for (i=0;i<after*channels;i++) x[i] = 0;
819     return;
820   }
821   {
822     /* Generate Window using a resonating IIR aka Goertzel's algorithm. */
823     float m0=1, m1=.5*LPC_GOERTZEL_CONST;
824     float a1 = LPC_GOERTZEL_CONST;
825     window[0] = 1;
826     for (i=1;i<LPC_PADDING;i++) {
827       window[i] = a1*m0 - m1;
828       m1 = m0;
829       m0 = window[i];
830     }
831     for (i=0;i<LPC_PADDING;i++) window[i] = .5+.5*window[i];
832   }
833   for (c=0;c<channels;c++) {
834     float lpc[LPC_ORDER];
835     vorbis_lpc_from_data(x-channels*before+c, lpc, before, channels);
836     for (i=0;i<after;i++) {
837       float sum;
838       int j;
839       sum = 0;
840       for (j=0;j<LPC_ORDER;j++) sum -= x[(i-j-1)*channels + c]*lpc[j];
841       x[i*channels + c] = sum;
842     }
843     for (i=0;i<after;i++) x[i*channels + c] *= window[i];
844   }
845 }
846
847 /* Some of these routines (autocorrelator, LPC coefficient estimator)
848    are derived from code written by Jutta Degener and Carsten Bormann;
849    thus we include their copyright below.  The entirety of this file
850    is freely redistributable on the condition that both of these
851    copyright notices are preserved without modification.  */
852
853 /* Preserved Copyright: *********************************************/
854
855 /* Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
856 Technische Universita"t Berlin
857
858 Any use of this software is permitted provided that this notice is not
859 removed and that neither the authors nor the Technische Universita"t
860 Berlin are deemed to have made any representations as to the
861 suitability of this software for any purpose nor are held responsible
862 for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR
863 THIS SOFTWARE.
864
865 As a matter of courtesy, the authors request to be informed about uses
866 this software has found, about bugs in this software, and about any
867 improvements that may be of general interest.
868
869 Berlin, 28.11.1994
870 Jutta Degener
871 Carsten Bormann
872
873 *********************************************************************/
874
875 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride) {
876   double aut[LPC_ORDER+1];
877   double lpc[LPC_ORDER];
878   double error;
879   double epsilon;
880   int i,j;
881
882   /* FIXME: Apply a window to the input. */
883   /* autocorrelation, p+1 lag coefficients */
884   j=LPC_ORDER+1;
885   while(j--){
886     double d=0; /* double needed for accumulator depth */
887     for(i=j;i<n;i++)d+=(double)data[i*stride]*data[(i-j)*stride];
888     aut[j]=d;
889   }
890
891   /* Apply lag windowing (better than bandwidth expansion) */
892   if (LPC_ORDER <= 64) {
893     for (i=1;i<=LPC_ORDER;i++) {
894       /* Approximate this gaussian for low enough order. */
895       /* aut[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
896       aut[i] -= aut[i]*(0.008f*0.008f)*i*i;
897     }
898   }
899   /* Generate lpc coefficients from autocorr values */
900
901   /* set our noise floor to about -100dB */
902   error=aut[0] * (1. + 1e-7);
903   epsilon=1e-6*aut[0]+1e-7;
904
905   for(i=0;i<LPC_ORDER;i++){
906     double r= -aut[i+1];
907
908     if(error<epsilon){
909       memset(lpc+i,0,(LPC_ORDER-i)*sizeof(*lpc));
910       goto done;
911     }
912
913     /* Sum up this iteration's reflection coefficient; note that in
914        Vorbis we don't save it.  If anyone wants to recycle this code
915        and needs reflection coefficients, save the results of 'r' from
916        each iteration. */
917
918     for(j=0;j<i;j++)r-=lpc[j]*aut[i-j];
919     r/=error;
920
921     /* Update LPC coefficients and total error */
922
923     lpc[i]=r;
924     for(j=0;j<i/2;j++){
925       double tmp=lpc[j];
926
927       lpc[j]+=r*lpc[i-1-j];
928       lpc[i-1-j]+=r*tmp;
929     }
930     if(i&1)lpc[j]+=lpc[j]*r;
931
932     error*=1.-r*r;
933
934   }
935
936  done:
937
938   /* slightly damp the filter */
939   {
940     double g = .999;
941     double damp = g;
942     for(j=0;j<LPC_ORDER;j++){
943       lpc[j]*=damp;
944       damp*=g;
945     }
946   }
947
948   for(j=0;j<LPC_ORDER;j++)lpci[j]=(float)lpc[j];
949 }
950