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