?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Qt: simplify playlist item deletion
[vlc.git] / modules / codec / flac.c
blob3e4acbca769c034c431a127d29d833d3118f9a6e
1 /*****************************************************************************
2 * flac.c: flac decoder/packetizer/encoder module making use of libflac
3 *****************************************************************************
4 * Copyright (C) 1999-2001 the VideoLAN team
5 * $Id$
6 *
7 * Authors: Gildas Bazin <gbazin@videolan.org>
8 * Sigmund Augdal Helberg <dnumgis@videolan.org>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
36 #include <vlc_aout.h>
37
38 #ifdef HAVE_FLAC_STREAM_DECODER_H
39 # include <FLAC/stream_decoder.h>
40 # include <FLAC/stream_encoder.h>
41 # define USE_LIBFLAC
42 #endif
43
44 #include <vlc_block_helper.h>
45 #include <vlc_bits.h>
46
47 #define MAX_FLAC_HEADER_SIZE 16
48
49 #if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT >= 8
50 # define USE_NEW_FLAC_API
51 #endif
52
53 /*****************************************************************************
54 * decoder_sys_t : FLAC decoder descriptor
55 *****************************************************************************/
56 struct decoder_sys_t
57 {
58 /*
59 * Input properties
60 */
61 int i_state;
62
63 block_bytestream_t bytestream;
64
65 /*
66 * Input/Output properties
67 */
68 block_t *p_block;
69 aout_buffer_t *p_aout_buffer;
70
71 /*
72 * FLAC properties
73 */
74 #ifdef USE_LIBFLAC
75 FLAC__StreamDecoder *p_flac;
76 FLAC__StreamMetadata_StreamInfo stream_info;
77 #else
78 struct
79 {
80 unsigned min_blocksize, max_blocksize;
81 unsigned min_framesize, max_framesize;
82 unsigned sample_rate;
83 unsigned channels;
84 unsigned bits_per_sample;
85
86 } stream_info;
87 #endif
88 bool b_stream_info;
89
90 /*
91 * Common properties
92 */
93 date_t end_date;
94 mtime_t i_pts;
95
96 int i_frame_size, i_frame_length, i_bits_per_sample;
97 unsigned int i_rate, i_channels, i_channels_conf;
98 };
99
100 enum {
101
102 STATE_NOSYNC,
103 STATE_SYNC,
104 STATE_HEADER,
105 STATE_NEXT_SYNC,
106 STATE_GET_DATA,
107 STATE_SEND_DATA
108 };
109
110 static const int pi_channels_maps[7] =
111 {
112 0,
113 AOUT_CHAN_CENTER,
114 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
115 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
116 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
117 | AOUT_CHAN_REARRIGHT,
118 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
119 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
120 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
121 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
122 };
123
124 /*****************************************************************************
125 * Local prototypes
126 *****************************************************************************/
127 static int OpenDecoder ( vlc_object_t * );
128 static int OpenPacketizer( vlc_object_t * );
129 static void CloseDecoder ( vlc_object_t * );
130
131 #ifdef USE_LIBFLAC
132 static int OpenEncoder ( vlc_object_t * );
133 static void CloseEncoder ( vlc_object_t * );
134 #endif
135
136 #ifdef USE_LIBFLAC
137 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
138 #endif
139 static block_t *PacketizeBlock( decoder_t *, block_t ** );
140
141 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
142 unsigned int *,int * );
143
144
145 #ifdef USE_LIBFLAC
146 static FLAC__StreamDecoderReadStatus
147 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
148 FLAC__byte buffer[], unsigned *bytes, void *client_data );
149
150 static FLAC__StreamDecoderWriteStatus
151 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
152 const FLAC__Frame *frame,
153 const FLAC__int32 *const buffer[], void *client_data );
154
155 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
156 const FLAC__StreamMetadata *metadata,
157 void *client_data );
158 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
159 FLAC__StreamDecoderErrorStatus status,
160 void *client_data);
161
162 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
163 const int *pi_order, int i_nb_channels, int i_samples );
164 static void Interleave24( int8_t *p_out, const int32_t * const *pp_in,
165 const int *pi_order, int i_nb_channels, int i_samples );
166 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
167 const int *pi_order, int i_nb_channels, int i_samples );
168
169 static void decoder_state_error( decoder_t *p_dec,
170 FLAC__StreamDecoderState state );
171 #endif
172
173 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
174 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
175
176 /*****************************************************************************
177 * Module descriptor
178 *****************************************************************************/
179 vlc_module_begin ()
180
181 set_category( CAT_INPUT )
182 set_subcategory( SUBCAT_INPUT_ACODEC )
183 add_shortcut( "flac" )
184
185 #ifdef USE_LIBFLAC
186 set_description( N_("Flac audio decoder") )
187 set_capability( "decoder", 100 )
188 set_callbacks( OpenDecoder, CloseDecoder )
189
190 add_submodule ()
191 add_shortcut( "flac" )
192 set_description( N_("Flac audio encoder") )
193 set_capability( "encoder", 100 )
194 set_callbacks( OpenEncoder, CloseEncoder )
195
196 add_submodule ()
197 add_shortcut( "flac" )
198 #endif
199 set_description( N_("Flac audio packetizer") )
200 set_capability( "packetizer", 100 )
201 set_callbacks( OpenPacketizer, CloseDecoder )
202
203 vlc_module_end ()
204
205 /*****************************************************************************
206 * OpenDecoder: probe the decoder and return score
207 *****************************************************************************/
208 static int OpenDecoder( vlc_object_t *p_this )
209 {
210 decoder_t *p_dec = (decoder_t*)p_this;
211 decoder_sys_t *p_sys;
212
213 if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
214 {
215 return VLC_EGENERIC;
216 }
217
218 /* Allocate the memory needed to store the decoder's structure */
219 if( ( p_dec->p_sys = p_sys = malloc(sizeof(*p_sys)) ) == NULL )
220 return VLC_ENOMEM;
221
222 /* Misc init */
223 date_Set( &p_sys->end_date, 0 );
224 p_sys->i_state = STATE_NOSYNC;
225 p_sys->b_stream_info = false;
226 p_sys->p_block=NULL;
227 p_sys->i_pts = VLC_TS_INVALID;
228 p_sys->bytestream = block_BytestreamInit();
229
230 #ifdef USE_LIBFLAC
231 /* Take care of flac init */
232 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
233 {
234 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
235 free( p_sys );
236 return VLC_EGENERIC;
237 }
238
239 #ifdef USE_NEW_FLAC_API
240 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
241 DecoderReadCallback,
242 NULL,
243 NULL,
244 NULL,
245 NULL,
246 DecoderWriteCallback,
247 DecoderMetadataCallback,
248 DecoderErrorCallback,
249 p_dec )
250 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
251 {
252 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
253 FLAC__stream_decoder_delete( p_sys->p_flac );
254 free( p_sys );
255 return VLC_EGENERIC;
256 }
257 #else
258 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
259 DecoderReadCallback );
260 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
261 DecoderWriteCallback );
262 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
263 DecoderMetadataCallback );
264 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
265 DecoderErrorCallback );
266 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
267
268 FLAC__stream_decoder_init( p_sys->p_flac );
269 #endif
270 #endif
271
272 /* Set output properties */
273 p_dec->fmt_out.i_cat = AUDIO_ES;
274 p_dec->fmt_out.i_codec = VLC_CODEC_FL32;
275
276 /* Set callbacks */
277 #ifdef USE_LIBFLAC
278 p_dec->pf_decode_audio = DecodeBlock;
279 #endif
280
281 return VLC_SUCCESS;
282 }
283
284 static int OpenPacketizer( vlc_object_t *p_this )
285 {
286 decoder_t *p_dec = (decoder_t*)p_this;
287 es_format_t es_save = p_dec->fmt_out;
288 int i_ret;
289
290 /* */
291 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
292
293 i_ret = OpenDecoder( p_this );
294 p_dec->pf_decode_audio = NULL;
295 p_dec->pf_packetize = PacketizeBlock;
296
297 /* Set output properties */
298 p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
299
300 if( i_ret != VLC_SUCCESS )
301 {
302 es_format_Clean( &p_dec->fmt_out );
303 p_dec->fmt_out = es_save;
304 }
305 return i_ret;
306 }
307
308 /*****************************************************************************
309 * CloseDecoder: flac decoder destruction
310 *****************************************************************************/
311 static void CloseDecoder( vlc_object_t *p_this )
312 {
313 decoder_t *p_dec = (decoder_t *)p_this;
314 decoder_sys_t *p_sys = p_dec->p_sys;
315
316 #ifdef USE_LIBFLAC
317 FLAC__stream_decoder_finish( p_sys->p_flac );
318 FLAC__stream_decoder_delete( p_sys->p_flac );
319 #endif
320
321 free( p_sys->p_block );
322 free( p_sys );
323 }
324
325 /*****************************************************************************
326 * ProcessHeader: process Flac header.
327 *****************************************************************************/
328 static void ProcessHeader( decoder_t *p_dec )
329 {
330 decoder_sys_t *p_sys = p_dec->p_sys;
331
332 #ifdef USE_LIBFLAC
333 if( !p_dec->fmt_in.i_extra ) return;
334
335 /* Decode STREAMINFO */
336 msg_Dbg( p_dec, "decode STREAMINFO" );
337 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
338 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
339 p_dec->fmt_in.i_extra );
340 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
341 msg_Dbg( p_dec, "STREAMINFO decoded" );
342
343 #else
344 bs_t bs;
345
346 if( !p_dec->fmt_in.i_extra ) return;
347
348 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
349
350 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
351 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
352
353 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
354 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
355
356 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
357 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
358 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
359 #endif
360
361 if( !p_sys->b_stream_info ) return;
362
363 if( p_dec->fmt_out.i_codec == VLC_CODEC_FLAC )
364 {
365 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
366 p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
367 p_dec->fmt_out.i_extra );
368 memcpy( p_dec->fmt_out.p_extra,
369 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
370 }
371 }
372
373 /****************************************************************************
374 * PacketizeBlock: the whole thing
375 ****************************************************************************
376 * This function is called just after the thread is launched.
377 ****************************************************************************/
378 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
379 {
380 decoder_sys_t *p_sys = p_dec->p_sys;
381 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
382 block_t *p_sout_block;
383
384 if( !pp_block || !*pp_block ) return NULL;
385
386 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
387 {
388 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
389 {
390 p_sys->i_state = STATE_NOSYNC;
391 block_BytestreamEmpty( &p_sys->bytestream );
392 }
393 date_Set( &p_sys->end_date, 0 );
394 block_Release( *pp_block );
395 return NULL;
396 }
397
398 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
399
400 if( p_sys->stream_info.channels > 6 )
401 {
402 msg_Err( p_dec, "This stream uses too many audio channels" );
403 return NULL;
404 }
405
406 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
407 {
408 /* We've just started the stream, wait for the first PTS. */
409 block_Release( *pp_block );
410 return NULL;
411 }
412 else if( !date_Get( &p_sys->end_date ) )
413 {
414 /* The first PTS is as good as anything else. */
415 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
416 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
417 date_Set( &p_sys->end_date, (*pp_block)->i_pts );
418 }
419
420 block_BytestreamPush( &p_sys->bytestream, *pp_block );
421
422 while( 1 )
423 {
424 switch( p_sys->i_state )
425 {
426 case STATE_NOSYNC:
427 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
428 == VLC_SUCCESS )
429 {
430 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
431 {
432 p_sys->i_state = STATE_SYNC;
433 break;
434 }
435 block_SkipByte( &p_sys->bytestream );
436 }
437 if( p_sys->i_state != STATE_SYNC )
438 {
439 block_BytestreamFlush( &p_sys->bytestream );
440
441 /* Need more data */
442 return NULL;
443 }
444
445 case STATE_SYNC:
446 /* New frame, set the Presentation Time Stamp */
447 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
448 if( p_sys->i_pts > VLC_TS_INVALID &&
449 p_sys->i_pts != date_Get( &p_sys->end_date ) )
450 {
451 date_Set( &p_sys->end_date, p_sys->i_pts );
452 }
453 p_sys->i_state = STATE_HEADER;
454
455 case STATE_HEADER:
456 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
457 if( block_PeekBytes( &p_sys->bytestream, p_header,
458 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
459 {
460 /* Need more data */
461 return NULL;
462 }
463
464 /* Check if frame is valid and get frame info */
465 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
466 &p_sys->i_channels,
467 &p_sys->i_channels_conf,
468 &p_sys->i_rate,
469 &p_sys->i_bits_per_sample );
470 if( !p_sys->i_frame_length )
471 {
472 msg_Dbg( p_dec, "emulated sync word" );
473 block_SkipByte( &p_sys->bytestream );
474 p_sys->i_state = STATE_NOSYNC;
475 break;
476 }
477 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
478 {
479 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
480 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
481 date_Set( &p_sys->end_date, p_sys->i_pts );
482 }
483 p_sys->i_state = STATE_NEXT_SYNC;
484 p_sys->i_frame_size = 1;
485
486 case STATE_NEXT_SYNC:
487 /* TODO: If pp_block == NULL, flush the buffer without checking the
488 * next sync word */
489
490 /* Check if next expected frame contains the sync word */
491 while( block_PeekOffsetBytes( &p_sys->bytestream,
492 p_sys->i_frame_size, p_header,
493 MAX_FLAC_HEADER_SIZE )
494 == VLC_SUCCESS )
495 {
496 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
497 {
498 /* Check if frame is valid and get frame info */
499 int i_frame_length =
500 SyncInfo( p_dec, p_header,
501 &p_sys->i_channels,
502 &p_sys->i_channels_conf,
503 &p_sys->i_rate,
504 &p_sys->i_bits_per_sample );
505
506 if( i_frame_length )
507 {
508 p_sys->i_state = STATE_SEND_DATA;
509 break;
510 }
511 }
512 p_sys->i_frame_size++;
513 }
514
515 if( p_sys->i_state != STATE_SEND_DATA )
516 {
517 /* Need more data */
518 return NULL;
519 }
520
521 case STATE_SEND_DATA:
522 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
523
524 /* Copy the whole frame into the buffer. When we reach this point
525 * we already know we have enough data available. */
526 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
527 p_sys->i_frame_size );
528
529 /* Make sure we don't reuse the same pts twice */
530 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
531 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
532
533 /* So p_block doesn't get re-added several times */
534 *pp_block = block_BytestreamPop( &p_sys->bytestream );
535
536 p_sys->i_state = STATE_NOSYNC;
537
538 /* Date management */
539 p_sout_block->i_pts =
540 p_sout_block->i_dts = date_Get( &p_sys->end_date );
541 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
542 p_sout_block->i_length =
543 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
544
545 return p_sout_block;
546 }
547 }
548
549 return NULL;
550 }
551
552 #ifdef USE_LIBFLAC
553 /****************************************************************************
554 * DecodeBlock: the whole thing
555 ****************************************************************************/
556 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
557 {
558 decoder_sys_t *p_sys = p_dec->p_sys;
559
560 if( !pp_block || !*pp_block ) return NULL;
561
562 p_sys->p_aout_buffer = 0;
563 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
564 {
565 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
566 {
567 decoder_state_error( p_dec,
568 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
569 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
570 }
571
572 /* If the decoder is in the "aborted" state,
573 * FLAC__stream_decoder_process_single() won't return an error. */
574 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
575 == FLAC__STREAM_DECODER_ABORTED )
576 {
577 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
578 }
579
580 block_Release( p_sys->p_block );
581 p_sys->p_block = NULL;
582 }
583
584 return p_sys->p_aout_buffer;
585 }
586
587 /*****************************************************************************
588 * DecoderReadCallback: called by libflac when it needs more data
589 *****************************************************************************/
590 static FLAC__StreamDecoderReadStatus
591 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
592 unsigned *bytes, void *client_data )
593 {
594 VLC_UNUSED(decoder);
595 decoder_t *p_dec = (decoder_t *)client_data;
596 decoder_sys_t *p_sys = p_dec->p_sys;
597
598 if( p_sys->p_block && p_sys->p_block->i_buffer )
599 {
600 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
601 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
602 p_sys->p_block->i_buffer -= *bytes;
603 p_sys->p_block->p_buffer += *bytes;
604 }
605 else
606 {
607 *bytes = 0;
608 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
609 }
610
611 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
612 }
613
614 /*****************************************************************************
615 * DecoderWriteCallback: called by libflac to output decoded samples
616 *****************************************************************************/
617 static FLAC__StreamDecoderWriteStatus
618 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
619 const FLAC__Frame *frame,
620 const FLAC__int32 *const buffer[], void *client_data )
621 {
622 /* XXX it supposes our internal format is WG4 */
623 static const int ppi_reorder[1+8][8] = {
624 {-1},
625 { 0, },
626 { 0, 1 },
627 { 0, 1, 2 },
628 { 0, 1, 2, 3 },
629 { 0, 1, 3, 4, 2 },
630 { 0, 1, 4, 5, 2, 3 },
631
632 { 0, 1, 6, 2, 3, 4, 5 }, /* 7.0 Unspecified by flac */
633 { 0, 1, 6, 7, 2, 3, 4, 5 }, /* 7.1 Unspecified by flac */
634 };
635
636 VLC_UNUSED(decoder);
637 decoder_t *p_dec = (decoder_t *)client_data;
638 decoder_sys_t *p_sys = p_dec->p_sys;
639
640 if( p_dec->fmt_out.audio.i_channels <= 0 ||
641 p_dec->fmt_out.audio.i_channels > 8 )
642 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
643 const int * const pi_reorder = ppi_reorder[p_dec->fmt_out.audio.i_channels];
644
645 p_sys->p_aout_buffer =
646 decoder_NewAudioBuffer( p_dec, frame->header.blocksize );
647
648 if( p_sys->p_aout_buffer == NULL )
649 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
650
651 switch( frame->header.bits_per_sample )
652 {
653 case 16:
654 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
655 frame->header.channels, frame->header.blocksize );
656 break;
657 case 24:
658 Interleave24( (int8_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
659 frame->header.channels, frame->header.blocksize );
660 break;
661 default:
662 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
663 frame->header.channels, frame->header.blocksize );
664 }
665
666 /* Date management (already done by packetizer) */
667 p_sys->p_aout_buffer->i_pts = p_sys->p_block->i_pts;
668 p_sys->p_aout_buffer->i_length = p_sys->p_block->i_length;
669
670 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
671 }
672
673 /*****************************************************************************
674 * DecoderMetadataCallback: called by libflac to when it encounters metadata
675 *****************************************************************************/
676 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
677 const FLAC__StreamMetadata *metadata,
678 void *client_data )
679 {
680 VLC_UNUSED(decoder);
681 decoder_t *p_dec = (decoder_t *)client_data;
682 decoder_sys_t *p_sys = p_dec->p_sys;
683
684 if( p_dec->pf_decode_audio )
685 {
686 switch( metadata->data.stream_info.bits_per_sample )
687 {
688 case 8:
689 p_dec->fmt_out.i_codec = VLC_CODEC_S8;
690 break;
691 case 16:
692 p_dec->fmt_out.i_codec = VLC_CODEC_S16N;
693 break;
694 case 24:
695 p_dec->fmt_out.i_codec = VLC_CODEC_S24N;
696 break;
697 default:
698 msg_Dbg( p_dec, "strange bit/sample value: %d",
699 metadata->data.stream_info.bits_per_sample );
700 p_dec->fmt_out.i_codec = VLC_CODEC_FI32;
701 break;
702 }
703 }
704
705 /* Setup the format */
706 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
707 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
708 p_dec->fmt_out.audio.i_physical_channels =
709 p_dec->fmt_out.audio.i_original_channels =
710 pi_channels_maps[metadata->data.stream_info.channels];
711 p_dec->fmt_out.audio.i_bitspersample =
712 metadata->data.stream_info.bits_per_sample;
713
714 date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
715
716 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
717 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
718 p_dec->fmt_out.audio.i_bitspersample );
719
720 p_sys->b_stream_info = true;
721 p_sys->stream_info = metadata->data.stream_info;
722
723 return;
724 }
725
726 /*****************************************************************************
727 * DecoderErrorCallback: called when the libflac decoder encounters an error
728 *****************************************************************************/
729 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
730 FLAC__StreamDecoderErrorStatus status,
731 void *client_data )
732 {
733 VLC_UNUSED(decoder);
734 decoder_t *p_dec = (decoder_t *)client_data;
735
736 switch( status )
737 {
738 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
739 msg_Warn( p_dec, "an error in the stream caused the decoder to "
740 "lose synchronization." );
741 break;
742 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
743 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
744 break;
745 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
746 msg_Err( p_dec, "frame's data did not match the CRC in the "
747 "footer." );
748 break;
749 default:
750 msg_Err( p_dec, "got decoder error: %d", status );
751 }
752
753 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
754 return;
755 }
756
757 /*****************************************************************************
758 * Interleave: helper function to interleave channels
759 *****************************************************************************/
760 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
761 const int pi_index[],
762 int i_nb_channels, int i_samples )
763 {
764 int i, j;
765 for ( j = 0; j < i_samples; j++ )
766 {
767 for ( i = 0; i < i_nb_channels; i++ )
768 {
769 p_out[j * i_nb_channels + i] = pp_in[pi_index[i]][j];
770 }
771 }
772 }
773
774 static void Interleave24( int8_t *p_out, const int32_t * const *pp_in,
775 const int pi_index[],
776 int i_nb_channels, int i_samples )
777 {
778 int i, j;
779 for ( j = 0; j < i_samples; j++ )
780 {
781 for ( i = 0; i < i_nb_channels; i++ )
782 {
783 const int i_index = pi_index[i];
784 #ifdef WORDS_BIGENDIAN
785 p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i_index][j] >> 16) & 0xff;
786 p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i_index][j] >> 8 ) & 0xff;
787 p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i_index][j] >> 0 ) & 0xff;
788 #else
789 p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i_index][j] >> 16) & 0xff;
790 p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i_index][j] >> 8 ) & 0xff;
791 p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i_index][j] >> 0 ) & 0xff;
792 #endif
793 }
794 }
795 }
796
797 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
798 const int pi_index[],
799 int i_nb_channels, int i_samples )
800 {
801 int i, j;
802 for ( j = 0; j < i_samples; j++ )
803 {
804 for ( i = 0; i < i_nb_channels; i++ )
805 {
806 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[pi_index[i]][j]);
807 }
808 }
809 }
810
811 /*****************************************************************************
812 * decoder_state_error: print meaningful error messages
813 *****************************************************************************/
814 static void decoder_state_error( decoder_t *p_dec,
815 FLAC__StreamDecoderState state )
816 {
817 switch ( state )
818 {
819 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
820 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
821 break;
822 case FLAC__STREAM_DECODER_READ_METADATA:
823 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
824 "reading metadata." );
825 break;
826 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
827 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
828 "searching for the frame sync code." );
829 break;
830 case FLAC__STREAM_DECODER_READ_FRAME:
831 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
832 "reading a frame." );
833 break;
834 case FLAC__STREAM_DECODER_END_OF_STREAM:
835 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
836 break;
837 #ifdef USE_NEW_FLAC_API
838 case FLAC__STREAM_DECODER_OGG_ERROR:
839 msg_Err( p_dec, "error occurred in the Ogg layer." );
840 break;
841 case FLAC__STREAM_DECODER_SEEK_ERROR:
842 msg_Err( p_dec, "error occurred while seeking." );
843 break;
844 #endif
845 case FLAC__STREAM_DECODER_ABORTED:
846 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
847 break;
848 #ifndef USE_NEW_FLAC_API
849 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
850 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
851 "in the stream." );
852 break;
853 #endif
854 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
855 msg_Err( p_dec, "error when allocating memory." );
856 break;
857 #ifndef USE_NEW_FLAC_API
858 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
859 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
860 "decoder was already initialized, usually because "
861 "FLAC__stream_decoder_finish() was not called." );
862 break;
863 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
864 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
865 "all callbacks being set." );
866 break;
867 #endif
868 case FLAC__STREAM_DECODER_UNINITIALIZED:
869 msg_Err( p_dec, "decoder in uninitialized state." );
870 break;
871 default:
872 msg_Warn(p_dec, "unknown error" );
873 }
874 }
875 #endif
876
877 /*****************************************************************************
878 * SyncInfo: parse FLAC sync info
879 *****************************************************************************/
880 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
881 unsigned int * pi_channels,
882 unsigned int * pi_channels_conf,
883 unsigned int * pi_sample_rate,
884 int * pi_bits_per_sample )
885 {
886 decoder_sys_t *p_sys = p_dec->p_sys;
887 int i_header, i_temp, i_read;
888 unsigned i_blocksize = 0;
889 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
890 uint64_t i_sample_number = 0;
891
892 bool b_variable_blocksize = ( p_sys->b_stream_info &&
893 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
894 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
895 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
896
897 /* Check syncword */
898 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
899
900 /* Check there is no emulated sync code in the rest of the header */
901 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
902
903 /* Find blocksize (framelength) */
904 switch( i_temp = p_buf[2] >> 4 )
905 {
906 case 0:
907 if( b_fixed_blocksize )
908 i_blocksize = p_sys->stream_info.min_blocksize;
909 else return 0; /* We can't do anything with this */
910 break;
911
912 case 1:
913 i_blocksize = 192;
914 break;
915
916 case 2:
917 case 3:
918 case 4:
919 case 5:
920 i_blocksize = 576 << (i_temp - 2);
921 break;
922
923 case 6:
924 case 7:
925 i_blocksize_hint = i_temp;
926 break;
927
928 case 8:
929 case 9:
930 case 10:
931 case 11:
932 case 12:
933 case 13:
934 case 14:
935 case 15:
936 i_blocksize = 256 << (i_temp - 8);
937 break;
938 }
939
940 /* Find samplerate */
941 switch( i_temp = p_buf[2] & 0x0f )
942 {
943 case 0:
944 if( p_sys->b_stream_info )
945 *pi_sample_rate = p_sys->stream_info.sample_rate;
946 else return 0; /* We can't do anything with this */
947 break;
948
949 case 1:
950 case 2:
951 case 3:
952 return 0;
953 break;
954
955 case 4:
956 *pi_sample_rate = 8000;
957 break;
958
959 case 5:
960 *pi_sample_rate = 16000;
961 break;
962
963 case 6:
964 *pi_sample_rate = 22050;
965 break;
966
967 case 7:
968 *pi_sample_rate = 24000;
969 break;
970
971 case 8:
972 *pi_sample_rate = 32000;
973 break;
974
975 case 9:
976 *pi_sample_rate = 44100;
977 break;
978
979 case 10:
980 *pi_sample_rate = 48000;
981 break;
982
983 case 11:
984 *pi_sample_rate = 96000;
985 break;
986
987 case 12:
988 case 13:
989 case 14:
990 i_sample_rate_hint = i_temp;
991 break;
992
993 case 15:
994 return 0;
995 }
996
997 /* Find channels */
998 i_temp = (unsigned)(p_buf[3] >> 4);
999 if( i_temp & 8 )
1000 {
1001 #ifdef USE_LIBFLAC
1002 int i_channel_assignment; /* ??? */
1003
1004 switch( i_temp & 7 )
1005 {
1006 case 0:
1007 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
1008 break;
1009 case 1:
1010 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
1011 break;
1012 case 2:
1013 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
1014 break;
1015 default:
1016 return 0;
1017 break;
1018 }
1019 #endif
1020
1021 *pi_channels = 2;
1022 }
1023 else
1024 {
1025 *pi_channels = i_temp + 1;
1026 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
1027 }
1028
1029 /* Find bits per sample */
1030 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
1031 {
1032 case 0:
1033 if( p_sys->b_stream_info )
1034 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
1035 else
1036 return 0;
1037 break;
1038
1039 case 1:
1040 *pi_bits_per_sample = 8;
1041 break;
1042
1043 case 2:
1044 *pi_bits_per_sample = 12;
1045 break;
1046
1047 case 4:
1048 *pi_bits_per_sample = 16;
1049 break;
1050
1051 case 5:
1052 *pi_bits_per_sample = 20;
1053 break;
1054
1055 case 6:
1056 *pi_bits_per_sample = 24;
1057 break;
1058
1059 case 3:
1060 case 7:
1061 return 0;
1062 break;
1063 }
1064
1065 /* Zero padding bit */
1066 if( p_buf[3] & 0x01 ) return 0;
1067
1068 /* End of fixed size header */
1069 i_header = 4;
1070
1071 /* Find Sample/Frame number */
1072 if( i_blocksize_hint && b_variable_blocksize )
1073 {
1074 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1075 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1076 }
1077 else
1078 {
1079 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1080 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1081
1082 if( p_sys->b_stream_info )
1083 i_sample_number *= p_sys->stream_info.min_blocksize;
1084 }
1085
1086 i_header += i_read;
1087
1088 /* Read blocksize */
1089 if( i_blocksize_hint )
1090 {
1091 int i_val1 = p_buf[i_header++];
1092 if( i_blocksize_hint == 7 )
1093 {
1094 int i_val2 = p_buf[i_header++];
1095 i_val1 = (i_val1 << 8) | i_val2;
1096 }
1097 i_blocksize = i_val1 + 1;
1098 }
1099
1100 /* Read sample rate */
1101 if( i_sample_rate_hint )
1102 {
1103 int i_val1 = p_buf[i_header++];
1104 if( i_sample_rate_hint != 12 )
1105 {
1106 int i_val2 = p_buf[i_header++];
1107 i_val1 = (i_val1 << 8) | i_val2;
1108 }
1109 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1110 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1111 else *pi_sample_rate = i_val1 * 10;
1112 }
1113
1114 /* Check the CRC-8 byte */
1115 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1116 {
1117 return 0;
1118 }
1119
1120 /* Sanity check using stream info header when possible */
1121 if( p_sys->b_stream_info )
1122 {
1123 if( i_blocksize < p_sys->stream_info.min_blocksize ||
1124 i_blocksize > p_sys->stream_info.max_blocksize )
1125 return 0;
1126 }
1127 return i_blocksize;
1128 }
1129
1130 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1131 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1132 {
1133 uint64_t i_result = 0;
1134 unsigned i, j;
1135
1136 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1137 {
1138 i_result = p_buf[0];
1139 i = 0;
1140 }
1141 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1142 {
1143 i_result = p_buf[0] & 0x1F;
1144 i = 1;
1145 }
1146 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1147 {
1148 i_result = p_buf[0] & 0x0F;
1149 i = 2;
1150 }
1151 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1152 {
1153 i_result = p_buf[0] & 0x07;
1154 i = 3;
1155 }
1156 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1157 {
1158 i_result = p_buf[0] & 0x03;
1159 i = 4;
1160 }
1161 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1162 {
1163 i_result = p_buf[0] & 0x01;
1164 i = 5;
1165 }
1166 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1167 {
1168 i_result = 0;
1169 i = 6;
1170 }
1171 else {
1172 return INT64_C(0xffffffffffffffff);
1173 }
1174
1175 for( j = 1; j <= i; j++ )
1176 {
1177 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1178 {
1179 return INT64_C(0xffffffffffffffff);
1180 }
1181 i_result <<= 6;
1182 i_result |= (p_buf[j] & 0x3F);
1183 }
1184
1185 *pi_read = i;
1186 return i_result;
1187 }
1188
1189 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1190 static const uint8_t flac_crc8_table[256] = {
1191 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1192 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1193 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1194 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1195 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1196 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1197 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1198 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1199 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1200 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1201 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1202 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1203 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1204 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1205 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1206 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1207 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1208 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1209 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1210 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1211 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1212 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1213 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1214 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1215 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1216 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1217 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1218 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1219 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1220 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1221 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1222 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1223 };
1224
1225 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1226 {
1227 uint8_t crc = 0;
1228
1229 while(len--)
1230 crc = flac_crc8_table[crc ^ *data++];
1231
1232 return crc;
1233 }
1234
1235 #ifdef USE_LIBFLAC
1236 /*****************************************************************************
1237 * encoder_sys_t : flac encoder descriptor
1238 *****************************************************************************/
1239 struct encoder_sys_t
1240 {
1241 /*
1242 * Input properties
1243 */
1244 int i_headers;
1245
1246 int i_samples_delay;
1247 int i_channels;
1248
1249 FLAC__int32 *p_buffer;
1250 unsigned int i_buffer;
1251
1252 block_t *p_chain;
1253
1254 /*
1255 * FLAC properties
1256 */
1257 FLAC__StreamEncoder *p_flac;
1258 FLAC__StreamMetadata_StreamInfo stream_info;
1259
1260 /*
1261 * Common properties
1262 */
1263 mtime_t i_pts;
1264 };
1265
1266 #define STREAMINFO_SIZE 38
1267
1268 static block_t *Encode( encoder_t *, aout_buffer_t * );
1269
1270 static FLAC__StreamEncoderWriteStatus
1271 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1272 const FLAC__byte buffer[],
1273 unsigned bytes, unsigned samples,
1274 unsigned current_frame, void *client_data );
1275
1276 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1277 const FLAC__StreamMetadata *metadata,
1278 void *client_data );
1279
1280 /*****************************************************************************
1281 * OpenEncoder: probe the encoder and return score
1282 *****************************************************************************/
1283 static int OpenEncoder( vlc_object_t *p_this )
1284 {
1285 encoder_t *p_enc = (encoder_t *)p_this;
1286 encoder_sys_t *p_sys;
1287
1288 if( p_enc->fmt_out.i_codec != VLC_CODEC_FLAC &&
1289 !p_enc->b_force )
1290 {
1291 return VLC_EGENERIC;
1292 }
1293
1294 /* Allocate the memory needed to store the decoder's structure */
1295 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1296 return VLC_ENOMEM;
1297 p_enc->p_sys = p_sys;
1298 p_enc->pf_encode_audio = Encode;
1299 p_enc->fmt_out.i_codec = VLC_CODEC_FLAC;
1300
1301 p_sys->i_headers = 0;
1302 p_sys->p_buffer = 0;
1303 p_sys->i_buffer = 0;
1304 p_sys->i_samples_delay = 0;
1305
1306 /* Create flac encoder */
1307 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1308 {
1309 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1310 free( p_sys );
1311 return VLC_EGENERIC;
1312 }
1313
1314 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1315 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1316 p_enc->fmt_in.audio.i_channels );
1317 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1318 p_enc->fmt_in.audio.i_rate );
1319 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1320 p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
1321
1322 /* Get and store the STREAMINFO metadata block as a p_extra */
1323 p_sys->p_chain = 0;
1324
1325 #ifdef USE_NEW_FLAC_API
1326 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1327 EncoderWriteCallback,
1328 NULL,
1329 NULL,
1330 EncoderMetadataCallback,
1331 p_enc )
1332 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1333 {
1334 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1335 FLAC__stream_encoder_delete( p_sys->p_flac );
1336 free( p_sys );
1337 return VLC_EGENERIC;
1338 }
1339 #else
1340 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1341 EncoderWriteCallback );
1342 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1343 EncoderMetadataCallback );
1344 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1345
1346 FLAC__stream_encoder_init( p_sys->p_flac );
1347 #endif
1348
1349 return VLC_SUCCESS;
1350 }
1351
1352 /****************************************************************************
1353 * Encode: the whole thing
1354 ****************************************************************************
1355 * This function spits out ogg packets.
1356 ****************************************************************************/
1357 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1358 {
1359 encoder_sys_t *p_sys = p_enc->p_sys;
1360 block_t *p_chain;
1361 unsigned int i;
1362
1363 p_sys->i_pts = p_aout_buf->i_pts -
1364 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1365 (mtime_t)p_enc->fmt_in.audio.i_rate;
1366
1367 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1368
1369 /* Convert samples to FLAC__int32 */
1370 if( p_sys->i_buffer < p_aout_buf->i_buffer * 2 )
1371 {
1372 p_sys->p_buffer =
1373 xrealloc( p_sys->p_buffer, p_aout_buf->i_buffer * 2 );
1374 p_sys->i_buffer = p_aout_buf->i_buffer * 2;
1375 }
1376
1377 for( i = 0 ; i < p_aout_buf->i_buffer / 2 ; i++ )
1378 {
1379 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1380 }
1381
1382 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1383 p_aout_buf->i_nb_samples );
1384
1385 p_chain = p_sys->p_chain;
1386 p_sys->p_chain = 0;
1387
1388 return p_chain;
1389 }
1390
1391 /*****************************************************************************
1392 * CloseEncoder: encoder destruction
1393 *****************************************************************************/
1394 static void CloseEncoder( vlc_object_t *p_this )
1395 {
1396 encoder_t *p_enc = (encoder_t *)p_this;
1397 encoder_sys_t *p_sys = p_enc->p_sys;
1398
1399 FLAC__stream_encoder_delete( p_sys->p_flac );
1400
1401 free( p_sys->p_buffer );
1402 free( p_sys );
1403 }
1404
1405 /*****************************************************************************
1406 * EncoderMetadataCallback: called by libflac to output metadata
1407 *****************************************************************************/
1408 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1409 const FLAC__StreamMetadata *metadata,
1410 void *client_data )
1411 {
1412 VLC_UNUSED(encoder);
1413 encoder_t *p_enc = (encoder_t *)client_data;
1414
1415 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1416 return;
1417 }
1418
1419 /*****************************************************************************
1420 * EncoderWriteCallback: called by libflac to output encoded samples
1421 *****************************************************************************/
1422 static FLAC__StreamEncoderWriteStatus
1423 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1424 const FLAC__byte buffer[],
1425 unsigned bytes, unsigned samples,
1426 unsigned current_frame, void *client_data )
1427 {
1428 VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
1429 encoder_t *p_enc = (encoder_t *)client_data;
1430 encoder_sys_t *p_sys = p_enc->p_sys;
1431 block_t *p_block;
1432
1433 if( samples == 0 )
1434 {
1435 if( p_sys->i_headers == 1 )
1436 {
1437 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1438
1439 /* Backup the STREAMINFO metadata block */
1440 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1441 p_enc->fmt_out.p_extra = xmalloc( STREAMINFO_SIZE + 4 );
1442 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1443 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1444 STREAMINFO_SIZE );
1445
1446 /* Fake this as the last metadata block */
1447 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1448 }
1449 p_sys->i_headers++;
1450 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1451 }
1452
1453 p_block = block_New( p_enc, bytes );
1454 memcpy( p_block->p_buffer, buffer, bytes );
1455
1456 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1457
1458 p_sys->i_samples_delay -= samples;
1459
1460 p_block->i_length = (mtime_t)1000000 *
1461 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1462
1463 /* Update pts */
1464 p_sys->i_pts += p_block->i_length;
1465
1466 block_ChainAppend( &p_sys->p_chain, p_block );
1467
1468 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1469 }
1470 #endif
VLC Development tree mirror