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