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