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 *****************************************************************************/
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
38 #ifdef HAVE_FLAC_STREAM_DECODER_H
39 # include <FLAC/stream_decoder.h>
40 # include <FLAC/stream_encoder.h>
44 #include <vlc_block_helper.h>
47 #define MAX_FLAC_HEADER_SIZE 16
49 #if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT >= 8
50 # define USE_NEW_FLAC_API
53 /*****************************************************************************
54 * decoder_sys_t : FLAC decoder descriptor
55 *****************************************************************************/
63 block_bytestream_t bytestream;
66 * Input/Output properties
69 aout_buffer_t *p_aout_buffer;
75 FLAC__StreamDecoder *p_flac;
76 FLAC__StreamMetadata_StreamInfo stream_info;
80 unsigned min_blocksize, max_blocksize;
81 unsigned min_framesize, max_framesize;
84 unsigned bits_per_sample;
93 audio_date_t end_date;
96 int i_frame_size, i_frame_length, i_bits_per_sample;
97 unsigned int i_rate, i_channels, i_channels_conf;
110 static int pi_channels_maps[7] =
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
124 /*****************************************************************************
126 *****************************************************************************/
127 static int OpenDecoder ( vlc_object_t * );
128 static int OpenPacketizer( vlc_object_t * );
129 static void CloseDecoder ( vlc_object_t * );
132 static int OpenEncoder ( vlc_object_t * );
133 static void CloseEncoder ( vlc_object_t * );
137 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
139 static block_t *PacketizeBlock( decoder_t *, block_t ** );
141 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
142 unsigned int *,int * );
146 static FLAC__StreamDecoderReadStatus
147 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
148 FLAC__byte buffer[], unsigned *bytes, void *client_data );
150 static FLAC__StreamDecoderWriteStatus
151 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
152 const FLAC__Frame *frame,
153 const FLAC__int32 *const buffer[], void *client_data );
155 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
156 const FLAC__StreamMetadata *metadata,
158 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
159 FLAC__StreamDecoderErrorStatus status,
162 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
163 int i_nb_channels, int i_samples );
164 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
165 int i_nb_channels, int i_samples );
167 static void decoder_state_error( decoder_t *p_dec,
168 FLAC__StreamDecoderState state );
171 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
172 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
174 /*****************************************************************************
176 *****************************************************************************/
179 set_category( CAT_INPUT );
180 set_subcategory( SUBCAT_INPUT_ACODEC );
181 add_shortcut( "flac" );
184 set_description( N_("Flac audio decoder") );
185 set_capability( "decoder", 100 );
186 set_callbacks( OpenDecoder, CloseDecoder );
189 set_description( N_("Flac audio encoder") );
190 set_capability( "encoder", 100 );
191 set_callbacks( OpenEncoder, CloseEncoder );
195 set_description( N_("Flac audio packetizer") );
196 set_capability( "packetizer", 100 );
197 set_callbacks( OpenPacketizer, CloseDecoder );
201 /*****************************************************************************
202 * OpenDecoder: probe the decoder and return score
203 *****************************************************************************/
204 static int OpenDecoder( vlc_object_t *p_this )
206 decoder_t *p_dec = (decoder_t*)p_this;
207 decoder_sys_t *p_sys;
209 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
214 /* Allocate the memory needed to store the decoder's structure */
215 if( ( p_dec->p_sys = p_sys =
216 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
220 aout_DateSet( &p_sys->end_date, 0 );
221 p_sys->i_state = STATE_NOSYNC;
222 p_sys->b_stream_info = false;
224 p_sys->bytestream = block_BytestreamInit();
227 /* Take care of flac init */
228 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
230 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
235 #ifdef USE_NEW_FLAC_API
236 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
242 DecoderWriteCallback,
243 DecoderMetadataCallback,
244 DecoderErrorCallback,
246 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
248 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
249 FLAC__stream_decoder_delete( p_sys->p_flac );
254 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
255 DecoderReadCallback );
256 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
257 DecoderWriteCallback );
258 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
259 DecoderMetadataCallback );
260 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
261 DecoderErrorCallback );
262 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
264 FLAC__stream_decoder_init( p_sys->p_flac );
268 /* Set output properties */
269 p_dec->fmt_out.i_cat = AUDIO_ES;
270 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
274 p_dec->pf_decode_audio = DecodeBlock;
280 static int OpenPacketizer( vlc_object_t *p_this )
282 decoder_t *p_dec = (decoder_t*)p_this;
283 es_format_t es_save = p_dec->fmt_out;
287 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
289 i_ret = OpenDecoder( p_this );
290 p_dec->pf_decode_audio = NULL;
291 p_dec->pf_packetize = PacketizeBlock;
293 /* Set output properties */
294 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
296 if( i_ret != VLC_SUCCESS )
298 es_format_Clean( &p_dec->fmt_out );
299 p_dec->fmt_out = es_save;
304 /*****************************************************************************
305 * CloseDecoder: flac decoder destruction
306 *****************************************************************************/
307 static void CloseDecoder( vlc_object_t *p_this )
309 decoder_t *p_dec = (decoder_t *)p_this;
310 decoder_sys_t *p_sys = p_dec->p_sys;
313 FLAC__stream_decoder_finish( p_sys->p_flac );
314 FLAC__stream_decoder_delete( p_sys->p_flac );
317 free( p_sys->p_block );
321 /*****************************************************************************
322 * ProcessHeader: process Flac header.
323 *****************************************************************************/
324 static void ProcessHeader( decoder_t *p_dec )
326 decoder_sys_t *p_sys = p_dec->p_sys;
329 if( !p_dec->fmt_in.i_extra ) return;
331 /* Decode STREAMINFO */
332 msg_Dbg( p_dec, "decode STREAMINFO" );
333 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
334 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
335 p_dec->fmt_in.i_extra );
336 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
337 msg_Dbg( p_dec, "STREAMINFO decoded" );
342 if( !p_dec->fmt_in.i_extra ) return;
344 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
346 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
347 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
349 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
350 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
352 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
353 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
354 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
357 if( !p_sys->b_stream_info ) return;
359 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
361 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
362 p_dec->fmt_out.p_extra =
363 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
364 memcpy( p_dec->fmt_out.p_extra,
365 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
369 /****************************************************************************
370 * PacketizeBlock: the whole thing
371 ****************************************************************************
372 * This function is called just after the thread is launched.
373 ****************************************************************************/
374 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
376 decoder_sys_t *p_sys = p_dec->p_sys;
377 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
378 block_t *p_sout_block;
380 if( !pp_block || !*pp_block ) return NULL;
382 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
384 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
386 p_sys->i_state = STATE_NOSYNC;
387 block_BytestreamFlush( &p_sys->bytestream );
389 // aout_DateSet( &p_sys->end_date, 0 );
390 block_Release( *pp_block );
394 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
396 if( p_sys->stream_info.channels > 6 )
398 msg_Err( p_dec, "This stream uses too many audio channels" );
402 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
404 /* We've just started the stream, wait for the first PTS. */
405 block_Release( *pp_block );
408 else if( !aout_DateGet( &p_sys->end_date ) )
410 /* The first PTS is as good as anything else. */
411 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
414 block_BytestreamPush( &p_sys->bytestream, *pp_block );
418 switch( p_sys->i_state )
421 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
424 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
426 p_sys->i_state = STATE_SYNC;
429 block_SkipByte( &p_sys->bytestream );
431 if( p_sys->i_state != STATE_SYNC )
433 block_BytestreamFlush( &p_sys->bytestream );
440 /* New frame, set the Presentation Time Stamp */
441 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
442 if( p_sys->i_pts != 0 &&
443 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
445 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
447 p_sys->i_state = STATE_HEADER;
450 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
451 if( block_PeekBytes( &p_sys->bytestream, p_header,
452 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
458 /* Check if frame is valid and get frame info */
459 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
461 &p_sys->i_channels_conf,
463 &p_sys->i_bits_per_sample );
464 if( !p_sys->i_frame_length )
466 msg_Dbg( p_dec, "emulated sync word" );
467 block_SkipByte( &p_sys->bytestream );
468 p_sys->i_state = STATE_NOSYNC;
471 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
473 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
474 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
476 p_sys->i_state = STATE_NEXT_SYNC;
477 p_sys->i_frame_size = 1;
479 case STATE_NEXT_SYNC:
480 /* TODO: If pp_block == NULL, flush the buffer without checking the
483 /* Check if next expected frame contains the sync word */
484 while( block_PeekOffsetBytes( &p_sys->bytestream,
485 p_sys->i_frame_size, p_header,
486 MAX_FLAC_HEADER_SIZE )
489 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
491 /* Check if frame is valid and get frame info */
493 SyncInfo( p_dec, p_header,
495 &p_sys->i_channels_conf,
497 &p_sys->i_bits_per_sample );
501 p_sys->i_state = STATE_SEND_DATA;
505 p_sys->i_frame_size++;
508 if( p_sys->i_state != STATE_SEND_DATA )
514 case STATE_SEND_DATA:
515 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
517 /* Copy the whole frame into the buffer. When we reach this point
518 * we already know we have enough data available. */
519 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
520 p_sys->i_frame_size );
522 /* Make sure we don't reuse the same pts twice */
523 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
524 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
526 /* So p_block doesn't get re-added several times */
527 *pp_block = block_BytestreamPop( &p_sys->bytestream );
529 p_sys->i_state = STATE_NOSYNC;
531 /* Date management */
532 p_sout_block->i_pts =
533 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
534 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
535 p_sout_block->i_length =
536 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
546 /****************************************************************************
547 * DecodeBlock: the whole thing
548 ****************************************************************************/
549 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
551 decoder_sys_t *p_sys = p_dec->p_sys;
553 if( !pp_block || !*pp_block ) return NULL;
555 p_sys->p_aout_buffer = 0;
556 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
558 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
560 decoder_state_error( p_dec,
561 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
562 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
565 /* If the decoder is in the "aborted" state,
566 * FLAC__stream_decoder_process_single() won't return an error. */
567 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
568 == FLAC__STREAM_DECODER_ABORTED )
570 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
573 block_Release( p_sys->p_block );
574 p_sys->p_block = NULL;
577 return p_sys->p_aout_buffer;
580 /*****************************************************************************
581 * DecoderReadCallback: called by libflac when it needs more data
582 *****************************************************************************/
583 static FLAC__StreamDecoderReadStatus
584 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
585 unsigned *bytes, void *client_data )
588 decoder_t *p_dec = (decoder_t *)client_data;
589 decoder_sys_t *p_sys = p_dec->p_sys;
591 if( p_sys->p_block && p_sys->p_block->i_buffer )
593 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
594 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
595 p_sys->p_block->i_buffer -= *bytes;
596 p_sys->p_block->p_buffer += *bytes;
601 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
604 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
607 /*****************************************************************************
608 * DecoderWriteCallback: called by libflac to output decoded samples
609 *****************************************************************************/
610 static FLAC__StreamDecoderWriteStatus
611 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
612 const FLAC__Frame *frame,
613 const FLAC__int32 *const buffer[], void *client_data )
616 decoder_t *p_dec = (decoder_t *)client_data;
617 decoder_sys_t *p_sys = p_dec->p_sys;
619 p_sys->p_aout_buffer =
620 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
622 if( p_sys->p_aout_buffer == NULL )
623 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
625 switch( frame->header.bits_per_sample )
628 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
629 frame->header.channels, frame->header.blocksize );
632 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
633 frame->header.channels, frame->header.blocksize );
636 /* Date management (already done by packetizer) */
637 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
638 p_sys->p_aout_buffer->end_date =
639 p_sys->p_block->i_pts + p_sys->p_block->i_length;
641 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
644 /*****************************************************************************
645 * DecoderMetadataCallback: called by libflac to when it encounters metadata
646 *****************************************************************************/
647 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
648 const FLAC__StreamMetadata *metadata,
652 decoder_t *p_dec = (decoder_t *)client_data;
653 decoder_sys_t *p_sys = p_dec->p_sys;
655 if( p_dec->pf_decode_audio )
657 switch( metadata->data.stream_info.bits_per_sample )
660 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
663 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
666 msg_Dbg( p_dec, "strange bit/sample value: %d",
667 metadata->data.stream_info.bits_per_sample );
668 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
673 /* Setup the format */
674 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
675 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
676 p_dec->fmt_out.audio.i_physical_channels =
677 p_dec->fmt_out.audio.i_original_channels =
678 pi_channels_maps[metadata->data.stream_info.channels];
679 p_dec->fmt_out.audio.i_bitspersample =
680 metadata->data.stream_info.bits_per_sample;
682 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
684 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
685 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
686 p_dec->fmt_out.audio.i_bitspersample );
688 p_sys->b_stream_info = true;
689 p_sys->stream_info = metadata->data.stream_info;
694 /*****************************************************************************
695 * DecoderErrorCallback: called when the libflac decoder encounters an error
696 *****************************************************************************/
697 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
698 FLAC__StreamDecoderErrorStatus status,
702 decoder_t *p_dec = (decoder_t *)client_data;
706 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
707 msg_Warn( p_dec, "an error in the stream caused the decoder to "
708 "lose synchronization." );
710 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
711 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
713 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
714 msg_Err( p_dec, "frame's data did not match the CRC in the "
718 msg_Err( p_dec, "got decoder error: %d", status );
721 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
725 /*****************************************************************************
726 * Interleave: helper function to interleave channels
727 *****************************************************************************/
728 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
729 int i_nb_channels, int i_samples )
732 for ( j = 0; j < i_samples; j++ )
734 for ( i = 0; i < i_nb_channels; i++ )
736 p_out[j * i_nb_channels + i] = pp_in[i][j];
740 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
741 int i_nb_channels, int i_samples )
744 for ( j = 0; j < i_samples; j++ )
746 for ( i = 0; i < i_nb_channels; i++ )
748 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
753 /*****************************************************************************
754 * decoder_state_error: print meaningful error messages
755 *****************************************************************************/
756 static void decoder_state_error( decoder_t *p_dec,
757 FLAC__StreamDecoderState state )
761 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
762 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
764 case FLAC__STREAM_DECODER_READ_METADATA:
765 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
766 "reading metadata." );
768 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
769 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
770 "searching for the frame sync code." );
772 case FLAC__STREAM_DECODER_READ_FRAME:
773 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
774 "reading a frame." );
776 case FLAC__STREAM_DECODER_END_OF_STREAM:
777 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
779 #ifdef USE_NEW_FLAC_API
780 case FLAC__STREAM_DECODER_OGG_ERROR:
781 msg_Err( p_dec, "error occurred in the Ogg layer." );
783 case FLAC__STREAM_DECODER_SEEK_ERROR:
784 msg_Err( p_dec, "error occurred while seeking." );
787 case FLAC__STREAM_DECODER_ABORTED:
788 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
790 #ifndef USE_NEW_FLAC_API
791 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
792 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
796 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
797 msg_Err( p_dec, "error when allocating memory." );
799 #ifndef USE_NEW_FLAC_API
800 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
801 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
802 "decoder was already initialized, usually because "
803 "FLAC__stream_decoder_finish() was not called." );
805 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
806 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
807 "all callbacks being set." );
810 case FLAC__STREAM_DECODER_UNINITIALIZED:
811 msg_Err( p_dec, "decoder in uninitialized state." );
814 msg_Warn(p_dec, "unknown error" );
819 /*****************************************************************************
820 * SyncInfo: parse FLAC sync info
821 *****************************************************************************/
822 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
823 unsigned int * pi_channels,
824 unsigned int * pi_channels_conf,
825 unsigned int * pi_sample_rate,
826 int * pi_bits_per_sample )
828 decoder_sys_t *p_sys = p_dec->p_sys;
829 int i_header, i_temp, i_read;
830 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
831 uint64_t i_sample_number = 0;
833 bool b_variable_blocksize = ( p_sys->b_stream_info &&
834 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
835 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
836 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
839 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
841 /* Check there is no emulated sync code in the rest of the header */
842 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
844 /* Find blocksize (framelength) */
845 switch( i_temp = p_buf[2] >> 4 )
848 if( b_fixed_blocksize )
849 i_blocksize = p_sys->stream_info.min_blocksize;
850 else return 0; /* We can't do anything with this */
861 i_blocksize = 576 << (i_temp - 2);
866 i_blocksize_hint = i_temp;
877 i_blocksize = 256 << (i_temp - 8);
881 /* Find samplerate */
882 switch( i_temp = p_buf[2] & 0x0f )
885 if( p_sys->b_stream_info )
886 *pi_sample_rate = p_sys->stream_info.sample_rate;
887 else return 0; /* We can't do anything with this */
897 *pi_sample_rate = 8000;
901 *pi_sample_rate = 16000;
905 *pi_sample_rate = 22050;
909 *pi_sample_rate = 24000;
913 *pi_sample_rate = 32000;
917 *pi_sample_rate = 44100;
921 *pi_sample_rate = 48000;
925 *pi_sample_rate = 96000;
931 i_sample_rate_hint = i_temp;
939 i_temp = (unsigned)(p_buf[3] >> 4);
943 int i_channel_assignment; /* ??? */
948 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
951 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
954 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
966 *pi_channels = i_temp + 1;
967 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
970 /* Find bits per sample */
971 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
974 if( p_sys->b_stream_info )
975 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
981 *pi_bits_per_sample = 8;
985 *pi_bits_per_sample = 12;
989 *pi_bits_per_sample = 16;
993 *pi_bits_per_sample = 20;
997 *pi_bits_per_sample = 24;
1006 /* Zero padding bit */
1007 if( p_buf[3] & 0x01 ) return 0;
1009 /* End of fixed size header */
1012 /* Find Sample/Frame number */
1013 if( i_blocksize_hint && b_variable_blocksize )
1015 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1016 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1020 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1021 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1023 if( p_sys->b_stream_info )
1024 i_sample_number *= p_sys->stream_info.min_blocksize;
1029 /* Read blocksize */
1030 if( i_blocksize_hint )
1032 int i_val1 = p_buf[i_header++];
1033 if( i_blocksize_hint == 7 )
1035 int i_val2 = p_buf[i_header++];
1036 i_val1 = (i_val1 << 8) | i_val2;
1038 i_blocksize = i_val1 + 1;
1041 /* Read sample rate */
1042 if( i_sample_rate_hint )
1044 int i_val1 = p_buf[i_header++];
1045 if( i_sample_rate_hint != 12 )
1047 int i_val2 = p_buf[i_header++];
1048 i_val1 = (i_val1 << 8) | i_val2;
1050 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1051 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1052 else *pi_sample_rate = i_val1 * 10;
1055 /* Check the CRC-8 byte */
1056 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1064 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1065 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1067 uint64_t i_result = 0;
1070 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1072 i_result = p_buf[0];
1075 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1077 i_result = p_buf[0] & 0x1F;
1080 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1082 i_result = p_buf[0] & 0x0F;
1085 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1087 i_result = p_buf[0] & 0x07;
1090 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1092 i_result = p_buf[0] & 0x03;
1095 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1097 i_result = p_buf[0] & 0x01;
1100 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1106 return INT64_C(0xffffffffffffffff);
1109 for( j = 1; j <= i; j++ )
1111 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1113 return INT64_C(0xffffffffffffffff);
1116 i_result |= (p_buf[j] & 0x3F);
1123 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1124 static uint8_t const flac_crc8_table[256] = {
1125 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1126 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1127 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1128 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1129 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1130 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1131 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1132 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1133 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1134 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1135 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1136 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1137 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1138 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1139 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1140 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1141 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1142 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1143 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1144 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1145 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1146 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1147 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1148 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1149 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1150 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1151 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1152 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1153 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1154 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1155 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1156 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1159 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1164 crc = flac_crc8_table[crc ^ *data++];
1170 /*****************************************************************************
1171 * encoder_sys_t : flac encoder descriptor
1172 *****************************************************************************/
1173 struct encoder_sys_t
1180 int i_samples_delay;
1183 FLAC__int32 *p_buffer;
1184 unsigned int i_buffer;
1191 FLAC__StreamEncoder *p_flac;
1192 FLAC__StreamMetadata_StreamInfo stream_info;
1200 #define STREAMINFO_SIZE 38
1202 static block_t *Encode( encoder_t *, aout_buffer_t * );
1204 static FLAC__StreamEncoderWriteStatus
1205 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1206 const FLAC__byte buffer[],
1207 unsigned bytes, unsigned samples,
1208 unsigned current_frame, void *client_data );
1210 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1211 const FLAC__StreamMetadata *metadata,
1212 void *client_data );
1214 /*****************************************************************************
1215 * OpenEncoder: probe the encoder and return score
1216 *****************************************************************************/
1217 static int OpenEncoder( vlc_object_t *p_this )
1219 encoder_t *p_enc = (encoder_t *)p_this;
1220 encoder_sys_t *p_sys;
1222 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1225 return VLC_EGENERIC;
1228 /* Allocate the memory needed to store the decoder's structure */
1229 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1231 p_enc->p_sys = p_sys;
1232 p_enc->pf_encode_audio = Encode;
1233 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1235 p_sys->i_headers = 0;
1236 p_sys->p_buffer = 0;
1237 p_sys->i_buffer = 0;
1238 p_sys->i_samples_delay = 0;
1240 /* Create flac encoder */
1241 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1243 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1245 return VLC_EGENERIC;
1248 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1249 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1250 p_enc->fmt_in.audio.i_channels );
1251 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1252 p_enc->fmt_in.audio.i_rate );
1253 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1254 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1256 /* Get and store the STREAMINFO metadata block as a p_extra */
1259 #ifdef USE_NEW_FLAC_API
1260 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1261 EncoderWriteCallback,
1264 EncoderMetadataCallback,
1266 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1268 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1269 FLAC__stream_encoder_delete( p_sys->p_flac );
1271 return VLC_EGENERIC;
1274 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1275 EncoderWriteCallback );
1276 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1277 EncoderMetadataCallback );
1278 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1280 FLAC__stream_encoder_init( p_sys->p_flac );
1286 /****************************************************************************
1287 * Encode: the whole thing
1288 ****************************************************************************
1289 * This function spits out ogg packets.
1290 ****************************************************************************/
1291 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1293 encoder_sys_t *p_sys = p_enc->p_sys;
1297 p_sys->i_pts = p_aout_buf->start_date -
1298 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1299 (mtime_t)p_enc->fmt_in.audio.i_rate;
1301 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1303 /* Convert samples to FLAC__int32 */
1304 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1307 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1308 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1311 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1313 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1316 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1317 p_aout_buf->i_nb_samples );
1319 p_chain = p_sys->p_chain;
1325 /*****************************************************************************
1326 * CloseEncoder: encoder destruction
1327 *****************************************************************************/
1328 static void CloseEncoder( vlc_object_t *p_this )
1330 encoder_t *p_enc = (encoder_t *)p_this;
1331 encoder_sys_t *p_sys = p_enc->p_sys;
1333 FLAC__stream_encoder_delete( p_sys->p_flac );
1335 free( p_sys->p_buffer );
1339 /*****************************************************************************
1340 * EncoderMetadataCallback: called by libflac to output metadata
1341 *****************************************************************************/
1342 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1343 const FLAC__StreamMetadata *metadata,
1346 VLC_UNUSED(encoder);
1347 encoder_t *p_enc = (encoder_t *)client_data;
1349 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1353 /*****************************************************************************
1354 * EncoderWriteCallback: called by libflac to output encoded samples
1355 *****************************************************************************/
1356 static FLAC__StreamEncoderWriteStatus
1357 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1358 const FLAC__byte buffer[],
1359 unsigned bytes, unsigned samples,
1360 unsigned current_frame, void *client_data )
1362 VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
1363 encoder_t *p_enc = (encoder_t *)client_data;
1364 encoder_sys_t *p_sys = p_enc->p_sys;
1369 if( p_sys->i_headers == 1 )
1371 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1373 /* Backup the STREAMINFO metadata block */
1374 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1375 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1376 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1377 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1380 /* Fake this as the last metadata block */
1381 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1384 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1387 p_block = block_New( p_enc, bytes );
1388 memcpy( p_block->p_buffer, buffer, bytes );
1390 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1392 p_sys->i_samples_delay -= samples;
1394 p_block->i_length = (mtime_t)1000000 *
1395 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1398 p_sys->i_pts += p_block->i_length;
1400 block_ChainAppend( &p_sys->p_chain, p_block );
1402 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;