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