Preventing further damage when in unrecoverable error state
[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 unrecoverable;
97   int pull_api;
98   int rate;
99   int channels;
100   float *buffer;
101   int buffer_start;
102   int buffer_end;
103   SpeexResamplerState *re;
104   int frame_size;
105   int decision_delay;
106   int max_ogg_delay;
107   int global_granule_offset;
108   ogg_int64_t curr_granule;
109   ogg_int64_t write_granule;
110   ogg_int64_t last_page_granule;
111   unsigned char *chaining_keyframe;
112   int chaining_keyframe_length;
113   OpusEncCallbacks callbacks;
114   ope_packet_func packet_callback;
115   OpusHeader header;
116   int comment_padding;
117   EncStream *streams;
118   EncStream *last_stream;
119 };
120
121 #ifdef USE_OGGP
122 static void output_pages(OggOpusEnc *enc) {
123   unsigned char *page;
124   int len;
125   while (oggp_get_next_page(enc->oggp, &page, &len)) {
126     enc->callbacks.write(enc->streams->user_data, page, len);
127   }
128 }
129 static void oe_flush_page(OggOpusEnc *enc) {
130   oggp_flush_page(enc->oggp);
131   if (!enc->pull_api) output_pages(enc);
132 }
133
134 #else
135
136 static int oe_write_page(OggOpusEnc *enc, ogg_page *page, void *user_data)
137 {
138   int length;
139   int err;
140   err = enc->callbacks.write(user_data, page->header, page->header_len);
141   if (err) return -1;
142   err = enc->callbacks.write(user_data, page->body, page->body_len);
143   if (err) return -1;
144   length = page->header_len+page->body_len;
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 = 0;
171   if (obj->file) ret = fclose(obj->file);
172   free(obj);
173   return ret;
174 }
175
176 static const OpusEncCallbacks stdio_callbacks = {
177   stdio_write,
178   stdio_close
179 };
180
181 /* Create a new OggOpus file. */
182 OggOpusEnc *ope_create_file(const char *path, int rate, int channels, int family, int *error) {
183   OggOpusEnc *enc;
184   struct StdioObject *obj;
185   obj = malloc(sizeof(*obj));
186   enc = ope_create_callbacks(&stdio_callbacks, obj, rate, channels, family, error);
187   if (enc == NULL || (error && *error)) {
188     return NULL;
189   }
190   obj->file = fopen(path, "wb");
191   if (!obj->file) {
192     if (error) *error = OPE_CANNOT_OPEN;
193     ope_destroy(enc);
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   if (rate <= 0) {
248     if (error) *error = OPE_BAD_ARG;
249     return NULL;
250   }
251
252   if ( (enc = malloc(sizeof(*enc))) == NULL) goto fail;
253   enc->streams = NULL;
254   if ( (enc->streams = stream_create()) == NULL) goto fail;
255   enc->streams->next = NULL;
256   enc->last_stream = enc->streams;
257 #ifdef USE_OGGP
258   enc->oggp = NULL;
259 #endif
260   enc->unrecoverable = 0;
261   enc->pull_api = 0;
262   enc->packet_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 /* Create a new OggOpus stream, pulling one page at a time. */
321 OPE_EXPORT OggOpusEnc *ope_create_pull(int rate, int channels, int family, int *error) {
322   OggOpusEnc *enc = ope_create_callbacks(NULL, NULL, rate, channels, family, error);
323   enc->pull_api = 1;
324   return enc;
325 }
326
327 static void init_stream(OggOpusEnc *enc) {
328   assert(!enc->streams->stream_is_init);
329   if (!enc->streams->serialno_is_set) {
330     enc->streams->serialno = rand();
331   }
332
333 #ifdef USE_OGGP
334   if (enc->oggp != NULL) oggp_chain(enc->oggp, enc->streams->serialno);
335   else {
336     enc->oggp = oggp_create(enc->streams->serialno);
337     if (enc->oggp == NULL) {
338       enc->unrecoverable = 1;
339       return;
340     }
341     oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
342   }
343 #else
344   if (ogg_stream_init(&enc->streams->os, enc->streams->serialno) == -1) {
345     enc->unrecoverable = 1;
346     return;
347   }
348 #endif
349   comment_pad(&enc->streams->comment, &enc->streams->comment_length, enc->comment_padding);
350
351   /*Write header*/
352   {
353 #ifdef USE_OGGP
354     unsigned char *p;
355     p = oggp_get_packet_buffer(enc->oggp, 276);
356     int packet_size = opus_header_to_packet(&enc->header, p, 276);
357     oggp_commit_packet(enc->oggp, packet_size, 0, 0);
358     oe_flush_page(enc);
359     p = oggp_get_packet_buffer(enc->oggp, enc->streams->comment_length);
360     memcpy(p, enc->streams->comment, enc->streams->comment_length);
361     oggp_commit_packet(enc->oggp, enc->streams->comment_length, 0, 0);
362     oe_flush_page(enc);
363
364 #else
365
366     ogg_packet op;
367     /*The Identification Header is 19 bytes, plus a Channel Mapping Table for
368       mapping families other than 0. The Channel Mapping Table is 2 bytes +
369       1 byte per channel. Because the maximum number of channels is 255, the
370       maximum size of this header is 19 + 2 + 255 = 276 bytes.*/
371     unsigned char header_data[276];
372     int packet_size = opus_header_to_packet(&enc->header, header_data, sizeof(header_data));
373     op.packet=header_data;
374     op.bytes=packet_size;
375     op.b_o_s=1;
376     op.e_o_s=0;
377     op.granulepos=0;
378     op.packetno=0;
379     ogg_stream_packetin(&enc->streams->os, &op);
380     oe_flush_page(enc);
381
382     op.packet = (unsigned char *)enc->streams->comment;
383     op.bytes = enc->streams->comment_length;
384     op.b_o_s = 0;
385     op.e_o_s = 0;
386     op.granulepos = 0;
387     op.packetno = 1;
388     ogg_stream_packetin(&enc->streams->os, &op);
389     oe_flush_page(enc);
390 #endif
391   }
392   enc->streams->stream_is_init = 1;
393   enc->streams->packetno = 2;
394 }
395
396 static void shift_buffer(OggOpusEnc *enc) {
397     memmove(enc->buffer, &enc->buffer[enc->channels*enc->buffer_start], enc->channels*(enc->buffer_end-enc->buffer_start)*sizeof(*enc->buffer));
398     enc->buffer_end -= enc->buffer_start;
399     enc->buffer_start = 0;
400 }
401
402 static void encode_buffer(OggOpusEnc *enc) {
403   /* Round up when converting the granule pos because the decoder will round down. */
404   ogg_int64_t end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
405   while (enc->buffer_end-enc->buffer_start > enc->frame_size + enc->decision_delay) {
406     int cont;
407     opus_int32 pred;
408     int flush_needed;
409     ogg_packet op;
410 #ifndef USE_OGGP
411     ogg_page og;
412 #endif
413     int nbBytes;
414     unsigned char packet[MAX_PACKET_SIZE];
415     int is_keyframe=0;
416     if (enc->unrecoverable) return;
417     opus_multistream_encoder_ctl(enc->st, OPUS_GET_PREDICTION_DISABLED(&pred));
418     /* FIXME: a frame that follows a keyframe generally doesn't need to be a keyframe
419        unless there's two consecutive stream boundaries. */
420     if (enc->curr_granule + 2*enc->frame_size>= end_granule48k && enc->streams->next) {
421       opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(1));
422       is_keyframe = 1;
423     }
424     nbBytes = opus_multistream_encode_float(enc->st, &enc->buffer[enc->channels*enc->buffer_start],
425         enc->buffer_end-enc->buffer_start, packet, MAX_PACKET_SIZE);
426     if (nbBytes < 0) {
427       /* Anything better we can do here? */
428       enc->unrecoverable = 1;
429       return;
430     }
431     opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(pred));
432     assert(nbBytes > 0);
433     enc->curr_granule += enc->frame_size;
434     op.packet=packet;
435     op.bytes=nbBytes;
436     op.b_o_s=0;
437     op.packetno=enc->streams->packetno++;
438     do {
439       op.granulepos=enc->curr_granule-enc->streams->granule_offset;
440       op.e_o_s=enc->curr_granule >= end_granule48k;
441       cont = 0;
442       if (op.e_o_s) op.granulepos=end_granule48k-enc->streams->granule_offset;
443 #ifdef USE_OGGP
444       {
445         unsigned char *p;
446         p = oggp_get_packet_buffer(enc->oggp, MAX_PACKET_SIZE);
447         memcpy(p, packet, nbBytes);
448         oggp_commit_packet(enc->oggp, nbBytes, op.granulepos, op.e_o_s);
449       }
450 #else
451       ogg_stream_packetin(&enc->streams->os, &op);
452 #endif
453       if (enc->packet_callback) enc->packet_callback(enc->streams->user_data, op.packet, op.bytes, 0);
454       /* FIXME: Also flush on too many segments. */
455 #ifdef USE_OGGP
456       flush_needed = op.e_o_s;
457       if (flush_needed) oe_flush_page(enc);
458       else if (!enc->pull_api) output_pages(enc);
459 #else
460       flush_needed = op.e_o_s || enc->curr_granule - enc->last_page_granule >= enc->max_ogg_delay;
461       if (flush_needed) {
462         oe_flush_page(enc);
463       } else {
464         while (ogg_stream_pageout_fill(&enc->streams->os, &og, 255*255)) {
465           if (ogg_page_packets(&og) != 0) enc->last_page_granule = ogg_page_granulepos(&og) + enc->streams->granule_offset;
466           int ret = oe_write_page(enc, &og, enc->streams->user_data);
467           /* FIXME: what do we do if this fails? */
468           assert(ret != -1);
469         }
470       }
471 #endif
472       if (op.e_o_s) {
473         EncStream *tmp;
474         tmp = enc->streams->next;
475         if (enc->streams->close_at_end) enc->callbacks.close(enc->streams->user_data);
476         stream_destroy(enc->streams);
477         enc->streams = tmp;
478         if (!tmp) enc->last_stream = NULL;
479         if (enc->last_stream == NULL) return;
480         /* We're done with this stream, start the next one. */
481         enc->header.preskip = end_granule48k + enc->frame_size - enc->curr_granule;
482         enc->streams->granule_offset = enc->curr_granule - enc->frame_size;
483         if (enc->chaining_keyframe) {
484           enc->header.preskip += enc->frame_size;
485           enc->streams->granule_offset -= enc->frame_size;
486         }
487         init_stream(enc);
488         if (enc->chaining_keyframe) {
489           ogg_packet op2;
490           op2.packet = enc->chaining_keyframe;
491           op2.bytes = enc->chaining_keyframe_length;
492           op2.b_o_s = 0;
493           op2.e_o_s = 0;
494           op2.packetno=enc->streams->packetno++;
495           op2.granulepos=enc->curr_granule - enc->streams->granule_offset - enc->frame_size;
496 #ifdef USE_OGGP
497           {
498             unsigned char *p;
499             p = oggp_get_packet_buffer(enc->oggp, MAX_PACKET_SIZE);
500             memcpy(p, enc->chaining_keyframe, enc->chaining_keyframe_length);
501             oggp_commit_packet(enc->oggp, enc->chaining_keyframe_length, op2.granulepos, 0);
502           }
503 #else
504           ogg_stream_packetin(&enc->streams->os, &op2);
505 #endif
506           if (enc->packet_callback) enc->packet_callback(enc->streams->user_data, op2.packet, op2.bytes, 0);
507         }
508         end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
509         cont = 1;
510       }
511     } while (cont);
512     if (enc->chaining_keyframe) free(enc->chaining_keyframe);
513     if (is_keyframe) {
514       enc->chaining_keyframe = malloc(nbBytes);
515       enc->chaining_keyframe_length = nbBytes;
516       memcpy(enc->chaining_keyframe, packet, nbBytes);
517     } else {
518       enc->chaining_keyframe = NULL;
519       enc->chaining_keyframe_length = -1;
520     }
521     enc->buffer_start += enc->frame_size;
522   }
523   /* If we've reached the end of the buffer, move everything back to the front. */
524   if (enc->buffer_end == BUFFER_SAMPLES) {
525     shift_buffer(enc);
526   }
527   /* This function must never leave the buffer full. */
528   assert(enc->buffer_end < BUFFER_SAMPLES);
529 }
530
531 /* Add/encode any number of float samples to the file. */
532 int ope_write_float(OggOpusEnc *enc, const float *pcm, int samples_per_channel) {
533   int channels = enc->channels;
534   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
535   enc->last_stream->header_is_frozen = 1;
536   if (!enc->streams->stream_is_init) init_stream(enc);
537   if (samples_per_channel < 0) return OPE_BAD_ARG;
538   enc->write_granule += samples_per_channel;
539   enc->last_stream->end_granule = enc->write_granule;
540   do {
541     int i;
542     spx_uint32_t in_samples, out_samples;
543     out_samples = BUFFER_SAMPLES-enc->buffer_end;
544     if (enc->re != NULL) {
545       in_samples = samples_per_channel;
546       speex_resampler_process_interleaved_float(enc->re, pcm, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
547     } else {
548       int curr;
549       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
550       for (i=0;i<channels*curr;i++) {
551       enc->buffer[channels*enc->buffer_end+i] = pcm[i];
552       }
553       in_samples = out_samples = curr;
554     }
555     enc->buffer_end += out_samples;
556     pcm += in_samples*channels;
557     samples_per_channel -= in_samples;
558     encode_buffer(enc);
559     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
560   } while (samples_per_channel > 0);
561   return OPE_OK;
562 }
563
564 #define CONVERT_BUFFER 256
565
566 /* Add/encode any number of int16 samples to the file. */
567 int ope_write(OggOpusEnc *enc, const opus_int16 *pcm, int samples_per_channel) {
568   int channels = enc->channels;
569   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
570   enc->last_stream->header_is_frozen = 1;
571   if (!enc->streams->stream_is_init) init_stream(enc);
572   if (samples_per_channel < 0) return OPE_BAD_ARG;
573   enc->write_granule += samples_per_channel;
574   enc->last_stream->end_granule = enc->write_granule;
575   do {
576     int i;
577     spx_uint32_t in_samples, out_samples;
578     out_samples = BUFFER_SAMPLES-enc->buffer_end;
579     if (enc->re != NULL) {
580       float buf[CONVERT_BUFFER*MAX_CHANNELS];
581       in_samples = MIN(CONVERT_BUFFER, samples_per_channel);
582       for (i=0;i<channels*(int)in_samples;i++) {
583         buf[i] = (1.f/32768)*pcm[i];
584       }
585       speex_resampler_process_interleaved_float(enc->re, buf, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
586     } else {
587       int curr;
588       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
589       for (i=0;i<channels*curr;i++) {
590         enc->buffer[channels*enc->buffer_end+i] = (1.f/32768)*pcm[i];
591       }
592       in_samples = out_samples = curr;
593     }
594     enc->buffer_end += out_samples;
595     pcm += in_samples*channels;
596     samples_per_channel -= in_samples;
597     encode_buffer(enc);
598     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
599   } while (samples_per_channel > 0);
600   return OPE_OK;
601 }
602
603 /* Get the next page from the stream. Returns 1 if there is a page available, 0 if not. */
604 OPE_EXPORT int ope_get_page(OggOpusEnc *enc, unsigned char **page, int *len, int flush) {
605   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
606   if (!enc->pull_api) return 0;
607   else {
608     if (flush) oggp_flush_page(enc->oggp);
609     return oggp_get_next_page(enc->oggp, page, len);
610   }
611 }
612
613 int ope_drain(OggOpusEnc *enc) {
614   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
615   /* Check if it's already been drained. */
616   if (enc->streams == NULL) return OPE_TOO_LATE;
617   /* FIXME: Use a better value. */
618   int pad_samples = 3000;
619   if (!enc->streams->stream_is_init) init_stream(enc);
620   shift_buffer(enc);
621   /* FIXME: Do LPC extension instead. */
622   memset(&enc->buffer[enc->channels*enc->buffer_end], 0, pad_samples*enc->channels);
623   enc->decision_delay = 0;
624   enc->buffer_end += pad_samples;
625   assert(enc->buffer_end <= BUFFER_SAMPLES);
626   encode_buffer(enc);
627   assert(enc->streams == NULL);
628   return OPE_OK;
629 }
630
631 void ope_destroy(OggOpusEnc *enc) {
632   EncStream *stream;
633   stream = enc->streams;
634   while (stream != NULL) {
635     EncStream *tmp = stream;
636     stream = stream->next;
637     if (tmp->close_at_end) enc->callbacks.close(tmp->user_data);
638     stream_destroy(tmp);
639   }
640   if (enc->chaining_keyframe) free(enc->chaining_keyframe);
641   free(enc->buffer);
642 #ifdef USE_OGGP
643   if (enc->oggp) oggp_destroy(enc->oggp);
644 #endif
645   opus_multistream_encoder_destroy(enc->st);
646   if (enc->re) speex_resampler_destroy(enc->re);
647   free(enc);
648 }
649
650 /* Ends the stream and create a new stream within the same file. */
651 int ope_chain_current(OggOpusEnc *enc) {
652   enc->last_stream->close_at_end = 0;
653   return ope_continue_new_callbacks(enc, enc->last_stream->user_data);
654 }
655
656 /* Ends the stream and create a new file. */
657 int ope_continue_new_file(OggOpusEnc *enc, const char *path) {
658   int ret;
659   struct StdioObject *obj;
660   if (!(obj = malloc(sizeof(*obj)))) return OPE_ALLOC_FAIL;
661   obj->file = fopen(path, "wb");
662   if (!obj->file) {
663     free(obj);
664     /* By trying to open the file first, we can recover if we can't open it. */
665     return OPE_CANNOT_OPEN;
666   }
667   ret = ope_continue_new_callbacks(enc, obj);
668   if (ret == OPE_OK) return ret;
669   fclose(obj->file);
670   free(obj);
671   return ret;
672 }
673
674 /* Ends the stream and create a new file (callback-based). */
675 int ope_continue_new_callbacks(OggOpusEnc *enc, void *user_data) {
676   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
677   EncStream *new_stream;
678   assert(enc->streams);
679   assert(enc->last_stream);
680   new_stream = stream_create();
681   if (!new_stream) return OPE_ALLOC_FAIL;
682   new_stream->user_data = user_data;
683   enc->last_stream->next = new_stream;
684   enc->last_stream = new_stream;
685   return OPE_OK;
686 }
687
688 /* Add a comment to the file (can only be called before encoding samples). */
689 int ope_add_comment(OggOpusEnc *enc, const char *tag, const char *val) {
690   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
691   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
692   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
693   if (comment_add(&enc->last_stream->comment, &enc->last_stream->comment_length, tag, val)) return OPE_ALLOC_FAIL;
694   return OPE_OK;
695 }
696
697 int ope_add_picture(OggOpusEnc *enc, const char *spec) {
698   const char *error_message;
699   char *picture_data;
700   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
701   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
702   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
703   picture_data = parse_picture_specification(spec, &error_message, &enc->last_stream->seen_file_icons);
704   if(picture_data==NULL){
705     /* FIXME: return proper errors rather than printing a message. */
706     fprintf(stderr,"Error parsing picture option: %s\n",error_message);
707     return OPE_BAD_ARG;
708   }
709   comment_add(&enc->last_stream->comment, &enc->last_stream->comment_length, "METADATA_BLOCK_PICTURE", picture_data);
710   free(picture_data);
711   return OPE_OK;
712 }
713
714 /* Sets the Opus comment vendor string (optional, defaults to library info). */
715 int ope_set_vendor_string(OggOpusEnc *enc, const char *vendor) {
716   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
717   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
718   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
719   if (comment_replace_vendor_string(&enc->last_stream->comment, &enc->last_stream->comment_length, vendor)) return OPE_ALLOC_FAIL;
720   return OPE_OK;
721 }
722
723 int ope_flush_header(OggOpusEnc *enc) {
724   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
725   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
726   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
727   else init_stream(enc);
728   return OPE_OK;
729 }
730
731 /* Goes straight to the libopus ctl() functions. */
732 int ope_encoder_ctl(OggOpusEnc *enc, int request, ...) {
733   int ret;
734   int translate;
735   va_list ap;
736   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
737   va_start(ap, request);
738   switch (request) {
739     case OPUS_SET_APPLICATION_REQUEST:
740     case OPUS_SET_BITRATE_REQUEST:
741     case OPUS_SET_MAX_BANDWIDTH_REQUEST:
742     case OPUS_SET_VBR_REQUEST:
743     case OPUS_SET_BANDWIDTH_REQUEST:
744     case OPUS_SET_COMPLEXITY_REQUEST:
745     case OPUS_SET_INBAND_FEC_REQUEST:
746     case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
747     case OPUS_SET_DTX_REQUEST:
748     case OPUS_SET_VBR_CONSTRAINT_REQUEST:
749     case OPUS_SET_FORCE_CHANNELS_REQUEST:
750     case OPUS_SET_SIGNAL_REQUEST:
751     case OPUS_SET_LSB_DEPTH_REQUEST:
752     case OPUS_SET_PREDICTION_DISABLED_REQUEST:
753 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
754     case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
755 #endif
756     {
757       opus_int32 value = va_arg(ap, opus_int32);
758       ret = opus_multistream_encoder_ctl(enc->st, request, value);
759     }
760     break;
761     case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
762     {
763       opus_int32 value = va_arg(ap, opus_int32);
764       int max_supported = OPUS_FRAMESIZE_60_MS;
765 #ifdef OPUS_FRAMESIZE_120_MS
766       max_supported = OPUS_FRAMESIZE_120_MS;
767 #endif
768       if (value < OPUS_FRAMESIZE_2_5_MS || value > max_supported) {
769         ret = OPUS_UNIMPLEMENTED;
770         break;
771       }
772       ret = opus_multistream_encoder_ctl(enc->st, request, value);
773       if (ret == OPUS_OK) {
774         if (value <= OPUS_FRAMESIZE_40_MS)
775           enc->frame_size = 120<<(value-OPUS_FRAMESIZE_2_5_MS);
776         else
777           enc->frame_size = (value-OPUS_FRAMESIZE_2_5_MS-2)*960;
778       }
779     }
780     break;
781     case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
782     {
783       opus_int32 stream_id;
784       OpusEncoder **value;
785       stream_id = va_arg(ap, opus_int32);
786       value = va_arg(ap, OpusEncoder**);
787       ret = opus_multistream_encoder_ctl(enc->st, request, stream_id, value);
788     }
789     break;
790
791     /* ****************** libopusenc-specific requests. ********************** */
792     case OPE_SET_DECISION_DELAY_REQUEST:
793     {
794       opus_int32 value = va_arg(ap, opus_int32);
795       if (value < 0) {
796         ret = OPE_BAD_ARG;
797         break;
798       }
799       enc->decision_delay = value;
800       ret = OPE_OK;
801     }
802     break;
803     case OPE_SET_MUXING_DELAY_REQUEST:
804     {
805       opus_int32 value = va_arg(ap, opus_int32);
806       if (value < 0) {
807         ret = OPE_BAD_ARG;
808         break;
809       }
810       enc->max_ogg_delay = value;
811 #ifdef USE_OGGP
812       oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
813 #endif
814       ret = OPE_OK;
815     }
816     break;
817     case OPE_SET_COMMENT_PADDING_REQUEST:
818     {
819       opus_int32 value = va_arg(ap, opus_int32);
820       if (value < 0) {
821         ret = OPE_BAD_ARG;
822         break;
823       }
824       enc->comment_padding = value;
825       ret = OPE_OK;
826     }
827     break;
828     case OPE_SET_SERIALNO_REQUEST:
829     {
830       opus_int32 value = va_arg(ap, opus_int32);
831       if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
832       enc->last_stream->serialno = value;
833       enc->last_stream->serialno_is_set = 1;
834       ret = OPE_OK;
835     }
836     case OPE_SET_PACKET_CALLBACK_REQUEST:
837     {
838       ope_packet_func value = va_arg(ap, ope_packet_func);
839       enc->packet_callback = value;
840       ret = OPE_OK;
841     }
842     break;
843     default:
844       return OPE_UNIMPLEMENTED;
845   }
846   va_end(ap);
847   translate = request < 14000 || (ret < 0 && ret >= -10);
848   if (translate) {
849     if (ret == OPUS_BAD_ARG) ret = OPE_BAD_ARG;
850     else if (ret == OPUS_INTERNAL_ERROR) ret = OPE_INTERNAL_ERROR;
851     else if (ret == OPUS_UNIMPLEMENTED) ret = OPE_UNIMPLEMENTED;
852     else if (ret == OPUS_ALLOC_FAIL) ret = OPE_ALLOC_FAIL;
853     else ret = OPE_INTERNAL_ERROR;
854   }
855   assert(ret == 0 || ret < -10);
856   return ret;
857 }