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