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/decoder.h>
32 #ifdef HAVE_FLAC_STREAM_DECODER_H
33 # include <FLAC/stream_decoder.h>
34 # include <FLAC/stream_encoder.h>
38 #include "vlc_block_helper.h"
41 #define MAX_FLAC_HEADER_SIZE 16
43 /*****************************************************************************
44 * decoder_sys_t : FLAC decoder descriptor
45 *****************************************************************************/
53 block_bytestream_t bytestream;
56 * Input/Output properties
59 aout_buffer_t *p_aout_buffer;
65 FLAC__StreamDecoder *p_flac;
66 FLAC__StreamMetadata_StreamInfo stream_info;
70 unsigned min_blocksize, max_blocksize;
71 unsigned min_framesize, max_framesize;
74 unsigned bits_per_sample;
78 vlc_bool_t b_stream_info;
83 audio_date_t end_date;
86 int i_frame_size, i_frame_length, i_bits_per_sample;
87 unsigned int i_rate, i_channels, i_channels_conf;
100 static int pi_channels_maps[6] =
104 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
105 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
106 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
107 | AOUT_CHAN_REARRIGHT,
108 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
109 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
112 /*****************************************************************************
114 *****************************************************************************/
115 static int OpenDecoder ( vlc_object_t * );
116 static int OpenPacketizer( vlc_object_t * );
117 static void CloseDecoder ( vlc_object_t * );
120 static int OpenEncoder ( vlc_object_t * );
121 static void CloseEncoder ( vlc_object_t * );
125 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
127 static block_t *PacketizeBlock( decoder_t *, block_t ** );
129 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
130 unsigned int *,int * );
134 static FLAC__StreamDecoderReadStatus
135 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
136 FLAC__byte buffer[], unsigned *bytes, void *client_data );
138 static FLAC__StreamDecoderWriteStatus
139 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
140 const FLAC__Frame *frame,
141 const FLAC__int32 *const buffer[], void *client_data );
143 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
144 const FLAC__StreamMetadata *metadata,
146 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
147 FLAC__StreamDecoderErrorStatus status,
150 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
151 int i_nb_channels, int i_samples );
152 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
153 int i_nb_channels, int i_samples );
155 static void decoder_state_error( decoder_t *p_dec,
156 FLAC__StreamDecoderState state );
159 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
160 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
162 /*****************************************************************************
164 *****************************************************************************/
167 set_category( CAT_INPUT );
168 set_subcategory( SUBCAT_INPUT_ACODEC );
171 set_description( _("Flac audio decoder") );
172 set_capability( "decoder", 100 );
173 set_callbacks( OpenDecoder, CloseDecoder );
176 set_description( _("Flac audio encoder") );
177 set_capability( "encoder", 100 );
178 set_callbacks( OpenEncoder, CloseEncoder );
182 set_description( _("Flac audio packetizer") );
183 set_capability( "packetizer", 100 );
184 set_callbacks( OpenPacketizer, CloseDecoder );
186 add_shortcut( "flac" );
189 /*****************************************************************************
190 * OpenDecoder: probe the decoder and return score
191 *****************************************************************************/
192 static int OpenDecoder( vlc_object_t *p_this )
194 decoder_t *p_dec = (decoder_t*)p_this;
195 decoder_sys_t *p_sys;
197 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
202 /* Allocate the memory needed to store the decoder's structure */
203 if( ( p_dec->p_sys = p_sys =
204 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
206 msg_Err( p_dec, "out of memory" );
211 aout_DateSet( &p_sys->end_date, 0 );
212 p_sys->i_state = STATE_NOSYNC;
213 p_sys->b_stream_info = VLC_FALSE;
215 p_sys->bytestream = block_BytestreamInit( p_dec );
218 /* Take care of flac init */
219 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
221 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
226 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
227 DecoderReadCallback );
228 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
229 DecoderWriteCallback );
230 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
231 DecoderMetadataCallback );
232 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
233 DecoderErrorCallback );
234 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
236 FLAC__stream_decoder_init( p_sys->p_flac );
239 /* Set output properties */
240 p_dec->fmt_out.i_cat = AUDIO_ES;
241 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
245 p_dec->pf_decode_audio = DecodeBlock;
247 p_dec->pf_packetize = PacketizeBlock;
252 static int OpenPacketizer( vlc_object_t *p_this )
254 decoder_t *p_dec = (decoder_t*)p_this;
257 /* Hmmm, mem leak ?*/
258 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
260 i_ret = OpenDecoder( p_this );
262 /* Set output properties */
263 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
265 if( i_ret != VLC_SUCCESS ) return i_ret;
270 /*****************************************************************************
271 * CloseDecoder: flac decoder destruction
272 *****************************************************************************/
273 static void CloseDecoder( vlc_object_t *p_this )
275 decoder_t *p_dec = (decoder_t *)p_this;
276 decoder_sys_t *p_sys = p_dec->p_sys;
279 FLAC__stream_decoder_finish( p_sys->p_flac );
280 FLAC__stream_decoder_delete( p_sys->p_flac );
283 if( p_sys->p_block ) free( p_sys->p_block );
287 /*****************************************************************************
288 * ProcessHeader: processe Flac header.
289 *****************************************************************************/
290 static void ProcessHeader( decoder_t *p_dec )
292 decoder_sys_t *p_sys = p_dec->p_sys;
295 if( !p_dec->fmt_in.i_extra ) return;
297 /* Decode STREAMINFO */
298 msg_Dbg( p_dec, "decode STREAMINFO" );
299 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
300 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
301 p_dec->fmt_in.i_extra );
302 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
303 msg_Dbg( p_dec, "STREAMINFO decoded" );
308 if( !p_dec->fmt_in.i_extra ) return;
310 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
312 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
313 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
315 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
316 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
318 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
319 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
320 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
323 if( !p_sys->b_stream_info ) return;
325 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
327 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
328 p_dec->fmt_out.p_extra =
329 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
330 memcpy( p_dec->fmt_out.p_extra,
331 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
335 /****************************************************************************
336 * PacketizeBlock: the whole thing
337 ****************************************************************************
338 * This function is called just after the thread is launched.
339 ****************************************************************************/
340 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
342 decoder_sys_t *p_sys = p_dec->p_sys;
343 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
344 block_t *p_sout_block;
346 if( !pp_block || !*pp_block ) return NULL;
348 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
350 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
352 /* We've just started the stream, wait for the first PTS. */
353 block_Release( *pp_block );
356 else if( !aout_DateGet( &p_sys->end_date ) )
358 /* The first PTS is as good as anything else. */
359 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
362 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
364 p_sys->i_state = STATE_NOSYNC;
367 block_BytestreamPush( &p_sys->bytestream, *pp_block );
371 switch( p_sys->i_state )
374 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
377 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
379 p_sys->i_state = STATE_SYNC;
382 block_SkipByte( &p_sys->bytestream );
384 if( p_sys->i_state != STATE_SYNC )
386 block_BytestreamFlush( &p_sys->bytestream );
393 /* New frame, set the Presentation Time Stamp */
394 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
395 if( p_sys->i_pts != 0 &&
396 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
398 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
400 p_sys->i_state = STATE_HEADER;
403 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
404 if( block_PeekBytes( &p_sys->bytestream, p_header,
405 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
411 /* Check if frame is valid and get frame info */
412 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
414 &p_sys->i_channels_conf,
416 &p_sys->i_bits_per_sample );
417 if( !p_sys->i_frame_length )
419 msg_Dbg( p_dec, "emulated sync word" );
420 block_SkipByte( &p_sys->bytestream );
421 p_sys->i_state = STATE_NOSYNC;
424 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
426 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
427 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
429 p_sys->i_state = STATE_NEXT_SYNC;
430 p_sys->i_frame_size = 1;
432 case STATE_NEXT_SYNC:
433 /* TODO: If pp_block == NULL, flush the buffer without checking the
436 /* Check if next expected frame contains the sync word */
437 while( block_PeekOffsetBytes( &p_sys->bytestream,
438 p_sys->i_frame_size, p_header,
439 MAX_FLAC_HEADER_SIZE )
442 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
444 /* Check if frame is valid and get frame info */
446 SyncInfo( p_dec, p_header,
448 &p_sys->i_channels_conf,
450 &p_sys->i_bits_per_sample );
454 p_sys->i_state = STATE_SEND_DATA;
458 p_sys->i_frame_size++;
461 if( p_sys->i_state != STATE_SEND_DATA )
467 case STATE_SEND_DATA:
468 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
470 /* Copy the whole frame into the buffer. When we reach this point
471 * we already know we have enough data available. */
472 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
473 p_sys->i_frame_size );
475 /* Make sure we don't reuse the same pts twice */
476 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
477 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
479 /* So p_block doesn't get re-added several times */
480 *pp_block = block_BytestreamPop( &p_sys->bytestream );
482 p_sys->i_state = STATE_NOSYNC;
484 /* Date management */
485 p_sout_block->i_pts =
486 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
487 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
488 p_sout_block->i_length =
489 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
499 /****************************************************************************
500 * DecodeBlock: the whole thing
501 ****************************************************************************/
502 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
504 decoder_sys_t *p_sys = p_dec->p_sys;
506 if( !pp_block || !*pp_block ) return NULL;
508 p_sys->p_aout_buffer = 0;
509 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
511 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
513 decoder_state_error( p_dec,
514 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
515 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
518 /* If the decoder is in the "aborted" state,
519 * FLAC__stream_decoder_process_single() won't return an error. */
520 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
521 == FLAC__STREAM_DECODER_ABORTED )
523 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
526 block_Release( p_sys->p_block );
527 p_sys->p_block = NULL;
530 return p_sys->p_aout_buffer;
533 /*****************************************************************************
534 * DecoderReadCallback: called by libflac when it needs more data
535 *****************************************************************************/
536 static FLAC__StreamDecoderReadStatus
537 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
538 unsigned *bytes, void *client_data )
540 decoder_t *p_dec = (decoder_t *)client_data;
541 decoder_sys_t *p_sys = p_dec->p_sys;
543 if( p_sys->p_block && p_sys->p_block->i_buffer )
545 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
546 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
547 p_sys->p_block->i_buffer -= *bytes;
548 p_sys->p_block->p_buffer += *bytes;
553 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
556 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
559 /*****************************************************************************
560 * DecoderWriteCallback: called by libflac to output decoded samples
561 *****************************************************************************/
562 static FLAC__StreamDecoderWriteStatus
563 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
564 const FLAC__Frame *frame,
565 const FLAC__int32 *const buffer[], void *client_data )
567 decoder_t *p_dec = (decoder_t *)client_data;
568 decoder_sys_t *p_sys = p_dec->p_sys;
570 p_sys->p_aout_buffer =
571 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
573 if( p_sys->p_aout_buffer == NULL )
574 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
576 switch( frame->header.bits_per_sample )
579 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
580 frame->header.channels, frame->header.blocksize );
583 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
584 frame->header.channels, frame->header.blocksize );
587 /* Date management (already done by packetizer) */
588 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
589 p_sys->p_aout_buffer->end_date =
590 p_sys->p_block->i_pts + p_sys->p_block->i_length;
592 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
595 /*****************************************************************************
596 * DecoderMetadataCallback: called by libflac to when it encounters metadata
597 *****************************************************************************/
598 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
599 const FLAC__StreamMetadata *metadata,
602 decoder_t *p_dec = (decoder_t *)client_data;
603 decoder_sys_t *p_sys = p_dec->p_sys;
605 switch( metadata->data.stream_info.bits_per_sample )
608 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
611 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
614 msg_Dbg( p_dec, "strange bit/sample value: %d",
615 metadata->data.stream_info.bits_per_sample );
616 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
620 /* Setup the format */
621 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
622 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
623 p_dec->fmt_out.audio.i_physical_channels =
624 p_dec->fmt_out.audio.i_original_channels =
625 pi_channels_maps[metadata->data.stream_info.channels];
626 p_dec->fmt_out.audio.i_bitspersample =
627 metadata->data.stream_info.bits_per_sample;
629 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
631 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
632 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
633 p_dec->fmt_out.audio.i_bitspersample );
635 p_sys->b_stream_info = VLC_TRUE;
636 p_sys->stream_info = metadata->data.stream_info;
641 /*****************************************************************************
642 * DecoderErrorCallback: called when the libflac decoder encounters an error
643 *****************************************************************************/
644 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
645 FLAC__StreamDecoderErrorStatus status,
648 decoder_t *p_dec = (decoder_t *)client_data;
652 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
653 msg_Warn( p_dec, "an error in the stream caused the decoder to "
654 "lose synchronization." );
656 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
657 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
659 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
660 msg_Err( p_dec, "frame's data did not match the CRC in the "
664 msg_Err( p_dec, "got decoder error: %d", status );
667 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
671 /*****************************************************************************
672 * Interleave: helper function to interleave channels
673 *****************************************************************************/
674 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
675 int i_nb_channels, int i_samples )
678 for ( j = 0; j < i_samples; j++ )
680 for ( i = 0; i < i_nb_channels; i++ )
682 p_out[j * i_nb_channels + i] = pp_in[i][j];
686 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
687 int i_nb_channels, int i_samples )
690 for ( j = 0; j < i_samples; j++ )
692 for ( i = 0; i < i_nb_channels; i++ )
694 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
699 /*****************************************************************************
700 * decoder_state_error: print meaningful error messages
701 *****************************************************************************/
702 static void decoder_state_error( decoder_t *p_dec,
703 FLAC__StreamDecoderState state )
707 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
708 msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
710 case FLAC__STREAM_DECODER_READ_METADATA:
711 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
712 "reading metadata." );
714 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
715 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
716 "searching for the frame sync code." );
718 case FLAC__STREAM_DECODER_READ_FRAME:
719 msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
720 "reading a frame." );
722 case FLAC__STREAM_DECODER_END_OF_STREAM:
723 msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
725 case FLAC__STREAM_DECODER_ABORTED:
726 msg_Warn( p_dec, "the decoder was aborted by the read callback." );
728 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
729 msg_Warn( p_dec, "the decoder encountered reserved fields in use "
732 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
733 msg_Err( p_dec, "error when allocating memory." );
735 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
736 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
737 "decoder was already initialized, usually because "
738 "FLAC__stream_decoder_finish() was not called." );
740 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
741 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
742 "all callbacks being set." );
744 case FLAC__STREAM_DECODER_UNINITIALIZED:
745 msg_Err( p_dec, "decoder in uninitialized state." );
748 msg_Warn(p_dec, "unknown error" );
753 /*****************************************************************************
754 * SyncInfo: parse FLAC sync info
755 *****************************************************************************/
756 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
757 unsigned int * pi_channels,
758 unsigned int * pi_channels_conf,
759 unsigned int * pi_sample_rate,
760 int * pi_bits_per_sample )
762 decoder_sys_t *p_sys = p_dec->p_sys;
763 int i_header, i_temp, i_read;
764 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
765 uint64_t i_sample_number = 0;
767 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
768 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
769 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
770 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
773 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
775 /* Check there is no emulated sync code in the rest of the header */
776 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
778 /* Find blocksize (framelength) */
779 switch( i_temp = p_buf[2] >> 4 )
782 if( b_fixed_blocksize )
783 i_blocksize = p_sys->stream_info.min_blocksize;
784 else return 0; /* We can't do anything with this */
795 i_blocksize = 576 << (i_temp - 2);
800 i_blocksize_hint = i_temp;
811 i_blocksize = 256 << (i_temp - 8);
815 /* Find samplerate */
816 switch( i_temp = p_buf[2] & 0x0f )
819 if( p_sys->b_stream_info )
820 *pi_sample_rate = p_sys->stream_info.sample_rate;
821 else return 0; /* We can't do anything with this */
831 *pi_sample_rate = 8000;
835 *pi_sample_rate = 16000;
839 *pi_sample_rate = 22050;
843 *pi_sample_rate = 24000;
847 *pi_sample_rate = 32000;
851 *pi_sample_rate = 44100;
855 *pi_sample_rate = 48000;
859 *pi_sample_rate = 96000;
865 i_sample_rate_hint = i_temp;
873 i_temp = (unsigned)(p_buf[3] >> 4);
877 int i_channel_assignment; /* ??? */
882 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
885 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
888 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
900 *pi_channels = i_temp + 1;
901 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
904 /* Find bits per sample */
905 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
908 if( p_sys->b_stream_info )
909 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
915 *pi_bits_per_sample = 8;
919 *pi_bits_per_sample = 12;
923 *pi_bits_per_sample = 16;
927 *pi_bits_per_sample = 20;
931 *pi_bits_per_sample = 24;
940 /* Zero padding bit */
941 if( p_buf[3] & 0x01 ) return 0;
943 /* End of fixed size header */
946 /* Find Sample/Frame number */
947 if( i_blocksize_hint && b_variable_blocksize )
949 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
950 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
954 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
955 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
957 if( p_sys->b_stream_info )
958 i_sample_number *= p_sys->stream_info.min_blocksize;
964 if( i_blocksize_hint )
966 int i_val1 = p_buf[i_header++];
967 if( i_blocksize_hint == 7 )
969 int i_val2 = p_buf[i_header++];
970 i_val1 = (i_val1 << 8) | i_val2;
972 i_blocksize = i_val1 + 1;
975 /* Read sample rate */
976 if( i_sample_rate_hint )
978 int i_val1 = p_buf[i_header++];
979 if( i_sample_rate_hint != 12 )
981 int i_val2 = p_buf[i_header++];
982 i_val1 = (i_val1 << 8) | i_val2;
984 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
985 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
986 else *pi_sample_rate = i_val1 * 10;
989 /* Check the CRC-8 byte */
990 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
998 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
999 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1001 uint64_t i_result = 0;
1004 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1006 i_result = p_buf[0];
1009 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1011 i_result = p_buf[0] & 0x1F;
1014 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1016 i_result = p_buf[0] & 0x0F;
1019 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1021 i_result = p_buf[0] & 0x07;
1024 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1026 i_result = p_buf[0] & 0x03;
1029 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1031 i_result = p_buf[0] & 0x01;
1034 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1040 return I64C(0xffffffffffffffff);
1043 for( j = 1; j <= i; j++ )
1045 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1047 return I64C(0xffffffffffffffff);
1050 i_result |= (p_buf[j] & 0x3F);
1057 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1058 static uint8_t const flac_crc8_table[256] = {
1059 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1060 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1061 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1062 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1063 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1064 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1065 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1066 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1067 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1068 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1069 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1070 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1071 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1072 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1073 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1074 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1075 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1076 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1077 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1078 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1079 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1080 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1081 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1082 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1083 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1084 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1085 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1086 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1087 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1088 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1089 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1090 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1093 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1098 crc = flac_crc8_table[crc ^ *data++];
1104 /*****************************************************************************
1105 * encoder_sys_t : flac encoder descriptor
1106 *****************************************************************************/
1107 struct encoder_sys_t
1114 int i_samples_delay;
1117 FLAC__int32 *p_buffer;
1118 unsigned int i_buffer;
1125 FLAC__StreamEncoder *p_flac;
1126 FLAC__StreamMetadata_StreamInfo stream_info;
1134 #define STREAMINFO_SIZE 38
1136 static block_t *Encode( encoder_t *, aout_buffer_t * );
1138 static FLAC__StreamEncoderWriteStatus
1139 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1140 const FLAC__byte buffer[],
1141 unsigned bytes, unsigned samples,
1142 unsigned current_frame, void *client_data );
1144 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1145 const FLAC__StreamMetadata *metadata,
1146 void *client_data );
1148 /*****************************************************************************
1149 * OpenEncoder: probe the encoder and return score
1150 *****************************************************************************/
1151 static int OpenEncoder( vlc_object_t *p_this )
1153 encoder_t *p_enc = (encoder_t *)p_this;
1154 encoder_sys_t *p_sys;
1156 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1159 return VLC_EGENERIC;
1162 /* Allocate the memory needed to store the decoder's structure */
1163 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1165 msg_Err( p_enc, "out of memory" );
1166 return VLC_EGENERIC;
1168 p_enc->p_sys = p_sys;
1169 p_enc->pf_encode_audio = Encode;
1170 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1172 p_sys->i_headers = 0;
1173 p_sys->p_buffer = 0;
1174 p_sys->i_buffer = 0;
1175 p_sys->i_samples_delay = 0;
1177 /* Create flac encoder */
1178 p_sys->p_flac = FLAC__stream_encoder_new();
1180 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1181 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1182 p_enc->fmt_in.audio.i_channels );
1183 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1184 p_enc->fmt_in.audio.i_rate );
1185 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1186 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1188 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1189 EncoderWriteCallback );
1190 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1191 EncoderMetadataCallback );
1192 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1194 /* Get and store the STREAMINFO metadata block as a p_extra */
1196 FLAC__stream_encoder_init( p_sys->p_flac );
1201 /****************************************************************************
1202 * Encode: the whole thing
1203 ****************************************************************************
1204 * This function spits out ogg packets.
1205 ****************************************************************************/
1206 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1208 encoder_sys_t *p_sys = p_enc->p_sys;
1212 p_sys->i_pts = p_aout_buf->start_date -
1213 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1214 (mtime_t)p_enc->fmt_in.audio.i_rate;
1216 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1218 /* Convert samples to FLAC__int32 */
1219 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1222 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1223 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1226 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1228 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1231 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1232 p_aout_buf->i_nb_samples );
1234 p_chain = p_sys->p_chain;
1240 /*****************************************************************************
1241 * CloseEncoder: encoder destruction
1242 *****************************************************************************/
1243 static void CloseEncoder( vlc_object_t *p_this )
1245 encoder_t *p_enc = (encoder_t *)p_this;
1246 encoder_sys_t *p_sys = p_enc->p_sys;
1248 FLAC__stream_encoder_delete( p_sys->p_flac );
1250 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1254 /*****************************************************************************
1255 * EncoderMetadataCallback: called by libflac to output metadata
1256 *****************************************************************************/
1257 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1258 const FLAC__StreamMetadata *metadata,
1261 encoder_t *p_enc = (encoder_t *)client_data;
1263 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1267 /*****************************************************************************
1268 * EncoderWriteCallback: called by libflac to output encoded samples
1269 *****************************************************************************/
1270 static FLAC__StreamEncoderWriteStatus
1271 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1272 const FLAC__byte buffer[],
1273 unsigned bytes, unsigned samples,
1274 unsigned current_frame, void *client_data )
1276 encoder_t *p_enc = (encoder_t *)client_data;
1277 encoder_sys_t *p_sys = p_enc->p_sys;
1282 if( p_sys->i_headers == 1 )
1284 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1286 /* Backup the STREAMINFO metadata block */
1287 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1288 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1289 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1290 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1293 /* Fake this as the last metadata block */
1294 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1297 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1300 p_block = block_New( p_enc, bytes );
1301 memcpy( p_block->p_buffer, buffer, bytes );
1303 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1305 p_sys->i_samples_delay -= samples;
1307 p_block->i_length = (mtime_t)1000000 *
1308 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1311 p_sys->i_pts += p_block->i_length;
1313 block_ChainAppend( &p_sys->p_chain, p_block );
1315 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;