1 /*****************************************************************************
2 * flac.c: flac decoder/packetizer/encoder module making use of libflac
3 *****************************************************************************
4 * Copyright (C) 1999-2001 VideoLAN
5 * $Id: flac.c,v 1.9 2004/02/25 17:48:52 fenrir Exp $
7 * Authors: Gildas Bazin <gbazin@netcourrier.com>
8 * Sigmund Augdal <sigmunau@idi.ntnu.no>
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., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
30 #include <vlc/decoder.h>
32 #include <FLAC/stream_decoder.h>
33 #include <FLAC/stream_encoder.h>
35 #include "vlc_block_helper.h"
37 #define MAX_FLAC_HEADER_SIZE 16
39 /*****************************************************************************
40 * decoder_sys_t : FLAC decoder descriptor
41 *****************************************************************************/
49 block_bytestream_t bytestream;
52 * Input/Output properties
55 aout_buffer_t *p_aout_buffer;
60 FLAC__StreamDecoder *p_flac;
62 vlc_bool_t b_stream_info;
63 FLAC__StreamMetadata_StreamInfo stream_info;
68 audio_date_t end_date;
71 int i_frame_size, i_frame_length, i_bits_per_sample;
72 unsigned int i_rate, i_channels, i_channels_conf;
85 static int pi_channels_maps[6] =
89 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
90 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
91 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
92 | AOUT_CHAN_REARRIGHT,
93 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
94 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
97 /*****************************************************************************
99 *****************************************************************************/
100 static int OpenDecoder ( vlc_object_t * );
101 static int OpenPacketizer( vlc_object_t * );
102 static void CloseDecoder ( vlc_object_t * );
104 static int OpenEncoder ( vlc_object_t * );
105 static void CloseEncoder ( vlc_object_t * );
107 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
108 static block_t *PacketizeBlock( decoder_t *, block_t ** );
110 static int SyncInfo( decoder_t *, uint8_t *, int *, int *, int *,int * );
113 static FLAC__StreamDecoderReadStatus
114 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
115 FLAC__byte buffer[], unsigned *bytes, void *client_data );
117 static FLAC__StreamDecoderWriteStatus
118 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
119 const FLAC__Frame *frame,
120 const FLAC__int32 *const buffer[], void *client_data );
122 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
123 const FLAC__StreamMetadata *metadata,
125 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
126 FLAC__StreamDecoderErrorStatus status,
129 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
130 int i_nb_channels, int i_samples );
131 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
132 int i_nb_channels, int i_samples );
134 static void decoder_state_error( decoder_t *p_dec,
135 FLAC__StreamDecoderState state );
137 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
138 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
140 /*****************************************************************************
142 *****************************************************************************/
145 set_description( _("Flac audio decoder") );
146 set_capability( "decoder", 100 );
147 set_callbacks( OpenDecoder, CloseDecoder );
150 set_description( _("Flac audio packetizer") );
151 set_capability( "packetizer", 100 );
152 set_callbacks( OpenPacketizer, CloseDecoder );
155 set_description( _("Flac audio encoder") );
156 set_capability( "encoder", 100 );
157 set_callbacks( OpenEncoder, CloseEncoder );
161 /*****************************************************************************
162 * OpenDecoder: probe the decoder and return score
163 *****************************************************************************/
164 static int OpenDecoder( vlc_object_t *p_this )
166 decoder_t *p_dec = (decoder_t*)p_this;
167 decoder_sys_t *p_sys;
169 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
174 /* Allocate the memory needed to store the decoder's structure */
175 if( ( p_dec->p_sys = p_sys =
176 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
178 msg_Err( p_dec, "out of memory" );
183 aout_DateSet( &p_sys->end_date, 0 );
184 p_sys->i_state = STATE_NOSYNC;
185 p_sys->b_stream_info = VLC_FALSE;
187 p_sys->bytestream = block_BytestreamInit( p_dec );
189 /* Take care of flac init */
190 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
192 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
197 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
198 DecoderReadCallback );
199 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
200 DecoderWriteCallback );
201 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
202 DecoderMetadataCallback );
203 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
204 DecoderErrorCallback );
205 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
207 FLAC__stream_decoder_init( p_sys->p_flac );
209 /* Set output properties */
210 p_dec->fmt_out.i_cat = AUDIO_ES;
211 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
214 p_dec->pf_decode_audio = DecodeBlock;
215 p_dec->pf_packetize = PacketizeBlock;
217 /* Decode STREAMINFO */
218 msg_Dbg( p_dec, "decode STREAMINFO" );
219 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
220 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
221 p_dec->fmt_in.i_extra );
222 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
223 msg_Dbg( p_dec, "STREAMINFO decoded" );
228 static int OpenPacketizer( vlc_object_t *p_this )
230 decoder_t *p_dec = (decoder_t*)p_this;
232 int i_ret = OpenDecoder( p_this );
234 if( i_ret != VLC_SUCCESS ) return i_ret;
236 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
241 /****************************************************************************
242 * PacketizeBlock: the whole thing
243 ****************************************************************************
244 * This function is called just after the thread is launched.
245 ****************************************************************************/
246 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
248 decoder_sys_t *p_sys = p_dec->p_sys;
249 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
250 block_t *p_sout_block;
252 if( !pp_block || !*pp_block ) return NULL;
254 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
256 /* We've just started the stream, wait for the first PTS. */
257 block_Release( *pp_block );
261 if( (*pp_block)->i_flags&BLOCK_FLAG_DISCONTINUITY )
263 p_sys->i_state = STATE_NOSYNC;
266 block_BytestreamPush( &p_sys->bytestream, *pp_block );
270 switch( p_sys->i_state )
273 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
276 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
278 p_sys->i_state = STATE_SYNC;
281 block_SkipByte( &p_sys->bytestream );
283 if( p_sys->i_state != STATE_SYNC )
285 block_BytestreamFlush( &p_sys->bytestream );
292 /* New frame, set the Presentation Time Stamp */
293 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
294 if( p_sys->i_pts != 0 &&
295 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
297 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
299 p_sys->i_state = STATE_HEADER;
302 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
303 if( block_PeekBytes( &p_sys->bytestream, p_header,
304 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
310 /* Check if frame is valid and get frame info */
311 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
313 &p_sys->i_channels_conf,
315 &p_sys->i_bits_per_sample );
316 if( !p_sys->i_frame_length )
318 msg_Dbg( p_dec, "emulated sync word" );
319 block_SkipByte( &p_sys->bytestream );
320 p_sys->i_state = STATE_NOSYNC;
323 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
325 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
326 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
327 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
329 p_sys->i_state = STATE_NEXT_SYNC;
330 p_sys->i_frame_size = 1;
332 case STATE_NEXT_SYNC:
333 /* TODO: If pp_block == NULL, flush the buffer without checking the
336 /* Check if next expected frame contains the sync word */
337 while( block_PeekOffsetBytes( &p_sys->bytestream,
338 p_sys->i_frame_size, p_header,
339 MAX_FLAC_HEADER_SIZE )
342 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
344 /* Check if frame is valid and get frame info */
346 SyncInfo( p_dec, p_header,
348 &p_sys->i_channels_conf,
350 &p_sys->i_bits_per_sample );
354 p_sys->i_state = STATE_SEND_DATA;
358 p_sys->i_frame_size++;
361 if( p_sys->i_state != STATE_SEND_DATA )
368 case STATE_SEND_DATA:
369 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
371 /* Copy the whole frame into the buffer. When we reach this point
372 * we already know we have enough data available. */
373 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
374 p_sys->i_frame_size );
376 /* Make sure we don't reuse the same pts twice */
377 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
378 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
380 /* So p_block doesn't get re-added several times */
381 *pp_block = block_BytestreamPop( &p_sys->bytestream );
383 p_sys->i_state = STATE_NOSYNC;
385 /* Date management */
386 p_sout_block->i_pts =
387 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
388 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
389 p_sout_block->i_length =
390 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
399 /****************************************************************************
400 * DecodeBlock: the whole thing
401 ****************************************************************************/
402 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
404 decoder_sys_t *p_sys = p_dec->p_sys;
406 if( !pp_block || !*pp_block ) return NULL;
408 p_sys->p_aout_buffer = 0;
409 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
411 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
413 decoder_state_error( p_dec,
414 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
415 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
418 /* If the decoder is in the "aborted" state,
419 * FLAC__stream_decoder_process_single() won't return an error. */
420 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
421 == FLAC__STREAM_DECODER_ABORTED )
423 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
426 block_Release( p_sys->p_block );
427 p_sys->p_block = NULL;
430 return p_sys->p_aout_buffer;
433 /*****************************************************************************
434 * CloseDecoder: flac decoder destruction
435 *****************************************************************************/
436 static void CloseDecoder( vlc_object_t *p_this )
438 decoder_t *p_dec = (decoder_t *)p_this;
439 decoder_sys_t *p_sys = p_dec->p_sys;
441 FLAC__stream_decoder_finish( p_sys->p_flac );
442 FLAC__stream_decoder_delete( p_sys->p_flac );
443 if( p_sys->p_block ) free( p_sys->p_block );
447 /*****************************************************************************
448 * DecoderReadCallback: called by libflac when it needs more data
449 *****************************************************************************/
450 static FLAC__StreamDecoderReadStatus
451 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
452 unsigned *bytes, void *client_data )
454 decoder_t *p_dec = (decoder_t *)client_data;
455 decoder_sys_t *p_sys = p_dec->p_sys;
457 if( p_sys->p_block && p_sys->p_block->i_buffer )
459 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
460 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
461 p_sys->p_block->i_buffer -= *bytes;
462 p_sys->p_block->p_buffer += *bytes;
467 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
470 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
473 /*****************************************************************************
474 * DecoderWriteCallback: called by libflac to output decoded samples
475 *****************************************************************************/
476 static FLAC__StreamDecoderWriteStatus
477 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
478 const FLAC__Frame *frame,
479 const FLAC__int32 *const buffer[], void *client_data )
481 decoder_t *p_dec = (decoder_t *)client_data;
482 decoder_sys_t *p_sys = p_dec->p_sys;
484 p_sys->p_aout_buffer =
485 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
487 if( p_sys->p_aout_buffer == NULL )
488 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
490 switch( frame->header.bits_per_sample )
493 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
494 frame->header.channels, frame->header.blocksize );
497 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
498 frame->header.channels, frame->header.blocksize );
501 /* Date management (already done by packetizer) */
502 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
503 p_sys->p_aout_buffer->end_date =
504 p_sys->p_block->i_pts + p_sys->p_block->i_length;
506 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
509 /*****************************************************************************
510 * DecoderMetadataCallback: called by libflac to when it encounters metadata
511 *****************************************************************************/
512 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
513 const FLAC__StreamMetadata *metadata,
516 decoder_t *p_dec = (decoder_t *)client_data;
517 decoder_sys_t *p_sys = p_dec->p_sys;
519 switch( metadata->data.stream_info.bits_per_sample )
522 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
525 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
528 msg_Dbg( p_dec, "strange bit/sample value: %d",
529 metadata->data.stream_info.bits_per_sample );
530 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
534 /* Setup the format */
535 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
536 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
537 p_dec->fmt_out.audio.i_physical_channels =
538 p_dec->fmt_out.audio.i_original_channels =
539 pi_channels_maps[metadata->data.stream_info.channels];
540 p_dec->fmt_out.audio.i_bitspersample =
541 metadata->data.stream_info.bits_per_sample;
543 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
545 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
546 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
547 p_dec->fmt_out.audio.i_bitspersample );
549 p_sys->b_stream_info = VLC_TRUE;
550 p_sys->stream_info = metadata->data.stream_info;
555 /*****************************************************************************
556 * DecoderErrorCallback: called when the libflac decoder encounters an error
557 *****************************************************************************/
558 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
559 FLAC__StreamDecoderErrorStatus status,
562 decoder_t *p_dec = (decoder_t *)client_data;
566 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
567 msg_Err( p_dec, "an error in the stream caused the decoder to "
568 "lose synchronization." );
570 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
571 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
573 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
574 msg_Err( p_dec, "frame's data did not match the CRC in the "
578 msg_Err( p_dec, "got decoder error: %d", status );
581 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
585 /*****************************************************************************
586 * Interleave: helper function to interleave channels
587 *****************************************************************************/
588 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
589 int i_nb_channels, int i_samples )
592 for ( j = 0; j < i_samples; j++ )
594 for ( i = 0; i < i_nb_channels; i++ )
596 p_out[j * i_nb_channels + i] = pp_in[i][j];
600 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
601 int i_nb_channels, int i_samples )
604 for ( j = 0; j < i_samples; j++ )
606 for ( i = 0; i < i_nb_channels; i++ )
608 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
613 /*****************************************************************************
614 * decoder_state_error: print meaningful error messages
615 *****************************************************************************/
616 static void decoder_state_error( decoder_t *p_dec,
617 FLAC__StreamDecoderState state )
621 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
622 msg_Err( p_dec, "the decoder is ready to search for metadata." );
624 case FLAC__STREAM_DECODER_READ_METADATA:
625 msg_Err( p_dec, "the decoder is ready to or is in the process of "
626 "reading metadata." );
628 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
629 msg_Err( p_dec, "the decoder is ready to or is in the process of "
630 "searching for the frame sync code." );
632 case FLAC__STREAM_DECODER_READ_FRAME:
633 msg_Err( p_dec, "the decoder is ready to or is in the process of "
634 "reading a frame." );
636 case FLAC__STREAM_DECODER_END_OF_STREAM:
637 msg_Err( p_dec, "the decoder has reached the end of the stream." );
639 case FLAC__STREAM_DECODER_ABORTED:
640 msg_Err( p_dec, "the decoder was aborted by the read callback." );
642 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
643 msg_Err( p_dec, "the decoder encountered reserved fields in use "
646 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
647 msg_Err( p_dec, "error when allocating memory." );
649 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
650 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
651 "decoder was already initialized, usually because "
652 "FLAC__stream_decoder_finish() was not called." );
654 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
655 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
656 "all callbacks being set." );
658 case FLAC__STREAM_DECODER_UNINITIALIZED:
659 msg_Err( p_dec, "decoder in uninitialized state." );
662 msg_Err(p_dec, "unknown error" );
666 /*****************************************************************************
667 * SyncInfo: parse FLAC sync info
668 *****************************************************************************/
669 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
670 int * pi_channels, int * pi_channels_conf,
671 int * pi_sample_rate, int * pi_bits_per_sample )
673 decoder_sys_t *p_sys = p_dec->p_sys;
674 int i_header, i_temp, i_read;
675 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
676 uint64_t i_sample_number = 0;
678 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
679 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
680 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
681 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
684 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
686 /* Check there is no emulated sync code in the rest of the header */
687 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
689 /* Find blocksize (framelength) */
690 switch( i_temp = p_buf[2] >> 4 )
693 if( b_fixed_blocksize )
694 i_blocksize = p_sys->stream_info.min_blocksize;
695 else return 0; /* We can't do anything with this */
706 i_blocksize = 576 << (i_temp - 2);
711 i_blocksize_hint = i_temp;
722 i_blocksize = 256 << (i_temp - 8);
726 /* Find samplerate */
727 switch( i_temp = p_buf[2] & 0x0f )
730 if( p_sys->b_stream_info )
731 *pi_sample_rate = p_sys->stream_info.sample_rate;
732 else return 0; /* We can't do anything with this */
742 *pi_sample_rate = 8000;
746 *pi_sample_rate = 16000;
750 *pi_sample_rate = 22050;
754 *pi_sample_rate = 24000;
758 *pi_sample_rate = 32000;
762 *pi_sample_rate = 44100;
766 *pi_sample_rate = 48000;
770 *pi_sample_rate = 96000;
776 i_sample_rate_hint = i_temp;
784 i_temp = (unsigned)(p_buf[3] >> 4);
787 int i_channel_assignment; /* ??? */
793 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
796 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
799 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
808 *pi_channels = i_temp + 1;
809 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
812 /* Find bits per sample */
813 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
816 if( p_sys->b_stream_info )
817 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
823 *pi_bits_per_sample = 8;
827 *pi_bits_per_sample = 12;
831 *pi_bits_per_sample = 16;
835 *pi_bits_per_sample = 20;
839 *pi_bits_per_sample = 24;
848 /* Zero padding bit */
849 if( p_buf[3] & 0x01 ) return 0;
851 /* End of fixed size header */
854 /* Find Sample/Frame number */
855 if( i_blocksize_hint && b_variable_blocksize )
857 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
858 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
862 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
863 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
865 if( p_sys->b_stream_info )
866 i_sample_number *= p_sys->stream_info.min_blocksize;
872 if( i_blocksize_hint )
874 int i_val1 = p_buf[i_header++];
875 if( i_blocksize_hint == 7 )
877 int i_val2 = p_buf[i_header++];
878 i_val1 = (i_val1 << 8) | i_val2;
880 i_blocksize = i_val1 + 1;
883 /* Read sample rate */
884 if( i_sample_rate_hint )
886 int i_val1 = p_buf[i_header++];
887 if( i_sample_rate_hint != 12 )
889 int i_val2 = p_buf[i_header++];
890 i_val1 = (i_val1 << 8) | i_val2;
892 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
893 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
894 else *pi_sample_rate = i_val1 * 10;
897 /* Check the CRC-8 byte */
898 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
906 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
907 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
909 uint64_t i_result = 0;
912 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
917 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
919 i_result = p_buf[0] & 0x1F;
922 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
924 i_result = p_buf[0] & 0x0F;
927 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
929 i_result = p_buf[0] & 0x07;
932 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
934 i_result = p_buf[0] & 0x03;
937 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
939 i_result = p_buf[0] & 0x01;
942 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
948 return I64C(0xffffffffffffffff);
951 for( j = 1; j <= i; j++ )
953 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
955 return I64C(0xffffffffffffffff);
958 i_result |= (p_buf[j] & 0x3F);
965 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
966 static uint8_t const flac_crc8_table[256] = {
967 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
968 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
969 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
970 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
971 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
972 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
973 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
974 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
975 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
976 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
977 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
978 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
979 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
980 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
981 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
982 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
983 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
984 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
985 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
986 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
987 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
988 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
989 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
990 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
991 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
992 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
993 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
994 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
995 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
996 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
997 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
998 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1001 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1006 crc = flac_crc8_table[crc ^ *data++];
1011 /*****************************************************************************
1012 * encoder_sys_t : flac encoder descriptor
1013 *****************************************************************************/
1014 struct encoder_sys_t
1021 int i_samples_delay;
1024 FLAC__int32 *p_buffer;
1032 FLAC__StreamEncoder *p_flac;
1033 FLAC__StreamMetadata_StreamInfo stream_info;
1041 #define STREAMINFO_SIZE 38
1043 static block_t *Encode( encoder_t *, aout_buffer_t * );
1045 static FLAC__StreamEncoderWriteStatus
1046 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1047 const FLAC__byte buffer[],
1048 unsigned bytes, unsigned samples,
1049 unsigned current_frame, void *client_data );
1051 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1052 const FLAC__StreamMetadata *metadata,
1053 void *client_data );
1055 /*****************************************************************************
1056 * OpenEncoder: probe the encoder and return score
1057 *****************************************************************************/
1058 static int OpenEncoder( vlc_object_t *p_this )
1060 encoder_t *p_enc = (encoder_t *)p_this;
1061 encoder_sys_t *p_sys;
1063 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') )
1065 return VLC_EGENERIC;
1068 /* Allocate the memory needed to store the decoder's structure */
1069 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1071 msg_Err( p_enc, "out of memory" );
1072 return VLC_EGENERIC;
1074 p_enc->p_sys = p_sys;
1075 p_enc->pf_encode_audio = Encode;
1076 p_sys->i_headers = 0;
1077 p_sys->p_buffer = 0;
1078 p_sys->i_buffer = 0;
1079 p_sys->i_samples_delay = 0;
1081 /* Create flac encoder */
1082 p_sys->p_flac = FLAC__stream_encoder_new();
1084 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1085 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1086 p_enc->fmt_in.audio.i_channels );
1087 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1088 p_enc->fmt_in.audio.i_rate );
1089 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1090 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1092 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1093 EncoderWriteCallback );
1094 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1095 EncoderMetadataCallback );
1096 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1098 /* Get and store the STREAMINFO metadata block as a p_extra */
1100 FLAC__stream_encoder_init( p_sys->p_flac );
1105 /****************************************************************************
1106 * Encode: the whole thing
1107 ****************************************************************************
1108 * This function spits out ogg packets.
1109 ****************************************************************************/
1110 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1112 encoder_sys_t *p_sys = p_enc->p_sys;
1116 p_sys->i_pts = p_aout_buf->start_date -
1117 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1118 (mtime_t)p_enc->fmt_in.audio.i_rate;
1120 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1122 /* Convert samples to FLAC__int32 */
1123 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1126 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1127 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1130 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1132 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1135 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1136 p_aout_buf->i_nb_samples );
1138 p_chain = p_sys->p_chain;
1144 /*****************************************************************************
1145 * CloseEncoder: encoder destruction
1146 *****************************************************************************/
1147 static void CloseEncoder( vlc_object_t *p_this )
1149 encoder_t *p_enc = (encoder_t *)p_this;
1150 encoder_sys_t *p_sys = p_enc->p_sys;
1152 FLAC__stream_encoder_delete( p_sys->p_flac );
1154 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1158 /*****************************************************************************
1159 * EncoderMetadataCallback: called by libflac to output metadata
1160 *****************************************************************************/
1161 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1162 const FLAC__StreamMetadata *metadata,
1165 encoder_t *p_enc = (encoder_t *)client_data;
1167 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1171 /*****************************************************************************
1172 * EncoderWriteCallback: called by libflac to output encoded samples
1173 *****************************************************************************/
1174 static FLAC__StreamEncoderWriteStatus
1175 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1176 const FLAC__byte buffer[],
1177 unsigned bytes, unsigned samples,
1178 unsigned current_frame, void *client_data )
1180 encoder_t *p_enc = (encoder_t *)client_data;
1181 encoder_sys_t *p_sys = p_enc->p_sys;
1186 if( p_sys->i_headers == 1 )
1188 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1190 /* Backup the STREAMINFO metadata block */
1191 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1192 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1193 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1194 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1197 /* Fake this as the last metadata block */
1198 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1201 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1204 p_block = block_New( p_enc, bytes );
1205 memcpy( p_block->p_buffer, buffer, bytes );
1207 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1209 p_sys->i_samples_delay -= samples;
1211 p_block->i_length = (mtime_t)1000000 *
1212 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1215 p_sys->i_pts += p_block->i_length;
1217 block_ChainAppend( &p_sys->p_chain, p_block );
1219 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;