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 Interleave24( int8_t *p_out, const int32_t * const *pp_in,
165 int i_nb_channels, int i_samples );
166 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
167 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 set_description( N_("Flac audio encoder") );
192 set_capability( "encoder", 100 );
193 set_callbacks( OpenEncoder, CloseEncoder );
197 set_description( N_("Flac audio packetizer") );
198 set_capability( "packetizer", 100 );
199 set_callbacks( OpenPacketizer, CloseDecoder );
203 /*****************************************************************************
204 * OpenDecoder: probe the decoder and return score
205 *****************************************************************************/
206 static int OpenDecoder( vlc_object_t *p_this )
208 decoder_t *p_dec = (decoder_t*)p_this;
209 decoder_sys_t *p_sys;
211 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
216 /* Allocate the memory needed to store the decoder's structure */
217 if( ( p_dec->p_sys = p_sys =
218 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
222 aout_DateSet( &p_sys->end_date, 0 );
223 p_sys->i_state = STATE_NOSYNC;
224 p_sys->b_stream_info = false;
226 p_sys->bytestream = block_BytestreamInit();
229 /* Take care of flac init */
230 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
232 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
237 #ifdef USE_NEW_FLAC_API
238 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
244 DecoderWriteCallback,
245 DecoderMetadataCallback,
246 DecoderErrorCallback,
248 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
250 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
251 FLAC__stream_decoder_delete( p_sys->p_flac );
256 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
257 DecoderReadCallback );
258 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
259 DecoderWriteCallback );
260 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
261 DecoderMetadataCallback );
262 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
263 DecoderErrorCallback );
264 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
266 FLAC__stream_decoder_init( p_sys->p_flac );
270 /* Set output properties */
271 p_dec->fmt_out.i_cat = AUDIO_ES;
272 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
276 p_dec->pf_decode_audio = DecodeBlock;
282 static int OpenPacketizer( vlc_object_t *p_this )
284 decoder_t *p_dec = (decoder_t*)p_this;
285 es_format_t es_save = p_dec->fmt_out;
289 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
291 i_ret = OpenDecoder( p_this );
292 p_dec->pf_decode_audio = NULL;
293 p_dec->pf_packetize = PacketizeBlock;
295 /* Set output properties */
296 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
298 if( i_ret != VLC_SUCCESS )
300 es_format_Clean( &p_dec->fmt_out );
301 p_dec->fmt_out = es_save;
306 /*****************************************************************************
307 * CloseDecoder: flac decoder destruction
308 *****************************************************************************/
309 static void CloseDecoder( vlc_object_t *p_this )
311 decoder_t *p_dec = (decoder_t *)p_this;
312 decoder_sys_t *p_sys = p_dec->p_sys;
315 FLAC__stream_decoder_finish( p_sys->p_flac );
316 FLAC__stream_decoder_delete( p_sys->p_flac );
319 free( p_sys->p_block );
323 /*****************************************************************************
324 * ProcessHeader: process Flac header.
325 *****************************************************************************/
326 static void ProcessHeader( decoder_t *p_dec )
328 decoder_sys_t *p_sys = p_dec->p_sys;
331 if( !p_dec->fmt_in.i_extra ) return;
333 /* Decode STREAMINFO */
334 msg_Dbg( p_dec, "decode STREAMINFO" );
335 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
336 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
337 p_dec->fmt_in.i_extra );
338 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
339 msg_Dbg( p_dec, "STREAMINFO decoded" );
344 if( !p_dec->fmt_in.i_extra ) return;
346 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
348 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
349 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
351 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
352 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
354 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
355 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
356 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
359 if( !p_sys->b_stream_info ) return;
361 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
363 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
364 p_dec->fmt_out.p_extra =
365 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
366 memcpy( p_dec->fmt_out.p_extra,
367 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
371 /****************************************************************************
372 * PacketizeBlock: the whole thing
373 ****************************************************************************
374 * This function is called just after the thread is launched.
375 ****************************************************************************/
376 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
378 decoder_sys_t *p_sys = p_dec->p_sys;
379 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
380 block_t *p_sout_block;
382 if( !pp_block || !*pp_block ) return NULL;
384 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
386 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
388 p_sys->i_state = STATE_NOSYNC;
389 block_BytestreamFlush( &p_sys->bytestream );
391 // aout_DateSet( &p_sys->end_date, 0 );
392 block_Release( *pp_block );
396 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
398 if( p_sys->stream_info.channels > 6 )
400 msg_Err( p_dec, "This stream uses too many audio channels" );
404 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
406 /* We've just started the stream, wait for the first PTS. */
407 block_Release( *pp_block );
410 else if( !aout_DateGet( &p_sys->end_date ) )
412 /* The first PTS is as good as anything else. */
413 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
414 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
415 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
418 block_BytestreamPush( &p_sys->bytestream, *pp_block );
422 switch( p_sys->i_state )
425 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
428 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
430 p_sys->i_state = STATE_SYNC;
433 block_SkipByte( &p_sys->bytestream );
435 if( p_sys->i_state != STATE_SYNC )
437 block_BytestreamFlush( &p_sys->bytestream );
444 /* New frame, set the Presentation Time Stamp */
445 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
446 if( p_sys->i_pts != 0 &&
447 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
449 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
451 p_sys->i_state = STATE_HEADER;
454 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
455 if( block_PeekBytes( &p_sys->bytestream, p_header,
456 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
462 /* Check if frame is valid and get frame info */
463 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
465 &p_sys->i_channels_conf,
467 &p_sys->i_bits_per_sample );
468 if( !p_sys->i_frame_length )
470 msg_Dbg( p_dec, "emulated sync word" );
471 block_SkipByte( &p_sys->bytestream );
472 p_sys->i_state = STATE_NOSYNC;
475 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
477 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
478 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
480 p_sys->i_state = STATE_NEXT_SYNC;
481 p_sys->i_frame_size = 1;
483 case STATE_NEXT_SYNC:
484 /* TODO: If pp_block == NULL, flush the buffer without checking the
487 /* Check if next expected frame contains the sync word */
488 while( block_PeekOffsetBytes( &p_sys->bytestream,
489 p_sys->i_frame_size, p_header,
490 MAX_FLAC_HEADER_SIZE )
493 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
495 /* Check if frame is valid and get frame info */
497 SyncInfo( p_dec, p_header,
499 &p_sys->i_channels_conf,
501 &p_sys->i_bits_per_sample );
505 p_sys->i_state = STATE_SEND_DATA;
509 p_sys->i_frame_size++;
512 if( p_sys->i_state != STATE_SEND_DATA )
518 case STATE_SEND_DATA:
519 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
521 /* Copy the whole frame into the buffer. When we reach this point
522 * we already know we have enough data available. */
523 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
524 p_sys->i_frame_size );
526 /* Make sure we don't reuse the same pts twice */
527 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
528 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
530 /* So p_block doesn't get re-added several times */
531 *pp_block = block_BytestreamPop( &p_sys->bytestream );
533 p_sys->i_state = STATE_NOSYNC;
535 /* Date management */
536 p_sout_block->i_pts =
537 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
538 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
539 p_sout_block->i_length =
540 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
550 /****************************************************************************
551 * DecodeBlock: the whole thing
552 ****************************************************************************/
553 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
555 decoder_sys_t *p_sys = p_dec->p_sys;
557 if( !pp_block || !*pp_block ) return NULL;
559 p_sys->p_aout_buffer = 0;
560 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
562 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
564 decoder_state_error( p_dec,
565 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
566 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
569 /* If the decoder is in the "aborted" state,
570 * FLAC__stream_decoder_process_single() won't return an error. */
571 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
572 == FLAC__STREAM_DECODER_ABORTED )
574 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
577 block_Release( p_sys->p_block );
578 p_sys->p_block = NULL;
581 return p_sys->p_aout_buffer;
584 /*****************************************************************************
585 * DecoderReadCallback: called by libflac when it needs more data
586 *****************************************************************************/
587 static FLAC__StreamDecoderReadStatus
588 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
589 unsigned *bytes, void *client_data )
592 decoder_t *p_dec = (decoder_t *)client_data;
593 decoder_sys_t *p_sys = p_dec->p_sys;
595 if( p_sys->p_block && p_sys->p_block->i_buffer )
597 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
598 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
599 p_sys->p_block->i_buffer -= *bytes;
600 p_sys->p_block->p_buffer += *bytes;
605 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
608 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
611 /*****************************************************************************
612 * DecoderWriteCallback: called by libflac to output decoded samples
613 *****************************************************************************/
614 static FLAC__StreamDecoderWriteStatus
615 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
616 const FLAC__Frame *frame,
617 const FLAC__int32 *const buffer[], void *client_data )
620 decoder_t *p_dec = (decoder_t *)client_data;
621 decoder_sys_t *p_sys = p_dec->p_sys;
623 p_sys->p_aout_buffer =
624 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
626 if( p_sys->p_aout_buffer == NULL )
627 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
629 switch( frame->header.bits_per_sample )
632 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
633 frame->header.channels, frame->header.blocksize );
636 Interleave24( (int8_t *)p_sys->p_aout_buffer->p_buffer, buffer,
637 frame->header.channels, frame->header.blocksize );
640 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
641 frame->header.channels, frame->header.blocksize );
644 /* Date management (already done by packetizer) */
645 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
646 p_sys->p_aout_buffer->end_date =
647 p_sys->p_block->i_pts + p_sys->p_block->i_length;
649 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
652 /*****************************************************************************
653 * DecoderMetadataCallback: called by libflac to when it encounters metadata
654 *****************************************************************************/
655 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
656 const FLAC__StreamMetadata *metadata,
660 decoder_t *p_dec = (decoder_t *)client_data;
661 decoder_sys_t *p_sys = p_dec->p_sys;
663 if( p_dec->pf_decode_audio )
665 switch( metadata->data.stream_info.bits_per_sample )
668 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
671 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
674 p_dec->fmt_out.i_codec = AOUT_FMT_S24_NE;
677 msg_Dbg( p_dec, "strange bit/sample value: %d",
678 metadata->data.stream_info.bits_per_sample );
679 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
684 /* Setup the format */
685 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
686 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
687 p_dec->fmt_out.audio.i_physical_channels =
688 p_dec->fmt_out.audio.i_original_channels =
689 pi_channels_maps[metadata->data.stream_info.channels];
690 p_dec->fmt_out.audio.i_bitspersample =
691 metadata->data.stream_info.bits_per_sample;
693 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
695 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
696 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
697 p_dec->fmt_out.audio.i_bitspersample );
699 p_sys->b_stream_info = true;
700 p_sys->stream_info = metadata->data.stream_info;
705 /*****************************************************************************
706 * DecoderErrorCallback: called when the libflac decoder encounters an error
707 *****************************************************************************/
708 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
709 FLAC__StreamDecoderErrorStatus status,
713 decoder_t *p_dec = (decoder_t *)client_data;
717 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
718 msg_Warn( p_dec, "an error in the stream caused the decoder to "
719 "lose synchronization." );
721 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
722 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
724 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
725 msg_Err( p_dec, "frame's data did not match the CRC in the "
729 msg_Err( p_dec, "got decoder error: %d", status );
732 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
736 /*****************************************************************************
737 * Interleave: helper function to interleave channels
738 *****************************************************************************/
739 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
740 int i_nb_channels, int i_samples )
743 for ( j = 0; j < i_samples; j++ )
745 for ( i = 0; i < i_nb_channels; i++ )
747 p_out[j * i_nb_channels + i] = pp_in[i][j];
752 static void Interleave24( int8_t *p_out, const int32_t * const *pp_in,
753 int i_nb_channels, int i_samples )
756 for ( j = 0; j < i_samples; j++ )
758 for ( i = 0; i < i_nb_channels; i++ )
760 #ifdef WORDS_BIGENDIAN
761 p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i][j] >> 16) & 0xff;
762 p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i][j] >> 8 ) & 0xff;
763 p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i][j] >> 0 ) & 0xff;
765 p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i][j] >> 16) & 0xff;
766 p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i][j] >> 8 ) & 0xff;
767 p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i][j] >> 0 ) & 0xff;
773 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
774 int i_nb_channels, int i_samples )
777 for ( j = 0; j < i_samples; j++ )
779 for ( i = 0; i < i_nb_channels; i++ )
781 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
786 /*****************************************************************************
787 * decoder_state_error: print meaningful error messages
788 *****************************************************************************/
789 static void decoder_state_error( decoder_t *p_dec,
790 FLAC__StreamDecoderState state )
794 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
795 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
797 case FLAC__STREAM_DECODER_READ_METADATA:
798 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
799 "reading metadata." );
801 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
802 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
803 "searching for the frame sync code." );
805 case FLAC__STREAM_DECODER_READ_FRAME:
806 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
807 "reading a frame." );
809 case FLAC__STREAM_DECODER_END_OF_STREAM:
810 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
812 #ifdef USE_NEW_FLAC_API
813 case FLAC__STREAM_DECODER_OGG_ERROR:
814 msg_Err( p_dec, "error occurred in the Ogg layer." );
816 case FLAC__STREAM_DECODER_SEEK_ERROR:
817 msg_Err( p_dec, "error occurred while seeking." );
820 case FLAC__STREAM_DECODER_ABORTED:
821 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
823 #ifndef USE_NEW_FLAC_API
824 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
825 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
829 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
830 msg_Err( p_dec, "error when allocating memory." );
832 #ifndef USE_NEW_FLAC_API
833 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
834 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
835 "decoder was already initialized, usually because "
836 "FLAC__stream_decoder_finish() was not called." );
838 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
839 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
840 "all callbacks being set." );
843 case FLAC__STREAM_DECODER_UNINITIALIZED:
844 msg_Err( p_dec, "decoder in uninitialized state." );
847 msg_Warn(p_dec, "unknown error" );
852 /*****************************************************************************
853 * SyncInfo: parse FLAC sync info
854 *****************************************************************************/
855 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
856 unsigned int * pi_channels,
857 unsigned int * pi_channels_conf,
858 unsigned int * pi_sample_rate,
859 int * pi_bits_per_sample )
861 decoder_sys_t *p_sys = p_dec->p_sys;
862 int i_header, i_temp, i_read;
863 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
864 uint64_t i_sample_number = 0;
866 bool b_variable_blocksize = ( p_sys->b_stream_info &&
867 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
868 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
869 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
872 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
874 /* Check there is no emulated sync code in the rest of the header */
875 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
877 /* Find blocksize (framelength) */
878 switch( i_temp = p_buf[2] >> 4 )
881 if( b_fixed_blocksize )
882 i_blocksize = p_sys->stream_info.min_blocksize;
883 else return 0; /* We can't do anything with this */
894 i_blocksize = 576 << (i_temp - 2);
899 i_blocksize_hint = i_temp;
910 i_blocksize = 256 << (i_temp - 8);
914 /* Find samplerate */
915 switch( i_temp = p_buf[2] & 0x0f )
918 if( p_sys->b_stream_info )
919 *pi_sample_rate = p_sys->stream_info.sample_rate;
920 else return 0; /* We can't do anything with this */
930 *pi_sample_rate = 8000;
934 *pi_sample_rate = 16000;
938 *pi_sample_rate = 22050;
942 *pi_sample_rate = 24000;
946 *pi_sample_rate = 32000;
950 *pi_sample_rate = 44100;
954 *pi_sample_rate = 48000;
958 *pi_sample_rate = 96000;
964 i_sample_rate_hint = i_temp;
972 i_temp = (unsigned)(p_buf[3] >> 4);
976 int i_channel_assignment; /* ??? */
981 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
984 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
987 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
999 *pi_channels = i_temp + 1;
1000 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
1003 /* Find bits per sample */
1004 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
1007 if( p_sys->b_stream_info )
1008 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
1014 *pi_bits_per_sample = 8;
1018 *pi_bits_per_sample = 12;
1022 *pi_bits_per_sample = 16;
1026 *pi_bits_per_sample = 20;
1030 *pi_bits_per_sample = 24;
1039 /* Zero padding bit */
1040 if( p_buf[3] & 0x01 ) return 0;
1042 /* End of fixed size header */
1045 /* Find Sample/Frame number */
1046 if( i_blocksize_hint && b_variable_blocksize )
1048 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1049 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1053 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1054 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1056 if( p_sys->b_stream_info )
1057 i_sample_number *= p_sys->stream_info.min_blocksize;
1062 /* Read blocksize */
1063 if( i_blocksize_hint )
1065 int i_val1 = p_buf[i_header++];
1066 if( i_blocksize_hint == 7 )
1068 int i_val2 = p_buf[i_header++];
1069 i_val1 = (i_val1 << 8) | i_val2;
1071 i_blocksize = i_val1 + 1;
1074 /* Read sample rate */
1075 if( i_sample_rate_hint )
1077 int i_val1 = p_buf[i_header++];
1078 if( i_sample_rate_hint != 12 )
1080 int i_val2 = p_buf[i_header++];
1081 i_val1 = (i_val1 << 8) | i_val2;
1083 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1084 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1085 else *pi_sample_rate = i_val1 * 10;
1088 /* Check the CRC-8 byte */
1089 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1094 /* Sanity check using stream info header when possible */
1095 if( p_sys->b_stream_info )
1097 if( i_blocksize < p_sys->stream_info.min_blocksize ||
1098 i_blocksize > p_sys->stream_info.max_blocksize )
1104 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1105 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1107 uint64_t i_result = 0;
1110 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1112 i_result = p_buf[0];
1115 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1117 i_result = p_buf[0] & 0x1F;
1120 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1122 i_result = p_buf[0] & 0x0F;
1125 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1127 i_result = p_buf[0] & 0x07;
1130 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1132 i_result = p_buf[0] & 0x03;
1135 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1137 i_result = p_buf[0] & 0x01;
1140 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1146 return INT64_C(0xffffffffffffffff);
1149 for( j = 1; j <= i; j++ )
1151 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1153 return INT64_C(0xffffffffffffffff);
1156 i_result |= (p_buf[j] & 0x3F);
1163 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1164 static const uint8_t flac_crc8_table[256] = {
1165 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1166 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1167 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1168 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1169 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1170 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1171 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1172 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1173 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1174 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1175 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1176 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1177 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1178 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1179 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1180 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1181 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1182 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1183 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1184 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1185 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1186 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1187 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1188 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1189 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1190 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1191 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1192 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1193 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1194 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1195 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1196 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1199 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1204 crc = flac_crc8_table[crc ^ *data++];
1210 /*****************************************************************************
1211 * encoder_sys_t : flac encoder descriptor
1212 *****************************************************************************/
1213 struct encoder_sys_t
1220 int i_samples_delay;
1223 FLAC__int32 *p_buffer;
1224 unsigned int i_buffer;
1231 FLAC__StreamEncoder *p_flac;
1232 FLAC__StreamMetadata_StreamInfo stream_info;
1240 #define STREAMINFO_SIZE 38
1242 static block_t *Encode( encoder_t *, aout_buffer_t * );
1244 static FLAC__StreamEncoderWriteStatus
1245 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1246 const FLAC__byte buffer[],
1247 unsigned bytes, unsigned samples,
1248 unsigned current_frame, void *client_data );
1250 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1251 const FLAC__StreamMetadata *metadata,
1252 void *client_data );
1254 /*****************************************************************************
1255 * OpenEncoder: probe the encoder and return score
1256 *****************************************************************************/
1257 static int OpenEncoder( vlc_object_t *p_this )
1259 encoder_t *p_enc = (encoder_t *)p_this;
1260 encoder_sys_t *p_sys;
1262 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1265 return VLC_EGENERIC;
1268 /* Allocate the memory needed to store the decoder's structure */
1269 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1271 p_enc->p_sys = p_sys;
1272 p_enc->pf_encode_audio = Encode;
1273 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1275 p_sys->i_headers = 0;
1276 p_sys->p_buffer = 0;
1277 p_sys->i_buffer = 0;
1278 p_sys->i_samples_delay = 0;
1280 /* Create flac encoder */
1281 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1283 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1285 return VLC_EGENERIC;
1288 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1289 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1290 p_enc->fmt_in.audio.i_channels );
1291 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1292 p_enc->fmt_in.audio.i_rate );
1293 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1294 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1296 /* Get and store the STREAMINFO metadata block as a p_extra */
1299 #ifdef USE_NEW_FLAC_API
1300 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1301 EncoderWriteCallback,
1304 EncoderMetadataCallback,
1306 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1308 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1309 FLAC__stream_encoder_delete( p_sys->p_flac );
1311 return VLC_EGENERIC;
1314 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1315 EncoderWriteCallback );
1316 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1317 EncoderMetadataCallback );
1318 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1320 FLAC__stream_encoder_init( p_sys->p_flac );
1326 /****************************************************************************
1327 * Encode: the whole thing
1328 ****************************************************************************
1329 * This function spits out ogg packets.
1330 ****************************************************************************/
1331 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1333 encoder_sys_t *p_sys = p_enc->p_sys;
1337 p_sys->i_pts = p_aout_buf->start_date -
1338 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1339 (mtime_t)p_enc->fmt_in.audio.i_rate;
1341 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1343 /* Convert samples to FLAC__int32 */
1344 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1347 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1348 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1351 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1353 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1356 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1357 p_aout_buf->i_nb_samples );
1359 p_chain = p_sys->p_chain;
1365 /*****************************************************************************
1366 * CloseEncoder: encoder destruction
1367 *****************************************************************************/
1368 static void CloseEncoder( vlc_object_t *p_this )
1370 encoder_t *p_enc = (encoder_t *)p_this;
1371 encoder_sys_t *p_sys = p_enc->p_sys;
1373 FLAC__stream_encoder_delete( p_sys->p_flac );
1375 free( p_sys->p_buffer );
1379 /*****************************************************************************
1380 * EncoderMetadataCallback: called by libflac to output metadata
1381 *****************************************************************************/
1382 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1383 const FLAC__StreamMetadata *metadata,
1386 VLC_UNUSED(encoder);
1387 encoder_t *p_enc = (encoder_t *)client_data;
1389 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1393 /*****************************************************************************
1394 * EncoderWriteCallback: called by libflac to output encoded samples
1395 *****************************************************************************/
1396 static FLAC__StreamEncoderWriteStatus
1397 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1398 const FLAC__byte buffer[],
1399 unsigned bytes, unsigned samples,
1400 unsigned current_frame, void *client_data )
1402 VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
1403 encoder_t *p_enc = (encoder_t *)client_data;
1404 encoder_sys_t *p_sys = p_enc->p_sys;
1409 if( p_sys->i_headers == 1 )
1411 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1413 /* Backup the STREAMINFO metadata block */
1414 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1415 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1416 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1417 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1420 /* Fake this as the last metadata block */
1421 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1424 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1427 p_block = block_New( p_enc, bytes );
1428 memcpy( p_block->p_buffer, buffer, bytes );
1430 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1432 p_sys->i_samples_delay -= samples;
1434 p_block->i_length = (mtime_t)1000000 *
1435 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1438 p_sys->i_pts += p_block->i_length;
1440 block_ChainAppend( &p_sys->p_chain, p_block );
1442 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;