1 /*****************************************************************************
2 * opus.c: opus decoder/encoder module making use of libopus.
3 *****************************************************************************
4 * Copyright (C) 2003-2009, 2012 VLC authors and VideoLAN
5 *
6 * Authors: Gregory Maxwell <greg@xiph.org>
7 * Based on speex.c by: Gildas Bazin <gbazin@videolan.org>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License as published by
11 * the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
23
24 /*****************************************************************************
25 * Preamble
26 *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32 #include <vlc_plugin.h>
33 #include <vlc_input.h>
34 #include <vlc_codec.h>
35 #include <vlc_aout.h>
36 #include "../demux/xiph.h"
37
38 #include <ogg/ogg.h>
39 #include <opus.h>
40 #include <opus_multistream.h>
41
42 #include "opus_header.h"
43
44 #ifndef OPUS_SET_GAIN
45 #include <math.h>
46 #endif
47
48 /*****************************************************************************
49 * Module descriptor
50 *****************************************************************************/
51 static int OpenDecoder ( vlc_object_t * );
52 static void CloseDecoder ( vlc_object_t * );
53 #ifdef ENABLE_SOUT
54 static int OpenEncoder ( vlc_object_t * );
55 static void CloseEncoder ( vlc_object_t * );
56 #endif
57
58 vlc_module_begin ()
59 set_category( CAT_INPUT )
60 set_subcategory( SUBCAT_INPUT_ACODEC )
61
62 set_description( N_("Opus audio decoder") )
63 set_capability( "audio decoder", 100 )
64 set_shortname( N_("Opus") )
65 set_callbacks( OpenDecoder, CloseDecoder )
66
67 #ifdef ENABLE_SOUT
68 add_submodule ()
69 set_description( N_("Opus audio encoder") )
70 set_capability( "encoder", 150 )
71 set_shortname( N_("Opus") )
72 set_callbacks( OpenEncoder, CloseEncoder )
73 #endif
74
75 vlc_module_end ()
76
77 /*****************************************************************************
78 * decoder_sys_t : opus decoder descriptor
79 *****************************************************************************/
80 struct decoder_sys_t
81 {
82 /*
83 * Input properties
84 */
85 bool b_has_headers;
86
87 /*
88 * Opus properties
89 */
90 OpusHeader header;
91 OpusMSDecoder *p_st;
92
93 /*
94 * Common properties
95 */
96 date_t end_date;
97 };
98
99 static const int pi_channels_maps[9] =
100 {
101 0,
102 AOUT_CHAN_CENTER,
103 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
104 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
105 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
106 | AOUT_CHAN_REARRIGHT,
107 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
108 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
109 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
110 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE,
111 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
112 | AOUT_CHAN_REARCENTER | AOUT_CHAN_MIDDLELEFT
113 | AOUT_CHAN_MIDDLERIGHT | AOUT_CHAN_LFE,
114 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT
115 | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
116 | AOUT_CHAN_LFE,
117 };
118
119 /*
120 ** channel order as defined in http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9
121 */
122
123 /* recommended vorbis channel order for 8 channels */
124 static const uint32_t pi_8channels_in[] =
125 { AOUT_CHAN_LEFT, AOUT_CHAN_CENTER, AOUT_CHAN_RIGHT,
126 AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_MIDDLERIGHT,
127 AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT,AOUT_CHAN_LFE, 0 };
128
129 /* recommended vorbis channel order for 7 channels */
130 static const uint32_t pi_7channels_in[] =
131 { AOUT_CHAN_LEFT, AOUT_CHAN_CENTER, AOUT_CHAN_RIGHT,
132 AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_MIDDLERIGHT,
133 AOUT_CHAN_REARCENTER, AOUT_CHAN_LFE, 0 };
134
135 /* recommended vorbis channel order for 6 channels */
136 static const uint32_t pi_6channels_in[] =
137 { AOUT_CHAN_LEFT, AOUT_CHAN_CENTER, AOUT_CHAN_RIGHT,
138 AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, AOUT_CHAN_LFE, 0 };
139
140 /* recommended vorbis channel order for 5 channels */
141 static const uint32_t pi_5channels_in[] =
142 { AOUT_CHAN_LEFT, AOUT_CHAN_CENTER, AOUT_CHAN_RIGHT,
143 AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, 0 };
144
145 /* recommended vorbis channel order for 4 channels */
146 static const uint32_t pi_4channels_in[] =
147 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, 0 };
148
149 /* recommended vorbis channel order for 3 channels */
150 static const uint32_t pi_3channels_in[] =
151 { AOUT_CHAN_LEFT, AOUT_CHAN_CENTER, AOUT_CHAN_RIGHT, 0 };
152
153 /****************************************************************************
154 * Local prototypes
155 ****************************************************************************/
156
157 static block_t *Packetize ( decoder_t *, block_t ** );
158 static int DecodeAudio ( decoder_t *, block_t * );
159 static void Flush( decoder_t * );
160 static int ProcessHeaders( decoder_t * );
161 static int ProcessInitialHeader ( decoder_t *, ogg_packet * );
162 static block_t *ProcessPacket( decoder_t *, ogg_packet *, block_t * );
163
164 static block_t *DecodePacket( decoder_t *, ogg_packet *, int, mtime_t );
165
166 /*****************************************************************************
167 * OpenDecoder: probe the decoder and return score
168 *****************************************************************************/
OpenDecoder(vlc_object_t * p_this)169 static int OpenDecoder( vlc_object_t *p_this )
170 {
171 decoder_t *p_dec = (decoder_t*)p_this;
172 decoder_sys_t *p_sys;
173
174 if( p_dec->fmt_in.i_codec != VLC_CODEC_OPUS )
175 return VLC_EGENERIC;
176
177 /* Allocate the memory needed to store the decoder's structure */
178 if( ( p_dec->p_sys = p_sys = malloc(sizeof(decoder_sys_t)) ) == NULL )
179 return VLC_ENOMEM;
180 p_dec->p_sys->b_has_headers = false;
181
182 date_Set( &p_sys->end_date, 0 );
183
184 /* Set output properties */
185 p_dec->fmt_out.i_codec = VLC_CODEC_FL32;
186
187 p_dec->pf_decode = DecodeAudio;
188 p_dec->pf_packetize = Packetize;
189 p_dec->pf_flush = Flush;
190
191 p_sys->p_st = NULL;
192
193 return VLC_SUCCESS;
194 }
195
196 /****************************************************************************
197 * DecodeBlock: the whole thing
198 ****************************************************************************
199 * This function must be fed with ogg packets.
200 ****************************************************************************/
DecodeBlock(decoder_t * p_dec,block_t * p_block)201 static block_t *DecodeBlock( decoder_t *p_dec, block_t *p_block )
202 {
203 decoder_sys_t *p_sys = p_dec->p_sys;
204 ogg_packet oggpacket;
205
206 /* Block to Ogg packet */
207 oggpacket.packet = p_block->p_buffer;
208 oggpacket.bytes = p_block->i_buffer;
209
210 oggpacket.granulepos = -1;
211 oggpacket.b_o_s = 0;
212 oggpacket.e_o_s = 0;
213 oggpacket.packetno = 0;
214
215 /* Check for headers */
216 if( !p_sys->b_has_headers )
217 {
218 if( ProcessHeaders( p_dec ) )
219 {
220 block_Release( p_block );
221 return NULL;
222 }
223 p_sys->b_has_headers = true;
224 }
225
226 return ProcessPacket( p_dec, &oggpacket, p_block );
227 }
228
DecodeAudio(decoder_t * p_dec,block_t * p_block)229 static int DecodeAudio( decoder_t *p_dec, block_t *p_block )
230 {
231 if( p_block == NULL ) /* No Drain */
232 return VLCDEC_SUCCESS;
233
234 p_block = DecodeBlock( p_dec, p_block );
235 if( p_block != NULL )
236 decoder_QueueAudio( p_dec, p_block );
237 return VLCDEC_SUCCESS;
238 }
239
Packetize(decoder_t * p_dec,block_t ** pp_block)240 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
241 {
242 if( pp_block == NULL ) /* No Drain */
243 return NULL;
244 block_t *p_block = *pp_block; *pp_block = NULL;
245 if( p_block == NULL )
246 return NULL;
247 return DecodeBlock( p_dec, p_block );
248 }
249
250 /*****************************************************************************
251 * ProcessHeaders: process Opus headers.
252 *****************************************************************************/
ProcessHeaders(decoder_t * p_dec)253 static int ProcessHeaders( decoder_t *p_dec )
254 {
255 ogg_packet oggpacket;
256
257 unsigned pi_size[XIPH_MAX_HEADER_COUNT];
258 const void *pp_data[XIPH_MAX_HEADER_COUNT];
259 unsigned i_count;
260
261 int i_extra = p_dec->fmt_in.i_extra;
262 uint8_t *p_extra = p_dec->fmt_in.p_extra;
263
264 /* If we have no header (e.g. from RTP), make one. */
265 bool b_dummy_header = false;
266 if( !i_extra ||
267 (i_extra > 10 && memcmp( &p_extra[2], "OpusHead", 8 )) ) /* Borked muxers */
268 {
269 OpusHeader header;
270 opus_prepare_header( p_dec->fmt_in.audio.i_channels,
271 p_dec->fmt_in.audio.i_rate, &header );
272 if( opus_write_header( &p_extra, &i_extra, &header,
273 opus_get_version_string() ) )
274 return VLC_ENOMEM;
275 b_dummy_header = true;
276 }
277
278 if( xiph_SplitHeaders( pi_size, pp_data, &i_count,
279 i_extra, p_extra ) )
280 {
281 if( b_dummy_header )
282 free( p_extra );
283 return VLC_EGENERIC;
284 }
285
286 if( i_count < 2 )
287 {
288 if( b_dummy_header )
289 free( p_extra );
290 return VLC_EGENERIC;
291 }
292
293 oggpacket.granulepos = -1;
294 oggpacket.e_o_s = 0;
295 oggpacket.packetno = 0;
296
297 /* Take care of the initial Opus header */
298 oggpacket.b_o_s = 1; /* yes this actually is a b_o_s packet :) */
299 oggpacket.bytes = pi_size[0];
300 oggpacket.packet = (void *)pp_data[0];
301 int ret = ProcessInitialHeader( p_dec, &oggpacket );
302
303 if (ret != VLC_SUCCESS)
304 msg_Err( p_dec, "initial Opus header is corrupted" );
305
306 if( b_dummy_header )
307 free( p_extra );
308
309 return ret;
310 }
311
312 /*****************************************************************************
313 * ProcessInitialHeader: processes the inital Opus header packet.
314 *****************************************************************************/
ProcessInitialHeader(decoder_t * p_dec,ogg_packet * p_oggpacket)315 static int ProcessInitialHeader( decoder_t *p_dec, ogg_packet *p_oggpacket )
316 {
317 int err;
318 unsigned char new_stream_map[8];
319 decoder_sys_t *p_sys = p_dec->p_sys;
320
321 OpusHeader *p_header = &p_sys->header;
322
323 if( !opus_header_parse((unsigned char *)p_oggpacket->packet,p_oggpacket->bytes,p_header) )
324 {
325 msg_Err( p_dec, "cannot read Opus header" );
326 return VLC_EGENERIC;
327 }
328 msg_Dbg( p_dec, "Opus audio with %d channels", p_header->channels);
329
330 if((p_header->channels>2 && p_header->channel_mapping==0) ||
331 p_header->channels>8 ||
332 p_header->channel_mapping>1)
333 {
334 msg_Err( p_dec, "Unsupported channel mapping" );
335 return VLC_EGENERIC;
336 }
337
338 /* Setup the format */
339 p_dec->fmt_out.audio.i_physical_channels =
340 pi_channels_maps[p_header->channels];
341 p_dec->fmt_out.audio.i_channels = p_header->channels;
342 p_dec->fmt_out.audio.i_rate = 48000;
343
344 if( p_header->channels>2 )
345 {
346 static const uint32_t *pi_ch[6] = { pi_3channels_in, pi_4channels_in,
347 pi_5channels_in, pi_6channels_in,
348 pi_7channels_in, pi_8channels_in };
349 uint8_t pi_chan_table[AOUT_CHAN_MAX];
350
351 aout_CheckChannelReorder( pi_ch[p_header->channels-3], NULL,
352 p_dec->fmt_out.audio.i_physical_channels,
353 pi_chan_table );
354 for(int i=0;i<p_header->channels;i++)
355 new_stream_map[pi_chan_table[i]]=p_header->stream_map[i];
356 }
357 /* Opus decoder init */
358 p_sys->p_st = opus_multistream_decoder_create( 48000, p_header->channels,
359 p_header->nb_streams, p_header->nb_coupled,
360 p_header->channels>2?new_stream_map:p_header->stream_map,
361 &err );
362 if( !p_sys->p_st || err!=OPUS_OK )
363 {
364 msg_Err( p_dec, "decoder initialization failed" );
365 return VLC_EGENERIC;
366 }
367
368 #ifdef OPUS_SET_GAIN
369 if( opus_multistream_decoder_ctl( p_sys->p_st,OPUS_SET_GAIN(p_header->gain) ) != OPUS_OK )
370 {
371 msg_Err( p_dec, "OPUS_SET_GAIN failed" );
372 opus_multistream_decoder_destroy( p_sys->p_st );
373 return VLC_EGENERIC;
374 }
375 #endif
376
377 date_Init( &p_sys->end_date, 48000, 1 );
378
379 return VLC_SUCCESS;
380 }
381
382 /*****************************************************************************
383 * Flush:
384 *****************************************************************************/
Flush(decoder_t * p_dec)385 static void Flush( decoder_t *p_dec )
386 {
387 decoder_sys_t *p_sys = p_dec->p_sys;
388
389 date_Set( &p_sys->end_date, 0 );
390 }
391
392 /*****************************************************************************
393 * ProcessPacket: processes a Opus packet.
394 *****************************************************************************/
ProcessPacket(decoder_t * p_dec,ogg_packet * p_oggpacket,block_t * p_block)395 static block_t *ProcessPacket( decoder_t *p_dec, ogg_packet *p_oggpacket,
396 block_t *p_block )
397 {
398 decoder_sys_t *p_sys = p_dec->p_sys;
399
400 if( p_block->i_flags & (BLOCK_FLAG_CORRUPTED|BLOCK_FLAG_DISCONTINUITY) )
401 {
402 Flush( p_dec );
403 if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
404 {
405 block_Release( p_block );
406 return NULL;
407 }
408 }
409
410 /* Date management */
411 if( p_block->i_pts > VLC_TS_INVALID &&
412 p_block->i_pts != date_Get( &p_sys->end_date ) )
413 {
414 date_Set( &p_sys->end_date, p_block->i_pts );
415 }
416
417 if( !date_Get( &p_sys->end_date ) )
418 {
419 /* We've just started the stream, wait for the first PTS. */
420 block_Release( p_block );
421 return NULL;
422 }
423
424 block_t *p_aout_buffer = DecodePacket( p_dec, p_oggpacket,
425 p_block->i_nb_samples,
426 p_block->i_length );
427
428 block_Release( p_block );
429 return p_aout_buffer;
430 }
431
432 /*****************************************************************************
433 * DecodePacket: decodes a Opus packet.
434 *****************************************************************************/
DecodePacket(decoder_t * p_dec,ogg_packet * p_oggpacket,int i_nb_samples,mtime_t i_duration)435 static block_t *DecodePacket( decoder_t *p_dec, ogg_packet *p_oggpacket,
436 int i_nb_samples, mtime_t i_duration )
437 {
438 decoder_sys_t *p_sys = p_dec->p_sys;
439
440 if( !p_oggpacket->bytes )
441 return NULL;
442
443 int spp;
444 spp=opus_packet_get_nb_frames(p_oggpacket->packet,p_oggpacket->bytes);
445 if(spp>0)spp*=opus_packet_get_samples_per_frame(p_oggpacket->packet,48000);
446 if(spp<120||spp>120*48)return NULL;
447
448 /* Since the information isn't always available at the demux level
449 * use the packet's sample number */
450 if(!i_nb_samples)
451 i_nb_samples = spp;
452
453 int i_duration_samples = ((i_duration + (CLOCK_FREQ / 48000)) * 48000)
454 / CLOCK_FREQ;
455 int i_end_trim;
456 if(i_duration_samples && i_duration_samples < i_nb_samples)
457 {
458 i_end_trim = spp - i_duration_samples;
459 msg_Dbg(p_dec, "truncating %d off %d samples", i_end_trim, i_nb_samples);
460 }
461 else
462 i_end_trim = 0;
463
464 if( decoder_UpdateAudioFormat( p_dec ) )
465 return NULL;
466 block_t *p_aout_buffer=decoder_NewAudioBuffer( p_dec, spp );
467 if ( !p_aout_buffer )
468 {
469 msg_Err(p_dec, "Oops: No new buffer was returned!");
470 return NULL;
471 }
472
473 spp=opus_multistream_decode_float(p_sys->p_st, p_oggpacket->packet,
474 p_oggpacket->bytes, (float *)p_aout_buffer->p_buffer, spp, 0);
475 if( spp < 0 || i_nb_samples <= 0 || i_end_trim >= i_nb_samples)
476 {
477 block_Release(p_aout_buffer);
478 if( spp < 0 )
479 msg_Err( p_dec, "Error: corrupted stream?" );
480 return NULL;
481 }
482
483 p_aout_buffer->i_buffer = (i_nb_samples - i_end_trim) *
484 p_sys->header.channels * sizeof(float);
485
486 if( spp > i_nb_samples )
487 {
488 memmove(p_aout_buffer->p_buffer,
489 p_aout_buffer->p_buffer
490 + (spp - i_nb_samples)*p_sys->header.channels*sizeof(float),
491 p_aout_buffer->i_buffer);
492 }
493 i_nb_samples -= i_end_trim;
494
495 #ifndef OPUS_SET_GAIN
496 if(p_sys->header.gain!=0)
497 {
498 float gain = pow(10., p_sys->header.gain/5120.);
499 float *buf =(float *)p_aout_buffer->p_buffer;
500 for( int i = 0; i < i_nb_samples*p_sys->header.channels; i++)
501 buf[i] *= gain;
502 }
503 #endif
504 p_aout_buffer->i_nb_samples = i_nb_samples;
505 p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
506 p_aout_buffer->i_length = date_Increment( &p_sys->end_date, i_nb_samples )
507 - p_aout_buffer->i_pts;
508 return p_aout_buffer;
509 }
510
511 /*****************************************************************************
512 * CloseDecoder: Opus decoder destruction
513 *****************************************************************************/
CloseDecoder(vlc_object_t * p_this)514 static void CloseDecoder( vlc_object_t *p_this )
515 {
516 decoder_t * p_dec = (decoder_t *)p_this;
517 decoder_sys_t *p_sys = p_dec->p_sys;
518
519 if( p_sys->p_st ) opus_multistream_decoder_destroy(p_sys->p_st);
520
521 free( p_sys );
522 }
523
524 #ifdef ENABLE_SOUT
525
526 /* only ever encode 20 ms at a time, going longer doesn't yield much compression
527 gain, shorter does have a compression loss, and doesn't matter so much in
528 Ogg, unless you really need low latency, which would also require muxing one
529 packet per page. */
530 static const unsigned OPUS_FRAME_SIZE = 960; /* 48000 * 20 / 1000 */
531
532 struct encoder_sys_t
533 {
534 OpusMSEncoder *enc;
535 float *buffer;
536 unsigned i_nb_samples;
537 int i_samples_delay;
538 block_t *padding;
539 int nb_streams;
540 };
541
fill_buffer(encoder_t * enc,unsigned src_start,block_t * src,unsigned samples)542 static unsigned fill_buffer(encoder_t *enc, unsigned src_start, block_t *src,
543 unsigned samples)
544 {
545 encoder_sys_t *p_sys = enc->p_sys;
546 const unsigned channels = enc->fmt_out.audio.i_channels;
547 const float *src_buf = ((const float *) src->p_buffer) + src_start;
548 float *dest_buf = p_sys->buffer + (p_sys->i_nb_samples * channels);
549 const unsigned len = samples * channels;
550
551 memcpy(dest_buf, src_buf, len * sizeof(float));
552
553 p_sys->i_nb_samples += samples;
554 src_start += len;
555
556 src->i_nb_samples -= samples;
557 return src_start;
558 }
559
Encode(encoder_t * enc,block_t * buf)560 static block_t *Encode(encoder_t *enc, block_t *buf)
561 {
562 encoder_sys_t *sys = enc->p_sys;
563
564 if (!buf)
565 return NULL;
566
567 mtime_t i_pts = buf->i_pts -
568 (mtime_t) CLOCK_FREQ * (mtime_t) sys->i_samples_delay /
569 (mtime_t) enc->fmt_in.audio.i_rate;
570
571 sys->i_samples_delay += buf->i_nb_samples;
572
573 block_t *result = NULL;
574 unsigned src_start = 0;
575 unsigned padding_start = 0;
576 /* The maximum Opus frame size is 1275 bytes + TOC sequence length. */
577 const unsigned OPUS_MAX_ENCODED_BYTES = ((1275 + 3) * sys->nb_streams) - 2;
578
579 while (sys->i_nb_samples + buf->i_nb_samples >= OPUS_FRAME_SIZE)
580 {
581 block_t *out_block = block_Alloc(OPUS_MAX_ENCODED_BYTES);
582
583 /* add padding to beginning */
584 if (sys->padding)
585 {
586 const size_t leftover_space = OPUS_FRAME_SIZE - sys->i_nb_samples;
587 padding_start = fill_buffer(enc, padding_start, sys->padding,
588 __MIN(sys->padding->i_nb_samples, leftover_space));
589 if (sys->padding->i_nb_samples <= 0)
590 {
591 block_Release(sys->padding);
592 sys->padding = NULL;
593 }
594 }
595
596 /* padding may have been freed either before or inside previous
597 * if-statement */
598 if (!sys->padding)
599 {
600 const size_t leftover_space = OPUS_FRAME_SIZE - sys->i_nb_samples;
601 src_start = fill_buffer(enc, src_start, buf,
602 __MIN(buf->i_nb_samples, leftover_space));
603 }
604
605 opus_int32 bytes_encoded = opus_multistream_encode_float(sys->enc, sys->buffer,
606 OPUS_FRAME_SIZE, out_block->p_buffer, out_block->i_buffer);
607
608 if (bytes_encoded < 0)
609 {
610 block_Release(out_block);
611 }
612 else
613 {
614 out_block->i_length = (mtime_t) CLOCK_FREQ *
615 (mtime_t) OPUS_FRAME_SIZE / (mtime_t) enc->fmt_in.audio.i_rate;
616
617 out_block->i_dts = out_block->i_pts = i_pts;
618
619 sys->i_samples_delay -= OPUS_FRAME_SIZE;
620
621 i_pts += out_block->i_length;
622
623 sys->i_nb_samples = 0;
624
625 out_block->i_buffer = bytes_encoded;
626 block_ChainAppend(&result, out_block);
627 }
628 }
629
630 /* put leftover samples at beginning of buffer */
631 if (buf->i_nb_samples > 0)
632 fill_buffer(enc, src_start, buf, buf->i_nb_samples);
633
634 return result;
635 }
636
OpenEncoder(vlc_object_t * p_this)637 static int OpenEncoder(vlc_object_t *p_this)
638 {
639 encoder_t *enc = (encoder_t *)p_this;
640
641 if (enc->fmt_out.i_codec != VLC_CODEC_OPUS)
642 return VLC_EGENERIC;
643
644 encoder_sys_t *sys = malloc(sizeof(*sys));
645 if (!sys)
646 return VLC_ENOMEM;
647
648 int status = VLC_SUCCESS;
649 sys->buffer = NULL;
650 sys->enc = NULL;
651
652 enc->pf_encode_audio = Encode;
653 enc->fmt_in.i_codec = VLC_CODEC_FL32;
654 enc->fmt_in.audio.i_rate = /* Only 48kHz */
655 enc->fmt_out.audio.i_rate = 48000;
656 enc->fmt_out.audio.i_channels = enc->fmt_in.audio.i_channels;
657
658 OpusHeader header;
659
660 opus_prepare_header(enc->fmt_out.audio.i_channels,
661 enc->fmt_out.audio.i_rate, &header);
662
663 /* needed for max encoded size calculation */
664 sys->nb_streams = header.nb_streams;
665
666 int err;
667 sys->enc =
668 opus_multistream_surround_encoder_create(enc->fmt_in.audio.i_rate,
669 enc->fmt_in.audio.i_channels, header.channel_mapping,
670 &header.nb_streams, &header.nb_coupled, header.stream_map,
671 OPUS_APPLICATION_AUDIO, &err);
672
673 if (err != OPUS_OK)
674 {
675 msg_Err(enc, "Could not create encoder: error %d", err);
676 sys->enc = NULL;
677 status = VLC_EGENERIC;
678 goto error;
679 }
680
681 /* TODO: vbr, fec */
682
683 if( enc->fmt_out.i_bitrate )
684 opus_multistream_encoder_ctl(sys->enc, OPUS_SET_BITRATE( enc->fmt_out.i_bitrate ));
685
686 /* Buffer for incoming audio, since opus only accepts frame sizes that are
687 multiples of 2.5ms */
688 enc->p_sys = sys;
689 sys->buffer = vlc_alloc(header.channels, sizeof(float) * OPUS_FRAME_SIZE);
690 if (!sys->buffer) {
691 status = VLC_ENOMEM;
692 goto error;
693 }
694
695 sys->i_nb_samples = 0;
696
697 sys->i_samples_delay = 0;
698 int ret = opus_multistream_encoder_ctl(enc->p_sys->enc,
699 OPUS_GET_LOOKAHEAD(&sys->i_samples_delay));
700 if (ret != OPUS_OK)
701 msg_Err(enc, "Unable to get number of lookahead samples: %s\n",
702 opus_strerror(ret));
703
704 header.preskip = sys->i_samples_delay;
705
706 /* Now that we have preskip, we can write the header to extradata */
707 if (opus_write_header((uint8_t **) &enc->fmt_out.p_extra,
708 &enc->fmt_out.i_extra, &header, opus_get_version_string()))
709 {
710 msg_Err(enc, "Failed to write header.");
711 status = VLC_ENOMEM;
712 goto error;
713 }
714
715 if (sys->i_samples_delay > 0)
716 {
717 const unsigned padding_samples = sys->i_samples_delay *
718 enc->fmt_out.audio.i_channels;
719 sys->padding = block_Alloc(padding_samples * sizeof(float));
720 if (!sys->padding) {
721 status = VLC_ENOMEM;
722 goto error;
723 }
724 sys->padding->i_nb_samples = sys->i_samples_delay;
725 float *pad_ptr = (float *) sys->padding->p_buffer;
726 memset(pad_ptr, 0, padding_samples * sizeof(float));
727 }
728 else
729 {
730 sys->padding = NULL;
731 }
732
733 return status;
734
735 error:
736 if (sys->enc)
737 opus_multistream_encoder_destroy(sys->enc);
738 free(sys->buffer);
739 free(sys);
740 return status;
741 }
742
CloseEncoder(vlc_object_t * p_this)743 static void CloseEncoder(vlc_object_t *p_this)
744 {
745 encoder_t *enc = (encoder_t *)p_this;
746 encoder_sys_t *sys = enc->p_sys;
747
748 opus_multistream_encoder_destroy(sys->enc);
749 if (sys->padding)
750 block_Release(sys->padding);
751 free(sys->buffer);
752 free(sys);
753 }
754 #endif /* ENABLE_SOUT */
755