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;
89 unsigned int i_rate, i_channels, i_bits_per_sample;
102 /*****************************************************************************
104 *****************************************************************************/
105 static block_t *Packetize( decoder_t *, block_t ** );
107 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *,
108 unsigned int *, unsigned int * );
110 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
111 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
113 static int Open( vlc_object_t *p_this )
115 decoder_t *p_dec = (decoder_t*)p_this;
116 decoder_sys_t *p_sys;
118 if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
122 p_dec->p_sys = p_sys = malloc(sizeof(*p_sys));
126 date_Set( &p_sys->end_date, 0 );
127 p_sys->i_state = STATE_NOSYNC;
128 p_sys->b_stream_info = false;
129 p_sys->i_pts = VLC_TS_INVALID;
130 p_sys->bytestream = block_BytestreamInit();
133 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
134 p_dec->fmt_out.i_cat = AUDIO_ES;
135 p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
138 p_dec->pf_decode_audio = NULL;
139 p_dec->pf_packetize = Packetize;
144 static void Close( vlc_object_t *p_this )
146 decoder_t *p_dec = (decoder_t *)p_this;
147 decoder_sys_t *p_sys = p_dec->p_sys;
149 block_BytestreamRelease( &p_sys->bytestream );
153 /*****************************************************************************
154 * ProcessHeader: process Flac header.
155 *****************************************************************************/
156 static void ProcessHeader( decoder_t *p_dec )
158 decoder_sys_t *p_sys = p_dec->p_sys;
162 if( p_dec->fmt_in.i_extra < 8 + 14 )
165 bs_init( &bs, (uint8_t*)p_dec->fmt_in.p_extra + 8, p_dec->fmt_in.i_extra - 8 );
167 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
168 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
170 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
171 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
173 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
174 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
175 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
177 p_sys->b_stream_info = true;
179 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
180 p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
181 p_dec->fmt_out.i_extra );
182 memcpy( p_dec->fmt_out.p_extra,
183 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
187 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
189 decoder_sys_t *p_sys = p_dec->p_sys;
190 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
191 block_t *p_sout_block;
193 if( !pp_block || !*pp_block ) return NULL;
195 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
197 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
199 p_sys->i_state = STATE_NOSYNC;
200 block_BytestreamEmpty( &p_sys->bytestream );
202 date_Set( &p_sys->end_date, 0 );
203 block_Release( *pp_block );
207 if( !p_sys->b_stream_info )
208 ProcessHeader( p_dec );
210 if( p_sys->stream_info.channels > 8 )
212 msg_Err( p_dec, "This stream uses too many audio channels" );
216 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
218 /* We've just started the stream, wait for the first PTS. */
219 block_Release( *pp_block );
222 else if( !date_Get( &p_sys->end_date ) )
224 /* The first PTS is as good as anything else. */
225 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
226 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
227 date_Set( &p_sys->end_date, (*pp_block)->i_pts );
230 block_BytestreamPush( &p_sys->bytestream, *pp_block );
234 switch( p_sys->i_state )
237 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
240 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
242 p_sys->i_state = STATE_SYNC;
245 block_SkipByte( &p_sys->bytestream );
247 if( p_sys->i_state != STATE_SYNC )
249 block_BytestreamFlush( &p_sys->bytestream );
256 /* New frame, set the Presentation Time Stamp */
257 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
258 if( p_sys->i_pts > VLC_TS_INVALID &&
259 p_sys->i_pts != date_Get( &p_sys->end_date ) )
261 date_Set( &p_sys->end_date, p_sys->i_pts );
263 p_sys->i_state = STATE_HEADER;
266 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
267 if( block_PeekBytes( &p_sys->bytestream, p_header,
268 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
274 /* Check if frame is valid and get frame info */
275 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
278 &p_sys->i_bits_per_sample );
279 if( !p_sys->i_frame_length )
281 msg_Dbg( p_dec, "emulated sync word" );
282 block_SkipByte( &p_sys->bytestream );
283 p_sys->i_state = STATE_NOSYNC;
286 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
288 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
289 const mtime_t i_end_date = date_Get( &p_sys->end_date );
290 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
291 date_Set( &p_sys->end_date, i_end_date );
293 p_sys->i_state = STATE_NEXT_SYNC;
294 p_sys->i_frame_size = p_sys->b_stream_info && p_sys->stream_info.min_framesize > 0 ?
295 p_sys->stream_info.min_framesize : 1;
297 case STATE_NEXT_SYNC:
298 /* TODO: If pp_block == NULL, flush the buffer without checking the
301 /* Check if next expected frame contains the sync word */
302 while( block_PeekOffsetBytes( &p_sys->bytestream,
303 p_sys->i_frame_size, p_header,
304 MAX_FLAC_HEADER_SIZE )
307 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
309 /* Check if frame is valid and get frame info */
311 SyncInfo( p_dec, p_header,
314 &p_sys->i_bits_per_sample );
318 p_sys->i_state = STATE_SEND_DATA;
322 p_sys->i_frame_size++;
325 if( p_sys->i_state != STATE_SEND_DATA )
327 if( p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
328 p_sys->i_frame_size > p_sys->stream_info.max_framesize )
330 block_SkipByte( &p_sys->bytestream );
331 p_sys->i_state = STATE_NOSYNC;
338 case STATE_SEND_DATA:
339 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
341 /* Copy the whole frame into the buffer. When we reach this point
342 * we already know we have enough data available. */
343 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
344 p_sys->i_frame_size );
346 /* Make sure we don't reuse the same pts twice */
347 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
348 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
350 /* So p_block doesn't get re-added several times */
351 *pp_block = block_BytestreamPop( &p_sys->bytestream );
353 p_sys->i_state = STATE_NOSYNC;
355 /* Date management */
356 p_sout_block->i_pts =
357 p_sout_block->i_dts = date_Get( &p_sys->end_date );
358 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
359 p_sout_block->i_length =
360 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
369 /*****************************************************************************
370 * SyncInfo: parse FLAC sync info
371 *****************************************************************************/
372 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
373 unsigned int * pi_channels,
374 unsigned int * pi_sample_rate,
375 unsigned int * pi_bits_per_sample )
377 decoder_sys_t *p_sys = p_dec->p_sys;
378 int i_header, i_temp, i_read;
379 unsigned i_blocksize = 0;
380 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
381 uint64_t i_sample_number = 0;
383 bool b_variable_blocksize = ( p_sys->b_stream_info &&
384 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
385 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
386 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
389 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
391 /* Check there is no emulated sync code in the rest of the header */
392 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
394 /* Find blocksize (framelength) */
395 switch( i_temp = p_buf[2] >> 4 )
398 if( b_fixed_blocksize )
399 i_blocksize = p_sys->stream_info.min_blocksize;
400 else return 0; /* We can't do anything with this */
411 i_blocksize = 576 << (i_temp - 2);
416 i_blocksize_hint = i_temp;
427 i_blocksize = 256 << (i_temp - 8);
431 /* Find samplerate */
432 switch( i_temp = p_buf[2] & 0x0f )
435 if( p_sys->b_stream_info )
436 *pi_sample_rate = p_sys->stream_info.sample_rate;
437 else return 0; /* We can't do anything with this */
441 *pi_sample_rate = 88200;
445 *pi_sample_rate = 176400;
449 *pi_sample_rate = 192000;
453 *pi_sample_rate = 8000;
457 *pi_sample_rate = 16000;
461 *pi_sample_rate = 22050;
465 *pi_sample_rate = 24000;
469 *pi_sample_rate = 32000;
473 *pi_sample_rate = 44100;
477 *pi_sample_rate = 48000;
481 *pi_sample_rate = 96000;
487 i_sample_rate_hint = i_temp;
495 i_temp = (unsigned)(p_buf[3] >> 4);
498 if( ( i_temp & 7 ) >= 3 )
504 *pi_channels = i_temp + 1;
507 /* Find bits per sample */
508 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
511 if( p_sys->b_stream_info )
512 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
518 *pi_bits_per_sample = 8;
522 *pi_bits_per_sample = 12;
526 *pi_bits_per_sample = 16;
530 *pi_bits_per_sample = 20;
534 *pi_bits_per_sample = 24;
543 /* Zero padding bit */
544 if( p_buf[3] & 0x01 ) return 0;
546 /* End of fixed size header */
549 /* Find Sample/Frame number */
550 if( i_blocksize_hint && b_variable_blocksize )
552 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
553 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
557 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
558 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
560 if( p_sys->b_stream_info )
561 i_sample_number *= p_sys->stream_info.min_blocksize;
567 if( i_blocksize_hint )
569 int i_val1 = p_buf[i_header++];
570 if( i_blocksize_hint == 7 )
572 int i_val2 = p_buf[i_header++];
573 i_val1 = (i_val1 << 8) | i_val2;
575 i_blocksize = i_val1 + 1;
578 /* Read sample rate */
579 if( i_sample_rate_hint )
581 int i_val1 = p_buf[i_header++];
582 if( i_sample_rate_hint != 12 )
584 int i_val2 = p_buf[i_header++];
585 i_val1 = (i_val1 << 8) | i_val2;
587 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
588 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
589 else *pi_sample_rate = i_val1 * 10;
592 /* Check the CRC-8 byte */
593 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
598 /* Sanity check using stream info header when possible */
599 if( p_sys->b_stream_info )
601 if( i_blocksize < p_sys->stream_info.min_blocksize ||
602 i_blocksize > p_sys->stream_info.max_blocksize )
604 if( *pi_bits_per_sample != p_sys->stream_info.bits_per_sample )
606 if( *pi_sample_rate != p_sys->stream_info.sample_rate )
612 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
613 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
615 uint64_t i_result = 0;
618 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
623 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
625 i_result = p_buf[0] & 0x1F;
628 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
630 i_result = p_buf[0] & 0x0F;
633 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
635 i_result = p_buf[0] & 0x07;
638 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
640 i_result = p_buf[0] & 0x03;
643 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
645 i_result = p_buf[0] & 0x01;
648 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
654 return INT64_C(0xffffffffffffffff);
657 for( j = 1; j <= i; j++ )
659 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
661 return INT64_C(0xffffffffffffffff);
664 i_result |= (p_buf[j] & 0x3F);
671 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
672 static const uint8_t flac_crc8_table[256] = {
673 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
674 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
675 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
676 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
677 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
678 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
679 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
680 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
681 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
682 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
683 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
684 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
685 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
686 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
687 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
688 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
689 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
690 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
691 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
692 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
693 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
694 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
695 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
696 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
697 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
698 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
699 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
700 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
701 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
702 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
703 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
704 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
707 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
712 crc = flac_crc8_table[crc ^ *data++];