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 <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 #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 *, int *, int *, int *,int * );
133 static FLAC__StreamDecoderReadStatus
134 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
135 FLAC__byte buffer[], unsigned *bytes, void *client_data );
137 static FLAC__StreamDecoderWriteStatus
138 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
139 const FLAC__Frame *frame,
140 const FLAC__int32 *const buffer[], void *client_data );
142 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
143 const FLAC__StreamMetadata *metadata,
145 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
146 FLAC__StreamDecoderErrorStatus status,
149 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
150 int i_nb_channels, int i_samples );
151 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
152 int i_nb_channels, int i_samples );
154 static void decoder_state_error( decoder_t *p_dec,
155 FLAC__StreamDecoderState state );
158 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
159 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
161 /*****************************************************************************
163 *****************************************************************************/
166 set_category( CAT_INPUT );
167 set_subcategory( SUBCAT_INPUT_ACODEC );
170 set_description( _("Flac audio decoder") );
171 set_capability( "decoder", 100 );
172 set_callbacks( OpenDecoder, CloseDecoder );
175 set_description( _("Flac audio encoder") );
176 set_capability( "encoder", 100 );
177 set_callbacks( OpenEncoder, CloseEncoder );
181 set_description( _("Flac audio packetizer") );
182 set_capability( "packetizer", 100 );
183 set_callbacks( OpenPacketizer, CloseDecoder );
185 add_shortcut( "flac" );
188 /*****************************************************************************
189 * OpenDecoder: probe the decoder and return score
190 *****************************************************************************/
191 static int OpenDecoder( vlc_object_t *p_this )
193 decoder_t *p_dec = (decoder_t*)p_this;
194 decoder_sys_t *p_sys;
196 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
201 /* Allocate the memory needed to store the decoder's structure */
202 if( ( p_dec->p_sys = p_sys =
203 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
205 msg_Err( p_dec, "out of memory" );
210 aout_DateSet( &p_sys->end_date, 0 );
211 p_sys->i_state = STATE_NOSYNC;
212 p_sys->b_stream_info = VLC_FALSE;
214 p_sys->bytestream = block_BytestreamInit( p_dec );
217 /* Take care of flac init */
218 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
220 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
225 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
226 DecoderReadCallback );
227 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
228 DecoderWriteCallback );
229 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
230 DecoderMetadataCallback );
231 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
232 DecoderErrorCallback );
233 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
235 FLAC__stream_decoder_init( p_sys->p_flac );
238 /* Set output properties */
239 p_dec->fmt_out.i_cat = AUDIO_ES;
240 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
244 p_dec->pf_decode_audio = DecodeBlock;
246 p_dec->pf_packetize = PacketizeBlock;
251 static int OpenPacketizer( vlc_object_t *p_this )
253 decoder_t *p_dec = (decoder_t*)p_this;
256 /* Hmmm, mem leak ?*/
257 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
259 i_ret = OpenDecoder( p_this );
261 /* Set output properties */
262 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
264 if( i_ret != VLC_SUCCESS ) return i_ret;
269 /*****************************************************************************
270 * CloseDecoder: flac decoder destruction
271 *****************************************************************************/
272 static void CloseDecoder( vlc_object_t *p_this )
274 decoder_t *p_dec = (decoder_t *)p_this;
275 decoder_sys_t *p_sys = p_dec->p_sys;
278 FLAC__stream_decoder_finish( p_sys->p_flac );
279 FLAC__stream_decoder_delete( p_sys->p_flac );
282 if( p_sys->p_block ) free( p_sys->p_block );
286 /*****************************************************************************
287 * ProcessHeader: processe Flac header.
288 *****************************************************************************/
289 static void ProcessHeader( decoder_t *p_dec )
291 decoder_sys_t *p_sys = p_dec->p_sys;
294 if( !p_dec->fmt_in.i_extra ) return;
296 /* Decode STREAMINFO */
297 msg_Dbg( p_dec, "decode STREAMINFO" );
298 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
299 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
300 p_dec->fmt_in.i_extra );
301 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
302 msg_Dbg( p_dec, "STREAMINFO decoded" );
307 if( !p_dec->fmt_in.i_extra ) return;
309 bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
311 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
312 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
314 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
315 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
317 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
318 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
319 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
322 if( !p_sys->b_stream_info ) return;
324 if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
326 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
327 p_dec->fmt_out.p_extra =
328 realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
329 memcpy( p_dec->fmt_out.p_extra,
330 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
334 /****************************************************************************
335 * PacketizeBlock: the whole thing
336 ****************************************************************************
337 * This function is called just after the thread is launched.
338 ****************************************************************************/
339 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
341 decoder_sys_t *p_sys = p_dec->p_sys;
342 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
343 block_t *p_sout_block;
345 if( !pp_block || !*pp_block ) return NULL;
347 if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
349 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
351 /* We've just started the stream, wait for the first PTS. */
352 block_Release( *pp_block );
355 else if( !aout_DateGet( &p_sys->end_date ) )
357 /* The first PTS is as good as anything else. */
358 aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
361 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
363 p_sys->i_state = STATE_NOSYNC;
366 block_BytestreamPush( &p_sys->bytestream, *pp_block );
370 switch( p_sys->i_state )
373 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
376 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
378 p_sys->i_state = STATE_SYNC;
381 block_SkipByte( &p_sys->bytestream );
383 if( p_sys->i_state != STATE_SYNC )
385 block_BytestreamFlush( &p_sys->bytestream );
392 /* New frame, set the Presentation Time Stamp */
393 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
394 if( p_sys->i_pts != 0 &&
395 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
397 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
399 p_sys->i_state = STATE_HEADER;
402 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
403 if( block_PeekBytes( &p_sys->bytestream, p_header,
404 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
410 /* Check if frame is valid and get frame info */
411 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
413 &p_sys->i_channels_conf,
415 &p_sys->i_bits_per_sample );
416 if( !p_sys->i_frame_length )
418 msg_Dbg( p_dec, "emulated sync word" );
419 block_SkipByte( &p_sys->bytestream );
420 p_sys->i_state = STATE_NOSYNC;
423 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
425 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
426 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
428 p_sys->i_state = STATE_NEXT_SYNC;
429 p_sys->i_frame_size = 1;
431 case STATE_NEXT_SYNC:
432 /* TODO: If pp_block == NULL, flush the buffer without checking the
435 /* Check if next expected frame contains the sync word */
436 while( block_PeekOffsetBytes( &p_sys->bytestream,
437 p_sys->i_frame_size, p_header,
438 MAX_FLAC_HEADER_SIZE )
441 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
443 /* Check if frame is valid and get frame info */
445 SyncInfo( p_dec, p_header,
447 &p_sys->i_channels_conf,
449 &p_sys->i_bits_per_sample );
453 p_sys->i_state = STATE_SEND_DATA;
457 p_sys->i_frame_size++;
460 if( p_sys->i_state != STATE_SEND_DATA )
466 case STATE_SEND_DATA:
467 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
469 /* Copy the whole frame into the buffer. When we reach this point
470 * we already know we have enough data available. */
471 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
472 p_sys->i_frame_size );
474 /* Make sure we don't reuse the same pts twice */
475 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
476 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
478 /* So p_block doesn't get re-added several times */
479 *pp_block = block_BytestreamPop( &p_sys->bytestream );
481 p_sys->i_state = STATE_NOSYNC;
483 /* Date management */
484 p_sout_block->i_pts =
485 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
486 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
487 p_sout_block->i_length =
488 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
498 /****************************************************************************
499 * DecodeBlock: the whole thing
500 ****************************************************************************/
501 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
503 decoder_sys_t *p_sys = p_dec->p_sys;
505 if( !pp_block || !*pp_block ) return NULL;
507 p_sys->p_aout_buffer = 0;
508 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
510 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
512 decoder_state_error( p_dec,
513 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
514 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
517 /* If the decoder is in the "aborted" state,
518 * FLAC__stream_decoder_process_single() won't return an error. */
519 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
520 == FLAC__STREAM_DECODER_ABORTED )
522 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
525 block_Release( p_sys->p_block );
526 p_sys->p_block = NULL;
529 return p_sys->p_aout_buffer;
532 /*****************************************************************************
533 * DecoderReadCallback: called by libflac when it needs more data
534 *****************************************************************************/
535 static FLAC__StreamDecoderReadStatus
536 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
537 unsigned *bytes, void *client_data )
539 decoder_t *p_dec = (decoder_t *)client_data;
540 decoder_sys_t *p_sys = p_dec->p_sys;
542 if( p_sys->p_block && p_sys->p_block->i_buffer )
544 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
545 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
546 p_sys->p_block->i_buffer -= *bytes;
547 p_sys->p_block->p_buffer += *bytes;
552 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
555 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
558 /*****************************************************************************
559 * DecoderWriteCallback: called by libflac to output decoded samples
560 *****************************************************************************/
561 static FLAC__StreamDecoderWriteStatus
562 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
563 const FLAC__Frame *frame,
564 const FLAC__int32 *const buffer[], void *client_data )
566 decoder_t *p_dec = (decoder_t *)client_data;
567 decoder_sys_t *p_sys = p_dec->p_sys;
569 p_sys->p_aout_buffer =
570 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
572 if( p_sys->p_aout_buffer == NULL )
573 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
575 switch( frame->header.bits_per_sample )
578 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
579 frame->header.channels, frame->header.blocksize );
582 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
583 frame->header.channels, frame->header.blocksize );
586 /* Date management (already done by packetizer) */
587 p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
588 p_sys->p_aout_buffer->end_date =
589 p_sys->p_block->i_pts + p_sys->p_block->i_length;
591 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
594 /*****************************************************************************
595 * DecoderMetadataCallback: called by libflac to when it encounters metadata
596 *****************************************************************************/
597 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
598 const FLAC__StreamMetadata *metadata,
601 decoder_t *p_dec = (decoder_t *)client_data;
602 decoder_sys_t *p_sys = p_dec->p_sys;
604 switch( metadata->data.stream_info.bits_per_sample )
607 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
610 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
613 msg_Dbg( p_dec, "strange bit/sample value: %d",
614 metadata->data.stream_info.bits_per_sample );
615 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
619 /* Setup the format */
620 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
621 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
622 p_dec->fmt_out.audio.i_physical_channels =
623 p_dec->fmt_out.audio.i_original_channels =
624 pi_channels_maps[metadata->data.stream_info.channels];
625 p_dec->fmt_out.audio.i_bitspersample =
626 metadata->data.stream_info.bits_per_sample;
628 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
630 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
631 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
632 p_dec->fmt_out.audio.i_bitspersample );
634 p_sys->b_stream_info = VLC_TRUE;
635 p_sys->stream_info = metadata->data.stream_info;
640 /*****************************************************************************
641 * DecoderErrorCallback: called when the libflac decoder encounters an error
642 *****************************************************************************/
643 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
644 FLAC__StreamDecoderErrorStatus status,
647 decoder_t *p_dec = (decoder_t *)client_data;
651 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
652 msg_Err( p_dec, "an error in the stream caused the decoder to "
653 "lose synchronization." );
655 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
656 msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
658 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
659 msg_Err( p_dec, "frame's data did not match the CRC in the "
663 msg_Err( p_dec, "got decoder error: %d", status );
666 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
670 /*****************************************************************************
671 * Interleave: helper function to interleave channels
672 *****************************************************************************/
673 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
674 int i_nb_channels, int i_samples )
677 for ( j = 0; j < i_samples; j++ )
679 for ( i = 0; i < i_nb_channels; i++ )
681 p_out[j * i_nb_channels + i] = pp_in[i][j];
685 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
686 int i_nb_channels, int i_samples )
689 for ( j = 0; j < i_samples; j++ )
691 for ( i = 0; i < i_nb_channels; i++ )
693 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
698 /*****************************************************************************
699 * decoder_state_error: print meaningful error messages
700 *****************************************************************************/
701 static void decoder_state_error( decoder_t *p_dec,
702 FLAC__StreamDecoderState state )
706 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
707 msg_Err( p_dec, "the decoder is ready to search for metadata." );
709 case FLAC__STREAM_DECODER_READ_METADATA:
710 msg_Err( p_dec, "the decoder is ready to or is in the process of "
711 "reading metadata." );
713 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
714 msg_Err( p_dec, "the decoder is ready to or is in the process of "
715 "searching for the frame sync code." );
717 case FLAC__STREAM_DECODER_READ_FRAME:
718 msg_Err( p_dec, "the decoder is ready to or is in the process of "
719 "reading a frame." );
721 case FLAC__STREAM_DECODER_END_OF_STREAM:
722 msg_Err( p_dec, "the decoder has reached the end of the stream." );
724 case FLAC__STREAM_DECODER_ABORTED:
725 msg_Err( p_dec, "the decoder was aborted by the read callback." );
727 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
728 msg_Err( p_dec, "the decoder encountered reserved fields in use "
731 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
732 msg_Err( p_dec, "error when allocating memory." );
734 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
735 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
736 "decoder was already initialized, usually because "
737 "FLAC__stream_decoder_finish() was not called." );
739 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
740 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
741 "all callbacks being set." );
743 case FLAC__STREAM_DECODER_UNINITIALIZED:
744 msg_Err( p_dec, "decoder in uninitialized state." );
747 msg_Err(p_dec, "unknown error" );
752 /*****************************************************************************
753 * SyncInfo: parse FLAC sync info
754 *****************************************************************************/
755 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
756 int * pi_channels, int * pi_channels_conf,
757 int * pi_sample_rate, int * pi_bits_per_sample )
759 decoder_sys_t *p_sys = p_dec->p_sys;
760 int i_header, i_temp, i_read;
761 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
762 uint64_t i_sample_number = 0;
764 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
765 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
766 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
767 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
770 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
772 /* Check there is no emulated sync code in the rest of the header */
773 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
775 /* Find blocksize (framelength) */
776 switch( i_temp = p_buf[2] >> 4 )
779 if( b_fixed_blocksize )
780 i_blocksize = p_sys->stream_info.min_blocksize;
781 else return 0; /* We can't do anything with this */
792 i_blocksize = 576 << (i_temp - 2);
797 i_blocksize_hint = i_temp;
808 i_blocksize = 256 << (i_temp - 8);
812 /* Find samplerate */
813 switch( i_temp = p_buf[2] & 0x0f )
816 if( p_sys->b_stream_info )
817 *pi_sample_rate = p_sys->stream_info.sample_rate;
818 else return 0; /* We can't do anything with this */
828 *pi_sample_rate = 8000;
832 *pi_sample_rate = 16000;
836 *pi_sample_rate = 22050;
840 *pi_sample_rate = 24000;
844 *pi_sample_rate = 32000;
848 *pi_sample_rate = 44100;
852 *pi_sample_rate = 48000;
856 *pi_sample_rate = 96000;
862 i_sample_rate_hint = i_temp;
870 i_temp = (unsigned)(p_buf[3] >> 4);
874 int i_channel_assignment; /* ??? */
879 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
882 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
885 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
897 *pi_channels = i_temp + 1;
898 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
901 /* Find bits per sample */
902 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
905 if( p_sys->b_stream_info )
906 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
912 *pi_bits_per_sample = 8;
916 *pi_bits_per_sample = 12;
920 *pi_bits_per_sample = 16;
924 *pi_bits_per_sample = 20;
928 *pi_bits_per_sample = 24;
937 /* Zero padding bit */
938 if( p_buf[3] & 0x01 ) return 0;
940 /* End of fixed size header */
943 /* Find Sample/Frame number */
944 if( i_blocksize_hint && b_variable_blocksize )
946 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
947 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
951 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
952 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
954 if( p_sys->b_stream_info )
955 i_sample_number *= p_sys->stream_info.min_blocksize;
961 if( i_blocksize_hint )
963 int i_val1 = p_buf[i_header++];
964 if( i_blocksize_hint == 7 )
966 int i_val2 = p_buf[i_header++];
967 i_val1 = (i_val1 << 8) | i_val2;
969 i_blocksize = i_val1 + 1;
972 /* Read sample rate */
973 if( i_sample_rate_hint )
975 int i_val1 = p_buf[i_header++];
976 if( i_sample_rate_hint != 12 )
978 int i_val2 = p_buf[i_header++];
979 i_val1 = (i_val1 << 8) | i_val2;
981 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
982 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
983 else *pi_sample_rate = i_val1 * 10;
986 /* Check the CRC-8 byte */
987 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
995 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
996 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
998 uint64_t i_result = 0;
1001 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1003 i_result = p_buf[0];
1006 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1008 i_result = p_buf[0] & 0x1F;
1011 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1013 i_result = p_buf[0] & 0x0F;
1016 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1018 i_result = p_buf[0] & 0x07;
1021 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1023 i_result = p_buf[0] & 0x03;
1026 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1028 i_result = p_buf[0] & 0x01;
1031 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1037 return I64C(0xffffffffffffffff);
1040 for( j = 1; j <= i; j++ )
1042 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1044 return I64C(0xffffffffffffffff);
1047 i_result |= (p_buf[j] & 0x3F);
1054 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1055 static uint8_t const flac_crc8_table[256] = {
1056 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1057 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1058 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1059 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1060 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1061 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1062 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1063 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1064 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1065 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1066 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1067 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1068 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1069 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1070 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1071 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1072 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1073 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1074 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1075 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1076 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1077 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1078 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1079 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1080 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1081 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1082 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1083 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1084 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1085 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1086 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1087 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1090 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1095 crc = flac_crc8_table[crc ^ *data++];
1101 /*****************************************************************************
1102 * encoder_sys_t : flac encoder descriptor
1103 *****************************************************************************/
1104 struct encoder_sys_t
1111 int i_samples_delay;
1114 FLAC__int32 *p_buffer;
1122 FLAC__StreamEncoder *p_flac;
1123 FLAC__StreamMetadata_StreamInfo stream_info;
1131 #define STREAMINFO_SIZE 38
1133 static block_t *Encode( encoder_t *, aout_buffer_t * );
1135 static FLAC__StreamEncoderWriteStatus
1136 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1137 const FLAC__byte buffer[],
1138 unsigned bytes, unsigned samples,
1139 unsigned current_frame, void *client_data );
1141 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1142 const FLAC__StreamMetadata *metadata,
1143 void *client_data );
1145 /*****************************************************************************
1146 * OpenEncoder: probe the encoder and return score
1147 *****************************************************************************/
1148 static int OpenEncoder( vlc_object_t *p_this )
1150 encoder_t *p_enc = (encoder_t *)p_this;
1151 encoder_sys_t *p_sys;
1153 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1156 return VLC_EGENERIC;
1159 /* Allocate the memory needed to store the decoder's structure */
1160 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1162 msg_Err( p_enc, "out of memory" );
1163 return VLC_EGENERIC;
1165 p_enc->p_sys = p_sys;
1166 p_enc->pf_encode_audio = Encode;
1167 p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1169 p_sys->i_headers = 0;
1170 p_sys->p_buffer = 0;
1171 p_sys->i_buffer = 0;
1172 p_sys->i_samples_delay = 0;
1174 /* Create flac encoder */
1175 p_sys->p_flac = FLAC__stream_encoder_new();
1177 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1178 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1179 p_enc->fmt_in.audio.i_channels );
1180 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1181 p_enc->fmt_in.audio.i_rate );
1182 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1183 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1185 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1186 EncoderWriteCallback );
1187 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1188 EncoderMetadataCallback );
1189 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1191 /* Get and store the STREAMINFO metadata block as a p_extra */
1193 FLAC__stream_encoder_init( p_sys->p_flac );
1198 /****************************************************************************
1199 * Encode: the whole thing
1200 ****************************************************************************
1201 * This function spits out ogg packets.
1202 ****************************************************************************/
1203 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1205 encoder_sys_t *p_sys = p_enc->p_sys;
1209 p_sys->i_pts = p_aout_buf->start_date -
1210 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1211 (mtime_t)p_enc->fmt_in.audio.i_rate;
1213 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1215 /* Convert samples to FLAC__int32 */
1216 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1219 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1220 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1223 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1225 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1228 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1229 p_aout_buf->i_nb_samples );
1231 p_chain = p_sys->p_chain;
1237 /*****************************************************************************
1238 * CloseEncoder: encoder destruction
1239 *****************************************************************************/
1240 static void CloseEncoder( vlc_object_t *p_this )
1242 encoder_t *p_enc = (encoder_t *)p_this;
1243 encoder_sys_t *p_sys = p_enc->p_sys;
1245 FLAC__stream_encoder_delete( p_sys->p_flac );
1247 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1251 /*****************************************************************************
1252 * EncoderMetadataCallback: called by libflac to output metadata
1253 *****************************************************************************/
1254 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1255 const FLAC__StreamMetadata *metadata,
1258 encoder_t *p_enc = (encoder_t *)client_data;
1260 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1264 /*****************************************************************************
1265 * EncoderWriteCallback: called by libflac to output encoded samples
1266 *****************************************************************************/
1267 static FLAC__StreamEncoderWriteStatus
1268 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1269 const FLAC__byte buffer[],
1270 unsigned bytes, unsigned samples,
1271 unsigned current_frame, void *client_data )
1273 encoder_t *p_enc = (encoder_t *)client_data;
1274 encoder_sys_t *p_sys = p_enc->p_sys;
1279 if( p_sys->i_headers == 1 )
1281 msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1283 /* Backup the STREAMINFO metadata block */
1284 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1285 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1286 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1287 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1290 /* Fake this as the last metadata block */
1291 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1294 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1297 p_block = block_New( p_enc, bytes );
1298 memcpy( p_block->p_buffer, buffer, bytes );
1300 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1302 p_sys->i_samples_delay -= samples;
1304 p_block->i_length = (mtime_t)1000000 *
1305 (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1308 p_sys->i_pts += p_block->i_length;
1310 block_ChainAppend( &p_sys->p_chain, p_block );
1312 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;