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 *****************************************************************************/
34 #include <vlc_codec.h>
37 #ifdef HAVE_FLAC_STREAM_DECODER_H
38 # include <FLAC/stream_decoder.h>
39 # include <FLAC/stream_encoder.h>
43 #include <vlc_block_helper.h>
46 #define MAX_FLAC_HEADER_SIZE 16
48 #if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT >= 8
49 # define USE_NEW_FLAC_API
52 /*****************************************************************************
53 * decoder_sys_t : FLAC decoder descriptor
54 *****************************************************************************/
62 block_bytestream_t bytestream;
65 * Input/Output properties
68 aout_buffer_t *p_aout_buffer;
74 FLAC__StreamDecoder *p_flac;
75 FLAC__StreamMetadata_StreamInfo stream_info;
79 unsigned min_blocksize, max_blocksize;
80 unsigned min_framesize, max_framesize;
83 unsigned bits_per_sample;
87 vlc_bool_t b_stream_info;
92 audio_date_t end_date;
95 int i_frame_size, i_frame_length, i_bits_per_sample;
96 unsigned int i_rate, i_channels, i_channels_conf;
109 static int pi_channels_maps[7] =
113 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
114 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
115 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
116 | AOUT_CHAN_REARRIGHT,
117 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
118 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
119 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
120 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
123 /*****************************************************************************
125 *****************************************************************************/
126 static int OpenDecoder ( vlc_object_t * );
127 static int OpenPacketizer( vlc_object_t * );
128 static void CloseDecoder ( vlc_object_t * );
131 static int OpenEncoder ( vlc_object_t * );
132 static void CloseEncoder ( vlc_object_t * );
136 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
138 static block_t *PacketizeBlock( decoder_t *, block_t ** );
140 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
141 unsigned int *,int * );
145 static FLAC__StreamDecoderReadStatus
146 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
147 FLAC__byte buffer[], unsigned *bytes, void *client_data );
149 static FLAC__StreamDecoderWriteStatus
150 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
151 const FLAC__Frame *frame,
152 const FLAC__int32 *const buffer[], void *client_data );
154 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
155 const FLAC__StreamMetadata *metadata,
157 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
158 FLAC__StreamDecoderErrorStatus status,
161 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
162 int i_nb_channels, int i_samples );
163 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
164 int i_nb_channels, int i_samples );
166 static void decoder_state_error( decoder_t *p_dec,
167 FLAC__StreamDecoderState state );
170 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
171 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
173 /*****************************************************************************
175 *****************************************************************************/
178 set_category( CAT_INPUT );
179 set_subcategory( SUBCAT_INPUT_ACODEC );
180 add_shortcut( "flac" );
183 set_description( _("Flac audio decoder") );
184 set_capability( "decoder", 100 );
185 set_callbacks( OpenDecoder, CloseDecoder );
188 set_description( _("Flac audio encoder") );
189 set_capability( "encoder", 100 );
190 set_callbacks( OpenEncoder, CloseEncoder );
194 set_description( _("Flac audio packetizer") );
195 set_capability( "packetizer", 100 );
196 set_callbacks( OpenPacketizer, CloseDecoder );
200 /*****************************************************************************
201 * OpenDecoder: probe the decoder and return score
202 *****************************************************************************/
203 static int OpenDecoder( vlc_object_t *p_this )
205 decoder_t *p_dec = (decoder_t*)p_this;
206 decoder_sys_t *p_sys;
208 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
213 /* Allocate the memory needed to store the decoder's structure */
214 if( ( p_dec->p_sys = p_sys =
215 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
217 msg_Err( p_dec, "out of memory" );
222 aout_DateSet( &p_sys->end_date, 0 );
223 p_sys->i_state = STATE_NOSYNC;
224 p_sys->b_stream_info = VLC_FALSE;
226 p_sys->bytestream = block_BytestreamInit( p_dec );
229 /* Take care of flac init */
230 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
232 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
237 #ifdef USE_NEW_FLAC_API
238 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
244 DecoderWriteCallback,
245 DecoderMetadataCallback,
246 DecoderErrorCallback,
248 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
250 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
251 FLAC__stream_decoder_delete( p_sys->p_flac );
256 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
257 DecoderReadCallback );
258 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
259 DecoderWriteCallback );
260 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
261 DecoderMetadataCallback );
262 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
263 DecoderErrorCallback );
264 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
266 FLAC__stream_decoder_init( p_sys->p_flac );
270 /* Set output properties */
271 p_dec->fmt_out.i_cat = AUDIO_ES;
272 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
276 p_dec->pf_decode_audio = DecodeBlock;
282 static int OpenPacketizer( vlc_object_t *p_this )
284 decoder_t *p_dec = (decoder_t*)p_this;
285 es_format_t es_save = p_dec->fmt_out;
289 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
291 i_ret = OpenDecoder( p_this );
292 p_dec->pf_decode_audio = NULL;
293 p_dec->pf_packetize = PacketizeBlock;
295 /* Set output properties */
296 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
298 if( i_ret != VLC_SUCCESS )
300 es_format_Clean( &p_dec->fmt_out );
301 p_dec->fmt_out = es_save;
306 /*****************************************************************************
307 * CloseDecoder: flac decoder destruction
308 *****************************************************************************/
309 static void CloseDecoder( vlc_object_t *p_this )
311 decoder_t *p_dec = (decoder_t *)p_this;
312 decoder_sys_t *p_sys = p_dec->p_sys;
315 FLAC__stream_decoder_finish( p_sys->p_flac );
316 FLAC__stream_decoder_delete( p_sys->p_flac );
319 if( p_sys->p_block ) free( p_sys->p_block );
323 /*****************************************************************************
324 * ProcessHeader: process Flac header.
325 *****************************************************************************/
326 static void ProcessHeader( decoder_t *p_dec )
328 decoder_sys_t *p_sys = p_dec->p_sys;
331 if( !p_dec->fmt_in.i_extra ) return;
333 /* Decode STREAMINFO */
334 msg_Dbg( p_dec, "decode STREAMINFO" );
335 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
336 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
337 p_dec->fmt_in.i_extra );
338 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
339 msg_Dbg( p_dec, "STREAMINFO decoded" );
344 if( !p_dec->fmt_in.i_extra ) return;
346 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
348 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
349 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
351 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
352 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
354 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
355 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
356 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
359 if( !p_sys->b_stream_info ) return;
361 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
363 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
364 p_dec->fmt_out.p_extra =
365 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
366 memcpy( p_dec->fmt_out.p_extra,
367 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
371 /****************************************************************************
372 * PacketizeBlock: the whole thing
373 ****************************************************************************
374 * This function is called just after the thread is launched.
375 ****************************************************************************/
376 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
378 decoder_sys_t *p_sys = p_dec->p_sys;
379 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
380 block_t *p_sout_block;
382 if( !pp_block || !*pp_block ) return NULL;
384 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
386 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
388 p_sys->i_state = STATE_NOSYNC;
389 block_BytestreamFlush( &p_sys->bytestream );
391 // aout_DateSet( &p_sys->end_date, 0 );
392 block_Release( *pp_block );
396 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
398 if( p_sys->stream_info.channels > 6 )
400 msg_Err( p_dec, "This stream uses too many audio channels" );
404 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
406 /* We've just started the stream, wait for the first PTS. */
407 block_Release( *pp_block );
410 else if( !aout_DateGet( &p_sys->end_date ) )
412 /* The first PTS is as good as anything else. */
413 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
416 block_BytestreamPush( &p_sys->bytestream, *pp_block );
420 switch( p_sys->i_state )
423 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
426 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
428 p_sys->i_state = STATE_SYNC;
431 block_SkipByte( &p_sys->bytestream );
433 if( p_sys->i_state != STATE_SYNC )
435 block_BytestreamFlush( &p_sys->bytestream );
442 /* New frame, set the Presentation Time Stamp */
443 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
444 if( p_sys->i_pts != 0 &&
445 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
447 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
449 p_sys->i_state = STATE_HEADER;
452 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
453 if( block_PeekBytes( &p_sys->bytestream, p_header,
454 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
460 /* Check if frame is valid and get frame info */
461 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
463 &p_sys->i_channels_conf,
465 &p_sys->i_bits_per_sample );
466 if( !p_sys->i_frame_length )
468 msg_Dbg( p_dec, "emulated sync word" );
469 block_SkipByte( &p_sys->bytestream );
470 p_sys->i_state = STATE_NOSYNC;
473 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
475 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
476 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
478 p_sys->i_state = STATE_NEXT_SYNC;
479 p_sys->i_frame_size = 1;
481 case STATE_NEXT_SYNC:
482 /* TODO: If pp_block == NULL, flush the buffer without checking the
485 /* Check if next expected frame contains the sync word */
486 while( block_PeekOffsetBytes( &p_sys->bytestream,
487 p_sys->i_frame_size, p_header,
488 MAX_FLAC_HEADER_SIZE )
491 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
493 /* Check if frame is valid and get frame info */
495 SyncInfo( p_dec, p_header,
497 &p_sys->i_channels_conf,
499 &p_sys->i_bits_per_sample );
503 p_sys->i_state = STATE_SEND_DATA;
507 p_sys->i_frame_size++;
510 if( p_sys->i_state != STATE_SEND_DATA )
516 case STATE_SEND_DATA:
517 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
519 /* Copy the whole frame into the buffer. When we reach this point
520 * we already know we have enough data available. */
521 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
522 p_sys->i_frame_size );
524 /* Make sure we don't reuse the same pts twice */
525 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
526 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
528 /* So p_block doesn't get re-added several times */
529 *pp_block = block_BytestreamPop( &p_sys->bytestream );
531 p_sys->i_state = STATE_NOSYNC;
533 /* Date management */
534 p_sout_block->i_pts =
535 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
536 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
537 p_sout_block->i_length =
538 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
548 /****************************************************************************
549 * DecodeBlock: the whole thing
550 ****************************************************************************/
551 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
553 decoder_sys_t *p_sys = p_dec->p_sys;
555 if( !pp_block || !*pp_block ) return NULL;
557 p_sys->p_aout_buffer = 0;
558 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
560 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
562 decoder_state_error( p_dec,
563 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
564 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
567 /* If the decoder is in the "aborted" state,
568 * FLAC__stream_decoder_process_single() won't return an error. */
569 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
570 == FLAC__STREAM_DECODER_ABORTED )
572 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
575 block_Release( p_sys->p_block );
576 p_sys->p_block = NULL;
579 return p_sys->p_aout_buffer;
582 /*****************************************************************************
583 * DecoderReadCallback: called by libflac when it needs more data
584 *****************************************************************************/
585 static FLAC__StreamDecoderReadStatus
586 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
587 unsigned *bytes, void *client_data )
589 decoder_t *p_dec = (decoder_t *)client_data;
590 decoder_sys_t *p_sys = p_dec->p_sys;
592 if( p_sys->p_block && p_sys->p_block->i_buffer )
594 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
595 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
596 p_sys->p_block->i_buffer -= *bytes;
597 p_sys->p_block->p_buffer += *bytes;
602 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
605 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
608 /*****************************************************************************
609 * DecoderWriteCallback: called by libflac to output decoded samples
610 *****************************************************************************/
611 static FLAC__StreamDecoderWriteStatus
612 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
613 const FLAC__Frame *frame,
614 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,
651 decoder_t *p_dec = (decoder_t *)client_data;
652 decoder_sys_t *p_sys = p_dec->p_sys;
654 if( p_dec->pf_decode_audio )
656 switch( metadata->data.stream_info.bits_per_sample )
659 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
662 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
665 msg_Dbg( p_dec, "strange bit/sample value: %d",
666 metadata->data.stream_info.bits_per_sample );
667 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
672 /* Setup the format */
673 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
674 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
675 p_dec->fmt_out.audio.i_physical_channels =
676 p_dec->fmt_out.audio.i_original_channels =
677 pi_channels_maps[metadata->data.stream_info.channels];
678 p_dec->fmt_out.audio.i_bitspersample =
679 metadata->data.stream_info.bits_per_sample;
681 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
683 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
684 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
685 p_dec->fmt_out.audio.i_bitspersample );
687 p_sys->b_stream_info = VLC_TRUE;
688 p_sys->stream_info = metadata->data.stream_info;
693 /*****************************************************************************
694 * DecoderErrorCallback: called when the libflac decoder encounters an error
695 *****************************************************************************/
696 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
697 FLAC__StreamDecoderErrorStatus status,
700 decoder_t *p_dec = (decoder_t *)client_data;
704 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
705 msg_Warn( p_dec, "an error in the stream caused the decoder to "
706 "lose synchronization." );
708 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
709 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
711 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
712 msg_Err( p_dec, "frame's data did not match the CRC in the "
716 msg_Err( p_dec, "got decoder error: %d", status );
719 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
723 /*****************************************************************************
724 * Interleave: helper function to interleave channels
725 *****************************************************************************/
726 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
727 int i_nb_channels, int i_samples )
730 for ( j = 0; j < i_samples; j++ )
732 for ( i = 0; i < i_nb_channels; i++ )
734 p_out[j * i_nb_channels + i] = pp_in[i][j];
738 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
739 int i_nb_channels, int i_samples )
742 for ( j = 0; j < i_samples; j++ )
744 for ( i = 0; i < i_nb_channels; i++ )
746 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
751 /*****************************************************************************
752 * decoder_state_error: print meaningful error messages
753 *****************************************************************************/
754 static void decoder_state_error( decoder_t *p_dec,
755 FLAC__StreamDecoderState state )
759 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
760 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
762 case FLAC__STREAM_DECODER_READ_METADATA:
763 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
764 "reading metadata." );
766 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
767 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
768 "searching for the frame sync code." );
770 case FLAC__STREAM_DECODER_READ_FRAME:
771 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
772 "reading a frame." );
774 case FLAC__STREAM_DECODER_END_OF_STREAM:
775 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
777 #ifdef USE_NEW_FLAC_API
778 case FLAC__STREAM_DECODER_OGG_ERROR:
779 msg_Err( p_dec, "error occurred in the Ogg layer." );
781 case FLAC__STREAM_DECODER_SEEK_ERROR:
782 msg_Err( p_dec, "error occurred while seeking." );
785 case FLAC__STREAM_DECODER_ABORTED:
786 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
788 #ifndef USE_NEW_FLAC_API
789 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
790 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
794 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
795 msg_Err( p_dec, "error when allocating memory." );
797 #ifndef USE_NEW_FLAC_API
798 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
799 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
800 "decoder was already initialized, usually because "
801 "FLAC__stream_decoder_finish() was not called." );
803 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
804 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
805 "all callbacks being set." );
808 case FLAC__STREAM_DECODER_UNINITIALIZED:
809 msg_Err( p_dec, "decoder in uninitialized state." );
812 msg_Warn(p_dec, "unknown error" );
817 /*****************************************************************************
818 * SyncInfo: parse FLAC sync info
819 *****************************************************************************/
820 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
821 unsigned int * pi_channels,
822 unsigned int * pi_channels_conf,
823 unsigned int * pi_sample_rate,
824 int * pi_bits_per_sample )
826 decoder_sys_t *p_sys = p_dec->p_sys;
827 int i_header, i_temp, i_read;
828 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
829 uint64_t i_sample_number = 0;
831 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
832 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
833 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
834 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
837 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
839 /* Check there is no emulated sync code in the rest of the header */
840 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
842 /* Find blocksize (framelength) */
843 switch( i_temp = p_buf[2] >> 4 )
846 if( b_fixed_blocksize )
847 i_blocksize = p_sys->stream_info.min_blocksize;
848 else return 0; /* We can't do anything with this */
859 i_blocksize = 576 << (i_temp - 2);
864 i_blocksize_hint = i_temp;
875 i_blocksize = 256 << (i_temp - 8);
879 /* Find samplerate */
880 switch( i_temp = p_buf[2] & 0x0f )
883 if( p_sys->b_stream_info )
884 *pi_sample_rate = p_sys->stream_info.sample_rate;
885 else return 0; /* We can't do anything with this */
895 *pi_sample_rate = 8000;
899 *pi_sample_rate = 16000;
903 *pi_sample_rate = 22050;
907 *pi_sample_rate = 24000;
911 *pi_sample_rate = 32000;
915 *pi_sample_rate = 44100;
919 *pi_sample_rate = 48000;
923 *pi_sample_rate = 96000;
929 i_sample_rate_hint = i_temp;
937 i_temp = (unsigned)(p_buf[3] >> 4);
941 int i_channel_assignment; /* ??? */
946 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
949 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
952 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
964 *pi_channels = i_temp + 1;
965 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
968 /* Find bits per sample */
969 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
972 if( p_sys->b_stream_info )
973 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
979 *pi_bits_per_sample = 8;
983 *pi_bits_per_sample = 12;
987 *pi_bits_per_sample = 16;
991 *pi_bits_per_sample = 20;
995 *pi_bits_per_sample = 24;
1004 /* Zero padding bit */
1005 if( p_buf[3] & 0x01 ) return 0;
1007 /* End of fixed size header */
1010 /* Find Sample/Frame number */
1011 if( i_blocksize_hint && b_variable_blocksize )
1013 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1014 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
1018 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1019 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
1021 if( p_sys->b_stream_info )
1022 i_sample_number *= p_sys->stream_info.min_blocksize;
1027 /* Read blocksize */
1028 if( i_blocksize_hint )
1030 int i_val1 = p_buf[i_header++];
1031 if( i_blocksize_hint == 7 )
1033 int i_val2 = p_buf[i_header++];
1034 i_val1 = (i_val1 << 8) | i_val2;
1036 i_blocksize = i_val1 + 1;
1039 /* Read sample rate */
1040 if( i_sample_rate_hint )
1042 int i_val1 = p_buf[i_header++];
1043 if( i_sample_rate_hint != 12 )
1045 int i_val2 = p_buf[i_header++];
1046 i_val1 = (i_val1 << 8) | i_val2;
1048 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1049 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1050 else *pi_sample_rate = i_val1 * 10;
1053 /* Check the CRC-8 byte */
1054 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1062 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1063 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1065 uint64_t i_result = 0;
1068 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1070 i_result = p_buf[0];
1073 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1075 i_result = p_buf[0] & 0x1F;
1078 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1080 i_result = p_buf[0] & 0x0F;
1083 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1085 i_result = p_buf[0] & 0x07;
1088 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1090 i_result = p_buf[0] & 0x03;
1093 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1095 i_result = p_buf[0] & 0x01;
1098 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1104 return I64C(0xffffffffffffffff);
1107 for( j = 1; j <= i; j++ )
1109 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1111 return I64C(0xffffffffffffffff);
1114 i_result |= (p_buf[j] & 0x3F);
1121 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1122 static uint8_t const flac_crc8_table[256] = {
1123 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1124 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1125 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1126 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1127 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1128 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1129 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1130 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1131 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1132 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1133 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1134 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1135 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1136 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1137 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1138 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1139 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1140 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1141 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1142 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1143 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1144 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1145 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1146 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1147 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1148 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1149 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1150 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1151 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1152 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1153 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1154 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1157 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1162 crc = flac_crc8_table[crc ^ *data++];
1168 /*****************************************************************************
1169 * encoder_sys_t : flac encoder descriptor
1170 *****************************************************************************/
1171 struct encoder_sys_t
1178 int i_samples_delay;
1181 FLAC__int32 *p_buffer;
1182 unsigned int i_buffer;
1189 FLAC__StreamEncoder *p_flac;
1190 FLAC__StreamMetadata_StreamInfo stream_info;
1198 #define STREAMINFO_SIZE 38
1200 static block_t *Encode( encoder_t *, aout_buffer_t * );
1202 static FLAC__StreamEncoderWriteStatus
1203 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1204 const FLAC__byte buffer[],
1205 unsigned bytes, unsigned samples,
1206 unsigned current_frame, void *client_data );
1208 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1209 const FLAC__StreamMetadata *metadata,
1210 void *client_data );
1212 /*****************************************************************************
1213 * OpenEncoder: probe the encoder and return score
1214 *****************************************************************************/
1215 static int OpenEncoder( vlc_object_t *p_this )
1217 encoder_t *p_enc = (encoder_t *)p_this;
1218 encoder_sys_t *p_sys;
1220 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1223 return VLC_EGENERIC;
1226 /* Allocate the memory needed to store the decoder's structure */
1227 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1229 msg_Err( p_enc, "out of memory" );
1230 return VLC_EGENERIC;
1232 p_enc->p_sys = p_sys;
1233 p_enc->pf_encode_audio = Encode;
1234 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1236 p_sys->i_headers = 0;
1237 p_sys->p_buffer = 0;
1238 p_sys->i_buffer = 0;
1239 p_sys->i_samples_delay = 0;
1241 /* Create flac encoder */
1242 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1244 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1246 return VLC_EGENERIC;
1249 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1250 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1251 p_enc->fmt_in.audio.i_channels );
1252 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1253 p_enc->fmt_in.audio.i_rate );
1254 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1255 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1257 /* Get and store the STREAMINFO metadata block as a p_extra */
1260 #ifdef USE_NEW_FLAC_API
1261 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1262 EncoderWriteCallback,
1265 EncoderMetadataCallback,
1267 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1269 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1270 FLAC__stream_encoder_delete( p_sys->p_flac );
1272 return VLC_EGENERIC;
1275 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1276 EncoderWriteCallback );
1277 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1278 EncoderMetadataCallback );
1279 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1281 FLAC__stream_encoder_init( p_sys->p_flac );
1287 /****************************************************************************
1288 * Encode: the whole thing
1289 ****************************************************************************
1290 * This function spits out ogg packets.
1291 ****************************************************************************/
1292 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1294 encoder_sys_t *p_sys = p_enc->p_sys;
1298 p_sys->i_pts = p_aout_buf->start_date -
1299 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1300 (mtime_t)p_enc->fmt_in.audio.i_rate;
1302 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1304 /* Convert samples to FLAC__int32 */
1305 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1308 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1309 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1312 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1314 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1317 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1318 p_aout_buf->i_nb_samples );
1320 p_chain = p_sys->p_chain;
1326 /*****************************************************************************
1327 * CloseEncoder: encoder destruction
1328 *****************************************************************************/
1329 static void CloseEncoder( vlc_object_t *p_this )
1331 encoder_t *p_enc = (encoder_t *)p_this;
1332 encoder_sys_t *p_sys = p_enc->p_sys;
1334 FLAC__stream_encoder_delete( p_sys->p_flac );
1336 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1340 /*****************************************************************************
1341 * EncoderMetadataCallback: called by libflac to output metadata
1342 *****************************************************************************/
1343 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1344 const FLAC__StreamMetadata *metadata,
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 encoder_t *p_enc = (encoder_t *)client_data;
1363 encoder_sys_t *p_sys = p_enc->p_sys;
1368 if( p_sys->i_headers == 1 )
1370 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1372 /* Backup the STREAMINFO metadata block */
1373 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1374 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1375 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1376 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1379 /* Fake this as the last metadata block */
1380 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1383 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1386 p_block = block_New( p_enc, bytes );
1387 memcpy( p_block->p_buffer, buffer, bytes );
1389 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1391 p_sys->i_samples_delay -= samples;
1393 p_block->i_length = (mtime_t)1000000 *
1394 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1397 p_sys->i_pts += p_block->i_length;
1399 block_ChainAppend( &p_sys->p_chain, p_block );
1401 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;