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