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 const mtime_t i_end_date = date_Get( &p_sys->end_date );
289 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
290 date_Set( &p_sys->end_date, i_end_date );
292 p_sys->i_state = STATE_NEXT_SYNC;
293 p_sys->i_frame_size = p_sys->b_stream_info && p_sys->stream_info.min_framesize > 0 ?
294 p_sys->stream_info.min_framesize : 1;
296 case STATE_NEXT_SYNC:
297 /* TODO: If pp_block == NULL, flush the buffer without checking the
300 /* Check if next expected frame contains the sync word */
301 while( block_PeekOffsetBytes( &p_sys->bytestream,
302 p_sys->i_frame_size, p_header,
303 MAX_FLAC_HEADER_SIZE )
306 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
308 /* Check if frame is valid and get frame info */
310 SyncInfo( p_dec, p_header,
313 &p_sys->i_bits_per_sample );
317 p_sys->i_state = STATE_SEND_DATA;
321 p_sys->i_frame_size++;
324 if( p_sys->i_state != STATE_SEND_DATA )
326 if( p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
327 p_sys->i_frame_size > p_sys->stream_info.max_framesize )
329 block_SkipByte( &p_sys->bytestream );
330 p_sys->i_state = STATE_NOSYNC;
337 case STATE_SEND_DATA:
338 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
340 /* Copy the whole frame into the buffer. When we reach this point
341 * we already know we have enough data available. */
342 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
343 p_sys->i_frame_size );
345 /* Make sure we don't reuse the same pts twice */
346 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
347 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
349 /* So p_block doesn't get re-added several times */
350 *pp_block = block_BytestreamPop( &p_sys->bytestream );
352 p_sys->i_state = STATE_NOSYNC;
354 /* Date management */
355 p_sout_block->i_pts =
356 p_sout_block->i_dts = date_Get( &p_sys->end_date );
357 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
358 p_sout_block->i_length =
359 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
368 /*****************************************************************************
369 * SyncInfo: parse FLAC sync info
370 *****************************************************************************/
371 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
372 unsigned int * pi_channels,
373 unsigned int * pi_sample_rate,
374 int * pi_bits_per_sample )
376 decoder_sys_t *p_sys = p_dec->p_sys;
377 int i_header, i_temp, i_read;
378 unsigned i_blocksize = 0;
379 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
380 uint64_t i_sample_number = 0;
382 bool b_variable_blocksize = ( p_sys->b_stream_info &&
383 p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
384 bool b_fixed_blocksize = ( p_sys->b_stream_info &&
385 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
388 if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
390 /* Check there is no emulated sync code in the rest of the header */
391 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
393 /* Find blocksize (framelength) */
394 switch( i_temp = p_buf[2] >> 4 )
397 if( b_fixed_blocksize )
398 i_blocksize = p_sys->stream_info.min_blocksize;
399 else return 0; /* We can't do anything with this */
410 i_blocksize = 576 << (i_temp - 2);
415 i_blocksize_hint = i_temp;
426 i_blocksize = 256 << (i_temp - 8);
430 /* Find samplerate */
431 switch( i_temp = p_buf[2] & 0x0f )
434 if( p_sys->b_stream_info )
435 *pi_sample_rate = p_sys->stream_info.sample_rate;
436 else return 0; /* We can't do anything with this */
440 *pi_sample_rate = 88200;
444 *pi_sample_rate = 176400;
448 *pi_sample_rate = 192000;
452 *pi_sample_rate = 8000;
456 *pi_sample_rate = 16000;
460 *pi_sample_rate = 22050;
464 *pi_sample_rate = 24000;
468 *pi_sample_rate = 32000;
472 *pi_sample_rate = 44100;
476 *pi_sample_rate = 48000;
480 *pi_sample_rate = 96000;
486 i_sample_rate_hint = i_temp;
494 i_temp = (unsigned)(p_buf[3] >> 4);
497 if( ( i_temp & 7 ) >= 3 )
503 *pi_channels = i_temp + 1;
506 /* Find bits per sample */
507 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
510 if( p_sys->b_stream_info )
511 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
517 *pi_bits_per_sample = 8;
521 *pi_bits_per_sample = 12;
525 *pi_bits_per_sample = 16;
529 *pi_bits_per_sample = 20;
533 *pi_bits_per_sample = 24;
542 /* Zero padding bit */
543 if( p_buf[3] & 0x01 ) return 0;
545 /* End of fixed size header */
548 /* Find Sample/Frame number */
549 if( i_blocksize_hint && b_variable_blocksize )
551 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
552 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
556 i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
557 if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
559 if( p_sys->b_stream_info )
560 i_sample_number *= p_sys->stream_info.min_blocksize;
566 if( i_blocksize_hint )
568 int i_val1 = p_buf[i_header++];
569 if( i_blocksize_hint == 7 )
571 int i_val2 = p_buf[i_header++];
572 i_val1 = (i_val1 << 8) | i_val2;
574 i_blocksize = i_val1 + 1;
577 /* Read sample rate */
578 if( i_sample_rate_hint )
580 int i_val1 = p_buf[i_header++];
581 if( i_sample_rate_hint != 12 )
583 int i_val2 = p_buf[i_header++];
584 i_val1 = (i_val1 << 8) | i_val2;
586 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
587 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
588 else *pi_sample_rate = i_val1 * 10;
591 /* Check the CRC-8 byte */
592 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
597 /* Sanity check using stream info header when possible */
598 if( p_sys->b_stream_info )
600 if( i_blocksize < p_sys->stream_info.min_blocksize ||
601 i_blocksize > p_sys->stream_info.max_blocksize )
603 if( *pi_bits_per_sample != p_sys->stream_info.bits_per_sample )
605 if( *pi_sample_rate != p_sys->stream_info.sample_rate )
611 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
612 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
614 uint64_t i_result = 0;
617 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
622 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
624 i_result = p_buf[0] & 0x1F;
627 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
629 i_result = p_buf[0] & 0x0F;
632 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
634 i_result = p_buf[0] & 0x07;
637 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
639 i_result = p_buf[0] & 0x03;
642 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
644 i_result = p_buf[0] & 0x01;
647 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
653 return INT64_C(0xffffffffffffffff);
656 for( j = 1; j <= i; j++ )
658 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
660 return INT64_C(0xffffffffffffffff);
663 i_result |= (p_buf[j] & 0x3F);
670 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
671 static const uint8_t flac_crc8_table[256] = {
672 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
673 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
674 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
675 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
676 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
677 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
678 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
679 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
680 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
681 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
682 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
683 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
684 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
685 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
686 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
687 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
688 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
689 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
690 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
691 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
692 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
693 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
694 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
695 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
696 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
697 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
698 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
699 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
700 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
701 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
702 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
703 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
706 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
711 crc = flac_crc8_table[crc ^ *data++];