21a550f56ec5d995398a3023fb42e771f5e9f0f6
[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   ret = OPE_OK;
667   switch (request) {
668     case OPUS_SET_APPLICATION_REQUEST:
669     case OPUS_SET_BITRATE_REQUEST:
670     case OPUS_SET_MAX_BANDWIDTH_REQUEST:
671     case OPUS_SET_VBR_REQUEST:
672     case OPUS_SET_BANDWIDTH_REQUEST:
673     case OPUS_SET_COMPLEXITY_REQUEST:
674     case OPUS_SET_INBAND_FEC_REQUEST:
675     case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
676     case OPUS_SET_DTX_REQUEST:
677     case OPUS_SET_VBR_CONSTRAINT_REQUEST:
678     case OPUS_SET_FORCE_CHANNELS_REQUEST:
679     case OPUS_SET_SIGNAL_REQUEST:
680     case OPUS_SET_LSB_DEPTH_REQUEST:
681     case OPUS_SET_PREDICTION_DISABLED_REQUEST:
682 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
683     case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
684 #endif
685     {
686       opus_int32 value = va_arg(ap, opus_int32);
687       ret = opus_multistream_encoder_ctl(enc->st, request, value);
688     }
689     break;
690     case OPUS_GET_LOOKAHEAD_REQUEST:
691     {
692       opus_int32 *value = va_arg(ap, opus_int32*);
693       ret = opus_multistream_encoder_ctl(enc->st, request, value);
694     }
695     break;
696     case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
697     {
698       opus_int32 value = va_arg(ap, opus_int32);
699       int max_supported = OPUS_FRAMESIZE_60_MS;
700 #ifdef OPUS_FRAMESIZE_120_MS
701       max_supported = OPUS_FRAMESIZE_120_MS;
702 #endif
703       if (value < OPUS_FRAMESIZE_2_5_MS || value > max_supported) {
704         ret = OPUS_UNIMPLEMENTED;
705         break;
706       }
707       ret = opus_multistream_encoder_ctl(enc->st, request, value);
708       if (ret == OPUS_OK) {
709         if (value <= OPUS_FRAMESIZE_40_MS)
710           enc->frame_size = 120<<(value-OPUS_FRAMESIZE_2_5_MS);
711         else
712           enc->frame_size = (value-OPUS_FRAMESIZE_2_5_MS-2)*960;
713       }
714     }
715     break;
716     case OPUS_GET_APPLICATION_REQUEST:
717     case OPUS_GET_BITRATE_REQUEST:
718     case OPUS_GET_MAX_BANDWIDTH_REQUEST:
719     case OPUS_GET_VBR_REQUEST:
720     case OPUS_GET_BANDWIDTH_REQUEST:
721     case OPUS_GET_COMPLEXITY_REQUEST:
722     case OPUS_GET_INBAND_FEC_REQUEST:
723     case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
724     case OPUS_GET_DTX_REQUEST:
725     case OPUS_GET_VBR_CONSTRAINT_REQUEST:
726     case OPUS_GET_FORCE_CHANNELS_REQUEST:
727     case OPUS_GET_SIGNAL_REQUEST:
728     case OPUS_GET_LSB_DEPTH_REQUEST:
729     case OPUS_GET_PREDICTION_DISABLED_REQUEST:
730 #ifdef OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST
731     case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
732 #endif
733     {
734       opus_int32 *value = va_arg(ap, opus_int32*);
735       ret = opus_multistream_encoder_ctl(enc->st, request, value);
736     }
737     break;
738     case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
739     {
740       opus_int32 stream_id;
741       OpusEncoder **value;
742       stream_id = va_arg(ap, opus_int32);
743       value = va_arg(ap, OpusEncoder**);
744       ret = opus_multistream_encoder_ctl(enc->st, request, stream_id, value);
745     }
746     break;
747
748     /* ****************** libopusenc-specific requests. ********************** */
749     case OPE_SET_DECISION_DELAY_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->decision_delay = value;
757     }
758     break;
759     case OPE_GET_DECISION_DELAY_REQUEST:
760     {
761       opus_int32 *value = va_arg(ap, opus_int32*);
762       *value = enc->decision_delay;
763     }
764     break;
765     case OPE_SET_MUXING_DELAY_REQUEST:
766     {
767       opus_int32 value = va_arg(ap, opus_int32);
768       if (value < 0) {
769         ret = OPE_BAD_ARG;
770         break;
771       }
772       enc->max_ogg_delay = value;
773       oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
774     }
775     break;
776     case OPE_GET_MUXING_DELAY_REQUEST:
777     {
778       opus_int32 *value = va_arg(ap, opus_int32*);
779       *value = enc->max_ogg_delay;
780     }
781     break;
782     case OPE_SET_COMMENT_PADDING_REQUEST:
783     {
784       opus_int32 value = va_arg(ap, opus_int32);
785       if (value < 0) {
786         ret = OPE_BAD_ARG;
787         break;
788       }
789       enc->comment_padding = value;
790       ret = OPE_OK;
791     }
792     break;
793     case OPE_GET_COMMENT_PADDING_REQUEST:
794     {
795       opus_int32 *value = va_arg(ap, opus_int32*);
796       *value = enc->comment_padding;
797     }
798     break;
799     case OPE_SET_SERIALNO_REQUEST:
800     {
801       opus_int32 value = va_arg(ap, opus_int32);
802       if (!enc->last_stream || enc->last_stream->header_is_frozen) {
803         ret = OPE_TOO_LATE;
804         break;
805       }
806       enc->last_stream->serialno = value;
807       enc->last_stream->serialno_is_set = 1;
808       ret = OPE_OK;
809     }
810     break;
811     case OPE_GET_SERIALNO_REQUEST:
812     {
813       opus_int32 *value = va_arg(ap, opus_int32*);
814       *value = enc->last_stream->serialno;
815     }
816     break;
817     case OPE_SET_PACKET_CALLBACK_REQUEST:
818     {
819       ope_packet_func value = va_arg(ap, ope_packet_func);
820       void *data = va_arg(ap, void *);
821       enc->packet_callback = value;
822       enc->packet_callback_data = data;
823       ret = OPE_OK;
824     }
825     break;
826     case OPE_SET_HEADER_GAIN_REQUEST:
827     {
828       opus_int32 value = va_arg(ap, opus_int32);
829       if (!enc->last_stream || enc->last_stream->header_is_frozen) {
830         ret = OPE_TOO_LATE;
831         break;
832       }
833       enc->header.gain = value;
834       ret = OPE_OK;
835     }
836     break;
837     case OPE_GET_HEADER_GAIN_REQUEST:
838     {
839       opus_int32 *value = va_arg(ap, opus_int32*);
840       *value = enc->header.gain;
841     }
842     break;
843     default:
844       ret = OPE_UNIMPLEMENTED;
845   }
846   va_end(ap);
847   translate = ret != 0 && (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 }
858
859 const char *ope_strerror(int error) {
860   static const char * const ope_error_strings[5] = {
861     "cannot open file",
862     "call cannot be made at this point",
863     "unrecoverable error",
864     "invalid picture file",
865     "invalid icon file (pictures of type 1 MUST be 32x32 PNGs)"
866   };
867   if (error == 0) return "success";
868   else if (error >= -10) return "unknown error";
869   else if (error > -30) return opus_strerror(error+10);
870   else if (error >= OPE_INVALID_ICON) return ope_error_strings[-error-30];
871   else return "unknown error";
872 }
873
874 const char *ope_get_version_string(void)
875 {
876   return "libopusenc " PACKAGE_VERSION;
877 }
878
879 int ope_get_abi_version(void) {
880   return OPE_ABI_VERSION;
881 }
882
883 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride);
884
885 static void extend_signal(float *x, int before, int after, int channels) {
886   int c;
887   int i;
888   float window[LPC_PADDING];
889   if (after==0) return;
890   before = MIN(before, LPC_INPUT);
891   if (before < 4*LPC_ORDER) {
892     int i;
893     for (i=0;i<after*channels;i++) x[i] = 0;
894     return;
895   }
896   {
897     /* Generate Window using a resonating IIR aka Goertzel's algorithm. */
898     float m0=1, m1=.5*LPC_GOERTZEL_CONST;
899     float a1 = LPC_GOERTZEL_CONST;
900     window[0] = 1;
901     for (i=1;i<LPC_PADDING;i++) {
902       window[i] = a1*m0 - m1;
903       m1 = m0;
904       m0 = window[i];
905     }
906     for (i=0;i<LPC_PADDING;i++) window[i] = .5+.5*window[i];
907   }
908   for (c=0;c<channels;c++) {
909     float lpc[LPC_ORDER];
910     vorbis_lpc_from_data(x-channels*before+c, lpc, before, channels);
911     for (i=0;i<after;i++) {
912       float sum;
913       int j;
914       sum = 0;
915       for (j=0;j<LPC_ORDER;j++) sum -= x[(i-j-1)*channels + c]*lpc[j];
916       x[i*channels + c] = sum;
917     }
918     for (i=0;i<after;i++) x[i*channels + c] *= window[i];
919   }
920 }
921
922 /* Some of these routines (autocorrelator, LPC coefficient estimator)
923    are derived from code written by Jutta Degener and Carsten Bormann;
924    thus we include their copyright below.  The entirety of this file
925    is freely redistributable on the condition that both of these
926    copyright notices are preserved without modification.  */
927
928 /* Preserved Copyright: *********************************************/
929
930 /* Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
931 Technische Universita"t Berlin
932
933 Any use of this software is permitted provided that this notice is not
934 removed and that neither the authors nor the Technische Universita"t
935 Berlin are deemed to have made any representations as to the
936 suitability of this software for any purpose nor are held responsible
937 for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR
938 THIS SOFTWARE.
939
940 As a matter of courtesy, the authors request to be informed about uses
941 this software has found, about bugs in this software, and about any
942 improvements that may be of general interest.
943
944 Berlin, 28.11.1994
945 Jutta Degener
946 Carsten Bormann
947
948 *********************************************************************/
949
950 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride) {
951   double aut[LPC_ORDER+1];
952   double lpc[LPC_ORDER];
953   double error;
954   double epsilon;
955   int i,j;
956
957   /* FIXME: Apply a window to the input. */
958   /* autocorrelation, p+1 lag coefficients */
959   j=LPC_ORDER+1;
960   while(j--){
961     double d=0; /* double needed for accumulator depth */
962     for(i=j;i<n;i++)d+=(double)data[i*stride]*data[(i-j)*stride];
963     aut[j]=d;
964   }
965
966   /* Apply lag windowing (better than bandwidth expansion) */
967   if (LPC_ORDER <= 64) {
968     for (i=1;i<=LPC_ORDER;i++) {
969       /* Approximate this gaussian for low enough order. */
970       /* aut[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
971       aut[i] -= aut[i]*(0.008f*0.008f)*i*i;
972     }
973   }
974   /* Generate lpc coefficients from autocorr values */
975
976   /* set our noise floor to about -100dB */
977   error=aut[0] * (1. + 1e-7);
978   epsilon=1e-6*aut[0]+1e-7;
979
980   for(i=0;i<LPC_ORDER;i++){
981     double r= -aut[i+1];
982
983     if(error<epsilon){
984       memset(lpc+i,0,(LPC_ORDER-i)*sizeof(*lpc));
985       goto done;
986     }
987
988     /* Sum up this iteration's reflection coefficient; note that in
989        Vorbis we don't save it.  If anyone wants to recycle this code
990        and needs reflection coefficients, save the results of 'r' from
991        each iteration. */
992
993     for(j=0;j<i;j++)r-=lpc[j]*aut[i-j];
994     r/=error;
995
996     /* Update LPC coefficients and total error */
997
998     lpc[i]=r;
999     for(j=0;j<i/2;j++){
1000       double tmp=lpc[j];
1001
1002       lpc[j]+=r*lpc[i-1-j];
1003       lpc[i-1-j]+=r*tmp;
1004     }
1005     if(i&1)lpc[j]+=lpc[j]*r;
1006
1007     error*=1.-r*r;
1008
1009   }
1010
1011  done:
1012
1013   /* slightly damp the filter */
1014   {
1015     double g = .999;
1016     double damp = g;
1017     for(j=0;j<LPC_ORDER;j++){
1018       lpc[j]*=damp;
1019       damp*=g;
1020     }
1021   }
1022
1023   for(j=0;j<LPC_ORDER;j++)lpci[j]=(float)lpc[j];
1024 }
1025