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>
39 #include "packetizer_helper.h"
41 /*****************************************************************************
43 *****************************************************************************/
44 static int Open ( vlc_object_t * );
45 static void Close( vlc_object_t * );
48 set_category( CAT_SOUT )
49 set_subcategory( SUBCAT_SOUT_PACKETIZER )
50 set_description( N_("Flac audio packetizer") )
51 set_capability( "packetizer", 50 )
52 set_callbacks( Open, Close )
55 /*****************************************************************************
56 * decoder_sys_t : FLAC decoder descriptor
57 *****************************************************************************/
58 #define MAX_FLAC_HEADER_SIZE 16
66 block_bytestream_t bytestream;
73 unsigned min_blocksize, max_blocksize;
74 unsigned min_framesize, max_framesize;
77 unsigned bits_per_sample;
90 unsigned int i_rate, i_channels, i_bits_per_sample;
93 /*****************************************************************************
95 *****************************************************************************/
96 static block_t *Packetize( decoder_t *, block_t ** );
98 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *,
99 unsigned int *, unsigned int * );
101 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
102 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
104 static int Open( vlc_object_t *p_this )
106 decoder_t *p_dec = (decoder_t*)p_this;
107 decoder_sys_t *p_sys;
109 if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
113 p_dec->p_sys = p_sys = malloc(sizeof(*p_sys));
117 date_Set( &p_sys->end_date, 0 );
118 p_sys->i_state = STATE_NOSYNC;
119 p_sys->b_stream_info = false;
120 p_sys->i_pts = VLC_TS_INVALID;
121 block_BytestreamInit( &p_sys->bytestream );
124 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
125 p_dec->fmt_out.i_cat = AUDIO_ES;
126 p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
129 p_dec->pf_decode_audio = NULL;
130 p_dec->pf_packetize = Packetize;
135 static void Close( vlc_object_t *p_this )
137 decoder_t *p_dec = (decoder_t *)p_this;
138 decoder_sys_t *p_sys = p_dec->p_sys;
140 block_BytestreamRelease( &p_sys->bytestream );
144 /*****************************************************************************
145 * ProcessHeader: process Flac header.
146 *****************************************************************************/
147 static void ProcessHeader( decoder_t *p_dec )
149 decoder_sys_t *p_sys = p_dec->p_sys;
153 if( p_dec->fmt_in.i_extra < 8 + 14 )
156 bs_init( &bs, (uint8_t*)p_dec->fmt_in.p_extra + 8, p_dec->fmt_in.i_extra - 8 );
158 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
159 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
161 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
162 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
164 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
165 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
166 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
168 p_sys->b_stream_info = true;
170 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
171 p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
172 p_dec->fmt_out.i_extra );
173 memcpy( p_dec->fmt_out.p_extra,
174 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
178 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
180 decoder_sys_t *p_sys = p_dec->p_sys;
181 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
182 block_t *p_sout_block;
184 if( !pp_block || !*pp_block ) return NULL;
186 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
188 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
190 p_sys->i_state = STATE_NOSYNC;
191 block_BytestreamEmpty( &p_sys->bytestream );
193 date_Set( &p_sys->end_date, 0 );
194 block_Release( *pp_block );
198 if( !p_sys->b_stream_info )
199 ProcessHeader( p_dec );
201 if( p_sys->stream_info.channels > 8 )
203 msg_Err( p_dec, "This stream uses too many audio channels" );
207 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
209 /* We've just started the stream, wait for the first PTS. */
210 block_Release( *pp_block );
213 else if( !date_Get( &p_sys->end_date ) )
215 /* The first PTS is as good as anything else. */
216 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
217 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
218 date_Set( &p_sys->end_date, (*pp_block)->i_pts );
221 block_BytestreamPush( &p_sys->bytestream, *pp_block );
225 switch( p_sys->i_state )
228 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
231 if( p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8 )
233 p_sys->i_state = STATE_SYNC;
236 block_SkipByte( &p_sys->bytestream );
238 if( p_sys->i_state != STATE_SYNC )
240 block_BytestreamFlush( &p_sys->bytestream );
247 /* New frame, set the Presentation Time Stamp */
248 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
249 if( p_sys->i_pts > VLC_TS_INVALID &&
250 p_sys->i_pts != date_Get( &p_sys->end_date ) )
252 date_Set( &p_sys->end_date, p_sys->i_pts );
254 p_sys->i_state = STATE_HEADER;
257 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
258 if( block_PeekBytes( &p_sys->bytestream, p_header,
259 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
265 /* Check if frame is valid and get frame info */
266 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
269 &p_sys->i_bits_per_sample );
270 if( !p_sys->i_frame_length )
272 msg_Dbg( p_dec, "emulated sync word" );
273 block_SkipByte( &p_sys->bytestream );
274 p_sys->i_state = STATE_NOSYNC;
277 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
279 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
280 const mtime_t i_end_date = date_Get( &p_sys->end_date );
281 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
282 date_Set( &p_sys->end_date, i_end_date );
284 p_sys->i_state = STATE_NEXT_SYNC;
285 p_sys->i_frame_size = p_sys->b_stream_info && p_sys->stream_info.min_framesize > 0 ?
286 p_sys->stream_info.min_framesize : 1;
288 case STATE_NEXT_SYNC:
289 /* TODO: If pp_block == NULL, flush the buffer without checking the
292 /* Check if next expected frame contains the sync word */
293 while( block_PeekOffsetBytes( &p_sys->bytestream,
294 p_sys->i_frame_size, p_header,
295 MAX_FLAC_HEADER_SIZE )
298 if( p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8 )
300 /* Check if frame is valid and get frame info */
302 SyncInfo( p_dec, p_header,
305 &p_sys->i_bits_per_sample );
309 p_sys->i_state = STATE_SEND_DATA;
313 p_sys->i_frame_size++;
316 if( p_sys->i_state != STATE_SEND_DATA )
318 if( p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
319 p_sys->i_frame_size > p_sys->stream_info.max_framesize )
321 block_SkipByte( &p_sys->bytestream );
322 p_sys->i_state = STATE_NOSYNC;
329 case STATE_SEND_DATA:
330 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
332 /* Copy the whole frame into the buffer. When we reach this point
333 * we already know we have enough data available. */
334 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
335 p_sys->i_frame_size );
337 /* Make sure we don't reuse the same pts twice */
338 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
339 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
341 /* So p_block doesn't get re-added several times */
342 *pp_block = block_BytestreamPop( &p_sys->bytestream );
344 p_sys->i_state = STATE_NOSYNC;
346 /* Date management */
347 p_sout_block->i_pts =
348 p_sout_block->i_dts = date_Get( &p_sys->end_date );
349 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
350 p_sout_block->i_length =
351 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
360 /*****************************************************************************
361 * SyncInfo: parse FLAC sync info
362 *****************************************************************************/
363 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
364 unsigned int * pi_channels,
365 unsigned int * pi_sample_rate,
366 unsigned int * pi_bits_per_sample )
368 decoder_sys_t *p_sys = p_dec->p_sys;
369 int i_header, i_temp, i_read;
370 unsigned i_blocksize = 0;
371 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
374 if( p_buf[0] != 0xFF || (p_buf[1] & 0xFE) != 0xF8 ) return 0;
376 /* Check there is no emulated sync code in the rest of the header */
377 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
379 /* Find blocksize (framelength) */
380 switch( i_temp = p_buf[2] >> 4 )
383 if( p_sys->b_stream_info &&
384 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize )
385 i_blocksize = p_sys->stream_info.min_blocksize;
386 else return 0; /* We can't do anything with this */
397 i_blocksize = 576 << (i_temp - 2);
402 i_blocksize_hint = i_temp;
413 i_blocksize = 256 << (i_temp - 8);
416 if( p_sys->b_stream_info &&
417 ( i_blocksize < p_sys->stream_info.min_blocksize ||
418 i_blocksize > p_sys->stream_info.max_blocksize ) )
421 /* Find samplerate */
422 switch( i_temp = p_buf[2] & 0x0f )
425 if( p_sys->b_stream_info )
426 *pi_sample_rate = p_sys->stream_info.sample_rate;
427 else return 0; /* We can't do anything with this */
431 *pi_sample_rate = 88200;
435 *pi_sample_rate = 176400;
439 *pi_sample_rate = 192000;
443 *pi_sample_rate = 8000;
447 *pi_sample_rate = 16000;
451 *pi_sample_rate = 22050;
455 *pi_sample_rate = 24000;
459 *pi_sample_rate = 32000;
463 *pi_sample_rate = 44100;
467 *pi_sample_rate = 48000;
471 *pi_sample_rate = 96000;
477 i_sample_rate_hint = i_temp;
485 i_temp = (unsigned)(p_buf[3] >> 4);
488 if( ( i_temp & 7 ) >= 3 )
494 *pi_channels = i_temp + 1;
497 /* Find bits per sample */
498 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
501 if( p_sys->b_stream_info )
502 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
508 *pi_bits_per_sample = 8;
512 *pi_bits_per_sample = 12;
516 *pi_bits_per_sample = 16;
520 *pi_bits_per_sample = 20;
524 *pi_bits_per_sample = 24;
533 /* Zero padding bit */
534 if( p_buf[3] & 0x01 ) return 0;
536 /* End of fixed size header */
539 /* Check Sample/Frame number */
540 if( read_utf8( &p_buf[i_header++], &i_read ) == INT64_C(0xffffffffffffffff) )
546 if( i_blocksize_hint )
548 int i_val1 = p_buf[i_header++];
549 if( i_blocksize_hint == 7 )
551 int i_val2 = p_buf[i_header++];
552 i_val1 = (i_val1 << 8) | i_val2;
554 i_blocksize = i_val1 + 1;
557 /* Read sample rate */
558 if( i_sample_rate_hint )
560 int i_val1 = p_buf[i_header++];
561 if( i_sample_rate_hint != 12 )
563 int i_val2 = p_buf[i_header++];
564 i_val1 = (i_val1 << 8) | i_val2;
566 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
567 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
568 else *pi_sample_rate = i_val1 * 10;
571 /* Check the CRC-8 byte */
572 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
577 /* Sanity check using stream info header when possible */
578 if( p_sys->b_stream_info )
580 if( i_blocksize < p_sys->stream_info.min_blocksize ||
581 i_blocksize > p_sys->stream_info.max_blocksize )
583 if( *pi_bits_per_sample != p_sys->stream_info.bits_per_sample )
585 if( *pi_sample_rate != p_sys->stream_info.sample_rate )
591 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
592 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
594 uint64_t i_result = 0;
597 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
602 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
604 i_result = p_buf[0] & 0x1F;
607 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
609 i_result = p_buf[0] & 0x0F;
612 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
614 i_result = p_buf[0] & 0x07;
617 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
619 i_result = p_buf[0] & 0x03;
622 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
624 i_result = p_buf[0] & 0x01;
627 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
633 return INT64_C(0xffffffffffffffff);
636 for( j = 1; j <= i; j++ )
638 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
640 return INT64_C(0xffffffffffffffff);
643 i_result |= (p_buf[j] & 0x3F);
650 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
651 static const uint8_t flac_crc8_table[256] = {
652 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
653 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
654 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
655 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
656 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
657 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
658 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
659 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
660 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
661 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
662 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
663 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
664 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
665 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
666 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
667 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
668 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
669 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
670 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
671 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
672 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
673 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
674 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
675 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
676 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
677 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
678 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
679 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
680 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
681 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
682 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
683 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
686 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
691 crc = flac_crc8_table[crc ^ *data++];