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;
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 const int *pi_order, int i_nb_channels, int i_samples );
164 static void Interleave24( int8_t *p_out, const int32_t * const *pp_in,
165 const int *pi_order, int i_nb_channels, int i_samples );
166 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
167 const int *pi_order, int i_nb_channels, int i_samples );
169 static void decoder_state_error( decoder_t *p_dec,
170 FLAC__StreamDecoderState state );
173 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
174 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
176 /*****************************************************************************
178 *****************************************************************************/
181 set_category( CAT_INPUT )
182 set_subcategory( SUBCAT_INPUT_ACODEC )
183 add_shortcut( "flac" )
186 set_description( N_("Flac audio decoder") )
187 set_capability( "decoder", 100 )
188 set_callbacks( OpenDecoder, CloseDecoder )
191 add_shortcut( "flac" )
192 set_description( N_("Flac audio encoder") )
193 set_capability( "encoder", 100 )
194 set_callbacks( OpenEncoder, CloseEncoder )
197 add_shortcut( "flac" )
199 set_description( N_("Flac audio packetizer") )
200 set_capability( "packetizer", 100 )
201 set_callbacks( OpenPacketizer, CloseDecoder )
205 /*****************************************************************************
206 * OpenDecoder: probe the decoder and return score
207 *****************************************************************************/
208 static int OpenDecoder( vlc_object_t *p_this )
210 decoder_t *p_dec = (decoder_t*)p_this;
211 decoder_sys_t *p_sys;
213 if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
218 /* Allocate the memory needed to store the decoder's structure */
219 if( ( p_dec->p_sys = p_sys = malloc(sizeof(*p_sys)) ) == NULL )
223 date_Set( &p_sys->end_date, 0 );
224 p_sys->i_state = STATE_NOSYNC;
225 p_sys->b_stream_info = false;
227 p_sys->bytestream = block_BytestreamInit();
230 /* Take care of flac init */
231 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
233 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
238 #ifdef USE_NEW_FLAC_API
239 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
245 DecoderWriteCallback,
246 DecoderMetadataCallback,
247 DecoderErrorCallback,
249 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
251 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
252 FLAC__stream_decoder_delete( p_sys->p_flac );
257 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
258 DecoderReadCallback );
259 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
260 DecoderWriteCallback );
261 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
262 DecoderMetadataCallback );
263 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
264 DecoderErrorCallback );
265 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
267 FLAC__stream_decoder_init( p_sys->p_flac );
271 /* Set output properties */
272 p_dec->fmt_out.i_cat = AUDIO_ES;
273 p_dec->fmt_out.i_codec = VLC_CODEC_FL32;
277 p_dec->pf_decode_audio = DecodeBlock;
283 static int OpenPacketizer( vlc_object_t *p_this )
285 decoder_t *p_dec = (decoder_t*)p_this;
286 es_format_t es_save = p_dec->fmt_out;
290 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
292 i_ret = OpenDecoder( p_this );
293 p_dec->pf_decode_audio = NULL;
294 p_dec->pf_packetize = PacketizeBlock;
296 /* Set output properties */
297 p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
299 if( i_ret != VLC_SUCCESS )
301 es_format_Clean( &p_dec->fmt_out );
302 p_dec->fmt_out = es_save;
307 /*****************************************************************************
308 * CloseDecoder: flac decoder destruction
309 *****************************************************************************/
310 static void CloseDecoder( vlc_object_t *p_this )
312 decoder_t *p_dec = (decoder_t *)p_this;
313 decoder_sys_t *p_sys = p_dec->p_sys;
316 FLAC__stream_decoder_finish( p_sys->p_flac );
317 FLAC__stream_decoder_delete( p_sys->p_flac );
320 free( p_sys->p_block );
324 /*****************************************************************************
325 * ProcessHeader: process Flac header.
326 *****************************************************************************/
327 static void ProcessHeader( decoder_t *p_dec )
329 decoder_sys_t *p_sys = p_dec->p_sys;
332 if( !p_dec->fmt_in.i_extra ) return;
334 /* Decode STREAMINFO */
335 msg_Dbg( p_dec, "decode STREAMINFO" );
336 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
337 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
338 p_dec->fmt_in.i_extra );
339 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
340 msg_Dbg( p_dec, "STREAMINFO decoded" );
345 if( !p_dec->fmt_in.i_extra ) return;
347 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
349 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
350 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
352 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
353 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
355 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
356 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
357 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
360 if( !p_sys->b_stream_info ) return;
362 if( p_dec->fmt_out.i_codec == VLC_CODEC_FLAC )
364 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
365 p_dec->fmt_out.p_extra =
366 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
367 memcpy( p_dec->fmt_out.p_extra,
368 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
372 /****************************************************************************
373 * PacketizeBlock: the whole thing
374 ****************************************************************************
375 * This function is called just after the thread is launched.
376 ****************************************************************************/
377 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
379 decoder_sys_t *p_sys = p_dec->p_sys;
380 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
381 block_t *p_sout_block;
383 if( !pp_block || !*pp_block ) return NULL;
385 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
387 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
389 p_sys->i_state = STATE_NOSYNC;
390 block_BytestreamEmpty( &p_sys->bytestream );
392 date_Set( &p_sys->end_date, 0 );
393 block_Release( *pp_block );
397 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
399 if( p_sys->stream_info.channels > 6 )
401 msg_Err( p_dec, "This stream uses too many audio channels" );
405 if( !date_Get( &p_sys->end_date ) && !(*pp_block)->i_pts )
407 /* We've just started the stream, wait for the first PTS. */
408 block_Release( *pp_block );
411 else if( !date_Get( &p_sys->end_date ) )
413 /* The first PTS is as good as anything else. */
414 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
415 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
416 date_Set( &p_sys->end_date, (*pp_block)->i_pts );
419 block_BytestreamPush( &p_sys->bytestream, *pp_block );
423 switch( p_sys->i_state )
426 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
429 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
431 p_sys->i_state = STATE_SYNC;
434 block_SkipByte( &p_sys->bytestream );
436 if( p_sys->i_state != STATE_SYNC )
438 block_BytestreamFlush( &p_sys->bytestream );
445 /* New frame, set the Presentation Time Stamp */
446 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
447 if( p_sys->i_pts != 0 &&
448 p_sys->i_pts != date_Get( &p_sys->end_date ) )
450 date_Set( &p_sys->end_date, p_sys->i_pts );
452 p_sys->i_state = STATE_HEADER;
455 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
456 if( block_PeekBytes( &p_sys->bytestream, p_header,
457 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
463 /* Check if frame is valid and get frame info */
464 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
466 &p_sys->i_channels_conf,
468 &p_sys->i_bits_per_sample );
469 if( !p_sys->i_frame_length )
471 msg_Dbg( p_dec, "emulated sync word" );
472 block_SkipByte( &p_sys->bytestream );
473 p_sys->i_state = STATE_NOSYNC;
476 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
478 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
479 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
481 p_sys->i_state = STATE_NEXT_SYNC;
482 p_sys->i_frame_size = 1;
484 case STATE_NEXT_SYNC:
485 /* TODO: If pp_block == NULL, flush the buffer without checking the
488 /* Check if next expected frame contains the sync word */
489 while( block_PeekOffsetBytes( &p_sys->bytestream,
490 p_sys->i_frame_size, p_header,
491 MAX_FLAC_HEADER_SIZE )
494 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
496 /* Check if frame is valid and get frame info */
498 SyncInfo( p_dec, p_header,
500 &p_sys->i_channels_conf,
502 &p_sys->i_bits_per_sample );
506 p_sys->i_state = STATE_SEND_DATA;
510 p_sys->i_frame_size++;
513 if( p_sys->i_state != STATE_SEND_DATA )
519 case STATE_SEND_DATA:
520 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
522 /* Copy the whole frame into the buffer. When we reach this point
523 * we already know we have enough data available. */
524 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
525 p_sys->i_frame_size );
527 /* Make sure we don't reuse the same pts twice */
528 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
529 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
531 /* So p_block doesn't get re-added several times */
532 *pp_block = block_BytestreamPop( &p_sys->bytestream );
534 p_sys->i_state = STATE_NOSYNC;
536 /* Date management */
537 p_sout_block->i_pts =
538 p_sout_block->i_dts = date_Get( &p_sys->end_date );
539 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
540 p_sout_block->i_length =
541 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
551 /****************************************************************************
552 * DecodeBlock: the whole thing
553 ****************************************************************************/
554 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
556 decoder_sys_t *p_sys = p_dec->p_sys;
558 if( !pp_block || !*pp_block ) return NULL;
560 p_sys->p_aout_buffer = 0;
561 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
563 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
565 decoder_state_error( p_dec,
566 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
567 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
570 /* If the decoder is in the "aborted" state,
571 * FLAC__stream_decoder_process_single() won't return an error. */
572 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
573 == FLAC__STREAM_DECODER_ABORTED )
575 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
578 block_Release( p_sys->p_block );
579 p_sys->p_block = NULL;
582 return p_sys->p_aout_buffer;
585 /*****************************************************************************
586 * DecoderReadCallback: called by libflac when it needs more data
587 *****************************************************************************/
588 static FLAC__StreamDecoderReadStatus
589 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
590 unsigned *bytes, void *client_data )
593 decoder_t *p_dec = (decoder_t *)client_data;
594 decoder_sys_t *p_sys = p_dec->p_sys;
596 if( p_sys->p_block && p_sys->p_block->i_buffer )
598 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
599 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
600 p_sys->p_block->i_buffer -= *bytes;
601 p_sys->p_block->p_buffer += *bytes;
606 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
609 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
612 /*****************************************************************************
613 * DecoderWriteCallback: called by libflac to output decoded samples
614 *****************************************************************************/
615 static FLAC__StreamDecoderWriteStatus
616 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
617 const FLAC__Frame *frame,
618 const FLAC__int32 *const buffer[], void *client_data )
620 /* XXX it supposes our internal format is WG4 */
621 static const int ppi_reorder[1+8][8] = {
628 { 0, 1, 4, 5, 2, 3 },
630 { 0, 1, 6, 2, 3, 4, 5 }, /* 7.0 Unspecified by flac */
631 { 0, 1, 6, 7, 2, 3, 4, 5 }, /* 7.1 Unspecified by flac */
635 decoder_t *p_dec = (decoder_t *)client_data;
636 decoder_sys_t *p_sys = p_dec->p_sys;
638 if( p_dec->fmt_out.audio.i_channels <= 0 ||
639 p_dec->fmt_out.audio.i_channels > 8 )
640 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
641 const int * const pi_reorder = ppi_reorder[p_dec->fmt_out.audio.i_channels];
643 p_sys->p_aout_buffer =
644 decoder_NewAudioBuffer( p_dec, frame->header.blocksize );
646 if( p_sys->p_aout_buffer == NULL )
647 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
649 switch( frame->header.bits_per_sample )
652 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
653 frame->header.channels, frame->header.blocksize );
656 Interleave24( (int8_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
657 frame->header.channels, frame->header.blocksize );
660 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
661 frame->header.channels, frame->header.blocksize );
664 /* Date management (already done by packetizer) */
665 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
666 p_sys->p_aout_buffer->end_date =
667 p_sys->p_block->i_pts + p_sys->p_block->i_length;
669 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
672 /*****************************************************************************
673 * DecoderMetadataCallback: called by libflac to when it encounters metadata
674 *****************************************************************************/
675 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
676 const FLAC__StreamMetadata *metadata,
680 decoder_t *p_dec = (decoder_t *)client_data;
681 decoder_sys_t *p_sys = p_dec->p_sys;
683 if( p_dec->pf_decode_audio )
685 switch( metadata->data.stream_info.bits_per_sample )
688 p_dec->fmt_out.i_codec = VLC_CODEC_S8;
691 p_dec->fmt_out.i_codec = VLC_CODEC_S16N;
694 p_dec->fmt_out.i_codec = VLC_CODEC_S24N;
697 msg_Dbg( p_dec, "strange bit/sample value: %d",
698 metadata->data.stream_info.bits_per_sample );
699 p_dec->fmt_out.i_codec = VLC_CODEC_FI32;
704 /* Setup the format */
705 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
706 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
707 p_dec->fmt_out.audio.i_physical_channels =
708 p_dec->fmt_out.audio.i_original_channels =
709 pi_channels_maps[metadata->data.stream_info.channels];
710 p_dec->fmt_out.audio.i_bitspersample =
711 metadata->data.stream_info.bits_per_sample;
713 date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
715 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
716 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
717 p_dec->fmt_out.audio.i_bitspersample );
719 p_sys->b_stream_info = true;
720 p_sys->stream_info = metadata->data.stream_info;
725 /*****************************************************************************
726 * DecoderErrorCallback: called when the libflac decoder encounters an error
727 *****************************************************************************/
728 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
729 FLAC__StreamDecoderErrorStatus status,
733 decoder_t *p_dec = (decoder_t *)client_data;
737 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
738 msg_Warn( p_dec, "an error in the stream caused the decoder to "
739 "lose synchronization." );
741 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
742 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
744 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
745 msg_Err( p_dec, "frame's data did not match the CRC in the "
749 msg_Err( p_dec, "got decoder error: %d", status );
752 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
756 /*****************************************************************************
757 * Interleave: helper function to interleave channels
758 *****************************************************************************/
759 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
760 const int pi_index[],
761 int i_nb_channels, int i_samples )
764 for ( j = 0; j < i_samples; j++ )
766 for ( i = 0; i < i_nb_channels; i++ )
768 p_out[j * i_nb_channels + i] = pp_in[pi_index[i]][j];
773 static void Interleave24( int8_t *p_out, const int32_t * const *pp_in,
774 const int pi_index[],
775 int i_nb_channels, int i_samples )
778 for ( j = 0; j < i_samples; j++ )
780 for ( i = 0; i < i_nb_channels; i++ )
782 const int i_index = pi_index[i];
783 #ifdef WORDS_BIGENDIAN
784 p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i_index][j] >> 16) & 0xff;
785 p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i_index][j] >> 8 ) & 0xff;
786 p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i_index][j] >> 0 ) & 0xff;
788 p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i_index][j] >> 16) & 0xff;
789 p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i_index][j] >> 8 ) & 0xff;
790 p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i_index][j] >> 0 ) & 0xff;
796 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
797 const int pi_index[],
798 int i_nb_channels, int i_samples )
801 for ( j = 0; j < i_samples; j++ )
803 for ( i = 0; i < i_nb_channels; i++ )
805 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[pi_index[i]][j]);
810 /*****************************************************************************
811 * decoder_state_error: print meaningful error messages
812 *****************************************************************************/
813 static void decoder_state_error( decoder_t *p_dec,
814 FLAC__StreamDecoderState state )
818 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
819 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
821 case FLAC__STREAM_DECODER_READ_METADATA:
822 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
823 "reading metadata." );
825 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
826 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
827 "searching for the frame sync code." );
829 case FLAC__STREAM_DECODER_READ_FRAME:
830 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
831 "reading a frame." );
833 case FLAC__STREAM_DECODER_END_OF_STREAM:
834 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
836 #ifdef USE_NEW_FLAC_API
837 case FLAC__STREAM_DECODER_OGG_ERROR:
838 msg_Err( p_dec, "error occurred in the Ogg layer." );
840 case FLAC__STREAM_DECODER_SEEK_ERROR:
841 msg_Err( p_dec, "error occurred while seeking." );
844 case FLAC__STREAM_DECODER_ABORTED:
845 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
847 #ifndef USE_NEW_FLAC_API
848 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
849 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
853 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
854 msg_Err( p_dec, "error when allocating memory." );
856 #ifndef USE_NEW_FLAC_API
857 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
858 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
859 "decoder was already initialized, usually because "
860 "FLAC__stream_decoder_finish() was not called." );
862 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
863 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
864 "all callbacks being set." );
867 case FLAC__STREAM_DECODER_UNINITIALIZED:
868 msg_Err( p_dec, "decoder in uninitialized state." );
871 msg_Warn(p_dec, "unknown error" );
876 /*****************************************************************************
877 * SyncInfo: parse FLAC sync info
878 *****************************************************************************/
879 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
880 unsigned int * pi_channels,
881 unsigned int * pi_channels_conf,
882 unsigned int * pi_sample_rate,
883 int * pi_bits_per_sample )
885 decoder_sys_t *p_sys = p_dec->p_sys;
886 int i_header, i_temp, i_read;
887 unsigned i_blocksize = 0;
888 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
889 uint64_t i_sample_number = 0;
891 bool b_variable_blocksize = ( p_sys->b_stream_info &&
892 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
893 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
894 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
897 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
899 /* Check there is no emulated sync code in the rest of the header */
900 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
902 /* Find blocksize (framelength) */
903 switch( i_temp = p_buf[2] >> 4 )
906 if( b_fixed_blocksize )
907 i_blocksize = p_sys->stream_info.min_blocksize;
908 else return 0; /* We can't do anything with this */
919 i_blocksize = 576 << (i_temp - 2);
924 i_blocksize_hint = i_temp;
935 i_blocksize = 256 << (i_temp - 8);
939 /* Find samplerate */
940 switch( i_temp = p_buf[2] & 0x0f )
943 if( p_sys->b_stream_info )
944 *pi_sample_rate = p_sys->stream_info.sample_rate;
945 else return 0; /* We can't do anything with this */
955 *pi_sample_rate = 8000;
959 *pi_sample_rate = 16000;
963 *pi_sample_rate = 22050;
967 *pi_sample_rate = 24000;
971 *pi_sample_rate = 32000;
975 *pi_sample_rate = 44100;
979 *pi_sample_rate = 48000;
983 *pi_sample_rate = 96000;
989 i_sample_rate_hint = i_temp;
997 i_temp = (unsigned)(p_buf[3] >> 4);
1001 int i_channel_assignment; /* ??? */
1003 switch( i_temp & 7 )
1006 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
1009 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
1012 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
1024 *pi_channels = i_temp + 1;
1025 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
1028 /* Find bits per sample */
1029 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
1032 if( p_sys->b_stream_info )
1033 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
1039 *pi_bits_per_sample = 8;
1043 *pi_bits_per_sample = 12;
1047 *pi_bits_per_sample = 16;
1051 *pi_bits_per_sample = 20;
1055 *pi_bits_per_sample = 24;
1064 /* Zero padding bit */
1065 if( p_buf[3] & 0x01 ) return 0;
1067 /* End of fixed size header */
1070 /* Find Sample/Frame number */
1071 if( i_blocksize_hint && b_variable_blocksize )
1073 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1074 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1078 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1079 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1081 if( p_sys->b_stream_info )
1082 i_sample_number *= p_sys->stream_info.min_blocksize;
1087 /* Read blocksize */
1088 if( i_blocksize_hint )
1090 int i_val1 = p_buf[i_header++];
1091 if( i_blocksize_hint == 7 )
1093 int i_val2 = p_buf[i_header++];
1094 i_val1 = (i_val1 << 8) | i_val2;
1096 i_blocksize = i_val1 + 1;
1099 /* Read sample rate */
1100 if( i_sample_rate_hint )
1102 int i_val1 = p_buf[i_header++];
1103 if( i_sample_rate_hint != 12 )
1105 int i_val2 = p_buf[i_header++];
1106 i_val1 = (i_val1 << 8) | i_val2;
1108 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1109 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1110 else *pi_sample_rate = i_val1 * 10;
1113 /* Check the CRC-8 byte */
1114 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1119 /* Sanity check using stream info header when possible */
1120 if( p_sys->b_stream_info )
1122 if( i_blocksize < p_sys->stream_info.min_blocksize ||
1123 i_blocksize > p_sys->stream_info.max_blocksize )
1129 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1130 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1132 uint64_t i_result = 0;
1135 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1137 i_result = p_buf[0];
1140 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1142 i_result = p_buf[0] & 0x1F;
1145 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1147 i_result = p_buf[0] & 0x0F;
1150 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1152 i_result = p_buf[0] & 0x07;
1155 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1157 i_result = p_buf[0] & 0x03;
1160 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1162 i_result = p_buf[0] & 0x01;
1165 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1171 return INT64_C(0xffffffffffffffff);
1174 for( j = 1; j <= i; j++ )
1176 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1178 return INT64_C(0xffffffffffffffff);
1181 i_result |= (p_buf[j] & 0x3F);
1188 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1189 static const uint8_t flac_crc8_table[256] = {
1190 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1191 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1192 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1193 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1194 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1195 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1196 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1197 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1198 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1199 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1200 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1201 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1202 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1203 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1204 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1205 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1206 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1207 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1208 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1209 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1210 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1211 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1212 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1213 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1214 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1215 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1216 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1217 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1218 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1219 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1220 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1221 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1224 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1229 crc = flac_crc8_table[crc ^ *data++];
1235 /*****************************************************************************
1236 * encoder_sys_t : flac encoder descriptor
1237 *****************************************************************************/
1238 struct encoder_sys_t
1245 int i_samples_delay;
1248 FLAC__int32 *p_buffer;
1249 unsigned int i_buffer;
1256 FLAC__StreamEncoder *p_flac;
1257 FLAC__StreamMetadata_StreamInfo stream_info;
1265 #define STREAMINFO_SIZE 38
1267 static block_t *Encode( encoder_t *, aout_buffer_t * );
1269 static FLAC__StreamEncoderWriteStatus
1270 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1271 const FLAC__byte buffer[],
1272 unsigned bytes, unsigned samples,
1273 unsigned current_frame, void *client_data );
1275 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1276 const FLAC__StreamMetadata *metadata,
1277 void *client_data );
1279 /*****************************************************************************
1280 * OpenEncoder: probe the encoder and return score
1281 *****************************************************************************/
1282 static int OpenEncoder( vlc_object_t *p_this )
1284 encoder_t *p_enc = (encoder_t *)p_this;
1285 encoder_sys_t *p_sys;
1287 if( p_enc->fmt_out.i_codec != VLC_CODEC_FLAC &&
1290 return VLC_EGENERIC;
1293 /* Allocate the memory needed to store the decoder's structure */
1294 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1296 p_enc->p_sys = p_sys;
1297 p_enc->pf_encode_audio = Encode;
1298 p_enc->fmt_out.i_codec = VLC_CODEC_FLAC;
1300 p_sys->i_headers = 0;
1301 p_sys->p_buffer = 0;
1302 p_sys->i_buffer = 0;
1303 p_sys->i_samples_delay = 0;
1305 /* Create flac encoder */
1306 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1308 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1310 return VLC_EGENERIC;
1313 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1314 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1315 p_enc->fmt_in.audio.i_channels );
1316 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1317 p_enc->fmt_in.audio.i_rate );
1318 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1319 p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
1321 /* Get and store the STREAMINFO metadata block as a p_extra */
1324 #ifdef USE_NEW_FLAC_API
1325 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1326 EncoderWriteCallback,
1329 EncoderMetadataCallback,
1331 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1333 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1334 FLAC__stream_encoder_delete( p_sys->p_flac );
1336 return VLC_EGENERIC;
1339 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1340 EncoderWriteCallback );
1341 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1342 EncoderMetadataCallback );
1343 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1345 FLAC__stream_encoder_init( p_sys->p_flac );
1351 /****************************************************************************
1352 * Encode: the whole thing
1353 ****************************************************************************
1354 * This function spits out ogg packets.
1355 ****************************************************************************/
1356 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1358 encoder_sys_t *p_sys = p_enc->p_sys;
1362 p_sys->i_pts = p_aout_buf->start_date -
1363 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1364 (mtime_t)p_enc->fmt_in.audio.i_rate;
1366 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1368 /* Convert samples to FLAC__int32 */
1369 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1372 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1373 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1376 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1378 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1381 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1382 p_aout_buf->i_nb_samples );
1384 p_chain = p_sys->p_chain;
1390 /*****************************************************************************
1391 * CloseEncoder: encoder destruction
1392 *****************************************************************************/
1393 static void CloseEncoder( vlc_object_t *p_this )
1395 encoder_t *p_enc = (encoder_t *)p_this;
1396 encoder_sys_t *p_sys = p_enc->p_sys;
1398 FLAC__stream_encoder_delete( p_sys->p_flac );
1400 free( p_sys->p_buffer );
1404 /*****************************************************************************
1405 * EncoderMetadataCallback: called by libflac to output metadata
1406 *****************************************************************************/
1407 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1408 const FLAC__StreamMetadata *metadata,
1411 VLC_UNUSED(encoder);
1412 encoder_t *p_enc = (encoder_t *)client_data;
1414 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1418 /*****************************************************************************
1419 * EncoderWriteCallback: called by libflac to output encoded samples
1420 *****************************************************************************/
1421 static FLAC__StreamEncoderWriteStatus
1422 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1423 const FLAC__byte buffer[],
1424 unsigned bytes, unsigned samples,
1425 unsigned current_frame, void *client_data )
1427 VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
1428 encoder_t *p_enc = (encoder_t *)client_data;
1429 encoder_sys_t *p_sys = p_enc->p_sys;
1434 if( p_sys->i_headers == 1 )
1436 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1438 /* Backup the STREAMINFO metadata block */
1439 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1440 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1441 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1442 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1445 /* Fake this as the last metadata block */
1446 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1449 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1452 p_block = block_New( p_enc, bytes );
1453 memcpy( p_block->p_buffer, buffer, bytes );
1455 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1457 p_sys->i_samples_delay -= samples;
1459 p_block->i_length = (mtime_t)1000000 *
1460 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1463 p_sys->i_pts += p_block->i_length;
1465 block_ChainAppend( &p_sys->p_chain, p_block );
1467 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;