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 decoder_NewAudioBuffer( 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 unsigned i_blocksize = 0;
864 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
865 uint64_t i_sample_number = 0;
867 bool b_variable_blocksize = ( p_sys->b_stream_info &&
868 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
869 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
870 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
873 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
875 /* Check there is no emulated sync code in the rest of the header */
876 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
878 /* Find blocksize (framelength) */
879 switch( i_temp = p_buf[2] >> 4 )
882 if( b_fixed_blocksize )
883 i_blocksize = p_sys->stream_info.min_blocksize;
884 else return 0; /* We can't do anything with this */
895 i_blocksize = 576 << (i_temp - 2);
900 i_blocksize_hint = i_temp;
911 i_blocksize = 256 << (i_temp - 8);
915 /* Find samplerate */
916 switch( i_temp = p_buf[2] & 0x0f )
919 if( p_sys->b_stream_info )
920 *pi_sample_rate = p_sys->stream_info.sample_rate;
921 else return 0; /* We can't do anything with this */
931 *pi_sample_rate = 8000;
935 *pi_sample_rate = 16000;
939 *pi_sample_rate = 22050;
943 *pi_sample_rate = 24000;
947 *pi_sample_rate = 32000;
951 *pi_sample_rate = 44100;
955 *pi_sample_rate = 48000;
959 *pi_sample_rate = 96000;
965 i_sample_rate_hint = i_temp;
973 i_temp = (unsigned)(p_buf[3] >> 4);
977 int i_channel_assignment; /* ??? */
982 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
985 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
988 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
1000 *pi_channels = i_temp + 1;
1001 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
1004 /* Find bits per sample */
1005 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
1008 if( p_sys->b_stream_info )
1009 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
1015 *pi_bits_per_sample = 8;
1019 *pi_bits_per_sample = 12;
1023 *pi_bits_per_sample = 16;
1027 *pi_bits_per_sample = 20;
1031 *pi_bits_per_sample = 24;
1040 /* Zero padding bit */
1041 if( p_buf[3] & 0x01 ) return 0;
1043 /* End of fixed size header */
1046 /* Find Sample/Frame number */
1047 if( i_blocksize_hint && b_variable_blocksize )
1049 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1050 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1054 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1055 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1057 if( p_sys->b_stream_info )
1058 i_sample_number *= p_sys->stream_info.min_blocksize;
1063 /* Read blocksize */
1064 if( i_blocksize_hint )
1066 int i_val1 = p_buf[i_header++];
1067 if( i_blocksize_hint == 7 )
1069 int i_val2 = p_buf[i_header++];
1070 i_val1 = (i_val1 << 8) | i_val2;
1072 i_blocksize = i_val1 + 1;
1075 /* Read sample rate */
1076 if( i_sample_rate_hint )
1078 int i_val1 = p_buf[i_header++];
1079 if( i_sample_rate_hint != 12 )
1081 int i_val2 = p_buf[i_header++];
1082 i_val1 = (i_val1 << 8) | i_val2;
1084 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1085 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1086 else *pi_sample_rate = i_val1 * 10;
1089 /* Check the CRC-8 byte */
1090 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1095 /* Sanity check using stream info header when possible */
1096 if( p_sys->b_stream_info )
1098 if( i_blocksize < p_sys->stream_info.min_blocksize ||
1099 i_blocksize > p_sys->stream_info.max_blocksize )
1105 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1106 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1108 uint64_t i_result = 0;
1111 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1113 i_result = p_buf[0];
1116 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1118 i_result = p_buf[0] & 0x1F;
1121 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1123 i_result = p_buf[0] & 0x0F;
1126 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1128 i_result = p_buf[0] & 0x07;
1131 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1133 i_result = p_buf[0] & 0x03;
1136 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1138 i_result = p_buf[0] & 0x01;
1141 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1147 return INT64_C(0xffffffffffffffff);
1150 for( j = 1; j <= i; j++ )
1152 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1154 return INT64_C(0xffffffffffffffff);
1157 i_result |= (p_buf[j] & 0x3F);
1164 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1165 static const uint8_t flac_crc8_table[256] = {
1166 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1167 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1168 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1169 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1170 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1171 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1172 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1173 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1174 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1175 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1176 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1177 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1178 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1179 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1180 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1181 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1182 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1183 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1184 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1185 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1186 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1187 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1188 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1189 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1190 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1191 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1192 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1193 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1194 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1195 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1196 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1197 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1200 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1205 crc = flac_crc8_table[crc ^ *data++];
1211 /*****************************************************************************
1212 * encoder_sys_t : flac encoder descriptor
1213 *****************************************************************************/
1214 struct encoder_sys_t
1221 int i_samples_delay;
1224 FLAC__int32 *p_buffer;
1225 unsigned int i_buffer;
1232 FLAC__StreamEncoder *p_flac;
1233 FLAC__StreamMetadata_StreamInfo stream_info;
1241 #define STREAMINFO_SIZE 38
1243 static block_t *Encode( encoder_t *, aout_buffer_t * );
1245 static FLAC__StreamEncoderWriteStatus
1246 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1247 const FLAC__byte buffer[],
1248 unsigned bytes, unsigned samples,
1249 unsigned current_frame, void *client_data );
1251 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1252 const FLAC__StreamMetadata *metadata,
1253 void *client_data );
1255 /*****************************************************************************
1256 * OpenEncoder: probe the encoder and return score
1257 *****************************************************************************/
1258 static int OpenEncoder( vlc_object_t *p_this )
1260 encoder_t *p_enc = (encoder_t *)p_this;
1261 encoder_sys_t *p_sys;
1263 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1266 return VLC_EGENERIC;
1269 /* Allocate the memory needed to store the decoder's structure */
1270 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1272 p_enc->p_sys = p_sys;
1273 p_enc->pf_encode_audio = Encode;
1274 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1276 p_sys->i_headers = 0;
1277 p_sys->p_buffer = 0;
1278 p_sys->i_buffer = 0;
1279 p_sys->i_samples_delay = 0;
1281 /* Create flac encoder */
1282 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1284 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1286 return VLC_EGENERIC;
1289 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1290 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1291 p_enc->fmt_in.audio.i_channels );
1292 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1293 p_enc->fmt_in.audio.i_rate );
1294 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1295 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1297 /* Get and store the STREAMINFO metadata block as a p_extra */
1300 #ifdef USE_NEW_FLAC_API
1301 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1302 EncoderWriteCallback,
1305 EncoderMetadataCallback,
1307 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1309 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1310 FLAC__stream_encoder_delete( p_sys->p_flac );
1312 return VLC_EGENERIC;
1315 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1316 EncoderWriteCallback );
1317 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1318 EncoderMetadataCallback );
1319 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1321 FLAC__stream_encoder_init( p_sys->p_flac );
1327 /****************************************************************************
1328 * Encode: the whole thing
1329 ****************************************************************************
1330 * This function spits out ogg packets.
1331 ****************************************************************************/
1332 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1334 encoder_sys_t *p_sys = p_enc->p_sys;
1338 p_sys->i_pts = p_aout_buf->start_date -
1339 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1340 (mtime_t)p_enc->fmt_in.audio.i_rate;
1342 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1344 /* Convert samples to FLAC__int32 */
1345 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1348 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1349 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1352 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1354 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1357 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1358 p_aout_buf->i_nb_samples );
1360 p_chain = p_sys->p_chain;
1366 /*****************************************************************************
1367 * CloseEncoder: encoder destruction
1368 *****************************************************************************/
1369 static void CloseEncoder( vlc_object_t *p_this )
1371 encoder_t *p_enc = (encoder_t *)p_this;
1372 encoder_sys_t *p_sys = p_enc->p_sys;
1374 FLAC__stream_encoder_delete( p_sys->p_flac );
1376 free( p_sys->p_buffer );
1380 /*****************************************************************************
1381 * EncoderMetadataCallback: called by libflac to output metadata
1382 *****************************************************************************/
1383 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1384 const FLAC__StreamMetadata *metadata,
1387 VLC_UNUSED(encoder);
1388 encoder_t *p_enc = (encoder_t *)client_data;
1390 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1394 /*****************************************************************************
1395 * EncoderWriteCallback: called by libflac to output encoded samples
1396 *****************************************************************************/
1397 static FLAC__StreamEncoderWriteStatus
1398 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1399 const FLAC__byte buffer[],
1400 unsigned bytes, unsigned samples,
1401 unsigned current_frame, void *client_data )
1403 VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
1404 encoder_t *p_enc = (encoder_t *)client_data;
1405 encoder_sys_t *p_sys = p_enc->p_sys;
1410 if( p_sys->i_headers == 1 )
1412 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1414 /* Backup the STREAMINFO metadata block */
1415 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1416 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1417 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1418 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1421 /* Fake this as the last metadata block */
1422 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1425 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1428 p_block = block_New( p_enc, bytes );
1429 memcpy( p_block->p_buffer, buffer, bytes );
1431 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1433 p_sys->i_samples_delay -= samples;
1435 p_block->i_length = (mtime_t)1000000 *
1436 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1439 p_sys->i_pts += p_block->i_length;
1441 block_ChainAppend( &p_sys->p_chain, p_block );
1443 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;