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