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