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