1 /*****************************************************************************
2 * flac.c: flac packetizer module.
3 *****************************************************************************
4 * Copyright (C) 1999-2001 the VideoLAN team
7 * Authors: Gildas Bazin <gbazin@videolan.org>
8 * Sigmund Augdal Helberg <dnumgis@videolan.org>
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
37 #include <vlc_block_helper.h>
40 /*****************************************************************************
42 *****************************************************************************/
43 static int Open ( vlc_object_t * );
44 static void Close( vlc_object_t * );
47 set_category( CAT_SOUT )
48 set_subcategory( SUBCAT_SOUT_PACKETIZER )
49 set_description( N_("Flac audio packetizer") )
50 set_capability( "packetizer", 50 )
51 set_callbacks( Open, Close )
54 /*****************************************************************************
55 * decoder_sys_t : FLAC decoder descriptor
56 *****************************************************************************/
57 #define MAX_FLAC_HEADER_SIZE 16
65 block_bytestream_t bytestream;
72 unsigned min_blocksize, max_blocksize;
73 unsigned min_framesize, max_framesize;
76 unsigned bits_per_sample;
87 int i_frame_size, i_frame_length, i_bits_per_sample;
88 unsigned int i_rate, i_channels;
101 /*****************************************************************************
103 *****************************************************************************/
104 static block_t *Packetize( decoder_t *, block_t ** );
106 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *,
107 unsigned int *,int * );
109 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
110 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
112 static int Open( vlc_object_t *p_this )
114 decoder_t *p_dec = (decoder_t*)p_this;
115 decoder_sys_t *p_sys;
117 if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
121 p_dec->p_sys = p_sys = malloc(sizeof(*p_sys));
125 date_Set( &p_sys->end_date, 0 );
126 p_sys->i_state = STATE_NOSYNC;
127 p_sys->b_stream_info = false;
128 p_sys->i_pts = VLC_TS_INVALID;
129 p_sys->bytestream = block_BytestreamInit();
132 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
133 p_dec->fmt_out.i_cat = AUDIO_ES;
134 p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
137 p_dec->pf_decode_audio = NULL;
138 p_dec->pf_packetize = Packetize;
143 static void Close( vlc_object_t *p_this )
145 decoder_t *p_dec = (decoder_t *)p_this;
146 decoder_sys_t *p_sys = p_dec->p_sys;
148 block_BytestreamRelease( &p_sys->bytestream );
152 /*****************************************************************************
153 * ProcessHeader: process Flac header.
154 *****************************************************************************/
155 static void ProcessHeader( decoder_t *p_dec )
157 decoder_sys_t *p_sys = p_dec->p_sys;
161 if( p_dec->fmt_in.i_extra < 8 + 14 )
164 bs_init( &bs, (uint8_t*)p_dec->fmt_in.p_extra + 8, p_dec->fmt_in.i_extra - 8 );
166 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
167 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
169 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
170 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
172 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
173 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
174 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
176 p_sys->b_stream_info = true;
178 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
179 p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
180 p_dec->fmt_out.i_extra );
181 memcpy( p_dec->fmt_out.p_extra,
182 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
186 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
188 decoder_sys_t *p_sys = p_dec->p_sys;
189 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
190 block_t *p_sout_block;
192 if( !pp_block || !*pp_block ) return NULL;
194 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
196 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
198 p_sys->i_state = STATE_NOSYNC;
199 block_BytestreamEmpty( &p_sys->bytestream );
201 date_Set( &p_sys->end_date, 0 );
202 block_Release( *pp_block );
206 if( !p_sys->b_stream_info )
207 ProcessHeader( p_dec );
209 if( p_sys->stream_info.channels > 6 )
211 msg_Err( p_dec, "This stream uses too many audio channels" );
215 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
217 /* We've just started the stream, wait for the first PTS. */
218 block_Release( *pp_block );
221 else if( !date_Get( &p_sys->end_date ) )
223 /* The first PTS is as good as anything else. */
224 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
225 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
226 date_Set( &p_sys->end_date, (*pp_block)->i_pts );
229 block_BytestreamPush( &p_sys->bytestream, *pp_block );
233 switch( p_sys->i_state )
236 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
239 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
241 p_sys->i_state = STATE_SYNC;
244 block_SkipByte( &p_sys->bytestream );
246 if( p_sys->i_state != STATE_SYNC )
248 block_BytestreamFlush( &p_sys->bytestream );
255 /* New frame, set the Presentation Time Stamp */
256 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
257 if( p_sys->i_pts > VLC_TS_INVALID &&
258 p_sys->i_pts != date_Get( &p_sys->end_date ) )
260 date_Set( &p_sys->end_date, p_sys->i_pts );
262 p_sys->i_state = STATE_HEADER;
265 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
266 if( block_PeekBytes( &p_sys->bytestream, p_header,
267 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
273 /* Check if frame is valid and get frame info */
274 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
277 &p_sys->i_bits_per_sample );
278 if( !p_sys->i_frame_length )
280 msg_Dbg( p_dec, "emulated sync word" );
281 block_SkipByte( &p_sys->bytestream );
282 p_sys->i_state = STATE_NOSYNC;
285 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
287 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
288 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
289 date_Set( &p_sys->end_date, p_sys->i_pts );
291 p_sys->i_state = STATE_NEXT_SYNC;
292 p_sys->i_frame_size = p_sys->b_stream_info && p_sys->stream_info.min_framesize > 0 ?
293 p_sys->stream_info.min_framesize : 1;
295 case STATE_NEXT_SYNC:
296 /* TODO: If pp_block == NULL, flush the buffer without checking the
299 /* Check if next expected frame contains the sync word */
300 while( block_PeekOffsetBytes( &p_sys->bytestream,
301 p_sys->i_frame_size, p_header,
302 MAX_FLAC_HEADER_SIZE )
305 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
307 /* Check if frame is valid and get frame info */
309 SyncInfo( p_dec, p_header,
312 &p_sys->i_bits_per_sample );
316 p_sys->i_state = STATE_SEND_DATA;
320 p_sys->i_frame_size++;
323 if( p_sys->i_state != STATE_SEND_DATA )
325 if( p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
326 p_sys->i_frame_size > p_sys->stream_info.max_framesize )
328 block_SkipByte( &p_sys->bytestream );
329 p_sys->i_state = STATE_NOSYNC;
336 case STATE_SEND_DATA:
337 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
339 /* Copy the whole frame into the buffer. When we reach this point
340 * we already know we have enough data available. */
341 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
342 p_sys->i_frame_size );
344 /* Make sure we don't reuse the same pts twice */
345 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
346 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
348 /* So p_block doesn't get re-added several times */
349 *pp_block = block_BytestreamPop( &p_sys->bytestream );
351 p_sys->i_state = STATE_NOSYNC;
353 /* Date management */
354 p_sout_block->i_pts =
355 p_sout_block->i_dts = date_Get( &p_sys->end_date );
356 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
357 p_sout_block->i_length =
358 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
367 /*****************************************************************************
368 * SyncInfo: parse FLAC sync info
369 *****************************************************************************/
370 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
371 unsigned int * pi_channels,
372 unsigned int * pi_sample_rate,
373 int * pi_bits_per_sample )
375 decoder_sys_t *p_sys = p_dec->p_sys;
376 int i_header, i_temp, i_read;
377 unsigned i_blocksize = 0;
378 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
379 uint64_t i_sample_number = 0;
381 bool b_variable_blocksize = ( p_sys->b_stream_info &&
382 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
383 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
384 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
387 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
389 /* Check there is no emulated sync code in the rest of the header */
390 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
392 /* Find blocksize (framelength) */
393 switch( i_temp = p_buf[2] >> 4 )
396 if( b_fixed_blocksize )
397 i_blocksize = p_sys->stream_info.min_blocksize;
398 else return 0; /* We can't do anything with this */
409 i_blocksize = 576 << (i_temp - 2);
414 i_blocksize_hint = i_temp;
425 i_blocksize = 256 << (i_temp - 8);
429 /* Find samplerate */
430 switch( i_temp = p_buf[2] & 0x0f )
433 if( p_sys->b_stream_info )
434 *pi_sample_rate = p_sys->stream_info.sample_rate;
435 else return 0; /* We can't do anything with this */
439 *pi_sample_rate = 88200;
443 *pi_sample_rate = 176400;
447 *pi_sample_rate = 192000;
451 *pi_sample_rate = 8000;
455 *pi_sample_rate = 16000;
459 *pi_sample_rate = 22050;
463 *pi_sample_rate = 24000;
467 *pi_sample_rate = 32000;
471 *pi_sample_rate = 44100;
475 *pi_sample_rate = 48000;
479 *pi_sample_rate = 96000;
485 i_sample_rate_hint = i_temp;
493 i_temp = (unsigned)(p_buf[3] >> 4);
496 if( ( i_temp & 7 ) >= 3 )
502 *pi_channels = i_temp + 1;
505 /* Find bits per sample */
506 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
509 if( p_sys->b_stream_info )
510 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
516 *pi_bits_per_sample = 8;
520 *pi_bits_per_sample = 12;
524 *pi_bits_per_sample = 16;
528 *pi_bits_per_sample = 20;
532 *pi_bits_per_sample = 24;
541 /* Zero padding bit */
542 if( p_buf[3] & 0x01 ) return 0;
544 /* End of fixed size header */
547 /* Find Sample/Frame number */
548 if( i_blocksize_hint && b_variable_blocksize )
550 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
551 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
555 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
556 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
558 if( p_sys->b_stream_info )
559 i_sample_number *= p_sys->stream_info.min_blocksize;
565 if( i_blocksize_hint )
567 int i_val1 = p_buf[i_header++];
568 if( i_blocksize_hint == 7 )
570 int i_val2 = p_buf[i_header++];
571 i_val1 = (i_val1 << 8) | i_val2;
573 i_blocksize = i_val1 + 1;
576 /* Read sample rate */
577 if( i_sample_rate_hint )
579 int i_val1 = p_buf[i_header++];
580 if( i_sample_rate_hint != 12 )
582 int i_val2 = p_buf[i_header++];
583 i_val1 = (i_val1 << 8) | i_val2;
585 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
586 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
587 else *pi_sample_rate = i_val1 * 10;
590 /* Check the CRC-8 byte */
591 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
596 /* Sanity check using stream info header when possible */
597 if( p_sys->b_stream_info )
599 if( i_blocksize < p_sys->stream_info.min_blocksize ||
600 i_blocksize > p_sys->stream_info.max_blocksize )
606 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
607 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
609 uint64_t i_result = 0;
612 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
617 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
619 i_result = p_buf[0] & 0x1F;
622 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
624 i_result = p_buf[0] & 0x0F;
627 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
629 i_result = p_buf[0] & 0x07;
632 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
634 i_result = p_buf[0] & 0x03;
637 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
639 i_result = p_buf[0] & 0x01;
642 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
648 return INT64_C(0xffffffffffffffff);
651 for( j = 1; j <= i; j++ )
653 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
655 return INT64_C(0xffffffffffffffff);
658 i_result |= (p_buf[j] & 0x3F);
665 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
666 static const uint8_t flac_crc8_table[256] = {
667 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
668 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
669 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
670 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
671 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
672 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
673 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
674 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
675 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
676 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
677 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
678 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
679 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
680 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
681 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
682 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
683 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
684 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
685 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
686 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
687 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
688 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
689 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
690 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
691 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
692 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
693 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
694 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
695 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
696 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
697 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
698 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
701 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
706 crc = flac_crc8_table[crc ^ *data++];