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 #if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT >= 8
45 # define USE_NEW_FLAC_API
48 /*****************************************************************************
49 * decoder_sys_t : FLAC decoder descriptor
50 *****************************************************************************/
58 block_bytestream_t bytestream;
61 * Input/Output properties
64 aout_buffer_t *p_aout_buffer;
70 FLAC__StreamDecoder *p_flac;
71 FLAC__StreamMetadata_StreamInfo stream_info;
75 unsigned min_blocksize, max_blocksize;
76 unsigned min_framesize, max_framesize;
79 unsigned bits_per_sample;
83 vlc_bool_t b_stream_info;
88 audio_date_t end_date;
91 int i_frame_size, i_frame_length, i_bits_per_sample;
92 unsigned int i_rate, i_channels, i_channels_conf;
105 static int pi_channels_maps[7] =
109 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
110 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
111 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
112 | AOUT_CHAN_REARRIGHT,
113 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
114 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
115 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
116 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
119 /*****************************************************************************
121 *****************************************************************************/
122 static int OpenDecoder ( vlc_object_t * );
123 static int OpenPacketizer( vlc_object_t * );
124 static void CloseDecoder ( vlc_object_t * );
127 static int OpenEncoder ( vlc_object_t * );
128 static void CloseEncoder ( vlc_object_t * );
132 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
134 static block_t *PacketizeBlock( decoder_t *, block_t ** );
136 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
137 unsigned int *,int * );
141 static FLAC__StreamDecoderReadStatus
142 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
143 FLAC__byte buffer[], unsigned *bytes, void *client_data );
145 static FLAC__StreamDecoderWriteStatus
146 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
147 const FLAC__Frame *frame,
148 const FLAC__int32 *const buffer[], void *client_data );
150 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
151 const FLAC__StreamMetadata *metadata,
153 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
154 FLAC__StreamDecoderErrorStatus status,
157 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
158 int i_nb_channels, int i_samples );
159 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
160 int i_nb_channels, int i_samples );
162 static void decoder_state_error( decoder_t *p_dec,
163 FLAC__StreamDecoderState state );
166 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
167 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
169 /*****************************************************************************
171 *****************************************************************************/
174 set_category( CAT_INPUT );
175 set_subcategory( SUBCAT_INPUT_ACODEC );
178 set_description( _("Flac audio decoder") );
179 set_capability( "decoder", 100 );
180 set_callbacks( OpenDecoder, CloseDecoder );
183 set_description( _("Flac audio encoder") );
184 set_capability( "encoder", 100 );
185 set_callbacks( OpenEncoder, CloseEncoder );
189 set_description( _("Flac audio packetizer") );
190 set_capability( "packetizer", 100 );
191 set_callbacks( OpenPacketizer, CloseDecoder );
193 add_shortcut( "flac" );
196 /*****************************************************************************
197 * OpenDecoder: probe the decoder and return score
198 *****************************************************************************/
199 static int OpenDecoder( vlc_object_t *p_this )
201 decoder_t *p_dec = (decoder_t*)p_this;
202 decoder_sys_t *p_sys;
204 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
209 /* Allocate the memory needed to store the decoder's structure */
210 if( ( p_dec->p_sys = p_sys =
211 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
213 msg_Err( p_dec, "out of memory" );
218 aout_DateSet( &p_sys->end_date, 0 );
219 p_sys->i_state = STATE_NOSYNC;
220 p_sys->b_stream_info = VLC_FALSE;
222 p_sys->bytestream = block_BytestreamInit( p_dec );
225 /* Take care of flac init */
226 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
228 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
233 #ifdef USE_NEW_FLAC_API
234 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
240 DecoderWriteCallback,
241 DecoderMetadataCallback,
242 DecoderErrorCallback,
244 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
246 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
247 FLAC__stream_decoder_delete( p_sys->p_flac );
252 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
253 DecoderReadCallback );
254 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
255 DecoderWriteCallback );
256 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
257 DecoderMetadataCallback );
258 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
259 DecoderErrorCallback );
260 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
262 FLAC__stream_decoder_init( p_sys->p_flac );
266 /* Set output properties */
267 p_dec->fmt_out.i_cat = AUDIO_ES;
268 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
272 p_dec->pf_decode_audio = DecodeBlock;
274 p_dec->pf_packetize = PacketizeBlock;
279 static int OpenPacketizer( vlc_object_t *p_this )
281 decoder_t *p_dec = (decoder_t*)p_this;
284 /* Hmmm, mem leak ?*/
285 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
287 i_ret = OpenDecoder( p_this );
289 /* Set output properties */
290 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
292 if( i_ret != VLC_SUCCESS ) return i_ret;
297 /*****************************************************************************
298 * CloseDecoder: flac decoder destruction
299 *****************************************************************************/
300 static void CloseDecoder( vlc_object_t *p_this )
302 decoder_t *p_dec = (decoder_t *)p_this;
303 decoder_sys_t *p_sys = p_dec->p_sys;
306 FLAC__stream_decoder_finish( p_sys->p_flac );
307 FLAC__stream_decoder_delete( p_sys->p_flac );
310 if( p_sys->p_block ) free( p_sys->p_block );
314 /*****************************************************************************
315 * ProcessHeader: process Flac header.
316 *****************************************************************************/
317 static void ProcessHeader( decoder_t *p_dec )
319 decoder_sys_t *p_sys = p_dec->p_sys;
322 if( !p_dec->fmt_in.i_extra ) return;
324 /* Decode STREAMINFO */
325 msg_Dbg( p_dec, "decode STREAMINFO" );
326 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
327 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
328 p_dec->fmt_in.i_extra );
329 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
330 msg_Dbg( p_dec, "STREAMINFO decoded" );
335 if( !p_dec->fmt_in.i_extra ) return;
337 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
339 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
340 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
342 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
343 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
345 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
346 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
347 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
350 if( !p_sys->b_stream_info ) return;
352 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
354 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
355 p_dec->fmt_out.p_extra =
356 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
357 memcpy( p_dec->fmt_out.p_extra,
358 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
362 /****************************************************************************
363 * PacketizeBlock: the whole thing
364 ****************************************************************************
365 * This function is called just after the thread is launched.
366 ****************************************************************************/
367 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
369 decoder_sys_t *p_sys = p_dec->p_sys;
370 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
371 block_t *p_sout_block;
373 if( !pp_block || !*pp_block ) return NULL;
375 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
377 if( p_sys->stream_info.channels > 6 )
379 msg_Err( p_dec, "This stream uses too many audio channels" );
383 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
385 /* We've just started the stream, wait for the first PTS. */
386 block_Release( *pp_block );
389 else if( !aout_DateGet( &p_sys->end_date ) )
391 /* The first PTS is as good as anything else. */
392 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
395 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
397 p_sys->i_state = STATE_NOSYNC;
400 block_BytestreamPush( &p_sys->bytestream, *pp_block );
404 switch( p_sys->i_state )
407 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
410 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
412 p_sys->i_state = STATE_SYNC;
415 block_SkipByte( &p_sys->bytestream );
417 if( p_sys->i_state != STATE_SYNC )
419 block_BytestreamFlush( &p_sys->bytestream );
426 /* New frame, set the Presentation Time Stamp */
427 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
428 if( p_sys->i_pts != 0 &&
429 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
431 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
433 p_sys->i_state = STATE_HEADER;
436 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
437 if( block_PeekBytes( &p_sys->bytestream, p_header,
438 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
444 /* Check if frame is valid and get frame info */
445 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
447 &p_sys->i_channels_conf,
449 &p_sys->i_bits_per_sample );
450 if( !p_sys->i_frame_length )
452 msg_Dbg( p_dec, "emulated sync word" );
453 block_SkipByte( &p_sys->bytestream );
454 p_sys->i_state = STATE_NOSYNC;
457 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
459 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
460 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
462 p_sys->i_state = STATE_NEXT_SYNC;
463 p_sys->i_frame_size = 1;
465 case STATE_NEXT_SYNC:
466 /* TODO: If pp_block == NULL, flush the buffer without checking the
469 /* Check if next expected frame contains the sync word */
470 while( block_PeekOffsetBytes( &p_sys->bytestream,
471 p_sys->i_frame_size, p_header,
472 MAX_FLAC_HEADER_SIZE )
475 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
477 /* Check if frame is valid and get frame info */
479 SyncInfo( p_dec, p_header,
481 &p_sys->i_channels_conf,
483 &p_sys->i_bits_per_sample );
487 p_sys->i_state = STATE_SEND_DATA;
491 p_sys->i_frame_size++;
494 if( p_sys->i_state != STATE_SEND_DATA )
500 case STATE_SEND_DATA:
501 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
503 /* Copy the whole frame into the buffer. When we reach this point
504 * we already know we have enough data available. */
505 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
506 p_sys->i_frame_size );
508 /* Make sure we don't reuse the same pts twice */
509 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
510 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
512 /* So p_block doesn't get re-added several times */
513 *pp_block = block_BytestreamPop( &p_sys->bytestream );
515 p_sys->i_state = STATE_NOSYNC;
517 /* Date management */
518 p_sout_block->i_pts =
519 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
520 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
521 p_sout_block->i_length =
522 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
532 /****************************************************************************
533 * DecodeBlock: the whole thing
534 ****************************************************************************/
535 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
537 decoder_sys_t *p_sys = p_dec->p_sys;
539 if( !pp_block || !*pp_block ) return NULL;
541 p_sys->p_aout_buffer = 0;
542 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
544 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
546 decoder_state_error( p_dec,
547 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
548 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
551 /* If the decoder is in the "aborted" state,
552 * FLAC__stream_decoder_process_single() won't return an error. */
553 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
554 == FLAC__STREAM_DECODER_ABORTED )
556 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
559 block_Release( p_sys->p_block );
560 p_sys->p_block = NULL;
563 return p_sys->p_aout_buffer;
566 /*****************************************************************************
567 * DecoderReadCallback: called by libflac when it needs more data
568 *****************************************************************************/
569 static FLAC__StreamDecoderReadStatus
570 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
571 unsigned *bytes, void *client_data )
573 decoder_t *p_dec = (decoder_t *)client_data;
574 decoder_sys_t *p_sys = p_dec->p_sys;
576 if( p_sys->p_block && p_sys->p_block->i_buffer )
578 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
579 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
580 p_sys->p_block->i_buffer -= *bytes;
581 p_sys->p_block->p_buffer += *bytes;
586 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
589 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
592 /*****************************************************************************
593 * DecoderWriteCallback: called by libflac to output decoded samples
594 *****************************************************************************/
595 static FLAC__StreamDecoderWriteStatus
596 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
597 const FLAC__Frame *frame,
598 const FLAC__int32 *const buffer[], void *client_data )
600 decoder_t *p_dec = (decoder_t *)client_data;
601 decoder_sys_t *p_sys = p_dec->p_sys;
603 p_sys->p_aout_buffer =
604 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
606 if( p_sys->p_aout_buffer == NULL )
607 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
609 switch( frame->header.bits_per_sample )
612 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
613 frame->header.channels, frame->header.blocksize );
616 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
617 frame->header.channels, frame->header.blocksize );
620 /* Date management (already done by packetizer) */
621 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
622 p_sys->p_aout_buffer->end_date =
623 p_sys->p_block->i_pts + p_sys->p_block->i_length;
625 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
628 /*****************************************************************************
629 * DecoderMetadataCallback: called by libflac to when it encounters metadata
630 *****************************************************************************/
631 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
632 const FLAC__StreamMetadata *metadata,
635 decoder_t *p_dec = (decoder_t *)client_data;
636 decoder_sys_t *p_sys = p_dec->p_sys;
638 switch( metadata->data.stream_info.bits_per_sample )
641 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
644 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
647 msg_Dbg( p_dec, "strange bit/sample value: %d",
648 metadata->data.stream_info.bits_per_sample );
649 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
653 /* Setup the format */
654 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
655 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
656 p_dec->fmt_out.audio.i_physical_channels =
657 p_dec->fmt_out.audio.i_original_channels =
658 pi_channels_maps[metadata->data.stream_info.channels];
659 p_dec->fmt_out.audio.i_bitspersample =
660 metadata->data.stream_info.bits_per_sample;
662 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
664 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
665 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
666 p_dec->fmt_out.audio.i_bitspersample );
668 p_sys->b_stream_info = VLC_TRUE;
669 p_sys->stream_info = metadata->data.stream_info;
674 /*****************************************************************************
675 * DecoderErrorCallback: called when the libflac decoder encounters an error
676 *****************************************************************************/
677 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
678 FLAC__StreamDecoderErrorStatus status,
681 decoder_t *p_dec = (decoder_t *)client_data;
685 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
686 msg_Warn( p_dec, "an error in the stream caused the decoder to "
687 "lose synchronization." );
689 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
690 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
692 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
693 msg_Err( p_dec, "frame's data did not match the CRC in the "
697 msg_Err( p_dec, "got decoder error: %d", status );
700 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
704 /*****************************************************************************
705 * Interleave: helper function to interleave channels
706 *****************************************************************************/
707 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
708 int i_nb_channels, int i_samples )
711 for ( j = 0; j < i_samples; j++ )
713 for ( i = 0; i < i_nb_channels; i++ )
715 p_out[j * i_nb_channels + i] = pp_in[i][j];
719 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
720 int i_nb_channels, int i_samples )
723 for ( j = 0; j < i_samples; j++ )
725 for ( i = 0; i < i_nb_channels; i++ )
727 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
732 /*****************************************************************************
733 * decoder_state_error: print meaningful error messages
734 *****************************************************************************/
735 static void decoder_state_error( decoder_t *p_dec,
736 FLAC__StreamDecoderState state )
740 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
741 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
743 case FLAC__STREAM_DECODER_READ_METADATA:
744 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
745 "reading metadata." );
747 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
748 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
749 "searching for the frame sync code." );
751 case FLAC__STREAM_DECODER_READ_FRAME:
752 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
753 "reading a frame." );
755 case FLAC__STREAM_DECODER_END_OF_STREAM:
756 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
758 #ifdef USE_NEW_FLAC_API
759 case FLAC__STREAM_DECODER_OGG_ERROR:
760 msg_Err( p_dec, "error occurred in the Ogg layer." );
762 case FLAC__STREAM_DECODER_SEEK_ERROR:
763 msg_Err( p_dec, "error occurred while seeking." );
766 case FLAC__STREAM_DECODER_ABORTED:
767 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
769 #ifndef USE_NEW_FLAC_API
770 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
771 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
775 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
776 msg_Err( p_dec, "error when allocating memory." );
778 #ifndef USE_NEW_FLAC_API
779 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
780 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
781 "decoder was already initialized, usually because "
782 "FLAC__stream_decoder_finish() was not called." );
784 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
785 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
786 "all callbacks being set." );
789 case FLAC__STREAM_DECODER_UNINITIALIZED:
790 msg_Err( p_dec, "decoder in uninitialized state." );
793 msg_Warn(p_dec, "unknown error" );
798 /*****************************************************************************
799 * SyncInfo: parse FLAC sync info
800 *****************************************************************************/
801 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
802 unsigned int * pi_channels,
803 unsigned int * pi_channels_conf,
804 unsigned int * pi_sample_rate,
805 int * pi_bits_per_sample )
807 decoder_sys_t *p_sys = p_dec->p_sys;
808 int i_header, i_temp, i_read;
809 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
810 uint64_t i_sample_number = 0;
812 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
813 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
814 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
815 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
818 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
820 /* Check there is no emulated sync code in the rest of the header */
821 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
823 /* Find blocksize (framelength) */
824 switch( i_temp = p_buf[2] >> 4 )
827 if( b_fixed_blocksize )
828 i_blocksize = p_sys->stream_info.min_blocksize;
829 else return 0; /* We can't do anything with this */
840 i_blocksize = 576 << (i_temp - 2);
845 i_blocksize_hint = i_temp;
856 i_blocksize = 256 << (i_temp - 8);
860 /* Find samplerate */
861 switch( i_temp = p_buf[2] & 0x0f )
864 if( p_sys->b_stream_info )
865 *pi_sample_rate = p_sys->stream_info.sample_rate;
866 else return 0; /* We can't do anything with this */
876 *pi_sample_rate = 8000;
880 *pi_sample_rate = 16000;
884 *pi_sample_rate = 22050;
888 *pi_sample_rate = 24000;
892 *pi_sample_rate = 32000;
896 *pi_sample_rate = 44100;
900 *pi_sample_rate = 48000;
904 *pi_sample_rate = 96000;
910 i_sample_rate_hint = i_temp;
918 i_temp = (unsigned)(p_buf[3] >> 4);
922 int i_channel_assignment; /* ??? */
927 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
930 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
933 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
945 *pi_channels = i_temp + 1;
946 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
949 /* Find bits per sample */
950 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
953 if( p_sys->b_stream_info )
954 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
960 *pi_bits_per_sample = 8;
964 *pi_bits_per_sample = 12;
968 *pi_bits_per_sample = 16;
972 *pi_bits_per_sample = 20;
976 *pi_bits_per_sample = 24;
985 /* Zero padding bit */
986 if( p_buf[3] & 0x01 ) return 0;
988 /* End of fixed size header */
991 /* Find Sample/Frame number */
992 if( i_blocksize_hint && b_variable_blocksize )
994 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
995 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
999 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1000 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
1002 if( p_sys->b_stream_info )
1003 i_sample_number *= p_sys->stream_info.min_blocksize;
1008 /* Read blocksize */
1009 if( i_blocksize_hint )
1011 int i_val1 = p_buf[i_header++];
1012 if( i_blocksize_hint == 7 )
1014 int i_val2 = p_buf[i_header++];
1015 i_val1 = (i_val1 << 8) | i_val2;
1017 i_blocksize = i_val1 + 1;
1020 /* Read sample rate */
1021 if( i_sample_rate_hint )
1023 int i_val1 = p_buf[i_header++];
1024 if( i_sample_rate_hint != 12 )
1026 int i_val2 = p_buf[i_header++];
1027 i_val1 = (i_val1 << 8) | i_val2;
1029 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1030 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1031 else *pi_sample_rate = i_val1 * 10;
1034 /* Check the CRC-8 byte */
1035 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1043 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1044 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1046 uint64_t i_result = 0;
1049 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1051 i_result = p_buf[0];
1054 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1056 i_result = p_buf[0] & 0x1F;
1059 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1061 i_result = p_buf[0] & 0x0F;
1064 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1066 i_result = p_buf[0] & 0x07;
1069 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1071 i_result = p_buf[0] & 0x03;
1074 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1076 i_result = p_buf[0] & 0x01;
1079 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1085 return I64C(0xffffffffffffffff);
1088 for( j = 1; j <= i; j++ )
1090 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1092 return I64C(0xffffffffffffffff);
1095 i_result |= (p_buf[j] & 0x3F);
1102 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1103 static uint8_t const flac_crc8_table[256] = {
1104 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1105 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1106 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1107 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1108 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1109 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1110 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1111 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1112 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1113 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1114 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1115 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1116 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1117 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1118 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1119 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1120 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1121 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1122 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1123 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1124 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1125 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1126 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1127 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1128 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1129 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1130 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1131 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1132 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1133 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1134 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1135 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1138 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1143 crc = flac_crc8_table[crc ^ *data++];
1149 /*****************************************************************************
1150 * encoder_sys_t : flac encoder descriptor
1151 *****************************************************************************/
1152 struct encoder_sys_t
1159 int i_samples_delay;
1162 FLAC__int32 *p_buffer;
1163 unsigned int i_buffer;
1170 FLAC__StreamEncoder *p_flac;
1171 FLAC__StreamMetadata_StreamInfo stream_info;
1179 #define STREAMINFO_SIZE 38
1181 static block_t *Encode( encoder_t *, aout_buffer_t * );
1183 static FLAC__StreamEncoderWriteStatus
1184 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1185 const FLAC__byte buffer[],
1186 unsigned bytes, unsigned samples,
1187 unsigned current_frame, void *client_data );
1189 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1190 const FLAC__StreamMetadata *metadata,
1191 void *client_data );
1193 /*****************************************************************************
1194 * OpenEncoder: probe the encoder and return score
1195 *****************************************************************************/
1196 static int OpenEncoder( vlc_object_t *p_this )
1198 encoder_t *p_enc = (encoder_t *)p_this;
1199 encoder_sys_t *p_sys;
1201 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1204 return VLC_EGENERIC;
1207 /* Allocate the memory needed to store the decoder's structure */
1208 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1210 msg_Err( p_enc, "out of memory" );
1211 return VLC_EGENERIC;
1213 p_enc->p_sys = p_sys;
1214 p_enc->pf_encode_audio = Encode;
1215 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1217 p_sys->i_headers = 0;
1218 p_sys->p_buffer = 0;
1219 p_sys->i_buffer = 0;
1220 p_sys->i_samples_delay = 0;
1222 /* Create flac encoder */
1223 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1225 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1227 return VLC_EGENERIC;
1230 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1231 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1232 p_enc->fmt_in.audio.i_channels );
1233 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1234 p_enc->fmt_in.audio.i_rate );
1235 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1236 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1238 /* Get and store the STREAMINFO metadata block as a p_extra */
1241 #ifdef USE_NEW_FLAC_API
1242 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1243 EncoderWriteCallback,
1246 EncoderMetadataCallback,
1248 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1250 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1251 FLAC__stream_encoder_delete( p_sys->p_flac );
1253 return VLC_EGENERIC;
1256 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1257 EncoderWriteCallback );
1258 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1259 EncoderMetadataCallback );
1260 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1262 FLAC__stream_encoder_init( p_sys->p_flac );
1268 /****************************************************************************
1269 * Encode: the whole thing
1270 ****************************************************************************
1271 * This function spits out ogg packets.
1272 ****************************************************************************/
1273 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1275 encoder_sys_t *p_sys = p_enc->p_sys;
1279 p_sys->i_pts = p_aout_buf->start_date -
1280 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1281 (mtime_t)p_enc->fmt_in.audio.i_rate;
1283 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1285 /* Convert samples to FLAC__int32 */
1286 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1289 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1290 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1293 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1295 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1298 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1299 p_aout_buf->i_nb_samples );
1301 p_chain = p_sys->p_chain;
1307 /*****************************************************************************
1308 * CloseEncoder: encoder destruction
1309 *****************************************************************************/
1310 static void CloseEncoder( vlc_object_t *p_this )
1312 encoder_t *p_enc = (encoder_t *)p_this;
1313 encoder_sys_t *p_sys = p_enc->p_sys;
1315 FLAC__stream_encoder_delete( p_sys->p_flac );
1317 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1321 /*****************************************************************************
1322 * EncoderMetadataCallback: called by libflac to output metadata
1323 *****************************************************************************/
1324 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1325 const FLAC__StreamMetadata *metadata,
1328 encoder_t *p_enc = (encoder_t *)client_data;
1330 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1334 /*****************************************************************************
1335 * EncoderWriteCallback: called by libflac to output encoded samples
1336 *****************************************************************************/
1337 static FLAC__StreamEncoderWriteStatus
1338 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1339 const FLAC__byte buffer[],
1340 unsigned bytes, unsigned samples,
1341 unsigned current_frame, void *client_data )
1343 encoder_t *p_enc = (encoder_t *)client_data;
1344 encoder_sys_t *p_sys = p_enc->p_sys;
1349 if( p_sys->i_headers == 1 )
1351 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1353 /* Backup the STREAMINFO metadata block */
1354 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1355 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1356 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1357 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1360 /* Fake this as the last metadata block */
1361 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1364 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1367 p_block = block_New( p_enc, bytes );
1368 memcpy( p_block->p_buffer, buffer, bytes );
1370 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1372 p_sys->i_samples_delay -= samples;
1374 p_block->i_length = (mtime_t)1000000 *
1375 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1378 p_sys->i_pts += p_block->i_length;
1380 block_ChainAppend( &p_sys->p_chain, p_block );
1382 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;