1 /*****************************************************************************
2 * flac.c: flac decoder/packetizer module making use of libflac
3 *****************************************************************************
4 * Copyright (C) 1999-2001 VideoLAN
5 * $Id: flac.c,v 1.2 2003/11/21 12:18:54 gbazin 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 *****************************************************************************/
29 #include <vlc/decoder.h>
30 #include <vlc/input.h>
32 #include <FLAC/stream_decoder.h>
34 #include "vlc_block_helper.h"
36 #define MAX_FLAC_HEADER_SIZE 16
38 /*****************************************************************************
39 * decoder_sys_t : FLAC decoder descriptor
40 *****************************************************************************/
44 vlc_bool_t b_packetizer;
51 block_bytestream_t bytestream;
54 * Input/Output properties
57 aout_buffer_t *p_aout_buffer;
62 FLAC__StreamDecoder *p_flac;
64 vlc_bool_t b_stream_info;
65 FLAC__StreamMetadata_StreamInfo stream_info;
70 audio_date_t end_date;
73 int i_frame_size, i_frame_length, i_bits_per_sample;
74 unsigned int i_rate, i_channels, i_channels_conf;
87 static int pi_channels_maps[6] =
91 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
92 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
93 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
94 | AOUT_CHAN_REARRIGHT,
95 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
96 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
99 /*****************************************************************************
101 *****************************************************************************/
102 static int OpenDecoder ( vlc_object_t * );
103 static int OpenPacketizer( vlc_object_t * );
104 static void CloseDecoder ( vlc_object_t * );
106 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
107 static block_t *PacketizeBlock( decoder_t *, block_t ** );
109 static int SyncInfo( decoder_t *, uint8_t *, int *, int *, int *,int * );
112 static FLAC__StreamDecoderReadStatus
113 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
114 FLAC__byte buffer[], unsigned *bytes, void *client_data );
116 static FLAC__StreamDecoderWriteStatus
117 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
118 const FLAC__Frame *frame,
119 const FLAC__int32 *const buffer[], void *client_data );
121 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
122 const FLAC__StreamMetadata *metadata,
124 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
125 FLAC__StreamDecoderErrorStatus status,
128 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
129 int i_nb_channels, int i_samples );
130 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
131 int i_nb_channels, int i_samples );
133 static void decoder_state_error( decoder_t *p_dec,
134 FLAC__StreamDecoderState state );
136 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
137 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
139 /*****************************************************************************
141 *****************************************************************************/
144 set_description( _("Flac audio decoder") );
145 set_capability( "decoder", 100 );
146 set_callbacks( OpenDecoder, CloseDecoder );
149 set_description( _("Flac audio packetizer") );
150 set_capability( "packetizer", 100 );
151 set_callbacks( OpenPacketizer, CloseDecoder );
155 /*****************************************************************************
156 * OpenDecoder: probe the decoder and return score
157 *****************************************************************************/
158 static int OpenDecoder( vlc_object_t *p_this )
160 decoder_t *p_dec = (decoder_t*)p_this;
161 decoder_sys_t *p_sys;
163 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
168 /* Allocate the memory needed to store the decoder's structure */
169 if( ( p_dec->p_sys = p_sys =
170 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
172 msg_Err( p_dec, "out of memory" );
177 aout_DateSet( &p_sys->end_date, 0 );
178 p_sys->b_packetizer = VLC_FALSE;
179 p_sys->i_state = STATE_NOSYNC;
181 p_sys->bytestream = block_BytestreamInit( p_dec );
183 /* Take care of flac init */
184 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
186 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
191 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
192 DecoderReadCallback );
193 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
194 DecoderWriteCallback );
195 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
196 DecoderMetadataCallback );
197 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
198 DecoderErrorCallback );
199 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
201 FLAC__stream_decoder_init( p_sys->p_flac );
203 /* Set output properties */
204 p_dec->fmt_out.i_cat = AUDIO_ES;
205 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
208 p_dec->pf_decode_audio = DecodeBlock;
209 p_dec->pf_packetize = PacketizeBlock;
212 /* Decode STREAMINFO */
213 msg_Dbg( p_dec, "decode STREAMINFO" );
214 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra + 4 );
215 memcpy( p_sys->p_block->p_buffer + 4, p_dec->fmt_in.p_extra,
216 p_dec->fmt_in.i_extra );
217 memcpy( p_sys->p_block->p_buffer, "fLaC", 4 );
218 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
219 msg_Dbg( p_dec, "STREAMINFO decoded" );
224 static int OpenPacketizer( vlc_object_t *p_this )
226 decoder_t *p_dec = (decoder_t*)p_this;
228 int i_ret = OpenDecoder( p_this );
230 if( i_ret == VLC_SUCCESS )
232 p_dec->p_sys->b_packetizer = VLC_TRUE;
233 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
239 /****************************************************************************
240 * PacketizeBlock: the whole thing
241 ****************************************************************************
242 * This function is called just after the thread is launched.
243 ****************************************************************************/
244 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
246 decoder_sys_t *p_sys = p_dec->p_sys;
247 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
248 block_t *p_sout_block;
250 if( !pp_block || !*pp_block ) return NULL;
253 if( (*pp_block)->b_discontinuity )
255 p_sys->i_state = STATE_NOSYNC;
259 block_BytestreamPush( &p_sys->bytestream, *pp_block );
263 switch( p_sys->i_state )
266 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
269 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
271 p_sys->i_state = STATE_SYNC;
274 block_SkipByte( &p_sys->bytestream );
276 if( p_sys->i_state != STATE_SYNC )
278 block_BytestreamFlush( &p_sys->bytestream );
285 /* New frame, set the Presentation Time Stamp */
286 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
287 if( p_sys->i_pts != 0 &&
288 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
290 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
292 p_sys->i_state = STATE_HEADER;
295 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
296 if( block_PeekBytes( &p_sys->bytestream, p_header,
297 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
303 /* Check if frame is valid and get frame info */
304 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
306 &p_sys->i_channels_conf,
308 &p_sys->i_bits_per_sample );
309 if( !p_sys->i_frame_length )
311 msg_Dbg( p_dec, "emulated sync word" );
312 block_SkipByte( &p_sys->bytestream );
313 p_sys->i_state = STATE_NOSYNC;
316 p_sys->i_state = STATE_NEXT_SYNC;
317 p_sys->i_frame_size = 1;
319 case STATE_NEXT_SYNC:
320 /* TODO: If pp_block == NULL, flush the buffer without checking the
323 /* Check if next expected frame contains the sync word */
324 while( block_PeekOffsetBytes( &p_sys->bytestream,
325 p_sys->i_frame_size, p_header,
326 MAX_FLAC_HEADER_SIZE )
329 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
331 /* Check if frame is valid and get frame info */
332 p_sys->i_frame_length =
333 SyncInfo( p_dec, p_header,
335 &p_sys->i_channels_conf,
337 &p_sys->i_bits_per_sample );
339 if( p_sys->i_frame_length )
341 p_sys->i_state = STATE_SEND_DATA;
345 p_sys->i_frame_size++;
348 if( p_sys->i_state != STATE_SEND_DATA )
355 case STATE_SEND_DATA:
356 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
358 /* Copy the whole frame into the buffer. When we reach this point
359 * we already know we have enough data available. */
360 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
361 p_sys->i_frame_size );
363 /* Make sure we don't reuse the same pts twice */
364 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
365 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
367 /* So p_block doesn't get re-added several times */
368 *pp_block = block_BytestreamPop( &p_sys->bytestream );
370 p_sys->i_state = STATE_NOSYNC;
372 /* Date management */
373 p_sout_block->i_pts = aout_DateGet( &p_sys->end_date );
374 p_sout_block->i_length =
375 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
384 /****************************************************************************
385 * DecodeBlock: the whole thing
386 ****************************************************************************/
387 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
389 decoder_sys_t *p_sys = p_dec->p_sys;
391 if( !pp_block || !*pp_block ) return NULL;
393 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
395 /* We've just started the stream, wait for the first PTS. */
396 block_Release( *pp_block );
400 p_sys->p_aout_buffer = 0;
401 if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
403 if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
405 decoder_state_error( p_dec,
406 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
407 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
410 /* If the decoder is in the "aborted" state,
411 * FLAC__stream_decoder_process_single() won't return an error. */
412 if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
413 == FLAC__STREAM_DECODER_ABORTED )
415 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
418 block_Release( p_sys->p_block );
421 return p_sys->p_aout_buffer;
424 /*****************************************************************************
425 * CloseDecoder: flac decoder destruction
426 *****************************************************************************/
427 static void CloseDecoder( vlc_object_t *p_this )
429 decoder_t *p_dec = (decoder_t *)p_this;
430 decoder_sys_t *p_sys = p_dec->p_sys;
432 FLAC__stream_decoder_finish( p_sys->p_flac );
433 FLAC__stream_decoder_delete( p_sys->p_flac );
437 /*****************************************************************************
438 * DecoderReadCallback: called by libflac when it needs more data
439 *****************************************************************************/
440 static FLAC__StreamDecoderReadStatus
441 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
442 unsigned *bytes, void *client_data )
444 decoder_t *p_dec = (decoder_t *)client_data;
445 decoder_sys_t *p_sys = p_dec->p_sys;
447 if( p_sys->p_block && p_sys->p_block->i_buffer )
449 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
450 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
451 p_sys->p_block->i_buffer -= *bytes;
452 p_sys->p_block->p_buffer += *bytes;
457 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
460 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
463 /*****************************************************************************
464 * DecoderWriteCallback: called by libflac to output decoded samples
465 *****************************************************************************/
466 static FLAC__StreamDecoderWriteStatus
467 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
468 const FLAC__Frame *frame,
469 const FLAC__int32 *const buffer[], void *client_data )
471 decoder_t *p_dec = (decoder_t *)client_data;
472 decoder_sys_t *p_sys = p_dec->p_sys;
474 if( p_sys->p_block && p_sys->p_block->i_pts != 0 &&
475 p_sys->p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
477 aout_DateSet( &p_sys->end_date, p_sys->p_block->i_pts );
479 else if( !aout_DateGet( &p_sys->end_date ) )
481 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
484 if( p_sys->p_block ) p_sys->p_block->i_pts = 0;
486 p_sys->p_aout_buffer =
487 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
489 if( p_sys->p_aout_buffer == NULL )
490 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
492 switch( frame->header.bits_per_sample )
495 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
496 frame->header.channels, frame->header.blocksize );
499 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
500 frame->header.channels, frame->header.blocksize );
503 /* Date management */
504 p_sys->p_aout_buffer->start_date = aout_DateGet( &p_sys->end_date );
505 p_sys->p_aout_buffer->end_date =
506 aout_DateIncrement( &p_sys->end_date, frame->header.blocksize );
508 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
511 /*****************************************************************************
512 * DecoderMetadataCallback: called by libflac to when it encounters metadata
513 *****************************************************************************/
514 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
515 const FLAC__StreamMetadata *metadata,
518 decoder_t *p_dec = (decoder_t *)client_data;
519 decoder_sys_t *p_sys = p_dec->p_sys;
521 switch( metadata->data.stream_info.bits_per_sample )
524 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
527 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
530 msg_Dbg( p_dec, "strange bps %d",
531 metadata->data.stream_info.bits_per_sample );
532 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
536 /* Setup the format */
537 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
538 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
539 p_dec->fmt_out.audio.i_physical_channels =
540 p_dec->fmt_out.audio.i_original_channels =
541 pi_channels_maps[metadata->data.stream_info.channels];
542 p_dec->fmt_out.audio.i_bitspersample =
543 metadata->data.stream_info.bits_per_sample;
545 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
547 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
548 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
549 p_dec->fmt_out.audio.i_bitspersample );
551 p_sys->b_stream_info = VLC_TRUE;
552 p_sys->stream_info = metadata->data.stream_info;
557 /*****************************************************************************
558 * DecoderErrorCallback: called when the libflac decoder encounters an error
559 *****************************************************************************/
560 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
561 FLAC__StreamDecoderErrorStatus status,
564 decoder_t *p_dec = (decoder_t *)client_data;
568 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
569 msg_Err( p_dec, "An error in the stream caused the decoder to "
570 "loose synchronization." );
572 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
573 msg_Err( p_dec, "The decoder encountered a corrupted frame header." );
575 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
576 msg_Err( p_dec, "The frame's data did not match the CRC in the "
580 msg_Err( p_dec, "got decoder error: %d", status );
583 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
587 /*****************************************************************************
588 * Interleave: helper function to interleave channels
589 *****************************************************************************/
590 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
591 int i_nb_channels, int i_samples )
594 for ( j = 0; j < i_samples; j++ )
596 for ( i = 0; i < i_nb_channels; i++ )
598 p_out[j * i_nb_channels + i] = pp_in[i][j];
602 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
603 int i_nb_channels, int i_samples )
606 for ( j = 0; j < i_samples; j++ )
608 for ( i = 0; i < i_nb_channels; i++ )
610 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
615 /*****************************************************************************
616 * decoder_state_error: print meaningful error messages
617 *****************************************************************************/
618 static void decoder_state_error( decoder_t *p_dec,
619 FLAC__StreamDecoderState state )
623 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
624 msg_Err( p_dec, "The decoder is ready to search for metadata." );
626 case FLAC__STREAM_DECODER_READ_METADATA:
627 msg_Err( p_dec, "The decoder is ready to or is in the process of "
628 "reading metadata." );
630 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
631 msg_Err( p_dec, "The decoder is ready to or is in the process of "
632 "searching for the frame sync code." );
634 case FLAC__STREAM_DECODER_READ_FRAME:
635 msg_Err( p_dec, "The decoder is ready to or is in the process of "
636 "reading a frame." );
638 case FLAC__STREAM_DECODER_END_OF_STREAM:
639 msg_Err( p_dec, "The decoder has reached the end of the stream." );
641 case FLAC__STREAM_DECODER_ABORTED:
642 msg_Err( p_dec, "The decoder was aborted by the read callback." );
644 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
645 msg_Err( p_dec, "The decoder encountered reserved fields in use "
648 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
649 msg_Err( p_dec, "An error occurred allocating memory." );
651 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
652 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
653 "decoder was already initialized, usually because "
654 "FLAC__stream_decoder_finish() was not called." );
656 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
657 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
658 "all callbacks being set." );
660 case FLAC__STREAM_DECODER_UNINITIALIZED:
661 msg_Err( p_dec, "The decoder is in the uninitialized state." );
664 msg_Err(p_dec, "unknown error" );
668 /*****************************************************************************
669 * SyncInfo: parse FLAC sync info
670 *****************************************************************************/
671 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
672 int * pi_channels, int * pi_channels_conf,
673 int * pi_sample_rate, int * pi_bits_per_sample )
675 decoder_sys_t *p_sys = p_dec->p_sys;
676 int i_header, i_temp, i_read;
677 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
678 uint64_t i_sample_number = 0;
680 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
681 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
682 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
683 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
686 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
688 /* Check there is no emulated sync code in the rest of the header */
689 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
691 /* Find blocksize (framelength) */
692 switch( i_temp = p_buf[2] >> 4 )
695 if( b_fixed_blocksize )
696 i_blocksize = p_sys->stream_info.min_blocksize;
697 else return 0; /* We can't do anything with this */
708 i_blocksize = 576 << (i_temp - 2);
713 i_blocksize_hint = i_temp;
724 i_blocksize = 256 << (i_temp - 8);
728 /* Find samplerate */
729 switch( i_temp = p_buf[2] & 0x0f )
732 if( p_sys->b_stream_info )
733 *pi_sample_rate = p_sys->stream_info.sample_rate;
734 else return 0; /* We can't do anything with this */
744 *pi_sample_rate = 8000;
748 *pi_sample_rate = 16000;
752 *pi_sample_rate = 22050;
756 *pi_sample_rate = 24000;
760 *pi_sample_rate = 32000;
764 *pi_sample_rate = 44100;
768 *pi_sample_rate = 48000;
772 *pi_sample_rate = 96000;
778 i_sample_rate_hint = i_temp;
786 i_temp = (unsigned)(p_buf[3] >> 4);
789 int i_channel_assignment; /* ??? */
795 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
798 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
801 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
810 *pi_channels = i_temp + 1;
811 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
814 /* Find bits per sample */
815 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
818 if( p_sys->b_stream_info )
819 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
825 *pi_bits_per_sample = 8;
829 *pi_bits_per_sample = 12;
833 *pi_bits_per_sample = 16;
837 *pi_bits_per_sample = 20;
841 *pi_bits_per_sample = 24;
850 /* Zero padding bit */
851 if( p_buf[3] & 0x01 ) return 0;
853 /* End of fixed size header */
856 /* Find Sample/Frame number */
857 if( i_blocksize_hint && b_variable_blocksize )
859 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
860 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
864 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
865 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
867 if( p_sys->b_stream_info )
868 i_sample_number *= p_sys->stream_info.min_blocksize;
874 if( i_blocksize_hint )
876 int i_val1 = p_buf[i_header++];
877 if( i_blocksize_hint == 7 )
879 int i_val2 = p_buf[i_header++];
880 i_val1 = (i_val1 << 8) | i_val2;
882 i_blocksize = i_val1 + 1;
885 /* Read sample rate */
886 if( i_sample_rate_hint )
888 int i_val1 = p_buf[i_header++];
889 if( i_sample_rate_hint != 12 )
891 int i_val2 = p_buf[i_header++];
892 i_val1 = (i_val1 << 8) | i_val2;
894 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
895 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
896 else *pi_sample_rate = i_val1 * 10;
899 /* Check the CRC-8 byte */
900 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
908 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
909 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
911 uint64_t i_result = 0;
914 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
919 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
921 i_result = p_buf[0] & 0x1F;
924 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
926 i_result = p_buf[0] & 0x0F;
929 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
931 i_result = p_buf[0] & 0x07;
934 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
936 i_result = p_buf[0] & 0x03;
939 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
941 i_result = p_buf[0] & 0x01;
944 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
950 return I64C(0xffffffffffffffff);
953 for( j = 1; j <= i; j++ )
955 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
957 return I64C(0xffffffffffffffff);
960 i_result |= (p_buf[j] & 0x3F);
967 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
968 static uint8_t const flac_crc8_table[256] = {
969 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
970 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
971 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
972 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
973 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
974 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
975 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
976 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
977 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
978 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
979 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
980 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
981 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
982 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
983 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
984 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
985 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
986 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
987 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
988 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
989 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
990 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
991 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
992 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
993 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
994 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
995 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
996 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
997 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
998 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
999 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1000 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1003 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1008 crc = flac_crc8_table[crc ^ *data++];