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