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