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