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