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