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->i_pts = VLC_TS_INVALID;
228 p_sys->bytestream = block_BytestreamInit();
231 /* Take care of flac init */
232 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
234 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
239 #ifdef USE_NEW_FLAC_API
240 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
246 DecoderWriteCallback,
247 DecoderMetadataCallback,
248 DecoderErrorCallback,
250 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
252 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
253 FLAC__stream_decoder_delete( p_sys->p_flac );
258 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
259 DecoderReadCallback );
260 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
261 DecoderWriteCallback );
262 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
263 DecoderMetadataCallback );
264 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
265 DecoderErrorCallback );
266 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
268 FLAC__stream_decoder_init( p_sys->p_flac );
272 /* Set output properties */
273 p_dec->fmt_out.i_cat = AUDIO_ES;
274 p_dec->fmt_out.i_codec = VLC_CODEC_FL32;
278 p_dec->pf_decode_audio = DecodeBlock;
284 static int OpenPacketizer( vlc_object_t *p_this )
286 decoder_t *p_dec = (decoder_t*)p_this;
287 es_format_t es_save = p_dec->fmt_out;
291 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
293 i_ret = OpenDecoder( p_this );
294 p_dec->pf_decode_audio = NULL;
295 p_dec->pf_packetize = PacketizeBlock;
297 /* Set output properties */
298 p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
300 if( i_ret != VLC_SUCCESS )
302 es_format_Clean( &p_dec->fmt_out );
303 p_dec->fmt_out = es_save;
308 /*****************************************************************************
309 * CloseDecoder: flac decoder destruction
310 *****************************************************************************/
311 static void CloseDecoder( vlc_object_t *p_this )
313 decoder_t *p_dec = (decoder_t *)p_this;
314 decoder_sys_t *p_sys = p_dec->p_sys;
317 FLAC__stream_decoder_finish( p_sys->p_flac );
318 FLAC__stream_decoder_delete( p_sys->p_flac );
321 free( p_sys->p_block );
325 /*****************************************************************************
326 * ProcessHeader: process Flac header.
327 *****************************************************************************/
328 static void ProcessHeader( decoder_t *p_dec )
330 decoder_sys_t *p_sys = p_dec->p_sys;
333 if( !p_dec->fmt_in.i_extra ) return;
335 /* Decode STREAMINFO */
336 msg_Dbg( p_dec, "decode STREAMINFO" );
337 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
338 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
339 p_dec->fmt_in.i_extra );
340 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
341 msg_Dbg( p_dec, "STREAMINFO decoded" );
346 if( !p_dec->fmt_in.i_extra ) return;
348 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
350 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
351 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
353 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
354 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
356 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
357 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
358 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
361 if( !p_sys->b_stream_info ) return;
363 if( p_dec->fmt_out.i_codec == VLC_CODEC_FLAC )
365 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
366 p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
367 p_dec->fmt_out.i_extra );
368 memcpy( p_dec->fmt_out.p_extra,
369 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
373 /****************************************************************************
374 * PacketizeBlock: the whole thing
375 ****************************************************************************
376 * This function is called just after the thread is launched.
377 ****************************************************************************/
378 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
380 decoder_sys_t *p_sys = p_dec->p_sys;
381 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
382 block_t *p_sout_block;
384 if( !pp_block || !*pp_block ) return NULL;
386 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
388 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
390 p_sys->i_state = STATE_NOSYNC;
391 block_BytestreamEmpty( &p_sys->bytestream );
393 date_Set( &p_sys->end_date, 0 );
394 block_Release( *pp_block );
398 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
400 if( p_sys->stream_info.channels > 6 )
402 msg_Err( p_dec, "This stream uses too many audio channels" );
406 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
408 /* We've just started the stream, wait for the first PTS. */
409 block_Release( *pp_block );
412 else if( !date_Get( &p_sys->end_date ) )
414 /* The first PTS is as good as anything else. */
415 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
416 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
417 date_Set( &p_sys->end_date, (*pp_block)->i_pts );
420 block_BytestreamPush( &p_sys->bytestream, *pp_block );
424 switch( p_sys->i_state )
427 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
430 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
432 p_sys->i_state = STATE_SYNC;
435 block_SkipByte( &p_sys->bytestream );
437 if( p_sys->i_state != STATE_SYNC )
439 block_BytestreamFlush( &p_sys->bytestream );
446 /* New frame, set the Presentation Time Stamp */
447 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
448 if( p_sys->i_pts > VLC_TS_INVALID &&
449 p_sys->i_pts != date_Get( &p_sys->end_date ) )
451 date_Set( &p_sys->end_date, p_sys->i_pts );
453 p_sys->i_state = STATE_HEADER;
456 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
457 if( block_PeekBytes( &p_sys->bytestream, p_header,
458 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
464 /* Check if frame is valid and get frame info */
465 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
467 &p_sys->i_channels_conf,
469 &p_sys->i_bits_per_sample );
470 if( !p_sys->i_frame_length )
472 msg_Dbg( p_dec, "emulated sync word" );
473 block_SkipByte( &p_sys->bytestream );
474 p_sys->i_state = STATE_NOSYNC;
477 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
479 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
480 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
482 p_sys->i_state = STATE_NEXT_SYNC;
483 p_sys->i_frame_size = 1;
485 case STATE_NEXT_SYNC:
486 /* TODO: If pp_block == NULL, flush the buffer without checking the
489 /* Check if next expected frame contains the sync word */
490 while( block_PeekOffsetBytes( &p_sys->bytestream,
491 p_sys->i_frame_size, p_header,
492 MAX_FLAC_HEADER_SIZE )
495 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
497 /* Check if frame is valid and get frame info */
499 SyncInfo( p_dec, p_header,
501 &p_sys->i_channels_conf,
503 &p_sys->i_bits_per_sample );
507 p_sys->i_state = STATE_SEND_DATA;
511 p_sys->i_frame_size++;
514 if( p_sys->i_state != STATE_SEND_DATA )
520 case STATE_SEND_DATA:
521 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
523 /* Copy the whole frame into the buffer. When we reach this point
524 * we already know we have enough data available. */
525 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
526 p_sys->i_frame_size );
528 /* Make sure we don't reuse the same pts twice */
529 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
530 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
532 /* So p_block doesn't get re-added several times */
533 *pp_block = block_BytestreamPop( &p_sys->bytestream );
535 p_sys->i_state = STATE_NOSYNC;
537 /* Date management */
538 p_sout_block->i_pts =
539 p_sout_block->i_dts = date_Get( &p_sys->end_date );
540 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
541 p_sout_block->i_length =
542 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
552 /****************************************************************************
553 * DecodeBlock: the whole thing
554 ****************************************************************************/
555 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
557 decoder_sys_t *p_sys = p_dec->p_sys;
559 if( !pp_block || !*pp_block ) return NULL;
561 p_sys->p_aout_buffer = 0;
562 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
564 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
566 decoder_state_error( p_dec,
567 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
568 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
571 /* If the decoder is in the "aborted" state,
572 * FLAC__stream_decoder_process_single() won't return an error. */
573 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
574 == FLAC__STREAM_DECODER_ABORTED )
576 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
579 block_Release( p_sys->p_block );
580 p_sys->p_block = NULL;
583 return p_sys->p_aout_buffer;
586 /*****************************************************************************
587 * DecoderReadCallback: called by libflac when it needs more data
588 *****************************************************************************/
589 static FLAC__StreamDecoderReadStatus
590 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
591 unsigned *bytes, void *client_data )
594 decoder_t *p_dec = (decoder_t *)client_data;
595 decoder_sys_t *p_sys = p_dec->p_sys;
597 if( p_sys->p_block && p_sys->p_block->i_buffer )
599 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
600 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
601 p_sys->p_block->i_buffer -= *bytes;
602 p_sys->p_block->p_buffer += *bytes;
607 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
610 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
613 /*****************************************************************************
614 * DecoderWriteCallback: called by libflac to output decoded samples
615 *****************************************************************************/
616 static FLAC__StreamDecoderWriteStatus
617 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
618 const FLAC__Frame *frame,
619 const FLAC__int32 *const buffer[], void *client_data )
621 /* XXX it supposes our internal format is WG4 */
622 static const int ppi_reorder[1+8][8] = {
629 { 0, 1, 4, 5, 2, 3 },
631 { 0, 1, 6, 2, 3, 4, 5 }, /* 7.0 Unspecified by flac */
632 { 0, 1, 6, 7, 2, 3, 4, 5 }, /* 7.1 Unspecified by flac */
636 decoder_t *p_dec = (decoder_t *)client_data;
637 decoder_sys_t *p_sys = p_dec->p_sys;
639 if( p_dec->fmt_out.audio.i_channels <= 0 ||
640 p_dec->fmt_out.audio.i_channels > 8 )
641 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
642 const int * const pi_reorder = ppi_reorder[p_dec->fmt_out.audio.i_channels];
644 p_sys->p_aout_buffer =
645 decoder_NewAudioBuffer( p_dec, frame->header.blocksize );
647 if( p_sys->p_aout_buffer == NULL )
648 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
650 switch( frame->header.bits_per_sample )
653 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
654 frame->header.channels, frame->header.blocksize );
657 Interleave24( (int8_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
658 frame->header.channels, frame->header.blocksize );
661 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer, pi_reorder,
662 frame->header.channels, frame->header.blocksize );
665 /* Date management (already done by packetizer) */
666 p_sys->p_aout_buffer->i_pts = p_sys->p_block->i_pts;
667 p_sys->p_aout_buffer->i_length = 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->i_pts -
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_buffer * 2 )
1372 xrealloc( p_sys->p_buffer, p_aout_buf->i_buffer * 2 );
1373 p_sys->i_buffer = p_aout_buf->i_buffer * 2;
1376 for( i = 0 ; i < p_aout_buf->i_buffer / 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 = xmalloc( 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;