45b40d35c08464619419c9ea648e608b0818b9f3
[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
52 /* Allow up to 2 seconds for delayed decision. */
53 #define MAX_LOOKAHEAD 96000
54 /* We can't have a circular buffer (because of delayed decision), so let's not copy too often. */
55 #define BUFFER_EXTRA 24000
56
57 #define BUFFER_SAMPLES (MAX_LOOKAHEAD + BUFFER_EXTRA)
58
59 #define MIN(a,b) ((a) < (b) ? (a) : (b))
60 #define MAX(a,b) ((a) > (b) ? (a) : (b))
61
62 #define MAX_PACKET_SIZE (1276*8)
63
64 //#define USE_OGGP
65
66 struct StdioObject {
67   FILE *file;
68 };
69
70 typedef struct EncStream EncStream;
71
72 struct EncStream {
73   void *user_data;
74 #ifndef USE_OGGP
75   ogg_stream_state os;
76 #endif
77   int serialno_is_set;
78   int serialno;
79   int stream_is_init;
80   int packetno;
81   char *comment;
82   int comment_length;
83   int seen_file_icons;
84   int close_at_end;
85   int header_is_frozen;
86   ogg_int64_t end_granule;
87   ogg_int64_t granule_offset;
88   EncStream *next;
89 };
90
91 struct OggOpusEnc {
92   OpusMSEncoder *st;
93 #ifdef USE_OGGP
94   oggpacker *oggp;
95 #endif
96   int rate;
97   int channels;
98   float *buffer;
99   int buffer_start;
100   int buffer_end;
101   SpeexResamplerState *re;
102   int frame_size;
103   int decision_delay;
104   int max_ogg_delay;
105   int global_granule_offset;
106   ogg_int64_t curr_granule;
107   ogg_int64_t write_granule;
108   ogg_int64_t last_page_granule;
109   unsigned char *chaining_keyframe;
110   int chaining_keyframe_length;
111   OpusEncCallbacks callbacks;
112   ope_packet_func packet_callback;
113   ope_page_func page_callback;
114   OpusHeader header;
115   int comment_padding;
116   EncStream *streams;
117   EncStream *last_stream;
118 };
119
120 #ifdef USE_OGGP
121 static void output_pages(OggOpusEnc *enc) {
122   unsigned char *page;
123   int len;
124   while (oggp_get_next_page(enc->oggp, &page, &len)) {
125     enc->callbacks.write(enc->streams->user_data, page, len);
126   }
127 }
128 static void oe_flush_page(OggOpusEnc *enc) {
129   oggp_flush_page(enc->oggp);
130   output_pages(enc);
131 }
132
133 #else
134
135 static int oe_write_page(OggOpusEnc *enc, ogg_page *page, void *user_data)
136 {
137   int length;
138   int err;
139   err = enc->callbacks.write(user_data, page->header, page->header_len);
140   if (err) return -1;
141   err = enc->callbacks.write(user_data, page->body, page->body_len);
142   if (err) return -1;
143   length = page->header_len+page->body_len;
144   if (enc->page_callback) enc->page_callback(user_data, length, 0);
145   return length;
146 }
147
148 static void oe_flush_page(OggOpusEnc *enc) {
149   ogg_page og;
150   int ret;
151
152   while ( (ret = ogg_stream_flush_fill(&enc->streams->os, &og, 255*255))) {
153     if (ogg_page_packets(&og) != 0) enc->last_page_granule = ogg_page_granulepos(&og) + enc->streams->granule_offset;
154     ret = oe_write_page(enc, &og, enc->streams->user_data);
155     if (ret == -1) {
156       return;
157     }
158   }
159 }
160 #endif
161
162
163 int stdio_write(void *user_data, const unsigned char *ptr, int len) {
164   struct StdioObject *obj = (struct StdioObject*)user_data;
165   return fwrite(ptr, 1, len, obj->file) != (size_t)len;
166 }
167
168 int stdio_close(void *user_data) {
169   struct StdioObject *obj = (struct StdioObject*)user_data;
170   int ret = fclose(obj->file);
171   free(obj);
172   return ret;
173 }
174
175 static const OpusEncCallbacks stdio_callbacks = {
176   stdio_write,
177   stdio_close
178 };
179
180 /* Create a new OggOpus file. */
181 OggOpusEnc *ope_create_file(const char *path, int rate, int channels, int family, int *error) {
182   OggOpusEnc *enc;
183   struct StdioObject *obj;
184   obj = malloc(sizeof(*obj));
185   enc = ope_create_callbacks(&stdio_callbacks, obj, rate, channels, family, error);
186   if (enc == NULL || (error && *error)) {
187     return NULL;
188   }
189   obj->file = fopen(path, "wb");
190   if (!obj->file) {
191     if (error) *error = OPE_CANNOT_OPEN;
192     /* FIXME: Destroy the encoder properly. */
193     free(obj);
194     return NULL;
195   }
196   return enc;
197 }
198
199 EncStream *stream_create() {
200   EncStream *stream;
201   stream = malloc(sizeof(*stream));
202   if (!stream) return NULL;
203   stream->next = NULL;
204   stream->close_at_end = 1;
205   stream->serialno_is_set = 0;
206   stream->seen_file_icons = 0;
207   stream->stream_is_init = 0;
208   stream->header_is_frozen = 0;
209   stream->granule_offset = 0;
210   stream->comment = NULL;
211   comment_init(&stream->comment, &stream->comment_length, opus_get_version_string());
212   if (!stream->comment) goto fail;
213   {
214     char encoder_string[1024];
215     snprintf(encoder_string, sizeof(encoder_string), "%s version %s", PACKAGE_NAME, PACKAGE_VERSION);
216     comment_add(&stream->comment, &stream->comment_length, "ENCODER", encoder_string);
217   }
218   return stream;
219 fail:
220   if (stream->comment) free(stream->comment);
221   free(stream);
222   return NULL;
223 }
224
225 static void stream_destroy(EncStream *stream) {
226   if (stream->comment) free(stream->comment);
227 #ifndef USE_OGGP
228   if (stream->stream_is_init) ogg_stream_clear(&stream->os);
229 #endif
230   free(stream);
231 }
232
233 /* Create a new OggOpus file (callback-based). */
234 OggOpusEnc *ope_create_callbacks(const OpusEncCallbacks *callbacks, void *user_data,
235     int rate, int channels, int family, int *error) {
236   OpusMSEncoder *st=NULL;
237   OggOpusEnc *enc=NULL;
238   int ret;
239   if (family != 0 && family != 1 && family != 255) {
240     if (error) *error = OPE_UNIMPLEMENTED;
241     return NULL;
242   }
243   if (channels <= 0 || channels > 255) {
244     if (error) *error = OPE_BAD_ARG;
245     return NULL;
246   }
247   /* FIXME: Add resampling support. */
248   if (rate <= 0) {
249     if (error) *error = OPE_BAD_ARG;
250     return NULL;
251   }
252
253   if ( (enc = malloc(sizeof(*enc))) == NULL) goto fail;
254   enc->streams = NULL;
255   if ( (enc->streams = stream_create()) == NULL) goto fail;
256   enc->streams->next = NULL;
257   enc->last_stream = enc->streams;
258 #ifdef USE_OGGP
259   enc->oggp = NULL;
260 #endif
261   enc->packet_callback = NULL;
262   enc->page_callback = NULL;
263   enc->rate = rate;
264   enc->channels = channels;
265   enc->frame_size = 960;
266   enc->decision_delay = 96000;
267   enc->max_ogg_delay = 48000;
268   enc->chaining_keyframe = NULL;
269   enc->chaining_keyframe_length = -1;
270   enc->comment_padding = 512;
271   enc->header.channels=channels;
272   enc->header.channel_mapping=family;
273   enc->header.input_sample_rate=rate;
274   enc->header.gain=0;
275   st=opus_multistream_surround_encoder_create(48000, channels, enc->header.channel_mapping,
276       &enc->header.nb_streams, &enc->header.nb_coupled,
277       enc->header.stream_map, OPUS_APPLICATION_AUDIO, &ret);
278   if (! (ret == OPUS_OK && st != NULL) ) {
279     goto fail;
280   }
281   if (rate != 48000) {
282     enc->re = speex_resampler_init(channels, rate, 48000, 5, NULL);
283     if (enc->re == NULL) goto fail;
284     speex_resampler_skip_zeros(enc->re);
285   } else {
286     enc->re = NULL;
287   }
288   opus_multistream_encoder_ctl(st, OPUS_SET_EXPERT_FRAME_DURATION(OPUS_FRAMESIZE_20_MS));
289   {
290     opus_int32 tmp;
291     int ret;
292     ret = opus_multistream_encoder_ctl(st, OPUS_GET_LOOKAHEAD(&tmp));
293     if (ret == OPUS_OK) enc->header.preskip = tmp;
294     else enc->header.preskip = 0;
295     enc->global_granule_offset = enc->header.preskip;
296   }
297   enc->curr_granule = 0;
298   enc->write_granule = 0;
299   enc->last_page_granule = 0;
300   if ( (enc->buffer = malloc(sizeof(*enc->buffer)*BUFFER_SAMPLES*channels)) == NULL) goto fail;
301   enc->buffer_start = enc->buffer_end = 0;
302   enc->st = st;
303   enc->callbacks = *callbacks;
304   enc->streams->user_data = user_data;
305   if (error) *error = OPE_OK;
306   return enc;
307 fail:
308   if (enc) {
309     free(enc);
310     if (enc->buffer) free(enc->buffer);
311     if (enc->streams) stream_destroy(enc->streams);
312   }
313   if (st) {
314     opus_multistream_encoder_destroy(st);
315   }
316   if (error) *error = OPE_ALLOC_FAIL;
317   return NULL;
318 }
319
320 static void init_stream(OggOpusEnc *enc) {
321   assert(!enc->streams->stream_is_init);
322   if (!enc->streams->serialno_is_set) {
323     enc->streams->serialno = rand();
324   }
325
326 #ifdef USE_OGGP
327   if (enc->oggp != NULL) oggp_chain(enc->oggp, enc->streams->serialno);
328   else {
329     enc->oggp = oggp_create(enc->streams->serialno);
330     /* FIXME: How the hell do we handle failure here? */
331     oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
332   }
333 #else
334   if (ogg_stream_init(&enc->streams->os, enc->streams->serialno) == -1) {
335     assert(0);
336     /* FIXME: How the hell do we handle that? */
337   }
338 #endif
339   comment_pad(&enc->streams->comment, &enc->streams->comment_length, enc->comment_padding);
340
341   /*Write header*/
342   {
343 #ifdef USE_OGGP
344     unsigned char *p;
345     p = oggp_get_packet_buffer(enc->oggp, 276);
346     int packet_size = opus_header_to_packet(&enc->header, p, 276);
347     oggp_commit_packet(enc->oggp, packet_size, 0, 0);
348     oe_flush_page(enc);
349     p = oggp_get_packet_buffer(enc->oggp, enc->streams->comment_length);
350     memcpy(p, enc->streams->comment, enc->streams->comment_length);
351     oggp_commit_packet(enc->oggp, enc->streams->comment_length, 0, 0);
352     oe_flush_page(enc);
353
354 #else
355
356     ogg_packet op;
357     /*The Identification Header is 19 bytes, plus a Channel Mapping Table for
358       mapping families other than 0. The Channel Mapping Table is 2 bytes +
359       1 byte per channel. Because the maximum number of channels is 255, the
360       maximum size of this header is 19 + 2 + 255 = 276 bytes.*/
361     unsigned char header_data[276];
362     int packet_size = opus_header_to_packet(&enc->header, header_data, sizeof(header_data));
363     op.packet=header_data;
364     op.bytes=packet_size;
365     op.b_o_s=1;
366     op.e_o_s=0;
367     op.granulepos=0;
368     op.packetno=0;
369     ogg_stream_packetin(&enc->streams->os, &op);
370     oe_flush_page(enc);
371
372     op.packet = (unsigned char *)enc->streams->comment;
373     op.bytes = enc->streams->comment_length;
374     op.b_o_s = 0;
375     op.e_o_s = 0;
376     op.granulepos = 0;
377     op.packetno = 1;
378     ogg_stream_packetin(&enc->streams->os, &op);
379     oe_flush_page(enc);
380 #endif
381   }
382   enc->streams->stream_is_init = 1;
383   enc->streams->packetno = 2;
384 }
385
386 static void shift_buffer(OggOpusEnc *enc) {
387     memmove(enc->buffer, &enc->buffer[enc->channels*enc->buffer_start], enc->channels*(enc->buffer_end-enc->buffer_start)*sizeof(*enc->buffer));
388     enc->buffer_end -= enc->buffer_start;
389     enc->buffer_start = 0;
390 }
391
392 static void encode_buffer(OggOpusEnc *enc) {
393   /* Round up when converting the granule pos because the decoder will round down. */
394   ogg_int64_t end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
395   while (enc->buffer_end-enc->buffer_start > enc->frame_size + enc->decision_delay) {
396     int cont;
397     opus_int32 pred;
398     int flush_needed;
399     ogg_packet op;
400 #ifndef USE_OGGP
401     ogg_page og;
402 #endif
403     int nbBytes;
404     unsigned char packet[MAX_PACKET_SIZE];
405     int is_keyframe=0;
406     opus_multistream_encoder_ctl(enc->st, OPUS_GET_PREDICTION_DISABLED(&pred));
407     /* FIXME: a frame that follows a keyframe generally doesn't need to be a keyframe
408        unless there's two consecutive stream boundaries. */
409     if (enc->curr_granule + 2*enc->frame_size>= end_granule48k && enc->streams->next) {
410       opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(1));
411       is_keyframe = 1;
412     }
413     nbBytes = opus_multistream_encode_float(enc->st, &enc->buffer[enc->channels*enc->buffer_start],
414         enc->buffer_end-enc->buffer_start, packet, MAX_PACKET_SIZE);
415     /* FIXME: How do we handle failure here. */
416     opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(pred));
417     assert(nbBytes > 0);
418     enc->curr_granule += enc->frame_size;
419     op.packet=packet;
420     op.bytes=nbBytes;
421     op.b_o_s=0;
422     op.packetno=enc->streams->packetno++;
423     do {
424       op.granulepos=enc->curr_granule-enc->streams->granule_offset;
425       op.e_o_s=enc->curr_granule >= end_granule48k;
426       cont = 0;
427       if (op.e_o_s) op.granulepos=end_granule48k-enc->streams->granule_offset;
428 #ifdef USE_OGGP
429       {
430         unsigned char *p;
431         p = oggp_get_packet_buffer(enc->oggp, MAX_PACKET_SIZE);
432         memcpy(p, packet, nbBytes);
433         oggp_commit_packet(enc->oggp, nbBytes, op.granulepos, op.e_o_s);
434       }
435 #else
436       ogg_stream_packetin(&enc->streams->os, &op);
437 #endif
438       if (enc->packet_callback) enc->packet_callback(enc->streams->user_data, op.packet, op.bytes, 0);
439       /* FIXME: Also flush on too many segments. */
440 #ifdef USE_OGGP
441       flush_needed = op.e_o_s;
442       if (flush_needed) oe_flush_page(enc);
443       else output_pages(enc);
444 #else
445       flush_needed = op.e_o_s || enc->curr_granule - enc->last_page_granule >= enc->max_ogg_delay;
446       if (flush_needed) {
447         oe_flush_page(enc);
448       } else {
449         while (ogg_stream_pageout_fill(&enc->streams->os, &og, 255*255)) {
450           if (ogg_page_packets(&og) != 0) enc->last_page_granule = ogg_page_granulepos(&og) + enc->streams->granule_offset;
451           int ret = oe_write_page(enc, &og, enc->streams->user_data);
452           /* FIXME: what do we do if this fails? */
453           assert(ret != -1);
454         }
455       }
456 #endif
457       if (op.e_o_s) {
458         EncStream *tmp;
459         tmp = enc->streams->next;
460         if (enc->streams->close_at_end) enc->callbacks.close(enc->streams->user_data);
461         stream_destroy(enc->streams);
462         enc->streams = tmp;
463         if (!tmp) enc->last_stream = NULL;
464         if (enc->last_stream == NULL) return;
465         /* We're done with this stream, start the next one. */
466         enc->header.preskip = end_granule48k + enc->frame_size - enc->curr_granule;
467         enc->streams->granule_offset = enc->curr_granule - enc->frame_size;
468         if (enc->chaining_keyframe) {
469           enc->header.preskip += enc->frame_size;
470           enc->streams->granule_offset -= enc->frame_size;
471         }
472         init_stream(enc);
473         if (enc->chaining_keyframe) {
474           ogg_packet op2;
475           op2.packet = enc->chaining_keyframe;
476           op2.bytes = enc->chaining_keyframe_length;
477           op2.b_o_s = 0;
478           op2.e_o_s = 0;
479           op2.packetno=enc->streams->packetno++;
480           op2.granulepos=enc->curr_granule - enc->streams->granule_offset - enc->frame_size;
481 #ifdef USE_OGGP
482           {
483             unsigned char *p;
484             p = oggp_get_packet_buffer(enc->oggp, MAX_PACKET_SIZE);
485             memcpy(p, enc->chaining_keyframe, enc->chaining_keyframe_length);
486             oggp_commit_packet(enc->oggp, enc->chaining_keyframe_length, op2.granulepos, 0);
487           }
488 #else
489           ogg_stream_packetin(&enc->streams->os, &op2);
490 #endif
491           if (enc->packet_callback) enc->packet_callback(enc->streams->user_data, op2.packet, op2.bytes, 0);
492         }
493         end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
494         cont = 1;
495       }
496     } while (cont);
497     if (enc->chaining_keyframe) free(enc->chaining_keyframe);
498     if (is_keyframe) {
499       enc->chaining_keyframe = malloc(nbBytes);
500       enc->chaining_keyframe_length = nbBytes;
501       memcpy(enc->chaining_keyframe, packet, nbBytes);
502     } else {
503       enc->chaining_keyframe = NULL;
504       enc->chaining_keyframe_length = -1;
505     }
506     enc->buffer_start += enc->frame_size;
507   }
508   /* If we've reached the end of the buffer, move everything back to the front. */
509   if (enc->buffer_end == BUFFER_SAMPLES) {
510     shift_buffer(enc);
511   }
512   /* This function must never leave the buffer full. */
513   assert(enc->buffer_end < BUFFER_SAMPLES);
514 }
515
516 /* Add/encode any number of float samples to the file. */
517 int ope_write_float(OggOpusEnc *enc, const float *pcm, int samples_per_channel) {
518   int channels = enc->channels;
519   enc->last_stream->header_is_frozen = 1;
520   if (!enc->streams->stream_is_init) init_stream(enc);
521   if (samples_per_channel < 0) return OPE_BAD_ARG;
522   enc->write_granule += samples_per_channel;
523   enc->last_stream->end_granule = enc->write_granule;
524   do {
525     int i;
526     spx_uint32_t in_samples, out_samples;
527     out_samples = BUFFER_SAMPLES-enc->buffer_end;
528     if (enc->re != NULL) {
529       in_samples = samples_per_channel;
530       speex_resampler_process_interleaved_float(enc->re, pcm, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
531     } else {
532       int curr;
533       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
534       for (i=0;i<channels*curr;i++) {
535       enc->buffer[channels*enc->buffer_end+i] = pcm[i];
536       }
537       in_samples = out_samples = curr;
538     }
539     enc->buffer_end += out_samples;
540     pcm += in_samples*channels;
541     samples_per_channel -= in_samples;
542     encode_buffer(enc);
543   } while (samples_per_channel > 0);
544   return OPE_OK;
545 }
546
547 #define CONVERT_BUFFER 256
548
549 /* Add/encode any number of int16 samples to the file. */
550 int ope_write(OggOpusEnc *enc, const opus_int16 *pcm, int samples_per_channel) {
551   int channels = enc->channels;
552   enc->last_stream->header_is_frozen = 1;
553   if (!enc->streams->stream_is_init) init_stream(enc);
554   if (samples_per_channel < 0) return OPE_BAD_ARG;
555   enc->write_granule += samples_per_channel;
556   enc->last_stream->end_granule = enc->write_granule;
557   do {
558     int i;
559     spx_uint32_t in_samples, out_samples;
560     out_samples = BUFFER_SAMPLES-enc->buffer_end;
561     if (enc->re != NULL) {
562       float buf[CONVERT_BUFFER*MAX_CHANNELS];
563       in_samples = MIN(CONVERT_BUFFER, samples_per_channel);
564       for (i=0;i<channels*(int)in_samples;i++) {
565         buf[i] = (1.f/32768)*pcm[i];
566       }
567       speex_resampler_process_interleaved_float(enc->re, buf, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
568     } else {
569       int curr;
570       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
571       for (i=0;i<channels*curr;i++) {
572         enc->buffer[channels*enc->buffer_end+i] = (1.f/32768)*pcm[i];
573       }
574       in_samples = out_samples = curr;
575     }
576     enc->buffer_end += out_samples;
577     pcm += in_samples*channels;
578     samples_per_channel -= in_samples;
579     encode_buffer(enc);
580   } while (samples_per_channel > 0);
581   return OPE_OK;
582 }
583
584 static void finalize_all_streams(OggOpusEnc *enc) {
585   /* FIXME: Use a better value. */
586   int pad_samples = 3000;
587   if (!enc->streams->stream_is_init) init_stream(enc);
588   shift_buffer(enc);
589   /* FIXME: Do LPC extension instead. */
590   memset(&enc->buffer[enc->channels*enc->buffer_end], 0, pad_samples*enc->channels);
591   enc->decision_delay = 0;
592   enc->buffer_end += pad_samples;
593   assert(enc->buffer_end <= BUFFER_SAMPLES);
594   encode_buffer(enc);
595   assert(enc->streams == NULL);
596 }
597
598 /* Close/finalize the stream. */
599 int ope_close_and_free(OggOpusEnc *enc) {
600   finalize_all_streams(enc);
601   if (enc->chaining_keyframe) free(enc->chaining_keyframe);
602   free(enc->buffer);
603   opus_multistream_encoder_destroy(enc->st);
604   if (enc->re) speex_resampler_destroy(enc->re);
605   free(enc);
606   return OPE_OK;
607 }
608
609 /* Ends the stream and create a new stream within the same file. */
610 int ope_chain_current(OggOpusEnc *enc) {
611   enc->last_stream->close_at_end = 0;
612   return ope_continue_new_callbacks(enc, enc->last_stream->user_data);
613 }
614
615 /* Ends the stream and create a new file. */
616 int ope_continue_new_file(OggOpusEnc *enc, const char *path) {
617   int ret;
618   struct StdioObject *obj;
619   if (!(obj = malloc(sizeof(*obj)))) return OPE_ALLOC_FAIL;
620   obj->file = fopen(path, "wb");
621   if (!obj->file) {
622     free(obj);
623     /* By trying to open the file first, we can recover if we can't open it. */
624     return OPE_CANNOT_OPEN;
625   }
626   ret = ope_continue_new_callbacks(enc, obj);
627   if (ret == OPE_OK) return ret;
628   fclose(obj->file);
629   free(obj);
630   return ret;
631 }
632
633 /* Ends the stream and create a new file (callback-based). */
634 int ope_continue_new_callbacks(OggOpusEnc *enc, void *user_data) {
635   EncStream *new_stream;
636   assert(enc->streams);
637   assert(enc->last_stream);
638   new_stream = stream_create();
639   if (!new_stream) return OPE_ALLOC_FAIL;
640   new_stream->user_data = user_data;
641   enc->last_stream->next = new_stream;
642   enc->last_stream = new_stream;
643   return OPE_OK;
644 }
645
646 /* Add a comment to the file (can only be called before encoding samples). */
647 int ope_add_comment(OggOpusEnc *enc, const char *tag, const char *val) {
648   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
649   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
650   if (comment_add(&enc->last_stream->comment, &enc->last_stream->comment_length, tag, val)) return OPE_ALLOC_FAIL;
651   return OPE_OK;
652 }
653
654 int ope_add_picture(OggOpusEnc *enc, const char *spec) {
655   const char *error_message;
656   char *picture_data;
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   picture_data = parse_picture_specification(spec, &error_message, &enc->last_stream->seen_file_icons);
660   if(picture_data==NULL){
661     /* FIXME: return proper errors rather than printing a message. */
662     fprintf(stderr,"Error parsing picture option: %s\n",error_message);
663     return OPE_BAD_ARG;
664   }
665   comment_add(&enc->last_stream->comment, &enc->last_stream->comment_length, "METADATA_BLOCK_PICTURE", picture_data);
666   free(picture_data);
667   return OPE_OK;
668 }
669
670 /* Sets the Opus comment vendor string (optional, defaults to library info). */
671 int ope_set_vendor_string(OggOpusEnc *enc, const char *vendor) {
672   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
673   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
674   if (comment_replace_vendor_string(&enc->last_stream->comment, &enc->last_stream->comment_length, vendor)) return OPE_ALLOC_FAIL;
675   return OPE_OK;
676 }
677
678 int ope_flush_header(OggOpusEnc *enc) {
679   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
680   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
681   else init_stream(enc);
682   return OPE_OK;
683 }
684
685 /* Goes straight to the libopus ctl() functions. */
686 int ope_encoder_ctl(OggOpusEnc *enc, int request, ...) {
687   int ret;
688   int translate;
689   va_list ap;
690   va_start(ap, request);
691   switch (request) {
692     case OPUS_SET_APPLICATION_REQUEST:
693     case OPUS_SET_BITRATE_REQUEST:
694     case OPUS_SET_MAX_BANDWIDTH_REQUEST:
695     case OPUS_SET_VBR_REQUEST:
696     case OPUS_SET_BANDWIDTH_REQUEST:
697     case OPUS_SET_COMPLEXITY_REQUEST:
698     case OPUS_SET_INBAND_FEC_REQUEST:
699     case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
700     case OPUS_SET_DTX_REQUEST:
701     case OPUS_SET_VBR_CONSTRAINT_REQUEST:
702     case OPUS_SET_FORCE_CHANNELS_REQUEST:
703     case OPUS_SET_SIGNAL_REQUEST:
704     case OPUS_SET_LSB_DEPTH_REQUEST:
705     case OPUS_SET_PREDICTION_DISABLED_REQUEST:
706 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
707     case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
708 #endif
709     {
710       opus_int32 value = va_arg(ap, opus_int32);
711       ret = opus_multistream_encoder_ctl(enc->st, request, value);
712     }
713     break;
714     case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
715     {
716       opus_int32 value = va_arg(ap, opus_int32);
717       int max_supported = OPUS_FRAMESIZE_60_MS;
718 #ifdef OPUS_FRAMESIZE_120_MS
719       max_supported = OPUS_FRAMESIZE_120_MS;
720 #endif
721       if (value < OPUS_FRAMESIZE_2_5_MS || value > max_supported) {
722         ret = OPUS_UNIMPLEMENTED;
723         break;
724       }
725       ret = opus_multistream_encoder_ctl(enc->st, request, value);
726       if (ret == OPUS_OK) {
727         if (value <= OPUS_FRAMESIZE_40_MS)
728           enc->frame_size = 120<<(value-OPUS_FRAMESIZE_2_5_MS);
729         else
730           enc->frame_size = (value-OPUS_FRAMESIZE_2_5_MS-2)*960;
731       }
732     }
733     break;
734     case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
735     {
736       opus_int32 stream_id;
737       OpusEncoder **value;
738       stream_id = va_arg(ap, opus_int32);
739       value = va_arg(ap, OpusEncoder**);
740       ret = opus_multistream_encoder_ctl(enc->st, request, stream_id, value);
741     }
742     break;
743
744     /* ****************** libopusenc-specific requests. ********************** */
745     case OPE_SET_DECISION_DELAY_REQUEST:
746     {
747       opus_int32 value = va_arg(ap, opus_int32);
748       if (value < 0) {
749         ret = OPE_BAD_ARG;
750         break;
751       }
752       enc->decision_delay = value;
753       ret = OPE_OK;
754     }
755     break;
756     case OPE_SET_MUXING_DELAY_REQUEST:
757     {
758       opus_int32 value = va_arg(ap, opus_int32);
759       if (value < 0) {
760         ret = OPE_BAD_ARG;
761         break;
762       }
763       enc->max_ogg_delay = value;
764 #ifdef USE_OGGP
765       oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
766 #endif
767       ret = OPE_OK;
768     }
769     break;
770     case OPE_SET_COMMENT_PADDING_REQUEST:
771     {
772       opus_int32 value = va_arg(ap, opus_int32);
773       if (value < 0) {
774         ret = OPE_BAD_ARG;
775         break;
776       }
777       enc->comment_padding = value;
778       ret = OPE_OK;
779     }
780     break;
781     case OPE_SET_SERIALNO_REQUEST:
782     {
783       opus_int32 value = va_arg(ap, opus_int32);
784       if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
785       enc->last_stream->serialno = value;
786       enc->last_stream->serialno_is_set = 1;
787       ret = OPE_OK;
788     }
789     case OPE_SET_PACKET_CALLBACK_REQUEST:
790     {
791       ope_packet_func value = va_arg(ap, ope_packet_func);
792       enc->packet_callback = value;
793       ret = OPE_OK;
794     }
795     break;
796     case OPE_SET_PAGE_CALLBACK_REQUEST:
797     {
798       ope_page_func value = va_arg(ap, ope_page_func);
799       enc->page_callback = value;
800       ret = OPE_OK;
801     }
802     break;
803     default:
804       return OPE_UNIMPLEMENTED;
805   }
806   va_end(ap);
807   translate = request < 14000 || (ret < 0 && ret >= -10);
808   if (translate) {
809     if (ret == OPUS_BAD_ARG) ret = OPE_BAD_ARG;
810     else if (ret == OPUS_INTERNAL_ERROR) ret = OPE_INTERNAL_ERROR;
811     else if (ret == OPUS_UNIMPLEMENTED) ret = OPE_UNIMPLEMENTED;
812     else if (ret == OPUS_ALLOC_FAIL) ret = OPE_ALLOC_FAIL;
813     else ret = OPE_INTERNAL_ERROR;
814   }
815   assert(ret == 0 || ret < -10);
816   return ret;
817 }