Fixes mixed declaration and code
[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[enc->channels*LPC_INPUT], &enc->buffer[enc->channels*enc->buffer_start], enc->channels*(enc->buffer_end-enc->buffer_start)*sizeof(*enc->buffer));
397     enc->buffer_end -= enc->buffer_start-LPC_INPUT;
398     enc->buffer_start = LPC_INPUT;
399   }
400 }
401
402 static void encode_buffer(OggOpusEnc *enc) {
403   opus_int32 max_packet_size;
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   max_packet_size = (1277*6+2)*enc->header.nb_streams;
407   while (enc->buffer_end-enc->buffer_start > enc->frame_size + enc->decision_delay) {
408     int cont;
409     int e_o_s;
410     opus_int32 pred;
411     int nbBytes;
412     unsigned char *packet;
413     unsigned char *packet_copy = NULL;
414     int is_keyframe=0;
415     if (enc->unrecoverable) return;
416     opus_multistream_encoder_ctl(enc->st, OPUS_GET_PREDICTION_DISABLED(&pred));
417     /* FIXME: a frame that follows a keyframe generally doesn't need to be a keyframe
418        unless there's two consecutive stream boundaries. */
419     if (enc->curr_granule + 2*enc->frame_size>= end_granule48k && enc->streams->next) {
420       opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(1));
421       is_keyframe = 1;
422     }
423     packet = oggp_get_packet_buffer(enc->oggp, max_packet_size);
424     nbBytes = opus_multistream_encode_float(enc->st, &enc->buffer[enc->channels*enc->buffer_start],
425         enc->buffer_end-enc->buffer_start, packet, max_packet_size);
426     if (nbBytes < 0) {
427       /* Anything better we can do here? */
428       enc->unrecoverable = 1;
429       return;
430     }
431     opus_multistream_encoder_ctl(enc->st, OPUS_SET_PREDICTION_DISABLED(pred));
432     assert(nbBytes > 0);
433     enc->curr_granule += enc->frame_size;
434     do {
435       opus_int64 granulepos;
436       granulepos=enc->curr_granule-enc->streams->granule_offset;
437       e_o_s=enc->curr_granule >= end_granule48k;
438       cont = 0;
439       if (e_o_s) granulepos=end_granule48k-enc->streams->granule_offset;
440       if (packet_copy != NULL) {
441         packet = oggp_get_packet_buffer(enc->oggp, max_packet_size);
442         memcpy(packet, packet_copy, nbBytes);
443       }
444       if (enc->packet_callback) enc->packet_callback(enc->packet_callback_data, packet, nbBytes, 0);
445       if ((e_o_s || is_keyframe) && packet_copy == NULL) {
446         packet_copy = malloc(nbBytes);
447         if (packet_copy == NULL) {
448           /* Can't recover from allocation failing here. */
449           enc->unrecoverable = 1;
450           return;
451         }
452         memcpy(packet_copy, packet, nbBytes);
453       }
454       oggp_commit_packet(enc->oggp, nbBytes, granulepos, e_o_s);
455       if (e_o_s) oe_flush_page(enc);
456       else if (!enc->pull_api) output_pages(enc);
457       if (e_o_s) {
458         EncStream *tmp;
459         tmp = enc->streams->next;
460         if (enc->streams->close_at_end) enc->callbacks.close(enc->streams->user_data);
461         stream_destroy(enc->streams);
462         enc->streams = tmp;
463         if (!tmp) enc->last_stream = NULL;
464         if (enc->last_stream == NULL) {
465           if (packet_copy) free(packet_copy);
466           return;
467         }
468         /* We're done with this stream, start the next one. */
469         enc->header.preskip = end_granule48k + enc->frame_size - enc->curr_granule;
470         enc->streams->granule_offset = enc->curr_granule - enc->frame_size;
471         if (enc->chaining_keyframe) {
472           enc->header.preskip += enc->frame_size;
473           enc->streams->granule_offset -= enc->frame_size;
474         }
475         init_stream(enc);
476         if (enc->chaining_keyframe) {
477           unsigned char *p;
478           opus_int64 granulepos2=enc->curr_granule - enc->streams->granule_offset - enc->frame_size;
479           p = oggp_get_packet_buffer(enc->oggp, enc->chaining_keyframe_length);
480           memcpy(p, enc->chaining_keyframe, enc->chaining_keyframe_length);
481           if (enc->packet_callback) enc->packet_callback(enc->packet_callback_data, enc->chaining_keyframe, enc->chaining_keyframe_length, 0);
482           oggp_commit_packet(enc->oggp, enc->chaining_keyframe_length, granulepos2, 0);
483         }
484         end_granule48k = (enc->streams->end_granule*48000 + enc->rate - 1)/enc->rate + enc->global_granule_offset;
485         cont = 1;
486       }
487     } while (cont);
488     if (enc->chaining_keyframe) free(enc->chaining_keyframe);
489     if (is_keyframe) {
490       enc->chaining_keyframe_length = nbBytes;
491       enc->chaining_keyframe = packet_copy;
492       packet_copy = NULL;
493     } else {
494       enc->chaining_keyframe = NULL;
495       enc->chaining_keyframe_length = -1;
496     }
497     if (packet_copy) free(packet_copy);
498     enc->buffer_start += enc->frame_size;
499   }
500   /* If we've reached the end of the buffer, move everything back to the front. */
501   if (enc->buffer_end == BUFFER_SAMPLES) {
502     shift_buffer(enc);
503   }
504   /* This function must never leave the buffer full. */
505   assert(enc->buffer_end < BUFFER_SAMPLES);
506 }
507
508 /* Add/encode any number of float samples to the file. */
509 int ope_encoder_write_float(OggOpusEnc *enc, const float *pcm, int samples_per_channel) {
510   int channels = enc->channels;
511   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
512   enc->last_stream->header_is_frozen = 1;
513   if (!enc->streams->stream_is_init) init_stream(enc);
514   if (samples_per_channel < 0) return OPE_BAD_ARG;
515   enc->write_granule += samples_per_channel;
516   enc->last_stream->end_granule = enc->write_granule;
517   do {
518     int i;
519     spx_uint32_t in_samples, out_samples;
520     out_samples = BUFFER_SAMPLES-enc->buffer_end;
521     if (enc->re != NULL) {
522       in_samples = samples_per_channel;
523       speex_resampler_process_interleaved_float(enc->re, pcm, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
524     } else {
525       int curr;
526       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
527       for (i=0;i<channels*curr;i++) {
528       enc->buffer[channels*enc->buffer_end+i] = pcm[i];
529       }
530       in_samples = out_samples = curr;
531     }
532     enc->buffer_end += out_samples;
533     pcm += in_samples*channels;
534     samples_per_channel -= in_samples;
535     encode_buffer(enc);
536     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
537   } while (samples_per_channel > 0);
538   return OPE_OK;
539 }
540
541 #define CONVERT_BUFFER 4096
542
543 /* Add/encode any number of int16 samples to the file. */
544 int ope_encoder_write(OggOpusEnc *enc, const opus_int16 *pcm, int samples_per_channel) {
545   int channels = enc->channels;
546   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
547   enc->last_stream->header_is_frozen = 1;
548   if (!enc->streams->stream_is_init) init_stream(enc);
549   if (samples_per_channel < 0) return OPE_BAD_ARG;
550   enc->write_granule += samples_per_channel;
551   enc->last_stream->end_granule = enc->write_granule;
552   do {
553     int i;
554     spx_uint32_t in_samples, out_samples;
555     out_samples = BUFFER_SAMPLES-enc->buffer_end;
556     if (enc->re != NULL) {
557       float buf[CONVERT_BUFFER];
558       in_samples = MIN(CONVERT_BUFFER/channels, samples_per_channel);
559       for (i=0;i<channels*(int)in_samples;i++) {
560         buf[i] = (1.f/32768)*pcm[i];
561       }
562       speex_resampler_process_interleaved_float(enc->re, buf, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
563     } else {
564       int curr;
565       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
566       for (i=0;i<channels*curr;i++) {
567         enc->buffer[channels*enc->buffer_end+i] = (1.f/32768)*pcm[i];
568       }
569       in_samples = out_samples = curr;
570     }
571     enc->buffer_end += out_samples;
572     pcm += in_samples*channels;
573     samples_per_channel -= in_samples;
574     encode_buffer(enc);
575     if (enc->unrecoverable) return OPE_UNRECOVERABLE;
576   } while (samples_per_channel > 0);
577   return OPE_OK;
578 }
579
580 /* Get the next page from the stream. Returns 1 if there is a page available, 0 if not. */
581 OPE_EXPORT int ope_encoder_get_page(OggOpusEnc *enc, unsigned char **page, opus_int32 *len, int flush) {
582   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
583   if (!enc->pull_api) return 0;
584   else {
585     if (flush) oggp_flush_page(enc->oggp);
586     return oggp_get_next_page(enc->oggp, page, len);
587   }
588 }
589
590 static void extend_signal(float *x, int before, int after, int channels);
591
592 int ope_encoder_drain(OggOpusEnc *enc) {
593   int pad_samples;
594   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
595   /* Check if it's already been drained. */
596   if (enc->streams == NULL) return OPE_TOO_LATE;
597   pad_samples = MAX(LPC_PADDING, enc->global_granule_offset + enc->frame_size);
598   if (!enc->streams->stream_is_init) init_stream(enc);
599   shift_buffer(enc);
600   assert(enc->buffer_end + pad_samples <= BUFFER_SAMPLES);
601   memset(&enc->buffer[enc->channels*enc->buffer_end], 0, pad_samples*enc->channels*sizeof(enc->buffer[0]));
602   extend_signal(&enc->buffer[enc->channels*enc->buffer_end], enc->buffer_end, LPC_PADDING, enc->channels);
603   enc->decision_delay = 0;
604   enc->buffer_end += pad_samples;
605   assert(enc->buffer_end <= BUFFER_SAMPLES);
606   encode_buffer(enc);
607   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
608   /* Draining should have called all the streams to complete. */
609   assert(enc->streams == NULL);
610   return OPE_OK;
611 }
612
613 void ope_encoder_destroy(OggOpusEnc *enc) {
614   EncStream *stream;
615   stream = enc->streams;
616   while (stream != NULL) {
617     EncStream *tmp = stream;
618     stream = stream->next;
619     if (tmp->close_at_end) enc->callbacks.close(tmp->user_data);
620     stream_destroy(tmp);
621   }
622   if (enc->chaining_keyframe) free(enc->chaining_keyframe);
623   free(enc->buffer);
624   if (enc->oggp) oggp_destroy(enc->oggp);
625   opus_multistream_encoder_destroy(enc->st);
626   if (enc->re) speex_resampler_destroy(enc->re);
627   free(enc);
628 }
629
630 /* Ends the stream and create a new stream within the same file. */
631 int ope_encoder_chain_current(OggOpusEnc *enc, OggOpusComments *comments) {
632   enc->last_stream->close_at_end = 0;
633   return ope_encoder_continue_new_callbacks(enc, enc->last_stream->user_data, comments);
634 }
635
636 /* Ends the stream and create a new file. */
637 int ope_encoder_continue_new_file(OggOpusEnc *enc, const char *path, OggOpusComments *comments) {
638   int ret;
639   struct StdioObject *obj;
640   if (!(obj = malloc(sizeof(*obj)))) return OPE_ALLOC_FAIL;
641   obj->file = fopen(path, "wb");
642   if (!obj->file) {
643     free(obj);
644     /* By trying to open the file first, we can recover if we can't open it. */
645     return OPE_CANNOT_OPEN;
646   }
647   ret = ope_encoder_continue_new_callbacks(enc, obj, comments);
648   if (ret == OPE_OK) return ret;
649   fclose(obj->file);
650   free(obj);
651   return ret;
652 }
653
654 /* Ends the stream and create a new file (callback-based). */
655 int ope_encoder_continue_new_callbacks(OggOpusEnc *enc, void *user_data, OggOpusComments *comments) {
656   EncStream *new_stream;
657   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
658   assert(enc->streams);
659   assert(enc->last_stream);
660   new_stream = stream_create(comments);
661   if (!new_stream) return OPE_ALLOC_FAIL;
662   new_stream->user_data = user_data;
663   new_stream->end_granule = enc->write_granule;
664   enc->last_stream->next = new_stream;
665   enc->last_stream = new_stream;
666   return OPE_OK;
667 }
668
669 int ope_encoder_flush_header(OggOpusEnc *enc) {
670   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
671   if (enc->last_stream->header_is_frozen) return OPE_TOO_LATE;
672   if (enc->last_stream->stream_is_init) return OPE_TOO_LATE;
673   else init_stream(enc);
674   return OPE_OK;
675 }
676
677 /* Goes straight to the libopus ctl() functions. */
678 int ope_encoder_ctl(OggOpusEnc *enc, int request, ...) {
679   int ret;
680   int translate;
681   va_list ap;
682   if (enc->unrecoverable) return OPE_UNRECOVERABLE;
683   va_start(ap, request);
684   ret = OPE_OK;
685   switch (request) {
686     case OPUS_SET_APPLICATION_REQUEST:
687     case OPUS_SET_BITRATE_REQUEST:
688     case OPUS_SET_MAX_BANDWIDTH_REQUEST:
689     case OPUS_SET_VBR_REQUEST:
690     case OPUS_SET_BANDWIDTH_REQUEST:
691     case OPUS_SET_COMPLEXITY_REQUEST:
692     case OPUS_SET_INBAND_FEC_REQUEST:
693     case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
694     case OPUS_SET_DTX_REQUEST:
695     case OPUS_SET_VBR_CONSTRAINT_REQUEST:
696     case OPUS_SET_FORCE_CHANNELS_REQUEST:
697     case OPUS_SET_SIGNAL_REQUEST:
698     case OPUS_SET_LSB_DEPTH_REQUEST:
699     case OPUS_SET_PREDICTION_DISABLED_REQUEST:
700 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
701     case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
702 #endif
703     {
704       opus_int32 value = va_arg(ap, opus_int32);
705       ret = opus_multistream_encoder_ctl(enc->st, request, value);
706     }
707     break;
708     case OPUS_GET_LOOKAHEAD_REQUEST:
709     {
710       opus_int32 *value = va_arg(ap, opus_int32*);
711       ret = opus_multistream_encoder_ctl(enc->st, request, value);
712     }
713     break;
714     case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
715     {
716       opus_int32 value = va_arg(ap, opus_int32);
717       int max_supported = OPUS_FRAMESIZE_60_MS;
718 #ifdef OPUS_FRAMESIZE_120_MS
719       max_supported = OPUS_FRAMESIZE_120_MS;
720 #endif
721       if (value < OPUS_FRAMESIZE_2_5_MS || value > max_supported) {
722         ret = OPUS_UNIMPLEMENTED;
723         break;
724       }
725       ret = opus_multistream_encoder_ctl(enc->st, request, value);
726       if (ret == OPUS_OK) {
727         if (value <= OPUS_FRAMESIZE_40_MS)
728           enc->frame_size = 120<<(value-OPUS_FRAMESIZE_2_5_MS);
729         else
730           enc->frame_size = (value-OPUS_FRAMESIZE_2_5_MS-2)*960;
731       }
732     }
733     break;
734     case OPUS_GET_APPLICATION_REQUEST:
735     case OPUS_GET_BITRATE_REQUEST:
736     case OPUS_GET_MAX_BANDWIDTH_REQUEST:
737     case OPUS_GET_VBR_REQUEST:
738     case OPUS_GET_BANDWIDTH_REQUEST:
739     case OPUS_GET_COMPLEXITY_REQUEST:
740     case OPUS_GET_INBAND_FEC_REQUEST:
741     case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
742     case OPUS_GET_DTX_REQUEST:
743     case OPUS_GET_VBR_CONSTRAINT_REQUEST:
744     case OPUS_GET_FORCE_CHANNELS_REQUEST:
745     case OPUS_GET_SIGNAL_REQUEST:
746     case OPUS_GET_LSB_DEPTH_REQUEST:
747     case OPUS_GET_PREDICTION_DISABLED_REQUEST:
748 #ifdef OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST
749     case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
750 #endif
751     {
752       opus_int32 *value = va_arg(ap, opus_int32*);
753       ret = opus_multistream_encoder_ctl(enc->st, request, value);
754     }
755     break;
756     case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
757     {
758       opus_int32 stream_id;
759       OpusEncoder **value;
760       stream_id = va_arg(ap, opus_int32);
761       value = va_arg(ap, OpusEncoder**);
762       ret = opus_multistream_encoder_ctl(enc->st, request, stream_id, value);
763     }
764     break;
765
766     /* ****************** libopusenc-specific requests. ********************** */
767     case OPE_SET_DECISION_DELAY_REQUEST:
768     {
769       opus_int32 value = va_arg(ap, opus_int32);
770       if (value < 0) {
771         ret = OPE_BAD_ARG;
772         break;
773       }
774       enc->decision_delay = value;
775     }
776     break;
777     case OPE_GET_DECISION_DELAY_REQUEST:
778     {
779       opus_int32 *value = va_arg(ap, opus_int32*);
780       *value = enc->decision_delay;
781     }
782     break;
783     case OPE_SET_MUXING_DELAY_REQUEST:
784     {
785       opus_int32 value = va_arg(ap, opus_int32);
786       if (value < 0) {
787         ret = OPE_BAD_ARG;
788         break;
789       }
790       enc->max_ogg_delay = value;
791       oggp_set_muxing_delay(enc->oggp, enc->max_ogg_delay);
792     }
793     break;
794     case OPE_GET_MUXING_DELAY_REQUEST:
795     {
796       opus_int32 *value = va_arg(ap, opus_int32*);
797       *value = enc->max_ogg_delay;
798     }
799     break;
800     case OPE_SET_COMMENT_PADDING_REQUEST:
801     {
802       opus_int32 value = va_arg(ap, opus_int32);
803       if (value < 0) {
804         ret = OPE_BAD_ARG;
805         break;
806       }
807       enc->comment_padding = value;
808       ret = OPE_OK;
809     }
810     break;
811     case OPE_GET_COMMENT_PADDING_REQUEST:
812     {
813       opus_int32 *value = va_arg(ap, opus_int32*);
814       *value = enc->comment_padding;
815     }
816     break;
817     case OPE_SET_SERIALNO_REQUEST:
818     {
819       opus_int32 value = va_arg(ap, opus_int32);
820       if (!enc->last_stream || enc->last_stream->header_is_frozen) {
821         ret = OPE_TOO_LATE;
822         break;
823       }
824       enc->last_stream->serialno = value;
825       enc->last_stream->serialno_is_set = 1;
826       ret = OPE_OK;
827     }
828     break;
829     case OPE_GET_SERIALNO_REQUEST:
830     {
831       opus_int32 *value = va_arg(ap, opus_int32*);
832       *value = enc->last_stream->serialno;
833     }
834     break;
835     case OPE_SET_PACKET_CALLBACK_REQUEST:
836     {
837       ope_packet_func value = va_arg(ap, ope_packet_func);
838       void *data = va_arg(ap, void *);
839       enc->packet_callback = value;
840       enc->packet_callback_data = data;
841       ret = OPE_OK;
842     }
843     break;
844     case OPE_SET_HEADER_GAIN_REQUEST:
845     {
846       opus_int32 value = va_arg(ap, opus_int32);
847       if (!enc->last_stream || enc->last_stream->header_is_frozen) {
848         ret = OPE_TOO_LATE;
849         break;
850       }
851       enc->header.gain = value;
852       ret = OPE_OK;
853     }
854     break;
855     case OPE_GET_HEADER_GAIN_REQUEST:
856     {
857       opus_int32 *value = va_arg(ap, opus_int32*);
858       *value = enc->header.gain;
859     }
860     break;
861     default:
862       ret = OPE_UNIMPLEMENTED;
863   }
864   va_end(ap);
865   translate = ret != 0 && (request < 14000 || (ret < 0 && ret >= -10));
866   if (translate) {
867     if (ret == OPUS_BAD_ARG) ret = OPE_BAD_ARG;
868     else if (ret == OPUS_INTERNAL_ERROR) ret = OPE_INTERNAL_ERROR;
869     else if (ret == OPUS_UNIMPLEMENTED) ret = OPE_UNIMPLEMENTED;
870     else if (ret == OPUS_ALLOC_FAIL) ret = OPE_ALLOC_FAIL;
871     else ret = OPE_INTERNAL_ERROR;
872   }
873   assert(ret == 0 || ret < -10);
874   return ret;
875 }
876
877 const char *ope_strerror(int error) {
878   static const char * const ope_error_strings[5] = {
879     "cannot open file",
880     "call cannot be made at this point",
881     "unrecoverable error",
882     "invalid picture file",
883     "invalid icon file (pictures of type 1 MUST be 32x32 PNGs)"
884   };
885   if (error == 0) return "success";
886   else if (error >= -10) return "unknown error";
887   else if (error > -30) return opus_strerror(error+10);
888   else if (error >= OPE_INVALID_ICON) return ope_error_strings[-error-30];
889   else return "unknown error";
890 }
891
892 const char *ope_get_version_string(void)
893 {
894   return "libopusenc " PACKAGE_VERSION;
895 }
896
897 int ope_get_abi_version(void) {
898   return OPE_ABI_VERSION;
899 }
900
901 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride);
902
903 static void extend_signal(float *x, int before, int after, int channels) {
904   int c;
905   int i;
906   float window[LPC_PADDING];
907   if (after==0) return;
908   before = MIN(before, LPC_INPUT);
909   if (before < 4*LPC_ORDER) {
910     int i;
911     for (i=0;i<after*channels;i++) x[i] = 0;
912     return;
913   }
914   {
915     /* Generate Window using a resonating IIR aka Goertzel's algorithm. */
916     float m0=1, m1=.5*LPC_GOERTZEL_CONST;
917     float a1 = LPC_GOERTZEL_CONST;
918     window[0] = 1;
919     for (i=1;i<LPC_PADDING;i++) {
920       window[i] = a1*m0 - m1;
921       m1 = m0;
922       m0 = window[i];
923     }
924     for (i=0;i<LPC_PADDING;i++) window[i] = .5+.5*window[i];
925   }
926   for (c=0;c<channels;c++) {
927     float lpc[LPC_ORDER];
928     vorbis_lpc_from_data(x-channels*before+c, lpc, before, channels);
929     for (i=0;i<after;i++) {
930       float sum;
931       int j;
932       sum = 0;
933       for (j=0;j<LPC_ORDER;j++) sum -= x[(i-j-1)*channels + c]*lpc[j];
934       x[i*channels + c] = sum;
935     }
936     for (i=0;i<after;i++) x[i*channels + c] *= window[i];
937   }
938 }
939
940 /* Some of these routines (autocorrelator, LPC coefficient estimator)
941    are derived from code written by Jutta Degener and Carsten Bormann;
942    thus we include their copyright below.  The entirety of this file
943    is freely redistributable on the condition that both of these
944    copyright notices are preserved without modification.  */
945
946 /* Preserved Copyright: *********************************************/
947
948 /* Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
949 Technische Universita"t Berlin
950
951 Any use of this software is permitted provided that this notice is not
952 removed and that neither the authors nor the Technische Universita"t
953 Berlin are deemed to have made any representations as to the
954 suitability of this software for any purpose nor are held responsible
955 for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR
956 THIS SOFTWARE.
957
958 As a matter of courtesy, the authors request to be informed about uses
959 this software has found, about bugs in this software, and about any
960 improvements that may be of general interest.
961
962 Berlin, 28.11.1994
963 Jutta Degener
964 Carsten Bormann
965
966 *********************************************************************/
967
968 static void vorbis_lpc_from_data(float *data, float *lpci, int n, int stride) {
969   double aut[LPC_ORDER+1];
970   double lpc[LPC_ORDER];
971   double error;
972   double epsilon;
973   int i,j;
974
975   /* FIXME: Apply a window to the input. */
976   /* autocorrelation, p+1 lag coefficients */
977   j=LPC_ORDER+1;
978   while(j--){
979     double d=0; /* double needed for accumulator depth */
980     for(i=j;i<n;i++)d+=(double)data[i*stride]*data[(i-j)*stride];
981     aut[j]=d;
982   }
983
984   /* Apply lag windowing (better than bandwidth expansion) */
985   if (LPC_ORDER <= 64) {
986     for (i=1;i<=LPC_ORDER;i++) {
987       /* Approximate this gaussian for low enough order. */
988       /* aut[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
989       aut[i] -= aut[i]*(0.008f*0.008f)*i*i;
990     }
991   }
992   /* Generate lpc coefficients from autocorr values */
993
994   /* set our noise floor to about -100dB */
995   error=aut[0] * (1. + 1e-7);
996   epsilon=1e-6*aut[0]+1e-7;
997
998   for(i=0;i<LPC_ORDER;i++){
999     double r= -aut[i+1];
1000
1001     if(error<epsilon){
1002       memset(lpc+i,0,(LPC_ORDER-i)*sizeof(*lpc));
1003       goto done;
1004     }
1005
1006     /* Sum up this iteration's reflection coefficient; note that in
1007        Vorbis we don't save it.  If anyone wants to recycle this code
1008        and needs reflection coefficients, save the results of 'r' from
1009        each iteration. */
1010
1011     for(j=0;j<i;j++)r-=lpc[j]*aut[i-j];
1012     r/=error;
1013
1014     /* Update LPC coefficients and total error */
1015
1016     lpc[i]=r;
1017     for(j=0;j<i/2;j++){
1018       double tmp=lpc[j];
1019
1020       lpc[j]+=r*lpc[i-1-j];
1021       lpc[i-1-j]+=r*tmp;
1022     }
1023     if(i&1)lpc[j]+=lpc[j]*r;
1024
1025     error*=1.-r*r;
1026
1027   }
1028
1029  done:
1030
1031   /* slightly damp the filter */
1032   {
1033     double g = .999;
1034     double damp = g;
1035     for(j=0;j<LPC_ORDER;j++){
1036       lpc[j]*=damp;
1037       damp*=g;
1038     }
1039   }
1040
1041   for(j=0;j<LPC_ORDER;j++)lpci[j]=(float)lpc[j];
1042 }
1043