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 *****************************************************************************/
30 #include <vlc_codec.h>
33 #ifdef HAVE_FLAC_STREAM_DECODER_H
34 # include <FLAC/stream_decoder.h>
35 # include <FLAC/stream_encoder.h>
39 #include <vlc_block_helper.h>
42 #define MAX_FLAC_HEADER_SIZE 16
44 #if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT >= 8
45 # define USE_NEW_FLAC_API
48 /*****************************************************************************
49 * decoder_sys_t : FLAC decoder descriptor
50 *****************************************************************************/
58 block_bytestream_t bytestream;
61 * Input/Output properties
64 aout_buffer_t *p_aout_buffer;
70 FLAC__StreamDecoder *p_flac;
71 FLAC__StreamMetadata_StreamInfo stream_info;
75 unsigned min_blocksize, max_blocksize;
76 unsigned min_framesize, max_framesize;
79 unsigned bits_per_sample;
83 vlc_bool_t b_stream_info;
88 audio_date_t end_date;
91 int i_frame_size, i_frame_length, i_bits_per_sample;
92 unsigned int i_rate, i_channels, i_channels_conf;
105 static int pi_channels_maps[7] =
109 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
110 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
111 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
112 | AOUT_CHAN_REARRIGHT,
113 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
114 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
115 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
116 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
119 /*****************************************************************************
121 *****************************************************************************/
122 static int OpenDecoder ( vlc_object_t * );
123 static int OpenPacketizer( vlc_object_t * );
124 static void CloseDecoder ( vlc_object_t * );
127 static int OpenEncoder ( vlc_object_t * );
128 static void CloseEncoder ( vlc_object_t * );
132 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
134 static block_t *PacketizeBlock( decoder_t *, block_t ** );
136 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
137 unsigned int *,int * );
141 static FLAC__StreamDecoderReadStatus
142 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
143 FLAC__byte buffer[], unsigned *bytes, void *client_data );
145 static FLAC__StreamDecoderWriteStatus
146 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
147 const FLAC__Frame *frame,
148 const FLAC__int32 *const buffer[], void *client_data );
150 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
151 const FLAC__StreamMetadata *metadata,
153 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
154 FLAC__StreamDecoderErrorStatus status,
157 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
158 int i_nb_channels, int i_samples );
159 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
160 int i_nb_channels, int i_samples );
162 static void decoder_state_error( decoder_t *p_dec,
163 FLAC__StreamDecoderState state );
166 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
167 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
169 /*****************************************************************************
171 *****************************************************************************/
174 set_category( CAT_INPUT );
175 set_subcategory( SUBCAT_INPUT_ACODEC );
176 add_shortcut( "flac" );
179 set_description( _("Flac audio decoder") );
180 set_capability( "decoder", 100 );
181 set_callbacks( OpenDecoder, CloseDecoder );
184 set_description( _("Flac audio encoder") );
185 set_capability( "encoder", 100 );
186 set_callbacks( OpenEncoder, CloseEncoder );
190 set_description( _("Flac audio packetizer") );
191 set_capability( "packetizer", 100 );
192 set_callbacks( OpenPacketizer, CloseDecoder );
196 /*****************************************************************************
197 * OpenDecoder: probe the decoder and return score
198 *****************************************************************************/
199 static int OpenDecoder( vlc_object_t *p_this )
201 decoder_t *p_dec = (decoder_t*)p_this;
202 decoder_sys_t *p_sys;
204 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
209 /* Allocate the memory needed to store the decoder's structure */
210 if( ( p_dec->p_sys = p_sys =
211 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
213 msg_Err( p_dec, "out of memory" );
218 aout_DateSet( &p_sys->end_date, 0 );
219 p_sys->i_state = STATE_NOSYNC;
220 p_sys->b_stream_info = VLC_FALSE;
222 p_sys->bytestream = block_BytestreamInit( p_dec );
225 /* Take care of flac init */
226 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
228 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
233 #ifdef USE_NEW_FLAC_API
234 if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
240 DecoderWriteCallback,
241 DecoderMetadataCallback,
242 DecoderErrorCallback,
244 != FLAC__STREAM_DECODER_INIT_STATUS_OK )
246 msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
247 FLAC__stream_decoder_delete( p_sys->p_flac );
252 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
253 DecoderReadCallback );
254 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
255 DecoderWriteCallback );
256 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
257 DecoderMetadataCallback );
258 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
259 DecoderErrorCallback );
260 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
262 FLAC__stream_decoder_init( p_sys->p_flac );
266 /* Set output properties */
267 p_dec->fmt_out.i_cat = AUDIO_ES;
268 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
272 p_dec->pf_decode_audio = DecodeBlock;
278 static int OpenPacketizer( vlc_object_t *p_this )
280 decoder_t *p_dec = (decoder_t*)p_this;
281 es_format_t es_save = p_dec->fmt_out;
285 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
287 i_ret = OpenDecoder( p_this );
288 p_dec->pf_decode_audio = NULL;
289 p_dec->pf_packetize = PacketizeBlock;
291 /* Set output properties */
292 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
294 if( i_ret != VLC_SUCCESS )
296 es_format_Clean( &p_dec->fmt_out );
297 p_dec->fmt_out = es_save;
302 /*****************************************************************************
303 * CloseDecoder: flac decoder destruction
304 *****************************************************************************/
305 static void CloseDecoder( vlc_object_t *p_this )
307 decoder_t *p_dec = (decoder_t *)p_this;
308 decoder_sys_t *p_sys = p_dec->p_sys;
311 FLAC__stream_decoder_finish( p_sys->p_flac );
312 FLAC__stream_decoder_delete( p_sys->p_flac );
315 if( p_sys->p_block ) free( p_sys->p_block );
319 /*****************************************************************************
320 * ProcessHeader: process Flac header.
321 *****************************************************************************/
322 static void ProcessHeader( decoder_t *p_dec )
324 decoder_sys_t *p_sys = p_dec->p_sys;
327 if( !p_dec->fmt_in.i_extra ) return;
329 /* Decode STREAMINFO */
330 msg_Dbg( p_dec, "decode STREAMINFO" );
331 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
332 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
333 p_dec->fmt_in.i_extra );
334 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
335 msg_Dbg( p_dec, "STREAMINFO decoded" );
340 if( !p_dec->fmt_in.i_extra ) return;
342 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
344 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
345 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
347 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
348 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
350 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
351 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
352 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
355 if( !p_sys->b_stream_info ) return;
357 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
359 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
360 p_dec->fmt_out.p_extra =
361 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
362 memcpy( p_dec->fmt_out.p_extra,
363 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
367 /****************************************************************************
368 * PacketizeBlock: the whole thing
369 ****************************************************************************
370 * This function is called just after the thread is launched.
371 ****************************************************************************/
372 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
374 decoder_sys_t *p_sys = p_dec->p_sys;
375 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
376 block_t *p_sout_block;
378 if( !pp_block || !*pp_block ) return NULL;
380 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
382 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
384 p_sys->i_state = STATE_NOSYNC;
385 block_BytestreamFlush( &p_sys->bytestream );
387 // aout_DateSet( &p_sys->end_date, 0 );
388 block_Release( *pp_block );
392 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
394 if( p_sys->stream_info.channels > 6 )
396 msg_Err( p_dec, "This stream uses too many audio channels" );
400 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
402 /* We've just started the stream, wait for the first PTS. */
403 block_Release( *pp_block );
406 else if( !aout_DateGet( &p_sys->end_date ) )
408 /* The first PTS is as good as anything else. */
409 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
412 block_BytestreamPush( &p_sys->bytestream, *pp_block );
416 switch( p_sys->i_state )
419 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
422 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
424 p_sys->i_state = STATE_SYNC;
427 block_SkipByte( &p_sys->bytestream );
429 if( p_sys->i_state != STATE_SYNC )
431 block_BytestreamFlush( &p_sys->bytestream );
438 /* New frame, set the Presentation Time Stamp */
439 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
440 if( p_sys->i_pts != 0 &&
441 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
443 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
445 p_sys->i_state = STATE_HEADER;
448 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
449 if( block_PeekBytes( &p_sys->bytestream, p_header,
450 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
456 /* Check if frame is valid and get frame info */
457 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
459 &p_sys->i_channels_conf,
461 &p_sys->i_bits_per_sample );
462 if( !p_sys->i_frame_length )
464 msg_Dbg( p_dec, "emulated sync word" );
465 block_SkipByte( &p_sys->bytestream );
466 p_sys->i_state = STATE_NOSYNC;
469 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
471 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
472 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
474 p_sys->i_state = STATE_NEXT_SYNC;
475 p_sys->i_frame_size = 1;
477 case STATE_NEXT_SYNC:
478 /* TODO: If pp_block == NULL, flush the buffer without checking the
481 /* Check if next expected frame contains the sync word */
482 while( block_PeekOffsetBytes( &p_sys->bytestream,
483 p_sys->i_frame_size, p_header,
484 MAX_FLAC_HEADER_SIZE )
487 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
489 /* Check if frame is valid and get frame info */
491 SyncInfo( p_dec, p_header,
493 &p_sys->i_channels_conf,
495 &p_sys->i_bits_per_sample );
499 p_sys->i_state = STATE_SEND_DATA;
503 p_sys->i_frame_size++;
506 if( p_sys->i_state != STATE_SEND_DATA )
512 case STATE_SEND_DATA:
513 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
515 /* Copy the whole frame into the buffer. When we reach this point
516 * we already know we have enough data available. */
517 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
518 p_sys->i_frame_size );
520 /* Make sure we don't reuse the same pts twice */
521 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
522 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
524 /* So p_block doesn't get re-added several times */
525 *pp_block = block_BytestreamPop( &p_sys->bytestream );
527 p_sys->i_state = STATE_NOSYNC;
529 /* Date management */
530 p_sout_block->i_pts =
531 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
532 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
533 p_sout_block->i_length =
534 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
544 /****************************************************************************
545 * DecodeBlock: the whole thing
546 ****************************************************************************/
547 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
549 decoder_sys_t *p_sys = p_dec->p_sys;
551 if( !pp_block || !*pp_block ) return NULL;
553 p_sys->p_aout_buffer = 0;
554 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
556 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
558 decoder_state_error( p_dec,
559 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
560 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
563 /* If the decoder is in the "aborted" state,
564 * FLAC__stream_decoder_process_single() won't return an error. */
565 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
566 == FLAC__STREAM_DECODER_ABORTED )
568 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
571 block_Release( p_sys->p_block );
572 p_sys->p_block = NULL;
575 return p_sys->p_aout_buffer;
578 /*****************************************************************************
579 * DecoderReadCallback: called by libflac when it needs more data
580 *****************************************************************************/
581 static FLAC__StreamDecoderReadStatus
582 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
583 unsigned *bytes, void *client_data )
585 decoder_t *p_dec = (decoder_t *)client_data;
586 decoder_sys_t *p_sys = p_dec->p_sys;
588 if( p_sys->p_block && p_sys->p_block->i_buffer )
590 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
591 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
592 p_sys->p_block->i_buffer -= *bytes;
593 p_sys->p_block->p_buffer += *bytes;
598 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
601 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
604 /*****************************************************************************
605 * DecoderWriteCallback: called by libflac to output decoded samples
606 *****************************************************************************/
607 static FLAC__StreamDecoderWriteStatus
608 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
609 const FLAC__Frame *frame,
610 const FLAC__int32 *const buffer[], void *client_data )
612 decoder_t *p_dec = (decoder_t *)client_data;
613 decoder_sys_t *p_sys = p_dec->p_sys;
615 p_sys->p_aout_buffer =
616 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
618 if( p_sys->p_aout_buffer == NULL )
619 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
621 switch( frame->header.bits_per_sample )
624 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
625 frame->header.channels, frame->header.blocksize );
628 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
629 frame->header.channels, frame->header.blocksize );
632 /* Date management (already done by packetizer) */
633 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
634 p_sys->p_aout_buffer->end_date =
635 p_sys->p_block->i_pts + p_sys->p_block->i_length;
637 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
640 /*****************************************************************************
641 * DecoderMetadataCallback: called by libflac to when it encounters metadata
642 *****************************************************************************/
643 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
644 const FLAC__StreamMetadata *metadata,
647 decoder_t *p_dec = (decoder_t *)client_data;
648 decoder_sys_t *p_sys = p_dec->p_sys;
650 if( p_dec->pf_decode_audio )
652 switch( metadata->data.stream_info.bits_per_sample )
655 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
658 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
661 msg_Dbg( p_dec, "strange bit/sample value: %d",
662 metadata->data.stream_info.bits_per_sample );
663 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
668 /* Setup the format */
669 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
670 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
671 p_dec->fmt_out.audio.i_physical_channels =
672 p_dec->fmt_out.audio.i_original_channels =
673 pi_channels_maps[metadata->data.stream_info.channels];
674 p_dec->fmt_out.audio.i_bitspersample =
675 metadata->data.stream_info.bits_per_sample;
677 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
679 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
680 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
681 p_dec->fmt_out.audio.i_bitspersample );
683 p_sys->b_stream_info = VLC_TRUE;
684 p_sys->stream_info = metadata->data.stream_info;
689 /*****************************************************************************
690 * DecoderErrorCallback: called when the libflac decoder encounters an error
691 *****************************************************************************/
692 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
693 FLAC__StreamDecoderErrorStatus status,
696 decoder_t *p_dec = (decoder_t *)client_data;
700 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
701 msg_Warn( p_dec, "an error in the stream caused the decoder to "
702 "lose synchronization." );
704 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
705 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
707 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
708 msg_Err( p_dec, "frame's data did not match the CRC in the "
712 msg_Err( p_dec, "got decoder error: %d", status );
715 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
719 /*****************************************************************************
720 * Interleave: helper function to interleave channels
721 *****************************************************************************/
722 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
723 int i_nb_channels, int i_samples )
726 for ( j = 0; j < i_samples; j++ )
728 for ( i = 0; i < i_nb_channels; i++ )
730 p_out[j * i_nb_channels + i] = pp_in[i][j];
734 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
735 int i_nb_channels, int i_samples )
738 for ( j = 0; j < i_samples; j++ )
740 for ( i = 0; i < i_nb_channels; i++ )
742 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
747 /*****************************************************************************
748 * decoder_state_error: print meaningful error messages
749 *****************************************************************************/
750 static void decoder_state_error( decoder_t *p_dec,
751 FLAC__StreamDecoderState state )
755 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
756 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
758 case FLAC__STREAM_DECODER_READ_METADATA:
759 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
760 "reading metadata." );
762 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
763 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
764 "searching for the frame sync code." );
766 case FLAC__STREAM_DECODER_READ_FRAME:
767 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
768 "reading a frame." );
770 case FLAC__STREAM_DECODER_END_OF_STREAM:
771 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
773 #ifdef USE_NEW_FLAC_API
774 case FLAC__STREAM_DECODER_OGG_ERROR:
775 msg_Err( p_dec, "error occurred in the Ogg layer." );
777 case FLAC__STREAM_DECODER_SEEK_ERROR:
778 msg_Err( p_dec, "error occurred while seeking." );
781 case FLAC__STREAM_DECODER_ABORTED:
782 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
784 #ifndef USE_NEW_FLAC_API
785 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
786 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
790 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
791 msg_Err( p_dec, "error when allocating memory." );
793 #ifndef USE_NEW_FLAC_API
794 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
795 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
796 "decoder was already initialized, usually because "
797 "FLAC__stream_decoder_finish() was not called." );
799 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
800 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
801 "all callbacks being set." );
804 case FLAC__STREAM_DECODER_UNINITIALIZED:
805 msg_Err( p_dec, "decoder in uninitialized state." );
808 msg_Warn(p_dec, "unknown error" );
813 /*****************************************************************************
814 * SyncInfo: parse FLAC sync info
815 *****************************************************************************/
816 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
817 unsigned int * pi_channels,
818 unsigned int * pi_channels_conf,
819 unsigned int * pi_sample_rate,
820 int * pi_bits_per_sample )
822 decoder_sys_t *p_sys = p_dec->p_sys;
823 int i_header, i_temp, i_read;
824 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
825 uint64_t i_sample_number = 0;
827 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
828 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
829 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
830 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
833 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
835 /* Check there is no emulated sync code in the rest of the header */
836 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
838 /* Find blocksize (framelength) */
839 switch( i_temp = p_buf[2] >> 4 )
842 if( b_fixed_blocksize )
843 i_blocksize = p_sys->stream_info.min_blocksize;
844 else return 0; /* We can't do anything with this */
855 i_blocksize = 576 << (i_temp - 2);
860 i_blocksize_hint = i_temp;
871 i_blocksize = 256 << (i_temp - 8);
875 /* Find samplerate */
876 switch( i_temp = p_buf[2] & 0x0f )
879 if( p_sys->b_stream_info )
880 *pi_sample_rate = p_sys->stream_info.sample_rate;
881 else return 0; /* We can't do anything with this */
891 *pi_sample_rate = 8000;
895 *pi_sample_rate = 16000;
899 *pi_sample_rate = 22050;
903 *pi_sample_rate = 24000;
907 *pi_sample_rate = 32000;
911 *pi_sample_rate = 44100;
915 *pi_sample_rate = 48000;
919 *pi_sample_rate = 96000;
925 i_sample_rate_hint = i_temp;
933 i_temp = (unsigned)(p_buf[3] >> 4);
937 int i_channel_assignment; /* ??? */
942 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
945 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
948 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
960 *pi_channels = i_temp + 1;
961 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
964 /* Find bits per sample */
965 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
968 if( p_sys->b_stream_info )
969 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
975 *pi_bits_per_sample = 8;
979 *pi_bits_per_sample = 12;
983 *pi_bits_per_sample = 16;
987 *pi_bits_per_sample = 20;
991 *pi_bits_per_sample = 24;
1000 /* Zero padding bit */
1001 if( p_buf[3] & 0x01 ) return 0;
1003 /* End of fixed size header */
1006 /* Find Sample/Frame number */
1007 if( i_blocksize_hint && b_variable_blocksize )
1009 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1010 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
1014 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1015 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
1017 if( p_sys->b_stream_info )
1018 i_sample_number *= p_sys->stream_info.min_blocksize;
1023 /* Read blocksize */
1024 if( i_blocksize_hint )
1026 int i_val1 = p_buf[i_header++];
1027 if( i_blocksize_hint == 7 )
1029 int i_val2 = p_buf[i_header++];
1030 i_val1 = (i_val1 << 8) | i_val2;
1032 i_blocksize = i_val1 + 1;
1035 /* Read sample rate */
1036 if( i_sample_rate_hint )
1038 int i_val1 = p_buf[i_header++];
1039 if( i_sample_rate_hint != 12 )
1041 int i_val2 = p_buf[i_header++];
1042 i_val1 = (i_val1 << 8) | i_val2;
1044 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1045 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1046 else *pi_sample_rate = i_val1 * 10;
1049 /* Check the CRC-8 byte */
1050 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1058 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1059 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1061 uint64_t i_result = 0;
1064 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1066 i_result = p_buf[0];
1069 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1071 i_result = p_buf[0] & 0x1F;
1074 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1076 i_result = p_buf[0] & 0x0F;
1079 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1081 i_result = p_buf[0] & 0x07;
1084 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1086 i_result = p_buf[0] & 0x03;
1089 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1091 i_result = p_buf[0] & 0x01;
1094 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1100 return I64C(0xffffffffffffffff);
1103 for( j = 1; j <= i; j++ )
1105 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1107 return I64C(0xffffffffffffffff);
1110 i_result |= (p_buf[j] & 0x3F);
1117 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1118 static uint8_t const flac_crc8_table[256] = {
1119 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1120 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1121 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1122 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1123 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1124 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1125 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1126 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1127 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1128 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1129 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1130 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1131 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1132 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1133 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1134 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1135 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1136 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1137 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1138 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1139 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1140 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1141 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1142 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1143 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1144 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1145 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1146 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1147 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1148 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1149 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1150 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1153 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1158 crc = flac_crc8_table[crc ^ *data++];
1164 /*****************************************************************************
1165 * encoder_sys_t : flac encoder descriptor
1166 *****************************************************************************/
1167 struct encoder_sys_t
1174 int i_samples_delay;
1177 FLAC__int32 *p_buffer;
1178 unsigned int i_buffer;
1185 FLAC__StreamEncoder *p_flac;
1186 FLAC__StreamMetadata_StreamInfo stream_info;
1194 #define STREAMINFO_SIZE 38
1196 static block_t *Encode( encoder_t *, aout_buffer_t * );
1198 static FLAC__StreamEncoderWriteStatus
1199 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1200 const FLAC__byte buffer[],
1201 unsigned bytes, unsigned samples,
1202 unsigned current_frame, void *client_data );
1204 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1205 const FLAC__StreamMetadata *metadata,
1206 void *client_data );
1208 /*****************************************************************************
1209 * OpenEncoder: probe the encoder and return score
1210 *****************************************************************************/
1211 static int OpenEncoder( vlc_object_t *p_this )
1213 encoder_t *p_enc = (encoder_t *)p_this;
1214 encoder_sys_t *p_sys;
1216 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1219 return VLC_EGENERIC;
1222 /* Allocate the memory needed to store the decoder's structure */
1223 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1225 msg_Err( p_enc, "out of memory" );
1226 return VLC_EGENERIC;
1228 p_enc->p_sys = p_sys;
1229 p_enc->pf_encode_audio = Encode;
1230 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1232 p_sys->i_headers = 0;
1233 p_sys->p_buffer = 0;
1234 p_sys->i_buffer = 0;
1235 p_sys->i_samples_delay = 0;
1237 /* Create flac encoder */
1238 if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1240 msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1242 return VLC_EGENERIC;
1245 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1246 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1247 p_enc->fmt_in.audio.i_channels );
1248 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1249 p_enc->fmt_in.audio.i_rate );
1250 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1251 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1253 /* Get and store the STREAMINFO metadata block as a p_extra */
1256 #ifdef USE_NEW_FLAC_API
1257 if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1258 EncoderWriteCallback,
1261 EncoderMetadataCallback,
1263 != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1265 msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1266 FLAC__stream_encoder_delete( p_sys->p_flac );
1268 return VLC_EGENERIC;
1271 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1272 EncoderWriteCallback );
1273 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1274 EncoderMetadataCallback );
1275 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1277 FLAC__stream_encoder_init( p_sys->p_flac );
1283 /****************************************************************************
1284 * Encode: the whole thing
1285 ****************************************************************************
1286 * This function spits out ogg packets.
1287 ****************************************************************************/
1288 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1290 encoder_sys_t *p_sys = p_enc->p_sys;
1294 p_sys->i_pts = p_aout_buf->start_date -
1295 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1296 (mtime_t)p_enc->fmt_in.audio.i_rate;
1298 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1300 /* Convert samples to FLAC__int32 */
1301 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1304 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1305 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1308 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1310 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1313 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1314 p_aout_buf->i_nb_samples );
1316 p_chain = p_sys->p_chain;
1322 /*****************************************************************************
1323 * CloseEncoder: encoder destruction
1324 *****************************************************************************/
1325 static void CloseEncoder( vlc_object_t *p_this )
1327 encoder_t *p_enc = (encoder_t *)p_this;
1328 encoder_sys_t *p_sys = p_enc->p_sys;
1330 FLAC__stream_encoder_delete( p_sys->p_flac );
1332 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1336 /*****************************************************************************
1337 * EncoderMetadataCallback: called by libflac to output metadata
1338 *****************************************************************************/
1339 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1340 const FLAC__StreamMetadata *metadata,
1343 encoder_t *p_enc = (encoder_t *)client_data;
1345 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1349 /*****************************************************************************
1350 * EncoderWriteCallback: called by libflac to output encoded samples
1351 *****************************************************************************/
1352 static FLAC__StreamEncoderWriteStatus
1353 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1354 const FLAC__byte buffer[],
1355 unsigned bytes, unsigned samples,
1356 unsigned current_frame, void *client_data )
1358 encoder_t *p_enc = (encoder_t *)client_data;
1359 encoder_sys_t *p_sys = p_enc->p_sys;
1364 if( p_sys->i_headers == 1 )
1366 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1368 /* Backup the STREAMINFO metadata block */
1369 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1370 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1371 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1372 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1375 /* Fake this as the last metadata block */
1376 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1379 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1382 p_block = block_New( p_enc, bytes );
1383 memcpy( p_block->p_buffer, buffer, bytes );
1385 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1387 p_sys->i_samples_delay -= samples;
1389 p_block->i_length = (mtime_t)1000000 *
1390 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1393 p_sys->i_pts += p_block->i_length;
1395 block_ChainAppend( &p_sys->p_chain, p_block );
1397 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;