1 /*****************************************************************************
2 * flac.c: flac decoder/packetizer/encoder module making use of libflac
3 *****************************************************************************
4 * Copyright (C) 1999-2001 the VideoLAN team
7 * Authors: Gildas Bazin <gbazin@videolan.org>
8 * Sigmund Augdal Helberg <dnumgis@videolan.org>
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.
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.
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 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
30 #include <vlc_codec.h>
33 #ifdef HAVE_FLAC_STREAM_DECODER_H
34 # include <FLAC/stream_decoder.h>
35 # include <FLAC/stream_encoder.h>
39 #include <vlc_block_helper.h>
42 #define MAX_FLAC_HEADER_SIZE 16
44 /*****************************************************************************
45 * decoder_sys_t : FLAC decoder descriptor
46 *****************************************************************************/
54 block_bytestream_t bytestream;
57 * Input/Output properties
60 aout_buffer_t *p_aout_buffer;
66 FLAC__StreamDecoder *p_flac;
67 FLAC__StreamMetadata_StreamInfo stream_info;
71 unsigned min_blocksize, max_blocksize;
72 unsigned min_framesize, max_framesize;
75 unsigned bits_per_sample;
79 vlc_bool_t b_stream_info;
84 audio_date_t end_date;
87 int i_frame_size, i_frame_length, i_bits_per_sample;
88 unsigned int i_rate, i_channels, i_channels_conf;
101 static int pi_channels_maps[7] =
105 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
106 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
107 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
108 | AOUT_CHAN_REARRIGHT,
109 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
110 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
111 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
112 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
115 /*****************************************************************************
117 *****************************************************************************/
118 static int OpenDecoder ( vlc_object_t * );
119 static int OpenPacketizer( vlc_object_t * );
120 static void CloseDecoder ( vlc_object_t * );
123 static int OpenEncoder ( vlc_object_t * );
124 static void CloseEncoder ( vlc_object_t * );
128 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
130 static block_t *PacketizeBlock( decoder_t *, block_t ** );
132 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
133 unsigned int *,int * );
137 static FLAC__StreamDecoderReadStatus
138 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
139 FLAC__byte buffer[], unsigned *bytes, void *client_data );
141 static FLAC__StreamDecoderWriteStatus
142 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
143 const FLAC__Frame *frame,
144 const FLAC__int32 *const buffer[], void *client_data );
146 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
147 const FLAC__StreamMetadata *metadata,
149 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
150 FLAC__StreamDecoderErrorStatus status,
153 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
154 int i_nb_channels, int i_samples );
155 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
156 int i_nb_channels, int i_samples );
158 static void decoder_state_error( decoder_t *p_dec,
159 FLAC__StreamDecoderState state );
162 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
163 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
165 /*****************************************************************************
167 *****************************************************************************/
170 set_category( CAT_INPUT );
171 set_subcategory( SUBCAT_INPUT_ACODEC );
174 set_description( _("Flac audio decoder") );
175 set_capability( "decoder", 100 );
176 set_callbacks( OpenDecoder, CloseDecoder );
179 set_description( _("Flac audio encoder") );
180 set_capability( "encoder", 100 );
181 set_callbacks( OpenEncoder, CloseEncoder );
185 set_description( _("Flac audio packetizer") );
186 set_capability( "packetizer", 100 );
187 set_callbacks( OpenPacketizer, CloseDecoder );
189 add_shortcut( "flac" );
192 /*****************************************************************************
193 * OpenDecoder: probe the decoder and return score
194 *****************************************************************************/
195 static int OpenDecoder( vlc_object_t *p_this )
197 decoder_t *p_dec = (decoder_t*)p_this;
198 decoder_sys_t *p_sys;
200 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
205 /* Allocate the memory needed to store the decoder's structure */
206 if( ( p_dec->p_sys = p_sys =
207 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
209 msg_Err( p_dec, "out of memory" );
214 aout_DateSet( &p_sys->end_date, 0 );
215 p_sys->i_state = STATE_NOSYNC;
216 p_sys->b_stream_info = VLC_FALSE;
218 p_sys->bytestream = block_BytestreamInit( p_dec );
221 /* Take care of flac init */
222 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
224 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
229 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
230 DecoderReadCallback );
231 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
232 DecoderWriteCallback );
233 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
234 DecoderMetadataCallback );
235 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
236 DecoderErrorCallback );
237 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
239 FLAC__stream_decoder_init( p_sys->p_flac );
242 /* Set output properties */
243 p_dec->fmt_out.i_cat = AUDIO_ES;
244 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
248 p_dec->pf_decode_audio = DecodeBlock;
250 p_dec->pf_packetize = PacketizeBlock;
255 static int OpenPacketizer( vlc_object_t *p_this )
257 decoder_t *p_dec = (decoder_t*)p_this;
260 /* Hmmm, mem leak ?*/
261 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
263 i_ret = OpenDecoder( p_this );
265 /* Set output properties */
266 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
268 if( i_ret != VLC_SUCCESS ) return i_ret;
273 /*****************************************************************************
274 * CloseDecoder: flac decoder destruction
275 *****************************************************************************/
276 static void CloseDecoder( vlc_object_t *p_this )
278 decoder_t *p_dec = (decoder_t *)p_this;
279 decoder_sys_t *p_sys = p_dec->p_sys;
282 FLAC__stream_decoder_finish( p_sys->p_flac );
283 FLAC__stream_decoder_delete( p_sys->p_flac );
286 if( p_sys->p_block ) free( p_sys->p_block );
290 /*****************************************************************************
291 * ProcessHeader: process Flac header.
292 *****************************************************************************/
293 static void ProcessHeader( decoder_t *p_dec )
295 decoder_sys_t *p_sys = p_dec->p_sys;
298 if( !p_dec->fmt_in.i_extra ) return;
300 /* Decode STREAMINFO */
301 msg_Dbg( p_dec, "decode STREAMINFO" );
302 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
303 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
304 p_dec->fmt_in.i_extra );
305 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
306 msg_Dbg( p_dec, "STREAMINFO decoded" );
311 if( !p_dec->fmt_in.i_extra ) return;
313 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
315 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
316 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
318 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
319 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
321 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
322 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
323 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
326 if( !p_sys->b_stream_info ) return;
328 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
330 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
331 p_dec->fmt_out.p_extra =
332 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
333 memcpy( p_dec->fmt_out.p_extra,
334 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
338 /****************************************************************************
339 * PacketizeBlock: the whole thing
340 ****************************************************************************
341 * This function is called just after the thread is launched.
342 ****************************************************************************/
343 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
345 decoder_sys_t *p_sys = p_dec->p_sys;
346 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
347 block_t *p_sout_block;
349 if( !pp_block || !*pp_block ) return NULL;
351 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
353 if( p_sys->stream_info.channels > 6 )
355 msg_Err( p_dec, "This stream uses too many audio channels" );
359 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
361 /* We've just started the stream, wait for the first PTS. */
362 block_Release( *pp_block );
365 else if( !aout_DateGet( &p_sys->end_date ) )
367 /* The first PTS is as good as anything else. */
368 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
371 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
373 p_sys->i_state = STATE_NOSYNC;
376 block_BytestreamPush( &p_sys->bytestream, *pp_block );
380 switch( p_sys->i_state )
383 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
386 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
388 p_sys->i_state = STATE_SYNC;
391 block_SkipByte( &p_sys->bytestream );
393 if( p_sys->i_state != STATE_SYNC )
395 block_BytestreamFlush( &p_sys->bytestream );
402 /* New frame, set the Presentation Time Stamp */
403 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
404 if( p_sys->i_pts != 0 &&
405 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
407 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
409 p_sys->i_state = STATE_HEADER;
412 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
413 if( block_PeekBytes( &p_sys->bytestream, p_header,
414 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
420 /* Check if frame is valid and get frame info */
421 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
423 &p_sys->i_channels_conf,
425 &p_sys->i_bits_per_sample );
426 if( !p_sys->i_frame_length )
428 msg_Dbg( p_dec, "emulated sync word" );
429 block_SkipByte( &p_sys->bytestream );
430 p_sys->i_state = STATE_NOSYNC;
433 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
435 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
436 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
438 p_sys->i_state = STATE_NEXT_SYNC;
439 p_sys->i_frame_size = 1;
441 case STATE_NEXT_SYNC:
442 /* TODO: If pp_block == NULL, flush the buffer without checking the
445 /* Check if next expected frame contains the sync word */
446 while( block_PeekOffsetBytes( &p_sys->bytestream,
447 p_sys->i_frame_size, p_header,
448 MAX_FLAC_HEADER_SIZE )
451 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
453 /* Check if frame is valid and get frame info */
455 SyncInfo( p_dec, p_header,
457 &p_sys->i_channels_conf,
459 &p_sys->i_bits_per_sample );
463 p_sys->i_state = STATE_SEND_DATA;
467 p_sys->i_frame_size++;
470 if( p_sys->i_state != STATE_SEND_DATA )
476 case STATE_SEND_DATA:
477 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
479 /* Copy the whole frame into the buffer. When we reach this point
480 * we already know we have enough data available. */
481 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
482 p_sys->i_frame_size );
484 /* Make sure we don't reuse the same pts twice */
485 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
486 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
488 /* So p_block doesn't get re-added several times */
489 *pp_block = block_BytestreamPop( &p_sys->bytestream );
491 p_sys->i_state = STATE_NOSYNC;
493 /* Date management */
494 p_sout_block->i_pts =
495 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
496 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
497 p_sout_block->i_length =
498 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
508 /****************************************************************************
509 * DecodeBlock: the whole thing
510 ****************************************************************************/
511 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
513 decoder_sys_t *p_sys = p_dec->p_sys;
515 if( !pp_block || !*pp_block ) return NULL;
517 p_sys->p_aout_buffer = 0;
518 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
520 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
522 decoder_state_error( p_dec,
523 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
524 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
527 /* If the decoder is in the "aborted" state,
528 * FLAC__stream_decoder_process_single() won't return an error. */
529 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
530 == FLAC__STREAM_DECODER_ABORTED )
532 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
535 block_Release( p_sys->p_block );
536 p_sys->p_block = NULL;
539 return p_sys->p_aout_buffer;
542 /*****************************************************************************
543 * DecoderReadCallback: called by libflac when it needs more data
544 *****************************************************************************/
545 static FLAC__StreamDecoderReadStatus
546 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
547 unsigned *bytes, void *client_data )
549 decoder_t *p_dec = (decoder_t *)client_data;
550 decoder_sys_t *p_sys = p_dec->p_sys;
552 if( p_sys->p_block && p_sys->p_block->i_buffer )
554 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
555 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
556 p_sys->p_block->i_buffer -= *bytes;
557 p_sys->p_block->p_buffer += *bytes;
562 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
565 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
568 /*****************************************************************************
569 * DecoderWriteCallback: called by libflac to output decoded samples
570 *****************************************************************************/
571 static FLAC__StreamDecoderWriteStatus
572 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
573 const FLAC__Frame *frame,
574 const FLAC__int32 *const buffer[], void *client_data )
576 decoder_t *p_dec = (decoder_t *)client_data;
577 decoder_sys_t *p_sys = p_dec->p_sys;
579 p_sys->p_aout_buffer =
580 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
582 if( p_sys->p_aout_buffer == NULL )
583 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
585 switch( frame->header.bits_per_sample )
588 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
589 frame->header.channels, frame->header.blocksize );
592 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
593 frame->header.channels, frame->header.blocksize );
596 /* Date management (already done by packetizer) */
597 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
598 p_sys->p_aout_buffer->end_date =
599 p_sys->p_block->i_pts + p_sys->p_block->i_length;
601 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
604 /*****************************************************************************
605 * DecoderMetadataCallback: called by libflac to when it encounters metadata
606 *****************************************************************************/
607 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
608 const FLAC__StreamMetadata *metadata,
611 decoder_t *p_dec = (decoder_t *)client_data;
612 decoder_sys_t *p_sys = p_dec->p_sys;
614 switch( metadata->data.stream_info.bits_per_sample )
617 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
620 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
623 msg_Dbg( p_dec, "strange bit/sample value: %d",
624 metadata->data.stream_info.bits_per_sample );
625 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
629 /* Setup the format */
630 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
631 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
632 p_dec->fmt_out.audio.i_physical_channels =
633 p_dec->fmt_out.audio.i_original_channels =
634 pi_channels_maps[metadata->data.stream_info.channels];
635 p_dec->fmt_out.audio.i_bitspersample =
636 metadata->data.stream_info.bits_per_sample;
638 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
640 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
641 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
642 p_dec->fmt_out.audio.i_bitspersample );
644 p_sys->b_stream_info = VLC_TRUE;
645 p_sys->stream_info = metadata->data.stream_info;
650 /*****************************************************************************
651 * DecoderErrorCallback: called when the libflac decoder encounters an error
652 *****************************************************************************/
653 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
654 FLAC__StreamDecoderErrorStatus status,
657 decoder_t *p_dec = (decoder_t *)client_data;
661 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
662 msg_Warn( p_dec, "an error in the stream caused the decoder to "
663 "lose synchronization." );
665 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
666 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
668 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
669 msg_Err( p_dec, "frame's data did not match the CRC in the "
673 msg_Err( p_dec, "got decoder error: %d", status );
676 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
680 /*****************************************************************************
681 * Interleave: helper function to interleave channels
682 *****************************************************************************/
683 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
684 int i_nb_channels, int i_samples )
687 for ( j = 0; j < i_samples; j++ )
689 for ( i = 0; i < i_nb_channels; i++ )
691 p_out[j * i_nb_channels + i] = pp_in[i][j];
695 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
696 int i_nb_channels, int i_samples )
699 for ( j = 0; j < i_samples; j++ )
701 for ( i = 0; i < i_nb_channels; i++ )
703 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
708 /*****************************************************************************
709 * decoder_state_error: print meaningful error messages
710 *****************************************************************************/
711 static void decoder_state_error( decoder_t *p_dec,
712 FLAC__StreamDecoderState state )
716 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
717 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
719 case FLAC__STREAM_DECODER_READ_METADATA:
720 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
721 "reading metadata." );
723 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
724 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
725 "searching for the frame sync code." );
727 case FLAC__STREAM_DECODER_READ_FRAME:
728 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
729 "reading a frame." );
731 case FLAC__STREAM_DECODER_END_OF_STREAM:
732 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
734 case FLAC__STREAM_DECODER_ABORTED:
735 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
737 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
738 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
741 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
742 msg_Err( p_dec, "error when allocating memory." );
744 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
745 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
746 "decoder was already initialized, usually because "
747 "FLAC__stream_decoder_finish() was not called." );
749 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
750 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
751 "all callbacks being set." );
753 case FLAC__STREAM_DECODER_UNINITIALIZED:
754 msg_Err( p_dec, "decoder in uninitialized state." );
757 msg_Warn(p_dec, "unknown error" );
762 /*****************************************************************************
763 * SyncInfo: parse FLAC sync info
764 *****************************************************************************/
765 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
766 unsigned int * pi_channels,
767 unsigned int * pi_channels_conf,
768 unsigned int * pi_sample_rate,
769 int * pi_bits_per_sample )
771 decoder_sys_t *p_sys = p_dec->p_sys;
772 int i_header, i_temp, i_read;
773 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
774 uint64_t i_sample_number = 0;
776 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
777 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
778 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
779 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
782 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
784 /* Check there is no emulated sync code in the rest of the header */
785 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
787 /* Find blocksize (framelength) */
788 switch( i_temp = p_buf[2] >> 4 )
791 if( b_fixed_blocksize )
792 i_blocksize = p_sys->stream_info.min_blocksize;
793 else return 0; /* We can't do anything with this */
804 i_blocksize = 576 << (i_temp - 2);
809 i_blocksize_hint = i_temp;
820 i_blocksize = 256 << (i_temp - 8);
824 /* Find samplerate */
825 switch( i_temp = p_buf[2] & 0x0f )
828 if( p_sys->b_stream_info )
829 *pi_sample_rate = p_sys->stream_info.sample_rate;
830 else return 0; /* We can't do anything with this */
840 *pi_sample_rate = 8000;
844 *pi_sample_rate = 16000;
848 *pi_sample_rate = 22050;
852 *pi_sample_rate = 24000;
856 *pi_sample_rate = 32000;
860 *pi_sample_rate = 44100;
864 *pi_sample_rate = 48000;
868 *pi_sample_rate = 96000;
874 i_sample_rate_hint = i_temp;
882 i_temp = (unsigned)(p_buf[3] >> 4);
886 int i_channel_assignment; /* ??? */
891 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
894 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
897 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
909 *pi_channels = i_temp + 1;
910 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
913 /* Find bits per sample */
914 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
917 if( p_sys->b_stream_info )
918 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
924 *pi_bits_per_sample = 8;
928 *pi_bits_per_sample = 12;
932 *pi_bits_per_sample = 16;
936 *pi_bits_per_sample = 20;
940 *pi_bits_per_sample = 24;
949 /* Zero padding bit */
950 if( p_buf[3] & 0x01 ) return 0;
952 /* End of fixed size header */
955 /* Find Sample/Frame number */
956 if( i_blocksize_hint && b_variable_blocksize )
958 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
959 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
963 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
964 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
966 if( p_sys->b_stream_info )
967 i_sample_number *= p_sys->stream_info.min_blocksize;
973 if( i_blocksize_hint )
975 int i_val1 = p_buf[i_header++];
976 if( i_blocksize_hint == 7 )
978 int i_val2 = p_buf[i_header++];
979 i_val1 = (i_val1 << 8) | i_val2;
981 i_blocksize = i_val1 + 1;
984 /* Read sample rate */
985 if( i_sample_rate_hint )
987 int i_val1 = p_buf[i_header++];
988 if( i_sample_rate_hint != 12 )
990 int i_val2 = p_buf[i_header++];
991 i_val1 = (i_val1 << 8) | i_val2;
993 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
994 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
995 else *pi_sample_rate = i_val1 * 10;
998 /* Check the CRC-8 byte */
999 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1007 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1008 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1010 uint64_t i_result = 0;
1013 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1015 i_result = p_buf[0];
1018 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1020 i_result = p_buf[0] & 0x1F;
1023 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1025 i_result = p_buf[0] & 0x0F;
1028 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1030 i_result = p_buf[0] & 0x07;
1033 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1035 i_result = p_buf[0] & 0x03;
1038 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1040 i_result = p_buf[0] & 0x01;
1043 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1049 return I64C(0xffffffffffffffff);
1052 for( j = 1; j <= i; j++ )
1054 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1056 return I64C(0xffffffffffffffff);
1059 i_result |= (p_buf[j] & 0x3F);
1066 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1067 static uint8_t const flac_crc8_table[256] = {
1068 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1069 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1070 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1071 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1072 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1073 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1074 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1075 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1076 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1077 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1078 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1079 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1080 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1081 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1082 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1083 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1084 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1085 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1086 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1087 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1088 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1089 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1090 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1091 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1092 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1093 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1094 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1095 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1096 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1097 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1098 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1099 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1102 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1107 crc = flac_crc8_table[crc ^ *data++];
1113 /*****************************************************************************
1114 * encoder_sys_t : flac encoder descriptor
1115 *****************************************************************************/
1116 struct encoder_sys_t
1123 int i_samples_delay;
1126 FLAC__int32 *p_buffer;
1127 unsigned int i_buffer;
1134 FLAC__StreamEncoder *p_flac;
1135 FLAC__StreamMetadata_StreamInfo stream_info;
1143 #define STREAMINFO_SIZE 38
1145 static block_t *Encode( encoder_t *, aout_buffer_t * );
1147 static FLAC__StreamEncoderWriteStatus
1148 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1149 const FLAC__byte buffer[],
1150 unsigned bytes, unsigned samples,
1151 unsigned current_frame, void *client_data );
1153 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1154 const FLAC__StreamMetadata *metadata,
1155 void *client_data );
1157 /*****************************************************************************
1158 * OpenEncoder: probe the encoder and return score
1159 *****************************************************************************/
1160 static int OpenEncoder( vlc_object_t *p_this )
1162 encoder_t *p_enc = (encoder_t *)p_this;
1163 encoder_sys_t *p_sys;
1165 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1168 return VLC_EGENERIC;
1171 /* Allocate the memory needed to store the decoder's structure */
1172 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1174 msg_Err( p_enc, "out of memory" );
1175 return VLC_EGENERIC;
1177 p_enc->p_sys = p_sys;
1178 p_enc->pf_encode_audio = Encode;
1179 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1181 p_sys->i_headers = 0;
1182 p_sys->p_buffer = 0;
1183 p_sys->i_buffer = 0;
1184 p_sys->i_samples_delay = 0;
1186 /* Create flac encoder */
1187 p_sys->p_flac = FLAC__stream_encoder_new();
1189 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1190 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1191 p_enc->fmt_in.audio.i_channels );
1192 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1193 p_enc->fmt_in.audio.i_rate );
1194 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1195 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1197 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1198 EncoderWriteCallback );
1199 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1200 EncoderMetadataCallback );
1201 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1203 /* Get and store the STREAMINFO metadata block as a p_extra */
1205 FLAC__stream_encoder_init( p_sys->p_flac );
1210 /****************************************************************************
1211 * Encode: the whole thing
1212 ****************************************************************************
1213 * This function spits out ogg packets.
1214 ****************************************************************************/
1215 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1217 encoder_sys_t *p_sys = p_enc->p_sys;
1221 p_sys->i_pts = p_aout_buf->start_date -
1222 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1223 (mtime_t)p_enc->fmt_in.audio.i_rate;
1225 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1227 /* Convert samples to FLAC__int32 */
1228 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1231 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1232 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1235 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1237 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1240 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1241 p_aout_buf->i_nb_samples );
1243 p_chain = p_sys->p_chain;
1249 /*****************************************************************************
1250 * CloseEncoder: encoder destruction
1251 *****************************************************************************/
1252 static void CloseEncoder( vlc_object_t *p_this )
1254 encoder_t *p_enc = (encoder_t *)p_this;
1255 encoder_sys_t *p_sys = p_enc->p_sys;
1257 FLAC__stream_encoder_delete( p_sys->p_flac );
1259 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1263 /*****************************************************************************
1264 * EncoderMetadataCallback: called by libflac to output metadata
1265 *****************************************************************************/
1266 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1267 const FLAC__StreamMetadata *metadata,
1270 encoder_t *p_enc = (encoder_t *)client_data;
1272 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1276 /*****************************************************************************
1277 * EncoderWriteCallback: called by libflac to output encoded samples
1278 *****************************************************************************/
1279 static FLAC__StreamEncoderWriteStatus
1280 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1281 const FLAC__byte buffer[],
1282 unsigned bytes, unsigned samples,
1283 unsigned current_frame, void *client_data )
1285 encoder_t *p_enc = (encoder_t *)client_data;
1286 encoder_sys_t *p_sys = p_enc->p_sys;
1291 if( p_sys->i_headers == 1 )
1293 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1295 /* Backup the STREAMINFO metadata block */
1296 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1297 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1298 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1299 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1302 /* Fake this as the last metadata block */
1303 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1306 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1309 p_block = block_New( p_enc, bytes );
1310 memcpy( p_block->p_buffer, buffer, bytes );
1312 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1314 p_sys->i_samples_delay -= samples;
1316 p_block->i_length = (mtime_t)1000000 *
1317 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1320 p_sys->i_pts += p_block->i_length;
1322 block_ChainAppend( &p_sys->p_chain, p_block );
1324 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;