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