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