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.3 2003/11/21 20:49:13 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>
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 *****************************************************************************/
45 vlc_bool_t b_packetizer;
52 block_bytestream_t bytestream;
55 * Input/Output properties
58 aout_buffer_t *p_aout_buffer;
63 FLAC__StreamDecoder *p_flac;
65 vlc_bool_t b_stream_info;
66 FLAC__StreamMetadata_StreamInfo stream_info;
71 audio_date_t end_date;
74 int i_frame_size, i_frame_length, i_bits_per_sample;
75 unsigned int i_rate, i_channels, i_channels_conf;
88 static int pi_channels_maps[6] =
92 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
93 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
94 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
95 | AOUT_CHAN_REARRIGHT,
96 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
97 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
100 /*****************************************************************************
102 *****************************************************************************/
103 static int OpenDecoder ( vlc_object_t * );
104 static int OpenPacketizer( vlc_object_t * );
105 static void CloseDecoder ( vlc_object_t * );
107 static int OpenEncoder ( vlc_object_t * );
108 static void CloseEncoder ( vlc_object_t * );
110 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
111 static block_t *PacketizeBlock( decoder_t *, block_t ** );
113 static int SyncInfo( decoder_t *, uint8_t *, int *, int *, int *,int * );
116 static FLAC__StreamDecoderReadStatus
117 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
118 FLAC__byte buffer[], unsigned *bytes, void *client_data );
120 static FLAC__StreamDecoderWriteStatus
121 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
122 const FLAC__Frame *frame,
123 const FLAC__int32 *const buffer[], void *client_data );
125 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
126 const FLAC__StreamMetadata *metadata,
128 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
129 FLAC__StreamDecoderErrorStatus status,
132 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
133 int i_nb_channels, int i_samples );
134 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
135 int i_nb_channels, int i_samples );
137 static void decoder_state_error( decoder_t *p_dec,
138 FLAC__StreamDecoderState state );
140 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
141 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
143 /*****************************************************************************
145 *****************************************************************************/
148 set_description( _("Flac audio decoder") );
149 set_capability( "decoder", 100 );
150 set_callbacks( OpenDecoder, CloseDecoder );
153 set_description( _("Flac audio packetizer") );
154 set_capability( "packetizer", 100 );
155 set_callbacks( OpenPacketizer, CloseDecoder );
158 set_description( _("Flac audio encoder") );
159 set_capability( "encoder", 100 );
160 set_callbacks( OpenEncoder, CloseEncoder );
164 /*****************************************************************************
165 * OpenDecoder: probe the decoder and return score
166 *****************************************************************************/
167 static int OpenDecoder( vlc_object_t *p_this )
169 decoder_t *p_dec = (decoder_t*)p_this;
170 decoder_sys_t *p_sys;
172 if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
177 /* Allocate the memory needed to store the decoder's structure */
178 if( ( p_dec->p_sys = p_sys =
179 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
181 msg_Err( p_dec, "out of memory" );
186 aout_DateSet( &p_sys->end_date, 0 );
187 p_sys->b_packetizer = VLC_FALSE;
188 p_sys->i_state = STATE_NOSYNC;
190 p_sys->bytestream = block_BytestreamInit( p_dec );
192 /* Take care of flac init */
193 if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
195 msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
200 FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
201 DecoderReadCallback );
202 FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
203 DecoderWriteCallback );
204 FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
205 DecoderMetadataCallback );
206 FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
207 DecoderErrorCallback );
208 FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
210 FLAC__stream_decoder_init( p_sys->p_flac );
212 /* Set output properties */
213 p_dec->fmt_out.i_cat = AUDIO_ES;
214 p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
217 p_dec->pf_decode_audio = DecodeBlock;
218 p_dec->pf_packetize = PacketizeBlock;
221 /* Decode STREAMINFO */
222 msg_Dbg( p_dec, "decode STREAMINFO" );
223 p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
224 memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
225 p_dec->fmt_in.i_extra );
226 FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
227 msg_Dbg( p_dec, "STREAMINFO decoded" );
232 static int OpenPacketizer( vlc_object_t *p_this )
234 decoder_t *p_dec = (decoder_t*)p_this;
236 int i_ret = OpenDecoder( p_this );
238 if( i_ret == VLC_SUCCESS )
240 p_dec->p_sys->b_packetizer = VLC_TRUE;
241 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
247 /****************************************************************************
248 * PacketizeBlock: the whole thing
249 ****************************************************************************
250 * This function is called just after the thread is launched.
251 ****************************************************************************/
252 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
254 decoder_sys_t *p_sys = p_dec->p_sys;
255 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
256 block_t *p_sout_block;
258 if( !pp_block || !*pp_block ) return NULL;
261 if( (*pp_block)->b_discontinuity )
263 p_sys->i_state = STATE_NOSYNC;
267 block_BytestreamPush( &p_sys->bytestream, *pp_block );
271 switch( p_sys->i_state )
274 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
277 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
279 p_sys->i_state = STATE_SYNC;
282 block_SkipByte( &p_sys->bytestream );
284 if( p_sys->i_state != STATE_SYNC )
286 block_BytestreamFlush( &p_sys->bytestream );
293 /* New frame, set the Presentation Time Stamp */
294 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
295 if( p_sys->i_pts != 0 &&
296 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
298 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
300 p_sys->i_state = STATE_HEADER;
303 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
304 if( block_PeekBytes( &p_sys->bytestream, p_header,
305 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
311 /* Check if frame is valid and get frame info */
312 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
314 &p_sys->i_channels_conf,
316 &p_sys->i_bits_per_sample );
317 if( !p_sys->i_frame_length )
319 msg_Dbg( p_dec, "emulated sync word" );
320 block_SkipByte( &p_sys->bytestream );
321 p_sys->i_state = STATE_NOSYNC;
324 p_sys->i_state = STATE_NEXT_SYNC;
325 p_sys->i_frame_size = 1;
327 case STATE_NEXT_SYNC:
328 /* TODO: If pp_block == NULL, flush the buffer without checking the
331 /* Check if next expected frame contains the sync word */
332 while( block_PeekOffsetBytes( &p_sys->bytestream,
333 p_sys->i_frame_size, p_header,
334 MAX_FLAC_HEADER_SIZE )
337 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
339 /* Check if frame is valid and get frame info */
340 p_sys->i_frame_length =
341 SyncInfo( p_dec, p_header,
343 &p_sys->i_channels_conf,
345 &p_sys->i_bits_per_sample );
347 if( p_sys->i_frame_length )
349 p_sys->i_state = STATE_SEND_DATA;
353 p_sys->i_frame_size++;
356 if( p_sys->i_state != STATE_SEND_DATA )
363 case STATE_SEND_DATA:
364 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
366 /* Copy the whole frame into the buffer. When we reach this point
367 * we already know we have enough data available. */
368 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
369 p_sys->i_frame_size );
371 /* Make sure we don't reuse the same pts twice */
372 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
373 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
375 /* So p_block doesn't get re-added several times */
376 *pp_block = block_BytestreamPop( &p_sys->bytestream );
378 p_sys->i_state = STATE_NOSYNC;
380 /* Date management */
381 p_sout_block->i_pts = aout_DateGet( &p_sys->end_date );
382 p_sout_block->i_length =
383 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
392 /****************************************************************************
393 * DecodeBlock: the whole thing
394 ****************************************************************************/
395 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
397 decoder_sys_t *p_sys = p_dec->p_sys;
399 if( !pp_block || !*pp_block ) return NULL;
401 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
403 /* We've just started the stream, wait for the first PTS. */
404 block_Release( *pp_block );
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 );
429 return p_sys->p_aout_buffer;
432 /*****************************************************************************
433 * CloseDecoder: flac decoder destruction
434 *****************************************************************************/
435 static void CloseDecoder( vlc_object_t *p_this )
437 decoder_t *p_dec = (decoder_t *)p_this;
438 decoder_sys_t *p_sys = p_dec->p_sys;
440 FLAC__stream_decoder_finish( p_sys->p_flac );
441 FLAC__stream_decoder_delete( p_sys->p_flac );
445 /*****************************************************************************
446 * DecoderReadCallback: called by libflac when it needs more data
447 *****************************************************************************/
448 static FLAC__StreamDecoderReadStatus
449 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
450 unsigned *bytes, void *client_data )
452 decoder_t *p_dec = (decoder_t *)client_data;
453 decoder_sys_t *p_sys = p_dec->p_sys;
455 if( p_sys->p_block && p_sys->p_block->i_buffer )
457 *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
458 memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
459 p_sys->p_block->i_buffer -= *bytes;
460 p_sys->p_block->p_buffer += *bytes;
465 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
468 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
471 /*****************************************************************************
472 * DecoderWriteCallback: called by libflac to output decoded samples
473 *****************************************************************************/
474 static FLAC__StreamDecoderWriteStatus
475 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
476 const FLAC__Frame *frame,
477 const FLAC__int32 *const buffer[], void *client_data )
479 decoder_t *p_dec = (decoder_t *)client_data;
480 decoder_sys_t *p_sys = p_dec->p_sys;
482 if( p_sys->p_block && p_sys->p_block->i_pts != 0 &&
483 p_sys->p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
485 aout_DateSet( &p_sys->end_date, p_sys->p_block->i_pts );
487 else if( !aout_DateGet( &p_sys->end_date ) )
489 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
492 if( p_sys->p_block ) p_sys->p_block->i_pts = 0;
494 p_sys->p_aout_buffer =
495 p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
497 if( p_sys->p_aout_buffer == NULL )
498 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
500 switch( frame->header.bits_per_sample )
503 Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
504 frame->header.channels, frame->header.blocksize );
507 Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
508 frame->header.channels, frame->header.blocksize );
511 /* Date management */
512 p_sys->p_aout_buffer->start_date = aout_DateGet( &p_sys->end_date );
513 p_sys->p_aout_buffer->end_date =
514 aout_DateIncrement( &p_sys->end_date, frame->header.blocksize );
516 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
519 /*****************************************************************************
520 * DecoderMetadataCallback: called by libflac to when it encounters metadata
521 *****************************************************************************/
522 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
523 const FLAC__StreamMetadata *metadata,
526 decoder_t *p_dec = (decoder_t *)client_data;
527 decoder_sys_t *p_sys = p_dec->p_sys;
529 switch( metadata->data.stream_info.bits_per_sample )
532 p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
535 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
538 msg_Dbg( p_dec, "strange bps %d",
539 metadata->data.stream_info.bits_per_sample );
540 p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
544 /* Setup the format */
545 p_dec->fmt_out.audio.i_rate = metadata->data.stream_info.sample_rate;
546 p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
547 p_dec->fmt_out.audio.i_physical_channels =
548 p_dec->fmt_out.audio.i_original_channels =
549 pi_channels_maps[metadata->data.stream_info.channels];
550 p_dec->fmt_out.audio.i_bitspersample =
551 metadata->data.stream_info.bits_per_sample;
553 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
555 msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
556 p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
557 p_dec->fmt_out.audio.i_bitspersample );
559 p_sys->b_stream_info = VLC_TRUE;
560 p_sys->stream_info = metadata->data.stream_info;
565 /*****************************************************************************
566 * DecoderErrorCallback: called when the libflac decoder encounters an error
567 *****************************************************************************/
568 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
569 FLAC__StreamDecoderErrorStatus status,
572 decoder_t *p_dec = (decoder_t *)client_data;
576 case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
577 msg_Err( p_dec, "An error in the stream caused the decoder to "
578 "loose synchronization." );
580 case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
581 msg_Err( p_dec, "The decoder encountered a corrupted frame header." );
583 case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
584 msg_Err( p_dec, "The frame's data did not match the CRC in the "
588 msg_Err( p_dec, "got decoder error: %d", status );
591 FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
595 /*****************************************************************************
596 * Interleave: helper function to interleave channels
597 *****************************************************************************/
598 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
599 int i_nb_channels, int i_samples )
602 for ( j = 0; j < i_samples; j++ )
604 for ( i = 0; i < i_nb_channels; i++ )
606 p_out[j * i_nb_channels + i] = pp_in[i][j];
610 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
611 int i_nb_channels, int i_samples )
614 for ( j = 0; j < i_samples; j++ )
616 for ( i = 0; i < i_nb_channels; i++ )
618 p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
623 /*****************************************************************************
624 * decoder_state_error: print meaningful error messages
625 *****************************************************************************/
626 static void decoder_state_error( decoder_t *p_dec,
627 FLAC__StreamDecoderState state )
631 case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
632 msg_Err( p_dec, "The decoder is ready to search for metadata." );
634 case FLAC__STREAM_DECODER_READ_METADATA:
635 msg_Err( p_dec, "The decoder is ready to or is in the process of "
636 "reading metadata." );
638 case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
639 msg_Err( p_dec, "The decoder is ready to or is in the process of "
640 "searching for the frame sync code." );
642 case FLAC__STREAM_DECODER_READ_FRAME:
643 msg_Err( p_dec, "The decoder is ready to or is in the process of "
644 "reading a frame." );
646 case FLAC__STREAM_DECODER_END_OF_STREAM:
647 msg_Err( p_dec, "The decoder has reached the end of the stream." );
649 case FLAC__STREAM_DECODER_ABORTED:
650 msg_Err( p_dec, "The decoder was aborted by the read callback." );
652 case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
653 msg_Err( p_dec, "The decoder encountered reserved fields in use "
656 case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
657 msg_Err( p_dec, "An error occurred allocating memory." );
659 case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
660 msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
661 "decoder was already initialized, usually because "
662 "FLAC__stream_decoder_finish() was not called." );
664 case FLAC__STREAM_DECODER_INVALID_CALLBACK:
665 msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
666 "all callbacks being set." );
668 case FLAC__STREAM_DECODER_UNINITIALIZED:
669 msg_Err( p_dec, "The decoder is in the uninitialized state." );
672 msg_Err(p_dec, "unknown error" );
676 /*****************************************************************************
677 * SyncInfo: parse FLAC sync info
678 *****************************************************************************/
679 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
680 int * pi_channels, int * pi_channels_conf,
681 int * pi_sample_rate, int * pi_bits_per_sample )
683 decoder_sys_t *p_sys = p_dec->p_sys;
684 int i_header, i_temp, i_read;
685 int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
686 uint64_t i_sample_number = 0;
688 vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
689 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
690 vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
691 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
694 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
696 /* Check there is no emulated sync code in the rest of the header */
697 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
699 /* Find blocksize (framelength) */
700 switch( i_temp = p_buf[2] >> 4 )
703 if( b_fixed_blocksize )
704 i_blocksize = p_sys->stream_info.min_blocksize;
705 else return 0; /* We can't do anything with this */
716 i_blocksize = 576 << (i_temp - 2);
721 i_blocksize_hint = i_temp;
732 i_blocksize = 256 << (i_temp - 8);
736 /* Find samplerate */
737 switch( i_temp = p_buf[2] & 0x0f )
740 if( p_sys->b_stream_info )
741 *pi_sample_rate = p_sys->stream_info.sample_rate;
742 else return 0; /* We can't do anything with this */
752 *pi_sample_rate = 8000;
756 *pi_sample_rate = 16000;
760 *pi_sample_rate = 22050;
764 *pi_sample_rate = 24000;
768 *pi_sample_rate = 32000;
772 *pi_sample_rate = 44100;
776 *pi_sample_rate = 48000;
780 *pi_sample_rate = 96000;
786 i_sample_rate_hint = i_temp;
794 i_temp = (unsigned)(p_buf[3] >> 4);
797 int i_channel_assignment; /* ??? */
803 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
806 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
809 i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
818 *pi_channels = i_temp + 1;
819 *pi_channels_conf = pi_channels_maps[ *pi_channels ];
822 /* Find bits per sample */
823 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
826 if( p_sys->b_stream_info )
827 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
833 *pi_bits_per_sample = 8;
837 *pi_bits_per_sample = 12;
841 *pi_bits_per_sample = 16;
845 *pi_bits_per_sample = 20;
849 *pi_bits_per_sample = 24;
858 /* Zero padding bit */
859 if( p_buf[3] & 0x01 ) return 0;
861 /* End of fixed size header */
864 /* Find Sample/Frame number */
865 if( i_blocksize_hint && b_variable_blocksize )
867 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
868 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
872 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
873 if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
875 if( p_sys->b_stream_info )
876 i_sample_number *= p_sys->stream_info.min_blocksize;
882 if( i_blocksize_hint )
884 int i_val1 = p_buf[i_header++];
885 if( i_blocksize_hint == 7 )
887 int i_val2 = p_buf[i_header++];
888 i_val1 = (i_val1 << 8) | i_val2;
890 i_blocksize = i_val1 + 1;
893 /* Read sample rate */
894 if( i_sample_rate_hint )
896 int i_val1 = p_buf[i_header++];
897 if( i_sample_rate_hint != 12 )
899 int i_val2 = p_buf[i_header++];
900 i_val1 = (i_val1 << 8) | i_val2;
902 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
903 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
904 else *pi_sample_rate = i_val1 * 10;
907 /* Check the CRC-8 byte */
908 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
916 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
917 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
919 uint64_t i_result = 0;
922 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
927 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
929 i_result = p_buf[0] & 0x1F;
932 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
934 i_result = p_buf[0] & 0x0F;
937 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
939 i_result = p_buf[0] & 0x07;
942 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
944 i_result = p_buf[0] & 0x03;
947 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
949 i_result = p_buf[0] & 0x01;
952 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
958 return I64C(0xffffffffffffffff);
961 for( j = 1; j <= i; j++ )
963 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
965 return I64C(0xffffffffffffffff);
968 i_result |= (p_buf[j] & 0x3F);
975 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
976 static uint8_t const flac_crc8_table[256] = {
977 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
978 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
979 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
980 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
981 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
982 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
983 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
984 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
985 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
986 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
987 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
988 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
989 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
990 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
991 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
992 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
993 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
994 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
995 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
996 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
997 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
998 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
999 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1000 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1001 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1002 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1003 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1004 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1005 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1006 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1007 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1008 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1011 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1016 crc = flac_crc8_table[crc ^ *data++];
1021 /*****************************************************************************
1022 * encoder_sys_t : flac encoder descriptor
1023 *****************************************************************************/
1024 struct encoder_sys_t
1031 int i_samples_delay;
1034 FLAC__int32 *p_buffer;
1042 FLAC__StreamEncoder *p_flac;
1043 FLAC__StreamMetadata_StreamInfo stream_info;
1051 #define STREAMINFO_SIZE 38
1053 static block_t *Encode( encoder_t *, aout_buffer_t * );
1055 static FLAC__StreamEncoderWriteStatus
1056 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1057 const FLAC__byte buffer[],
1058 unsigned bytes, unsigned samples,
1059 unsigned current_frame, void *client_data );
1061 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1062 const FLAC__StreamMetadata *metadata,
1063 void *client_data );
1065 /*****************************************************************************
1066 * OpenEncoder: probe the encoder and return score
1067 *****************************************************************************/
1068 static int OpenEncoder( vlc_object_t *p_this )
1070 encoder_t *p_enc = (encoder_t *)p_this;
1071 encoder_sys_t *p_sys;
1073 if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') )
1075 return VLC_EGENERIC;
1078 /* Allocate the memory needed to store the decoder's structure */
1079 if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1081 msg_Err( p_enc, "out of memory" );
1082 return VLC_EGENERIC;
1084 p_enc->p_sys = p_sys;
1085 p_enc->pf_encode_audio = Encode;
1086 p_sys->i_headers = 0;
1087 p_sys->p_buffer = 0;
1088 p_sys->i_buffer = 0;
1090 /* Create flac encoder */
1091 p_sys->p_flac = FLAC__stream_encoder_new();
1093 FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1094 FLAC__stream_encoder_set_channels( p_sys->p_flac,
1095 p_enc->fmt_in.audio.i_channels );
1096 FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1097 p_enc->fmt_in.audio.i_rate );
1098 FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1099 p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1101 FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1102 EncoderWriteCallback );
1103 FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1104 EncoderMetadataCallback );
1105 FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1107 /* Get and store the STREAMINFO metadata block as a p_extra */
1109 FLAC__stream_encoder_init( p_sys->p_flac );
1114 /****************************************************************************
1115 * Encode: the whole thing
1116 ****************************************************************************
1117 * This function spits out ogg packets.
1118 ****************************************************************************/
1119 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1121 encoder_sys_t *p_sys = p_enc->p_sys;
1125 p_sys->i_pts = p_aout_buf->start_date -
1126 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1127 (mtime_t)p_enc->fmt_in.audio.i_rate;
1129 p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1131 /* Convert samples to FLAC__int32 */
1132 if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1135 realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1136 p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1139 for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1141 p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1144 FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1145 p_aout_buf->i_nb_samples );
1147 p_chain = p_sys->p_chain;
1153 /*****************************************************************************
1154 * CloseEncoder: encoder destruction
1155 *****************************************************************************/
1156 static void CloseEncoder( vlc_object_t *p_this )
1158 encoder_t *p_enc = (encoder_t *)p_this;
1159 encoder_sys_t *p_sys = p_enc->p_sys;
1161 FLAC__stream_encoder_delete( p_sys->p_flac );
1163 if( p_sys->p_buffer ) free( p_sys->p_buffer );
1167 /*****************************************************************************
1168 * EncoderMetadataCallback: called by libflac to output metadata
1169 *****************************************************************************/
1170 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1171 const FLAC__StreamMetadata *metadata,
1174 encoder_t *p_enc = (encoder_t *)client_data;
1176 msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1180 /*****************************************************************************
1181 * EncoderWriteCallback: called by libflac to output encoded samples
1182 *****************************************************************************/
1183 static FLAC__StreamEncoderWriteStatus
1184 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1185 const FLAC__byte buffer[],
1186 unsigned bytes, unsigned samples,
1187 unsigned current_frame, void *client_data )
1189 encoder_t *p_enc = (encoder_t *)client_data;
1190 encoder_sys_t *p_sys = p_enc->p_sys;
1193 if( samples == 0 && p_sys->i_headers <= 1 )
1195 if( p_sys->i_headers == 1 )
1197 msg_Err( p_enc, "Writing STREAMINFO: %i", bytes );
1199 /* Backup the STREAMINFO metadata block */
1200 p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1201 p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1202 memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1203 memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1204 STREAMINFO_SIZE + 4 );
1206 /* Fake this as the last metadata block */
1207 ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1210 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1213 p_block = block_New( p_enc, bytes );
1214 memcpy( p_block->p_buffer, buffer, bytes );
1216 p_block->i_dts = p_block->i_pts = p_block->i_length = 0;
1218 block_ChainAppend( &p_sys->p_chain, p_block );
1220 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;