Frame size support (untested)
[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
46 #define MAX_CHANNELS 8
47
48 #define LPC_PADDING 120
49
50 /* Allow up to 2 seconds for delayed decision. */
51 #define MAX_LOOKAHEAD 96000
52 /* We can't have a circular buffer (because of delayed decision), so let's not copy too often. */
53 #define BUFFER_EXTRA 24000
54
55 #define BUFFER_SAMPLES (MAX_LOOKAHEAD + BUFFER_EXTRA)
56
57 #define MIN(a,b) ((a) < (b) ? (a) : (b))
58 #define MAX(a,b) ((a) > (b) ? (a) : (b))
59
60 #define MAX_PACKET_SIZE (1276*8)
61
62 static int oe_write_page(ogg_page *page, OpusEncCallbacks *cb, void *user_data)
63 {
64    int err;
65    err = cb->write(user_data, page->header, page->header_len);
66    if (err) return -1;
67    err = cb->write(user_data, page->body, page->body_len);
68    if (err) return -1;
69    return page->header_len+page->body_len;
70 }
71
72 struct StdioObject {
73   FILE *file;
74 };
75
76 struct OggOpusEnc {
77   OpusMSEncoder *st;
78   int rate;
79   int channels;
80   float *buffer;
81   int buffer_start;
82   int buffer_end;
83   SpeexResamplerState *re;
84   int frame_size;
85   int decision_delay;
86   int max_ogg_delay;
87   ogg_int64_t curr_granule;
88   ogg_int64_t end_granule;
89   ogg_int64_t last_page_granule;
90   OpusEncCallbacks callbacks;
91   void *user_data;
92   OpusHeader header;
93   char *comment;
94   int comment_length;
95   ogg_stream_state os;
96   int stream_is_init;
97   int packetno;
98 };
99
100 static int oe_flush_page(OggOpusEnc *enc) {
101   ogg_page og;
102   int ret;
103   int written = 0;
104   while ( (ret = ogg_stream_flush(&enc->os, &og)) ) {
105     if (!ret) break;
106     ret = oe_write_page(&og, &enc->callbacks, enc->user_data);
107     if (ret == -1) {
108       return -1;
109     }
110     written += ret;
111   }
112   return written;
113 }
114
115 int stdio_write(void *user_data, const unsigned char *ptr, int len) {
116   struct StdioObject *obj = (struct StdioObject*)user_data;
117   return fwrite(ptr, 1, len, obj->file) != (size_t)len;
118 }
119
120 int stdio_close(void *user_data) {
121   struct StdioObject *obj = (struct StdioObject*)user_data;
122   int ret = fclose(obj->file);
123   free(obj);
124   return ret;
125 }
126
127 static const OpusEncCallbacks stdio_callbacks = {
128   stdio_write,
129   stdio_close
130 };
131
132 /* Create a new OggOpus file. */
133 OggOpusEnc *ope_create_file(const char *path, int rate, int channels, int family, int *error) {
134   OggOpusEnc *enc;
135   struct StdioObject *obj;
136   obj = malloc(sizeof(*obj));
137   enc = ope_create_callbacks(&stdio_callbacks, obj, rate, channels, family, error);
138   if (enc == NULL || (error && *error)) {
139     return NULL;
140   }
141   obj->file = fopen(path, "wb");
142   if (!obj->file) {
143     if (error) *error = OPE_CANNOT_OPEN;
144     /* FIXME: Destroy the encoder properly. */
145     free(obj);
146     return NULL;
147   }
148   return enc;
149 }
150
151 /* Create a new OggOpus file (callback-based). */
152 OggOpusEnc *ope_create_callbacks(const OpusEncCallbacks *callbacks, void *user_data,
153     int rate, int channels, int family, int *error) {
154   OpusMSEncoder *st=NULL;
155   OggOpusEnc *enc=NULL;
156   int ret;
157   if (family != 0 && family != 1 && family != 255) {
158     if (error) *error = OPE_UNIMPLEMENTED;
159     return NULL;
160   }
161   if (channels <= 0 || channels > 255) {
162     if (error) *error = OPE_BAD_ARG;
163     return NULL;
164   }
165   /* FIXME: Add resampling support. */
166   if (rate <= 0) {
167     if (error) *error = OPE_BAD_ARG;
168     return NULL;
169   }
170
171   if ( (enc = malloc(sizeof(*enc))) == NULL) goto fail;
172   enc->rate = rate;
173   enc->channels = channels;
174   enc->frame_size = 960;
175   enc->decision_delay = 96000;
176   enc->max_ogg_delay = 48000;
177   enc->header.channels=channels;
178   enc->header.channel_mapping=family;
179   enc->header.input_sample_rate=rate;
180   enc->header.gain=0;
181   st=opus_multistream_surround_encoder_create(48000, channels, enc->header.channel_mapping,
182       &enc->header.nb_streams, &enc->header.nb_coupled,
183       enc->header.stream_map, OPUS_APPLICATION_AUDIO, &ret);
184   if (! (ret == OPUS_OK && st != NULL) ) {
185     goto fail;
186   }
187   if (rate != 48000) {
188     enc->re = speex_resampler_init(channels, rate, 48000, 5, NULL);
189     if (enc->re == NULL) goto fail;
190     speex_resampler_skip_zeros(enc->re);
191   } else {
192     enc->re = NULL;
193   }
194   opus_multistream_encoder_ctl(st, OPUS_SET_EXPERT_FRAME_DURATION(OPUS_FRAMESIZE_20_MS));
195   enc->stream_is_init = 0;
196   enc->comment = NULL;
197   {
198     opus_int32 tmp;
199     int ret;
200     ret = opus_multistream_encoder_ctl(st, OPUS_GET_LOOKAHEAD(&tmp));
201     if (ret == OPUS_OK) enc->header.preskip = tmp;
202     else enc->header.preskip = 0;
203   }
204   enc->curr_granule = 0;
205   enc->end_granule = 0;
206   enc->last_page_granule = 0;
207   comment_init(&enc->comment, &enc->comment_length, opus_get_version_string());
208   {
209     char encoder_string[1024];
210     snprintf(encoder_string, sizeof(encoder_string), "%s version %s", PACKAGE_NAME, PACKAGE_VERSION);
211     comment_add(&enc->comment, &enc->comment_length, "ENCODER", encoder_string);
212   }
213   if (enc->comment == NULL) goto fail;
214   if ( (enc->buffer = malloc(sizeof(*enc->buffer)*BUFFER_SAMPLES*channels)) == NULL) goto fail;
215   enc->buffer_start = enc->buffer_end = 0;
216   enc->st = st;
217   enc->callbacks = *callbacks;
218   enc->user_data = user_data;
219   if (error) *error = OPUS_OK;
220   return enc;
221 fail:
222   if (enc) {
223     free(enc);
224     if (enc->buffer) free(enc->buffer);
225   }
226   if (st) {
227     opus_multistream_encoder_destroy(st);
228   }
229   return NULL;
230 }
231
232 static void init_stream(OggOpusEnc *enc) {
233   time_t start_time;
234   int serialno;
235   assert(!enc->stream_is_init);
236   start_time = time(NULL);
237   srand(((getpid()&65535)<<15)^start_time);
238
239   serialno = rand();
240   if (ogg_stream_init(&enc->os, serialno) == -1) {
241     assert(0);
242     /* FIXME: How the hell do we handle that? */
243   }
244   comment_pad(&enc->comment, &enc->comment_length, 512);
245
246   /*Write header*/
247   {
248     ogg_packet op;
249     /*The Identification Header is 19 bytes, plus a Channel Mapping Table for
250       mapping families other than 0. The Channel Mapping Table is 2 bytes +
251       1 byte per channel. Because the maximum number of channels is 255, the
252       maximum size of this header is 19 + 2 + 255 = 276 bytes.*/
253     unsigned char header_data[276];
254     int packet_size = opus_header_to_packet(&enc->header, header_data, sizeof(header_data));
255     op.packet=header_data;
256     op.bytes=packet_size;
257     op.b_o_s=1;
258     op.e_o_s=0;
259     op.granulepos=0;
260     op.packetno=0;
261     ogg_stream_packetin(&enc->os, &op);
262     oe_flush_page(enc);
263
264     op.packet = (unsigned char *)enc->comment;
265     op.bytes = enc->comment_length;
266     op.b_o_s = 0;
267     op.e_o_s = 0;
268     op.granulepos = 0;
269     op.packetno = 1;
270     ogg_stream_packetin(&enc->os, &op);
271     oe_flush_page(enc);
272   }
273   enc->stream_is_init = 1;
274   enc->packetno = 2;
275 }
276
277 static void shift_buffer(OggOpusEnc *enc) {
278     memmove(enc->buffer, &enc->buffer[enc->channels*enc->buffer_start], enc->channels*(enc->buffer_end-enc->buffer_start)*sizeof(*enc->buffer));
279     enc->buffer_end -= enc->buffer_start;
280     enc->buffer_start = 0;
281 }
282
283 static void encode_buffer(OggOpusEnc *enc) {
284   /* Round up when converting the granule pos because the decoder will round down. */
285   ogg_int64_t end_granule48k = (enc->end_granule*48000 + enc->rate - 1)/enc->rate + enc->header.preskip;
286   while (enc->buffer_end-enc->buffer_start > enc->frame_size + enc->decision_delay) {
287     int flush_needed;
288     ogg_packet op;
289     ogg_page og;
290     int nbBytes;
291     unsigned char packet[MAX_PACKET_SIZE];
292     nbBytes = opus_multistream_encode_float(enc->st, &enc->buffer[enc->channels*enc->buffer_start],
293         enc->buffer_end-enc->buffer_start, packet, MAX_PACKET_SIZE);
294     /* FIXME: How do we handle failure here. */
295     assert(nbBytes > 0);
296     enc->curr_granule += enc->frame_size;
297     op.packet=packet;
298     op.bytes=nbBytes;
299     op.b_o_s=0;
300     op.packetno=enc->packetno++;
301     op.granulepos=enc->curr_granule;
302     op.e_o_s=enc->curr_granule >= end_granule48k;
303     if (op.e_o_s) op.granulepos=end_granule48k;
304     ogg_stream_packetin(&enc->os, &op);
305     /* FIXME: Also flush on too many segments. */
306     flush_needed = op.e_o_s || enc->curr_granule - enc->last_page_granule > enc->max_ogg_delay;
307     if (flush_needed) {
308       while (ogg_stream_flush_fill(&enc->os, &og, 255*255)) {
309         if (ogg_page_packets(&og) != 0) enc->last_page_granule = ogg_page_granulepos(&og);
310         int ret = oe_write_page(&og, &enc->callbacks, enc->user_data);
311         /* FIXME: what do we do if this fails? */
312         assert(ret != -1);
313       }
314     } else {
315       while (ogg_stream_pageout_fill(&enc->os, &og, 255*255)) {
316         if (ogg_page_packets(&og) != 0) enc->last_page_granule = ogg_page_granulepos(&og);
317         int ret = oe_write_page(&og, &enc->callbacks, enc->user_data);
318         /* FIXME: what do we do if this fails? */
319         assert(ret != -1);
320       }
321     }
322     if (op.e_o_s) return;
323     enc->buffer_start += enc->frame_size;
324   }
325   /* If we've reached the end of the buffer, move everything back to the front. */
326   if (enc->buffer_end == BUFFER_SAMPLES) {
327     shift_buffer(enc);
328   }
329   /* This function must never leave the buffer full. */
330   assert(enc->buffer_end < BUFFER_SAMPLES);
331 }
332
333 /* Add/encode any number of float samples to the file. */
334 int ope_write_float(OggOpusEnc *enc, const float *pcm, int samples_per_channel) {
335   int channels = enc->channels;
336   if (!enc->stream_is_init) init_stream(enc);
337   if (samples_per_channel < 0) return OPE_BAD_ARG;
338   enc->end_granule += samples_per_channel;
339   do {
340     int i;
341     spx_uint32_t in_samples, out_samples;
342     out_samples = BUFFER_SAMPLES-enc->buffer_end;
343     if (enc->re != NULL) {
344       in_samples = samples_per_channel;
345       speex_resampler_process_interleaved_float(enc->re, pcm, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
346     } else {
347       int curr;
348       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
349       for (i=0;i<channels*curr;i++) {
350       enc->buffer[channels*enc->buffer_end+i] = pcm[i];
351       }
352       in_samples = out_samples = curr;
353     }
354     enc->buffer_end += out_samples;
355     pcm += in_samples*channels;
356     samples_per_channel -= in_samples;
357     encode_buffer(enc);
358   } while (samples_per_channel > 0);
359   return OPE_OK;
360 }
361
362 #define CONVERT_BUFFER 256
363
364 /* Add/encode any number of int16 samples to the file. */
365 int ope_write(OggOpusEnc *enc, const opus_int16 *pcm, int samples_per_channel) {
366   int channels = enc->channels;
367   if (!enc->stream_is_init) init_stream(enc);
368   if (samples_per_channel < 0) return OPE_BAD_ARG;
369   enc->end_granule += samples_per_channel;
370   do {
371     int i;
372     spx_uint32_t in_samples, out_samples;
373     out_samples = BUFFER_SAMPLES-enc->buffer_end;
374     if (enc->re != NULL) {
375       float buf[CONVERT_BUFFER*MAX_CHANNELS];
376       in_samples = MIN(CONVERT_BUFFER, samples_per_channel);
377       for (i=0;i<channels*(int)in_samples;i++) {
378         buf[i] = (1.f/32768)*pcm[i];
379       }
380       speex_resampler_process_interleaved_float(enc->re, buf, &in_samples, &enc->buffer[channels*enc->buffer_end], &out_samples);
381     } else {
382       int curr;
383       curr = MIN((spx_uint32_t)samples_per_channel, out_samples);
384       for (i=0;i<channels*curr;i++) {
385         enc->buffer[channels*enc->buffer_end+i] = (1.f/32768)*pcm[i];
386       }
387       in_samples = out_samples = curr;
388     }
389     enc->buffer_end += out_samples;
390     pcm += in_samples*channels;
391     samples_per_channel -= in_samples;
392     encode_buffer(enc);
393   } while (samples_per_channel > 0);
394   return OPE_OK;
395 }
396
397 static void finalize_stream(OggOpusEnc *enc) {
398   /* FIXME: Use a better value. */
399   int pad_samples = 3000;
400   if (!enc->stream_is_init) init_stream(enc);
401   shift_buffer(enc);
402   /* FIXME: Do LPC extension instead. */
403   memset(&enc->buffer[enc->channels*enc->buffer_end], 0, pad_samples*enc->channels);
404   enc->decision_delay = 0;
405   enc->buffer_end += pad_samples;
406   assert(enc->buffer_end <= BUFFER_SAMPLES);
407   encode_buffer(enc);
408 }
409
410 /* Close/finalize the stream. */
411 int ope_close_and_free(OggOpusEnc *enc) {
412   finalize_stream(enc);
413   enc->callbacks.close(enc->user_data);
414   free(enc->comment);
415   free(enc->buffer);
416   opus_multistream_encoder_destroy(enc->st);
417   if (enc->stream_is_init) ogg_stream_clear(&enc->os);
418   if (enc->re) speex_resampler_destroy(enc->re);
419   free(enc);
420   return OPE_OK;
421 }
422
423 /* Ends the stream and create a new stream within the same file. */
424 int ope_chain_current(OggOpusEnc *enc) {
425   (void)enc;
426   return OPE_UNIMPLEMENTED;
427 }
428
429 /* Ends the stream and create a new file. */
430 int ope_continue_new_file(OggOpusEnc *enc, const char *path) {
431   (void)enc;
432   (void)path;
433   return OPE_UNIMPLEMENTED;
434 }
435
436 /* Ends the stream and create a new file (callback-based). */
437 int ope_continue_new_callbacks(OggOpusEnc *enc, void *user_data) {
438   (void)enc;
439   (void)user_data;
440   return OPE_UNIMPLEMENTED;
441 }
442
443 /* Add a comment to the file (can only be called before encoding samples). */
444 int ope_add_comment(OggOpusEnc *enc, const char *tag, const char *val) {
445   if (comment_add(&enc->comment, &enc->comment_length, tag, val)) return OPE_INTERNAL_ERROR;
446   return OPE_OK;
447 }
448
449 /* Sets the Opus comment vendor string (optional, defaults to library info). */
450 int ope_set_vendor_string(OggOpusEnc *enc, const char *vendor) {
451   (void)enc;
452   (void)vendor;
453   return OPE_UNIMPLEMENTED;
454 }
455
456 /* Goes straight to the libopus ctl() functions. */
457 int ope_encoder_ctl(OggOpusEnc *enc, int request, ...) {
458   int ret;
459   va_list ap;
460   va_start(ap, request);
461   switch (request) {
462     case OPUS_SET_BITRATE_REQUEST:
463     case OPUS_SET_VBR_REQUEST:
464     case OPUS_SET_VBR_CONSTRAINT_REQUEST:
465     case OPUS_SET_COMPLEXITY_REQUEST:
466     case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
467     case OPUS_SET_LSB_DEPTH_REQUEST:
468     {
469       opus_int32 value = va_arg(ap, opus_int32);
470       ret = opus_multistream_encoder_ctl(enc->st, request, value);
471     }
472     break;
473     case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
474     {
475       opus_int32 value = va_arg(ap, opus_int32);
476       int max_supported = OPUS_FRAMESIZE_60_MS;
477 #ifdef OPUS_FRAMESIZE_120_MS
478       max_supported = OPUS_FRAMESIZE_120_MS;
479 #endif
480       if (value < OPUS_FRAMESIZE_2_5_MS || value > max_supported) {
481         ret = OPE_UNIMPLEMENTED;
482         break;
483       }
484       ret = opus_multistream_encoder_ctl(enc->st, request, value);
485       if (ret == OPUS_OK) {
486         if (value <= OPUS_FRAMESIZE_40_MS)
487           enc->frame_size = 120<<(value-OPUS_FRAMESIZE_2_5_MS);
488         else
489           enc->frame_size = (value-OPUS_FRAMESIZE_2_5_MS-2)*960;
490       }
491     }
492     break;
493     default:
494       ret = OPE_UNIMPLEMENTED;
495   }
496   va_end(ap);
497   return ret;
498 }
499
500 /* ctl()-type call for the OggOpus layer. */
501 int ope_set_params(OggOpusEnc *enc, int request, ...) {
502   (void)enc;
503   switch (request) {
504     default:
505       return OPE_UNIMPLEMENTED;
506   }
507 }