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