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 static const int pi_channels_maps[9] =
97 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
98 AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
99 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
100 | AOUT_CHAN_REARRIGHT,
101 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
102 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
103 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
104 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE,
105 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
106 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT
107 | AOUT_CHAN_MIDDLERIGHT,
108 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT
109 | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
114 /*****************************************************************************
116 *****************************************************************************/
117 static block_t *Packetize( decoder_t *, block_t ** );
119 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *,
120 unsigned int *, unsigned int * );
122 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
123 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
125 static int Open( vlc_object_t *p_this )
127 decoder_t *p_dec = (decoder_t*)p_this;
128 decoder_sys_t *p_sys;
130 if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
134 p_dec->p_sys = p_sys = malloc(sizeof(*p_sys));
138 date_Set( &p_sys->end_date, 0 );
139 p_sys->i_state = STATE_NOSYNC;
140 p_sys->b_stream_info = false;
141 p_sys->i_pts = VLC_TS_INVALID;
142 block_BytestreamInit( &p_sys->bytestream );
145 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
146 p_dec->fmt_out.i_cat = AUDIO_ES;
147 p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
150 p_dec->pf_decode_audio = NULL;
151 p_dec->pf_packetize = Packetize;
156 static void Close( vlc_object_t *p_this )
158 decoder_t *p_dec = (decoder_t *)p_this;
159 decoder_sys_t *p_sys = p_dec->p_sys;
161 block_BytestreamRelease( &p_sys->bytestream );
165 /*****************************************************************************
166 * ProcessHeader: process Flac header.
167 *****************************************************************************/
168 static void ProcessHeader( decoder_t *p_dec )
170 decoder_sys_t *p_sys = p_dec->p_sys;
174 if( p_dec->fmt_in.i_extra < 8 + 14 )
177 bs_init( &bs, (uint8_t*)p_dec->fmt_in.p_extra + 8, p_dec->fmt_in.i_extra - 8 );
179 p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
180 p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
182 p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
183 p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
185 p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
186 p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
187 p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
189 p_sys->b_stream_info = true;
191 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
192 p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
193 p_dec->fmt_out.i_extra );
194 memcpy( p_dec->fmt_out.p_extra,
195 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
199 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
201 decoder_sys_t *p_sys = p_dec->p_sys;
202 uint8_t p_header[MAX_FLAC_HEADER_SIZE];
203 block_t *p_sout_block;
205 if( !pp_block || !*pp_block ) return NULL;
207 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
209 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
211 p_sys->i_state = STATE_NOSYNC;
212 block_BytestreamEmpty( &p_sys->bytestream );
214 date_Set( &p_sys->end_date, 0 );
215 block_Release( *pp_block );
219 if( !p_sys->b_stream_info )
220 ProcessHeader( p_dec );
222 if( p_sys->stream_info.channels > 8 )
224 msg_Err( p_dec, "This stream uses too many audio channels" );
228 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
230 /* We've just started the stream, wait for the first PTS. */
231 block_Release( *pp_block );
234 else if( !date_Get( &p_sys->end_date ) )
236 /* The first PTS is as good as anything else. */
237 p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
238 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
239 date_Set( &p_sys->end_date, (*pp_block)->i_pts );
242 block_BytestreamPush( &p_sys->bytestream, *pp_block );
246 switch( p_sys->i_state )
249 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
252 if( p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8 )
254 p_sys->i_state = STATE_SYNC;
257 block_SkipByte( &p_sys->bytestream );
259 if( p_sys->i_state != STATE_SYNC )
261 block_BytestreamFlush( &p_sys->bytestream );
268 /* New frame, set the Presentation Time Stamp */
269 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
270 if( p_sys->i_pts > VLC_TS_INVALID &&
271 p_sys->i_pts != date_Get( &p_sys->end_date ) )
273 date_Set( &p_sys->end_date, p_sys->i_pts );
275 p_sys->i_state = STATE_HEADER;
278 /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
279 if( block_PeekBytes( &p_sys->bytestream, p_header,
280 MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
286 /* Check if frame is valid and get frame info */
287 p_sys->i_frame_length = SyncInfo( p_dec, p_header,
290 &p_sys->i_bits_per_sample );
291 if( !p_sys->i_frame_length )
293 msg_Dbg( p_dec, "emulated sync word" );
294 block_SkipByte( &p_sys->bytestream );
295 p_sys->i_state = STATE_NOSYNC;
298 if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
300 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
301 const mtime_t i_end_date = date_Get( &p_sys->end_date );
302 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
303 date_Set( &p_sys->end_date, i_end_date );
305 p_sys->i_state = STATE_NEXT_SYNC;
306 p_sys->i_frame_size = p_sys->b_stream_info && p_sys->stream_info.min_framesize > 0 ?
307 p_sys->stream_info.min_framesize : 1;
309 case STATE_NEXT_SYNC:
310 /* TODO: If pp_block == NULL, flush the buffer without checking the
313 /* Check if next expected frame contains the sync word */
314 while( block_PeekOffsetBytes( &p_sys->bytestream,
315 p_sys->i_frame_size, p_header,
316 MAX_FLAC_HEADER_SIZE )
319 if( p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8 )
321 /* Check if frame is valid and get frame info */
323 SyncInfo( p_dec, p_header,
326 &p_sys->i_bits_per_sample );
330 p_sys->i_state = STATE_SEND_DATA;
334 p_sys->i_frame_size++;
337 if( p_sys->i_state != STATE_SEND_DATA )
339 if( p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
340 p_sys->i_frame_size > p_sys->stream_info.max_framesize )
342 block_SkipByte( &p_sys->bytestream );
343 p_sys->i_state = STATE_NOSYNC;
350 case STATE_SEND_DATA:
351 p_sout_block = block_New( p_dec, p_sys->i_frame_size );
353 /* Copy the whole frame into the buffer. When we reach this point
354 * we already know we have enough data available. */
355 block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
356 p_sys->i_frame_size );
358 /* Make sure we don't reuse the same pts twice */
359 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
360 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
362 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
363 p_dec->fmt_out.audio.i_physical_channels =
364 p_dec->fmt_out.audio.i_original_channels =
365 pi_channels_maps[p_sys->stream_info.channels];
367 /* So p_block doesn't get re-added several times */
368 *pp_block = block_BytestreamPop( &p_sys->bytestream );
370 p_sys->i_state = STATE_NOSYNC;
372 /* Date management */
373 p_sout_block->i_pts =
374 p_sout_block->i_dts = date_Get( &p_sys->end_date );
375 date_Increment( &p_sys->end_date, p_sys->i_frame_length );
376 p_sout_block->i_length =
377 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
386 /*****************************************************************************
387 * SyncInfo: parse FLAC sync info
388 *****************************************************************************/
389 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
390 unsigned int * pi_channels,
391 unsigned int * pi_sample_rate,
392 unsigned int * pi_bits_per_sample )
394 decoder_sys_t *p_sys = p_dec->p_sys;
395 int i_header, i_temp, i_read;
396 unsigned i_blocksize = 0;
397 int i_blocksize_hint = 0, i_sample_rate_hint = 0;
400 if( p_buf[0] != 0xFF || (p_buf[1] & 0xFE) != 0xF8 ) return 0;
402 /* Check there is no emulated sync code in the rest of the header */
403 if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
405 /* Find blocksize (framelength) */
406 switch( i_temp = p_buf[2] >> 4 )
409 if( p_sys->b_stream_info &&
410 p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize )
411 i_blocksize = p_sys->stream_info.min_blocksize;
412 else return 0; /* We can't do anything with this */
423 i_blocksize = 576 << (i_temp - 2);
428 i_blocksize_hint = i_temp;
439 i_blocksize = 256 << (i_temp - 8);
442 if( p_sys->b_stream_info &&
443 ( i_blocksize < p_sys->stream_info.min_blocksize ||
444 i_blocksize > p_sys->stream_info.max_blocksize ) )
447 /* Find samplerate */
448 switch( i_temp = p_buf[2] & 0x0f )
451 if( p_sys->b_stream_info )
452 *pi_sample_rate = p_sys->stream_info.sample_rate;
453 else return 0; /* We can't do anything with this */
457 *pi_sample_rate = 88200;
461 *pi_sample_rate = 176400;
465 *pi_sample_rate = 192000;
469 *pi_sample_rate = 8000;
473 *pi_sample_rate = 16000;
477 *pi_sample_rate = 22050;
481 *pi_sample_rate = 24000;
485 *pi_sample_rate = 32000;
489 *pi_sample_rate = 44100;
493 *pi_sample_rate = 48000;
497 *pi_sample_rate = 96000;
503 i_sample_rate_hint = i_temp;
511 i_temp = (unsigned)(p_buf[3] >> 4);
514 if( ( i_temp & 7 ) >= 3 )
520 *pi_channels = i_temp + 1;
523 /* Find bits per sample */
524 switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
527 if( p_sys->b_stream_info )
528 *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
534 *pi_bits_per_sample = 8;
538 *pi_bits_per_sample = 12;
542 *pi_bits_per_sample = 16;
546 *pi_bits_per_sample = 20;
550 *pi_bits_per_sample = 24;
559 /* Zero padding bit */
560 if( p_buf[3] & 0x01 ) return 0;
562 /* End of fixed size header */
565 /* Check Sample/Frame number */
566 if( read_utf8( &p_buf[i_header++], &i_read ) == INT64_C(0xffffffffffffffff) )
572 if( i_blocksize_hint )
574 int i_val1 = p_buf[i_header++];
575 if( i_blocksize_hint == 7 )
577 int i_val2 = p_buf[i_header++];
578 i_val1 = (i_val1 << 8) | i_val2;
580 i_blocksize = i_val1 + 1;
583 /* Read sample rate */
584 if( i_sample_rate_hint )
586 int i_val1 = p_buf[i_header++];
587 if( i_sample_rate_hint != 12 )
589 int i_val2 = p_buf[i_header++];
590 i_val1 = (i_val1 << 8) | i_val2;
592 if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
593 else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
594 else *pi_sample_rate = i_val1 * 10;
597 /* Check the CRC-8 byte */
598 if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
603 /* Sanity check using stream info header when possible */
604 if( p_sys->b_stream_info )
606 if( i_blocksize < p_sys->stream_info.min_blocksize ||
607 i_blocksize > p_sys->stream_info.max_blocksize )
609 if( *pi_bits_per_sample != p_sys->stream_info.bits_per_sample )
611 if( *pi_sample_rate != p_sys->stream_info.sample_rate )
617 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
618 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
620 uint64_t i_result = 0;
623 if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
628 else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
630 i_result = p_buf[0] & 0x1F;
633 else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
635 i_result = p_buf[0] & 0x0F;
638 else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
640 i_result = p_buf[0] & 0x07;
643 else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
645 i_result = p_buf[0] & 0x03;
648 else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
650 i_result = p_buf[0] & 0x01;
653 else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
659 return INT64_C(0xffffffffffffffff);
662 for( j = 1; j <= i; j++ )
664 if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
666 return INT64_C(0xffffffffffffffff);
669 i_result |= (p_buf[j] & 0x3F);
676 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
677 static const uint8_t flac_crc8_table[256] = {
678 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
679 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
680 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
681 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
682 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
683 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
684 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
685 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
686 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
687 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
688 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
689 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
690 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
691 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
692 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
693 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
694 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
695 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
696 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
697 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
698 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
699 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
700 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
701 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
702 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
703 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
704 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
705 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
706 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
707 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
708 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
709 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
712 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
717 crc = flac_crc8_table[crc ^ *data++];