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