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.1 2003/11/21 01:45:48 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 ) );
408 block_Release( p_sys->p_block );
411 return p_sys->p_aout_buffer;
414 /*****************************************************************************
415 * CloseDecoder: flac decoder destruction
416 *****************************************************************************/
417 static void CloseDecoder( vlc_object_t *p_this )
419 decoder_t *p_dec = (decoder_t *)p_this;
420 decoder_sys_t *p_sys = p_dec->p_sys;
422 FLAC__stream_decoder_finish( p_sys->p_flac );
423 FLAC__stream_decoder_delete( p_sys->p_flac );
427 /*****************************************************************************
428 * DecoderReadCallback: called by libflac when it needs more data
429 *****************************************************************************/
430 static FLAC__StreamDecoderReadStatus
431 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
432 unsigned *bytes, void *client_data )
434 decoder_t *p_dec = (decoder_t *)client_data;
435 decoder_sys_t *p_sys = p_dec->p_sys;
437 msg_Err( p_dec, "buffer: %i", p_sys->p_block->i_buffer );
438 if( p_sys->p_block && p_sys->p_block->i_buffer )
440 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
441 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
442 p_sys->p_block->i_buffer -= *bytes;
443 p_sys->p_block->p_buffer += *bytes;
448 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
451 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
454 /*****************************************************************************
455 * DecoderWriteCallback: called by libflac to output decoded samples
456 *****************************************************************************/
457 static FLAC__StreamDecoderWriteStatus
458 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
459 const FLAC__Frame *frame,
460 const FLAC__int32 *const buffer[], void *client_data )
462 decoder_t *p_dec = (decoder_t *)client_data;
463 decoder_sys_t *p_sys = p_dec->p_sys;
465 if( p_sys->p_block && p_sys->p_block->i_pts != 0 &&
466 p_sys->p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
468 aout_DateSet( &p_sys->end_date, p_sys->p_block->i_pts );
470 else if( !aout_DateGet( &p_sys->end_date ) )
472 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
475 if( p_sys->p_block ) p_sys->p_block->i_pts = 0;
477 p_sys->p_aout_buffer =
478 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
480 if( p_sys->p_aout_buffer == NULL )
481 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
483 switch( frame->header.bits_per_sample )
486 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
487 frame->header.channels, frame->header.blocksize );
490 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
491 frame->header.channels, frame->header.blocksize );
494 /* Date management */
495 p_sys->p_aout_buffer->start_date = aout_DateGet( &p_sys->end_date );
496 p_sys->p_aout_buffer->end_date =
497 aout_DateIncrement( &p_sys->end_date, frame->header.blocksize );
499 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
502 /*****************************************************************************
503 * DecoderMetadataCallback: called by libflac to when it encounters metadata
504 *****************************************************************************/
505 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
506 const FLAC__StreamMetadata *metadata,
509 decoder_t *p_dec = (decoder_t *)client_data;
510 decoder_sys_t *p_sys = p_dec->p_sys;
512 switch( metadata->data.stream_info.bits_per_sample )
515 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
518 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
521 msg_Dbg( p_dec, "strange bps %d",
522 metadata->data.stream_info.bits_per_sample );
523 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
527 /* Setup the format */
528 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
529 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
530 p_dec->fmt_out.audio.i_physical_channels =
531 p_dec->fmt_out.audio.i_original_channels =
532 pi_channels_maps[metadata->data.stream_info.channels];
533 p_dec->fmt_out.audio.i_bitspersample =
534 metadata->data.stream_info.bits_per_sample;
536 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
538 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
539 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
540 p_dec->fmt_out.audio.i_bitspersample );
542 p_sys->b_stream_info = VLC_TRUE;
543 p_sys->stream_info = metadata->data.stream_info;
548 /*****************************************************************************
549 * DecoderErrorCallback: called when the libflac decoder encounters an error
550 *****************************************************************************/
551 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
552 FLAC__StreamDecoderErrorStatus status,
555 decoder_t *p_dec = (decoder_t *)client_data;
559 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
560 msg_Err( p_dec, "An error in the stream caused the decoder to "
561 "loose synchronization." );
563 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
564 msg_Err( p_dec, "The decoder encountered a corrupted frame header." );
566 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
567 msg_Err( p_dec, "The frame's data did not match the CRC in the "
571 msg_Err( p_dec, "got decoder error: %d", status );
576 /*****************************************************************************
577 * Interleave: helper function to interleave channels
578 *****************************************************************************/
579 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
580 int i_nb_channels, int i_samples )
583 for ( j = 0; j < i_samples; j++ )
585 for ( i = 0; i < i_nb_channels; i++ )
587 p_out[j * i_nb_channels + i] = pp_in[i][j];
591 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
592 int i_nb_channels, int i_samples )
595 for ( j = 0; j < i_samples; j++ )
597 for ( i = 0; i < i_nb_channels; i++ )
599 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
604 /*****************************************************************************
605 * decoder_state_error: print meaningful error messages
606 *****************************************************************************/
607 static void decoder_state_error( decoder_t *p_dec,
608 FLAC__StreamDecoderState state )
612 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
613 msg_Err( p_dec, "The decoder is ready to search for metadata." );
615 case FLAC__STREAM_DECODER_READ_METADATA:
616 msg_Err( p_dec, "The decoder is ready to or is in the process of "
617 "reading metadata." );
619 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
620 msg_Err( p_dec, "The decoder is ready to or is in the process of "
621 "searching for the frame sync code." );
623 case FLAC__STREAM_DECODER_READ_FRAME:
624 msg_Err( p_dec, "The decoder is ready to or is in the process of "
625 "reading a frame." );
627 case FLAC__STREAM_DECODER_END_OF_STREAM:
628 msg_Err( p_dec, "The decoder has reached the end of the stream." );
630 case FLAC__STREAM_DECODER_ABORTED:
631 msg_Err( p_dec, "The decoder was aborted by the read callback." );
633 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
634 msg_Err( p_dec, "The decoder encountered reserved fields in use "
636 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
638 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
639 msg_Err( p_dec, "An error occurred allocating memory." );
641 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
642 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
643 "decoder was already initialized, usually because "
644 "FLAC__stream_decoder_finish() was not called." );
646 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
647 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
648 "all callbacks being set." );
650 case FLAC__STREAM_DECODER_UNINITIALIZED:
651 msg_Err( p_dec, "The decoder is in the uninitialized state." );
654 msg_Err(p_dec, "unknown error" );
658 /*****************************************************************************
659 * SyncInfo: parse FLAC sync info
660 *****************************************************************************/
661 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
662 int * pi_channels, int * pi_channels_conf,
663 int * pi_sample_rate, int * pi_bits_per_sample )
665 decoder_sys_t *p_sys = p_dec->p_sys;
666 int i_header, i_temp, i_read;
667 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
668 uint64_t i_sample_number = 0;
670 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
671 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
672 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
673 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
676 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
678 /* Check there is no emulated sync code in the rest of the header */
679 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
681 /* Find blocksize (framelength) */
682 switch( i_temp = p_buf[2] >> 4 )
685 if( b_fixed_blocksize )
686 i_blocksize = p_sys->stream_info.min_blocksize;
687 else return 0; /* We can't do anything with this */
698 i_blocksize = 576 << (i_temp - 2);
703 i_blocksize_hint = i_temp;
714 i_blocksize = 256 << (i_temp - 8);
718 /* Find samplerate */
719 switch( i_temp = p_buf[2] & 0x0f )
722 if( p_sys->b_stream_info )
723 *pi_sample_rate = p_sys->stream_info.sample_rate;
724 else return 0; /* We can't do anything with this */
734 *pi_sample_rate = 8000;
738 *pi_sample_rate = 16000;
742 *pi_sample_rate = 22050;
746 *pi_sample_rate = 24000;
750 *pi_sample_rate = 32000;
754 *pi_sample_rate = 44100;
758 *pi_sample_rate = 48000;
762 *pi_sample_rate = 96000;
768 i_sample_rate_hint = i_temp;
776 i_temp = (unsigned)(p_buf[3] >> 4);
779 int i_channel_assignment; /* ??? */
785 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
788 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
791 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
800 *pi_channels = i_temp + 1;
801 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
804 /* Find bits per sample */
805 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
808 if( p_sys->b_stream_info )
809 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
815 *pi_bits_per_sample = 8;
819 *pi_bits_per_sample = 12;
823 *pi_bits_per_sample = 16;
827 *pi_bits_per_sample = 20;
831 *pi_bits_per_sample = 24;
840 /* Zero padding bit */
841 if( p_buf[3] & 0x01 ) return 0;
843 /* End of fixed size header */
846 /* Find Sample/Frame number */
847 if( i_blocksize_hint && b_variable_blocksize )
849 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
850 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
854 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
855 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
857 if( p_sys->b_stream_info )
858 i_sample_number *= p_sys->stream_info.min_blocksize;
864 if( i_blocksize_hint )
866 int i_val1 = p_buf[i_header++];
867 if( i_blocksize_hint == 7 )
869 int i_val2 = p_buf[i_header++];
870 i_val1 = (i_val1 << 8) | i_val2;
872 i_blocksize = i_val1 + 1;
875 /* Read sample rate */
876 if( i_sample_rate_hint )
878 int i_val1 = p_buf[i_header++];
879 if( i_sample_rate_hint != 12 )
881 int i_val2 = p_buf[i_header++];
882 i_val1 = (i_val1 << 8) | i_val2;
884 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
885 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
886 else *pi_sample_rate = i_val1 * 10;
889 /* Check the CRC-8 byte */
890 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
898 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
899 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
901 uint64_t i_result = 0;
904 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
909 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
911 i_result = p_buf[0] & 0x1F;
914 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
916 i_result = p_buf[0] & 0x0F;
919 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
921 i_result = p_buf[0] & 0x07;
924 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
926 i_result = p_buf[0] & 0x03;
929 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
931 i_result = p_buf[0] & 0x01;
934 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
940 return I64C(0xffffffffffffffff);
943 for( j = 1; j <= i; j++ )
945 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
947 return I64C(0xffffffffffffffff);
950 i_result |= (p_buf[j] & 0x3F);
957 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
958 static uint8_t const flac_crc8_table[256] = {
959 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
960 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
961 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
962 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
963 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
964 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
965 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
966 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
967 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
968 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
969 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
970 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
971 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
972 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
973 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
974 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
975 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
976 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
977 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
978 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
979 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
980 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
981 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
982 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
983 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
984 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
985 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
986 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
987 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
988 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
989 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
990 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
993 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
998 crc = flac_crc8_table[crc ^ *data++];