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