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