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 const 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 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
412 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
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 )
590 decoder_t *p_dec = (decoder_t *)client_data;
591 decoder_sys_t *p_sys = p_dec->p_sys;
593 if( p_sys->p_block && p_sys->p_block->i_buffer )
595 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
596 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
597 p_sys->p_block->i_buffer -= *bytes;
598 p_sys->p_block->p_buffer += *bytes;
603 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
606 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
609 /*****************************************************************************
610 * DecoderWriteCallback: called by libflac to output decoded samples
611 *****************************************************************************/
612 static FLAC__StreamDecoderWriteStatus
613 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
614 const FLAC__Frame *frame,
615 const FLAC__int32 *const buffer[], void *client_data )
618 decoder_t *p_dec = (decoder_t *)client_data;
619 decoder_sys_t *p_sys = p_dec->p_sys;
621 p_sys->p_aout_buffer =
622 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
624 if( p_sys->p_aout_buffer == NULL )
625 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
627 switch( frame->header.bits_per_sample )
630 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
631 frame->header.channels, frame->header.blocksize );
634 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
635 frame->header.channels, frame->header.blocksize );
638 /* Date management (already done by packetizer) */
639 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
640 p_sys->p_aout_buffer->end_date =
641 p_sys->p_block->i_pts + p_sys->p_block->i_length;
643 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
646 /*****************************************************************************
647 * DecoderMetadataCallback: called by libflac to when it encounters metadata
648 *****************************************************************************/
649 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
650 const FLAC__StreamMetadata *metadata,
654 decoder_t *p_dec = (decoder_t *)client_data;
655 decoder_sys_t *p_sys = p_dec->p_sys;
657 if( p_dec->pf_decode_audio )
659 switch( metadata->data.stream_info.bits_per_sample )
662 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
665 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
668 msg_Dbg( p_dec, "strange bit/sample value: %d",
669 metadata->data.stream_info.bits_per_sample );
670 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
675 /* Setup the format */
676 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
677 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
678 p_dec->fmt_out.audio.i_physical_channels =
679 p_dec->fmt_out.audio.i_original_channels =
680 pi_channels_maps[metadata->data.stream_info.channels];
681 p_dec->fmt_out.audio.i_bitspersample =
682 metadata->data.stream_info.bits_per_sample;
684 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
686 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
687 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
688 p_dec->fmt_out.audio.i_bitspersample );
690 p_sys->b_stream_info = true;
691 p_sys->stream_info = metadata->data.stream_info;
696 /*****************************************************************************
697 * DecoderErrorCallback: called when the libflac decoder encounters an error
698 *****************************************************************************/
699 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
700 FLAC__StreamDecoderErrorStatus status,
704 decoder_t *p_dec = (decoder_t *)client_data;
708 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
709 msg_Warn( p_dec, "an error in the stream caused the decoder to "
710 "lose synchronization." );
712 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
713 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
715 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
716 msg_Err( p_dec, "frame's data did not match the CRC in the "
720 msg_Err( p_dec, "got decoder error: %d", status );
723 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
727 /*****************************************************************************
728 * Interleave: helper function to interleave channels
729 *****************************************************************************/
730 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
731 int i_nb_channels, int i_samples )
734 for ( j = 0; j < i_samples; j++ )
736 for ( i = 0; i < i_nb_channels; i++ )
738 p_out[j * i_nb_channels + i] = pp_in[i][j];
742 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
743 int i_nb_channels, int i_samples )
746 for ( j = 0; j < i_samples; j++ )
748 for ( i = 0; i < i_nb_channels; i++ )
750 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
755 /*****************************************************************************
756 * decoder_state_error: print meaningful error messages
757 *****************************************************************************/
758 static void decoder_state_error( decoder_t *p_dec,
759 FLAC__StreamDecoderState state )
763 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
764 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
766 case FLAC__STREAM_DECODER_READ_METADATA:
767 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
768 "reading metadata." );
770 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
771 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
772 "searching for the frame sync code." );
774 case FLAC__STREAM_DECODER_READ_FRAME:
775 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
776 "reading a frame." );
778 case FLAC__STREAM_DECODER_END_OF_STREAM:
779 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
781 #ifdef USE_NEW_FLAC_API
782 case FLAC__STREAM_DECODER_OGG_ERROR:
783 msg_Err( p_dec, "error occurred in the Ogg layer." );
785 case FLAC__STREAM_DECODER_SEEK_ERROR:
786 msg_Err( p_dec, "error occurred while seeking." );
789 case FLAC__STREAM_DECODER_ABORTED:
790 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
792 #ifndef USE_NEW_FLAC_API
793 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
794 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
798 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
799 msg_Err( p_dec, "error when allocating memory." );
801 #ifndef USE_NEW_FLAC_API
802 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
803 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
804 "decoder was already initialized, usually because "
805 "FLAC__stream_decoder_finish() was not called." );
807 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
808 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
809 "all callbacks being set." );
812 case FLAC__STREAM_DECODER_UNINITIALIZED:
813 msg_Err( p_dec, "decoder in uninitialized state." );
816 msg_Warn(p_dec, "unknown error" );
821 /*****************************************************************************
822 * SyncInfo: parse FLAC sync info
823 *****************************************************************************/
824 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
825 unsigned int * pi_channels,
826 unsigned int * pi_channels_conf,
827 unsigned int * pi_sample_rate,
828 int * pi_bits_per_sample )
830 decoder_sys_t *p_sys = p_dec->p_sys;
831 int i_header, i_temp, i_read;
832 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
833 uint64_t i_sample_number = 0;
835 bool b_variable_blocksize = ( p_sys->b_stream_info &&
836 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
837 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
838 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
841 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
843 /* Check there is no emulated sync code in the rest of the header */
844 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
846 /* Find blocksize (framelength) */
847 switch( i_temp = p_buf[2] >> 4 )
850 if( b_fixed_blocksize )
851 i_blocksize = p_sys->stream_info.min_blocksize;
852 else return 0; /* We can't do anything with this */
863 i_blocksize = 576 << (i_temp - 2);
868 i_blocksize_hint = i_temp;
879 i_blocksize = 256 << (i_temp - 8);
883 /* Find samplerate */
884 switch( i_temp = p_buf[2] & 0x0f )
887 if( p_sys->b_stream_info )
888 *pi_sample_rate = p_sys->stream_info.sample_rate;
889 else return 0; /* We can't do anything with this */
899 *pi_sample_rate = 8000;
903 *pi_sample_rate = 16000;
907 *pi_sample_rate = 22050;
911 *pi_sample_rate = 24000;
915 *pi_sample_rate = 32000;
919 *pi_sample_rate = 44100;
923 *pi_sample_rate = 48000;
927 *pi_sample_rate = 96000;
933 i_sample_rate_hint = i_temp;
941 i_temp = (unsigned)(p_buf[3] >> 4);
945 int i_channel_assignment; /* ??? */
950 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
953 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
956 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
968 *pi_channels = i_temp + 1;
969 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
972 /* Find bits per sample */
973 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
976 if( p_sys->b_stream_info )
977 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
983 *pi_bits_per_sample = 8;
987 *pi_bits_per_sample = 12;
991 *pi_bits_per_sample = 16;
995 *pi_bits_per_sample = 20;
999 *pi_bits_per_sample = 24;
1008 /* Zero padding bit */
1009 if( p_buf[3] & 0x01 ) return 0;
1011 /* End of fixed size header */
1014 /* Find Sample/Frame number */
1015 if( i_blocksize_hint && b_variable_blocksize )
1017 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1018 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1022 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1023 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1025 if( p_sys->b_stream_info )
1026 i_sample_number *= p_sys->stream_info.min_blocksize;
1031 /* Read blocksize */
1032 if( i_blocksize_hint )
1034 int i_val1 = p_buf[i_header++];
1035 if( i_blocksize_hint == 7 )
1037 int i_val2 = p_buf[i_header++];
1038 i_val1 = (i_val1 << 8) | i_val2;
1040 i_blocksize = i_val1 + 1;
1043 /* Read sample rate */
1044 if( i_sample_rate_hint )
1046 int i_val1 = p_buf[i_header++];
1047 if( i_sample_rate_hint != 12 )
1049 int i_val2 = p_buf[i_header++];
1050 i_val1 = (i_val1 << 8) | i_val2;
1052 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1053 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1054 else *pi_sample_rate = i_val1 * 10;
1057 /* Check the CRC-8 byte */
1058 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1063 /* Sanity check using stream info header when possible */
1064 if( p_sys->b_stream_info )
1066 if( i_blocksize < p_sys->stream_info.min_blocksize ||
1067 i_blocksize > p_sys->stream_info.max_blocksize )
1073 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1074 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1076 uint64_t i_result = 0;
1079 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1081 i_result = p_buf[0];
1084 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1086 i_result = p_buf[0] & 0x1F;
1089 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1091 i_result = p_buf[0] & 0x0F;
1094 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1096 i_result = p_buf[0] & 0x07;
1099 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1101 i_result = p_buf[0] & 0x03;
1104 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1106 i_result = p_buf[0] & 0x01;
1109 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1115 return INT64_C(0xffffffffffffffff);
1118 for( j = 1; j <= i; j++ )
1120 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1122 return INT64_C(0xffffffffffffffff);
1125 i_result |= (p_buf[j] & 0x3F);
1132 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1133 static const uint8_t flac_crc8_table[256] = {
1134 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1135 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1136 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1137 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1138 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1139 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1140 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1141 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1142 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1143 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1144 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1145 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1146 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1147 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1148 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1149 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1150 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1151 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1152 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1153 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1154 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1155 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1156 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1157 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1158 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1159 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1160 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1161 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1162 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1163 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1164 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1165 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1168 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1173 crc = flac_crc8_table[crc ^ *data++];
1179 /*****************************************************************************
1180 * encoder_sys_t : flac encoder descriptor
1181 *****************************************************************************/
1182 struct encoder_sys_t
1189 int i_samples_delay;
1192 FLAC__int32 *p_buffer;
1193 unsigned int i_buffer;
1200 FLAC__StreamEncoder *p_flac;
1201 FLAC__StreamMetadata_StreamInfo stream_info;
1209 #define STREAMINFO_SIZE 38
1211 static block_t *Encode( encoder_t *, aout_buffer_t * );
1213 static FLAC__StreamEncoderWriteStatus
1214 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1215 const FLAC__byte buffer[],
1216 unsigned bytes, unsigned samples,
1217 unsigned current_frame, void *client_data );
1219 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1220 const FLAC__StreamMetadata *metadata,
1221 void *client_data );
1223 /*****************************************************************************
1224 * OpenEncoder: probe the encoder and return score
1225 *****************************************************************************/
1226 static int OpenEncoder( vlc_object_t *p_this )
1228 encoder_t *p_enc = (encoder_t *)p_this;
1229 encoder_sys_t *p_sys;
1231 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1234 return VLC_EGENERIC;
1237 /* Allocate the memory needed to store the decoder's structure */
1238 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1240 p_enc->p_sys = p_sys;
1241 p_enc->pf_encode_audio = Encode;
1242 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1244 p_sys->i_headers = 0;
1245 p_sys->p_buffer = 0;
1246 p_sys->i_buffer = 0;
1247 p_sys->i_samples_delay = 0;
1249 /* Create flac encoder */
1250 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1252 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1254 return VLC_EGENERIC;
1257 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1258 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1259 p_enc->fmt_in.audio.i_channels );
1260 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1261 p_enc->fmt_in.audio.i_rate );
1262 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1263 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1265 /* Get and store the STREAMINFO metadata block as a p_extra */
1268 #ifdef USE_NEW_FLAC_API
1269 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1270 EncoderWriteCallback,
1273 EncoderMetadataCallback,
1275 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1277 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1278 FLAC__stream_encoder_delete( p_sys->p_flac );
1280 return VLC_EGENERIC;
1283 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1284 EncoderWriteCallback );
1285 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1286 EncoderMetadataCallback );
1287 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1289 FLAC__stream_encoder_init( p_sys->p_flac );
1295 /****************************************************************************
1296 * Encode: the whole thing
1297 ****************************************************************************
1298 * This function spits out ogg packets.
1299 ****************************************************************************/
1300 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1302 encoder_sys_t *p_sys = p_enc->p_sys;
1306 p_sys->i_pts = p_aout_buf->start_date -
1307 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1308 (mtime_t)p_enc->fmt_in.audio.i_rate;
1310 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1312 /* Convert samples to FLAC__int32 */
1313 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1316 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1317 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1320 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1322 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1325 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1326 p_aout_buf->i_nb_samples );
1328 p_chain = p_sys->p_chain;
1334 /*****************************************************************************
1335 * CloseEncoder: encoder destruction
1336 *****************************************************************************/
1337 static void CloseEncoder( vlc_object_t *p_this )
1339 encoder_t *p_enc = (encoder_t *)p_this;
1340 encoder_sys_t *p_sys = p_enc->p_sys;
1342 FLAC__stream_encoder_delete( p_sys->p_flac );
1344 free( p_sys->p_buffer );
1348 /*****************************************************************************
1349 * EncoderMetadataCallback: called by libflac to output metadata
1350 *****************************************************************************/
1351 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1352 const FLAC__StreamMetadata *metadata,
1355 VLC_UNUSED(encoder);
1356 encoder_t *p_enc = (encoder_t *)client_data;
1358 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1362 /*****************************************************************************
1363 * EncoderWriteCallback: called by libflac to output encoded samples
1364 *****************************************************************************/
1365 static FLAC__StreamEncoderWriteStatus
1366 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1367 const FLAC__byte buffer[],
1368 unsigned bytes, unsigned samples,
1369 unsigned current_frame, void *client_data )
1371 VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
1372 encoder_t *p_enc = (encoder_t *)client_data;
1373 encoder_sys_t *p_sys = p_enc->p_sys;
1378 if( p_sys->i_headers == 1 )
1380 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1382 /* Backup the STREAMINFO metadata block */
1383 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1384 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1385 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1386 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1389 /* Fake this as the last metadata block */
1390 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1393 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1396 p_block = block_New( p_enc, bytes );
1397 memcpy( p_block->p_buffer, buffer, bytes );
1399 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1401 p_sys->i_samples_delay -= samples;
1403 p_block->i_length = (mtime_t)1000000 *
1404 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1407 p_sys->i_pts += p_block->i_length;
1409 block_ChainAppend( &p_sys->p_chain, p_block );
1411 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;