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