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