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