1 /*****************************************************************************
2 * dts.c: parse DTS audio sync info and packetize the stream
3 *****************************************************************************
4 * Copyright (C) 2003-2009 the VideoLAN team
7 * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
8 * Gildas Bazin <gbazin@netcourrier.com>
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 *****************************************************************************/
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_codec.h>
38 #include <vlc_block_helper.h>
41 /*****************************************************************************
43 *****************************************************************************/
44 static int OpenDecoder ( vlc_object_t * );
45 static int OpenPacketizer( vlc_object_t * );
46 static void CloseCommon ( vlc_object_t * );
49 set_description( N_("DTS parser") )
50 set_capability( "decoder", 100 )
51 set_callbacks( OpenDecoder, CloseCommon )
54 set_description( N_("DTS audio packetizer") )
55 set_capability( "packetizer", 10 )
56 set_callbacks( OpenPacketizer, CloseCommon )
59 /*****************************************************************************
60 * decoder_sys_t : decoder descriptor
61 *****************************************************************************/
72 block_bytestream_t bytestream;
81 bool b_dts_hd; /* Is the current frame a DTS HD one */
82 unsigned int i_bit_rate;
83 unsigned int i_frame_size;
84 unsigned int i_frame_length;
86 unsigned int i_channels;
87 unsigned int i_channels_conf;
100 #define DTS_HEADER_SIZE 14
102 /****************************************************************************
104 ****************************************************************************/
105 static int OpenCommon( vlc_object_t *, bool b_packetizer );
106 static void *DecodeBlock( decoder_t *, block_t ** );
108 static inline int SyncCode( const uint8_t * );
109 static int SyncInfo( const uint8_t *, bool *, unsigned int *, unsigned int *,
110 unsigned int *, unsigned int *, unsigned int * );
112 static uint8_t *GetOutBuffer ( decoder_t *, block_t ** );
113 static aout_buffer_t *GetAoutBuffer( decoder_t * );
114 static block_t *GetSoutBuffer( decoder_t * );
116 /*****************************************************************************
117 * OpenDecoder: probe the decoder
118 *****************************************************************************/
119 static int OpenDecoder( vlc_object_t *p_this )
121 /* HACK: Don't use this codec if we don't have an dts audio filter */
122 if( !module_exists( "dtstofloat32" ) )
125 return OpenCommon( p_this, false );
128 /*****************************************************************************
129 * OpenPacketizer: probe the packetizer
130 *****************************************************************************/
131 static int OpenPacketizer( vlc_object_t *p_this )
133 return OpenCommon( p_this, true );
136 /*****************************************************************************
138 *****************************************************************************/
139 static int OpenCommon( vlc_object_t *p_this, bool b_packetizer )
141 decoder_t *p_dec = (decoder_t*)p_this;
142 decoder_sys_t *p_sys;
144 if( p_dec->fmt_in.i_codec != VLC_CODEC_DTS )
147 /* Allocate the memory needed to store the decoder's structure */
148 if( ( p_dec->p_sys = p_sys = malloc(sizeof(*p_sys)) ) == NULL )
152 p_sys->b_packetizer = b_packetizer;
153 p_sys->i_state = STATE_NOSYNC;
154 date_Set( &p_sys->end_date, 0 );
155 p_sys->b_dts_hd = false;
156 p_sys->i_pts = VLC_TS_INVALID;
158 p_sys->bytestream = block_BytestreamInit();
160 /* Set output properties */
161 p_dec->fmt_out.i_cat = AUDIO_ES;
162 p_dec->fmt_out.i_codec = VLC_CODEC_DTS;
163 p_dec->fmt_out.audio.i_rate = 0; /* So end_date gets initialized */
166 p_dec->pf_decode_audio = (aout_buffer_t *(*)(decoder_t *, block_t **))
168 p_dec->pf_packetize = (block_t *(*)(decoder_t *, block_t **))
174 /****************************************************************************
175 * DecodeBlock: the whole thing
176 ****************************************************************************/
177 static void *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
179 decoder_sys_t *p_sys = p_dec->p_sys;
180 uint8_t p_header[DTS_HEADER_SIZE];
182 block_t *p_out_buffer;
184 if( !pp_block || !*pp_block )
187 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
189 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
191 p_sys->i_state = STATE_NOSYNC;
192 block_BytestreamEmpty( &p_sys->bytestream );
194 date_Set( &p_sys->end_date, 0 );
195 block_Release( *pp_block );
199 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
201 /* We've just started the stream, wait for the first PTS. */
202 block_Release( *pp_block );
206 block_BytestreamPush( &p_sys->bytestream, *pp_block );
210 switch( p_sys->i_state )
213 /* Look for sync code - should be 0x7ffe8001 */
214 while( block_PeekBytes( &p_sys->bytestream, p_header, 6 )
217 if( SyncCode( p_header ) == VLC_SUCCESS )
219 p_sys->i_state = STATE_SYNC;
222 block_SkipByte( &p_sys->bytestream );
224 if( p_sys->i_state != STATE_SYNC )
226 block_BytestreamFlush( &p_sys->bytestream );
233 /* New frame, set the Presentation Time Stamp */
234 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
235 if( p_sys->i_pts > VLC_TS_INVALID &&
236 p_sys->i_pts != date_Get( &p_sys->end_date ) )
238 date_Set( &p_sys->end_date, p_sys->i_pts );
240 p_sys->i_state = STATE_HEADER;
243 /* Get DTS frame header (DTS_HEADER_SIZE bytes) */
244 if( block_PeekBytes( &p_sys->bytestream, p_header,
245 DTS_HEADER_SIZE ) != VLC_SUCCESS )
251 /* Check if frame is valid and get frame info */
252 p_sys->i_frame_size = SyncInfo( p_header,
255 &p_sys->i_channels_conf,
258 &p_sys->i_frame_length );
259 if( !p_sys->i_frame_size )
261 msg_Dbg( p_dec, "emulated sync word" );
262 block_SkipByte( &p_sys->bytestream );
263 p_sys->i_state = STATE_NOSYNC;
266 p_sys->i_state = STATE_NEXT_SYNC;
268 case STATE_NEXT_SYNC:
269 /* TODO: If pp_block == NULL, flush the buffer without checking the
272 /* Check if next expected frame contains the sync word */
273 if( block_PeekOffsetBytes( &p_sys->bytestream,
274 p_sys->i_frame_size, p_header, 6 )
281 if( p_sys->b_packetizer &&
282 p_header[0] == 0 && p_header[1] == 0 )
284 /* DTS wav files and audio CD's use stuffing */
285 p_sys->i_state = STATE_SEND_DATA;
289 if( SyncCode( p_header ) != VLC_SUCCESS )
291 msg_Dbg( p_dec, "emulated sync word "
292 "(no sync on following frame): %2.2x%2.2x%2.2x%2.2x",
293 (int)p_header[0], (int)p_header[1],
294 (int)p_header[2], (int)p_header[3] );
295 p_sys->i_state = STATE_NOSYNC;
296 block_SkipByte( &p_sys->bytestream );
299 p_sys->i_state = STATE_SEND_DATA;
303 /* Make sure we have enough data.
304 * (Not useful if we went through NEXT_SYNC) */
305 if( block_WaitBytes( &p_sys->bytestream,
306 p_sys->i_frame_size ) != VLC_SUCCESS )
311 p_sys->i_state = STATE_SEND_DATA;
313 case STATE_SEND_DATA:
314 if( p_sys->b_dts_hd )
317 block_SkipBytes( &p_sys->bytestream, p_sys->i_frame_size );
318 p_sys->i_state = STATE_NOSYNC;
322 if( !(p_buf = GetOutBuffer( p_dec, &p_out_buffer )) )
324 //p_dec->b_error = true;
328 /* Copy the whole frame into the buffer. When we reach this point
329 * we already know we have enough data available. */
330 block_GetBytes( &p_sys->bytestream,
331 p_buf, __MIN( p_sys->i_frame_size, p_out_buffer->i_buffer ) );
333 /* Make sure we don't reuse the same pts twice */
334 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
335 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
337 p_sys->i_state = STATE_NOSYNC;
339 /* So p_block doesn't get re-added several times */
340 *pp_block = block_BytestreamPop( &p_sys->bytestream );
349 /*****************************************************************************
350 * CloseCommon: clean up the decoder
351 *****************************************************************************/
352 static void CloseCommon( vlc_object_t *p_this )
354 decoder_t *p_dec = (decoder_t*)p_this;
355 decoder_sys_t *p_sys = p_dec->p_sys;
357 block_BytestreamRelease( &p_sys->bytestream );
362 /*****************************************************************************
364 *****************************************************************************/
365 static uint8_t *GetOutBuffer( decoder_t *p_dec, block_t **pp_out_buffer )
367 decoder_sys_t *p_sys = p_dec->p_sys;
370 if( p_dec->fmt_out.audio.i_rate != p_sys->i_rate )
372 msg_Info( p_dec, "DTS channels:%d samplerate:%d bitrate:%d",
373 p_sys->i_channels, p_sys->i_rate, p_sys->i_bit_rate );
375 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
376 date_Set( &p_sys->end_date, p_sys->i_pts );
379 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
380 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
381 /* Hack for DTS S/PDIF filter which needs to pad the DTS frames */
382 p_dec->fmt_out.audio.i_bytes_per_frame =
383 __MAX( p_sys->i_frame_size, p_sys->i_frame_length * 4 );
384 p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
386 p_dec->fmt_out.audio.i_original_channels = p_sys->i_channels_conf;
387 p_dec->fmt_out.audio.i_physical_channels =
388 p_sys->i_channels_conf & AOUT_CHAN_PHYSMASK;
390 p_dec->fmt_out.i_bitrate = p_sys->i_bit_rate;
392 if( p_sys->b_packetizer )
394 block_t *p_sout_buffer = GetSoutBuffer( p_dec );
395 p_buf = p_sout_buffer ? p_sout_buffer->p_buffer : NULL;
396 *pp_out_buffer = p_sout_buffer;
400 aout_buffer_t *p_aout_buffer = GetAoutBuffer( p_dec );
401 p_buf = p_aout_buffer ? p_aout_buffer->p_buffer : NULL;
402 *pp_out_buffer = p_aout_buffer;
408 /*****************************************************************************
410 *****************************************************************************/
411 static aout_buffer_t *GetAoutBuffer( decoder_t *p_dec )
413 decoder_sys_t *p_sys = p_dec->p_sys;
414 aout_buffer_t *p_buf;
416 /* Hack for DTS S/PDIF filter which needs to send 3 frames at a time
417 * (plus a few header bytes) */
418 p_buf = decoder_NewAudioBuffer( p_dec, p_sys->i_frame_length * 4 );
419 if( p_buf == NULL ) return NULL;
420 p_buf->i_nb_samples = p_sys->i_frame_length;
421 p_buf->i_buffer = p_sys->i_frame_size;
423 p_buf->i_pts = date_Get( &p_sys->end_date );
424 p_buf->i_length = date_Increment( &p_sys->end_date, p_sys->i_frame_length )
430 /*****************************************************************************
432 *****************************************************************************/
433 static block_t *GetSoutBuffer( decoder_t *p_dec )
435 decoder_sys_t *p_sys = p_dec->p_sys;
438 p_block = block_New( p_dec, p_sys->i_frame_size );
439 if( p_block == NULL ) return NULL;
441 p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );
443 p_block->i_length = date_Increment( &p_sys->end_date,
444 p_sys->i_frame_length ) - p_block->i_pts;
449 /*****************************************************************************
450 * SyncInfo: parse DTS sync info
451 *****************************************************************************/
452 static const unsigned int ppi_dts_samplerate[] =
454 0, 8000, 16000, 32000, 0, 0, 11025, 22050, 44100, 0, 0,
455 12000, 24000, 48000, 96000, 192000
458 static const unsigned int ppi_dts_bitrate[] =
460 32000, 56000, 64000, 96000, 112000, 128000,
461 192000, 224000, 256000, 320000, 384000,
462 448000, 512000, 576000, 640000, 768000,
463 896000, 1024000, 1152000, 1280000, 1344000,
464 1408000, 1411200, 1472000, 1536000, 1920000,
465 2048000, 3072000, 3840000, 1/*open*/, 2/*variable*/, 3/*lossless*/
468 static int SyncInfo16be( const uint8_t *p_buf,
469 unsigned int *pi_audio_mode,
470 unsigned int *pi_sample_rate,
471 unsigned int *pi_bit_rate,
472 unsigned int *pi_frame_length )
474 unsigned int i_frame_size;
477 *pi_frame_length = (p_buf[4] & 0x01) << 6 | (p_buf[5] >> 2);
478 i_frame_size = (p_buf[5] & 0x03) << 12 | (p_buf[6] << 4) |
481 *pi_audio_mode = (p_buf[7] & 0x0f) << 2 | (p_buf[8] >> 6);
482 *pi_sample_rate = (p_buf[8] >> 2) & 0x0f;
483 *pi_bit_rate = (p_buf[8] & 0x03) << 3 | ((p_buf[9] >> 5) & 0x07);
485 i_lfe = (p_buf[10] >> 1) & 0x03;
486 if( i_lfe ) *pi_audio_mode |= 0x10000;
488 return i_frame_size + 1;
491 static void BufLeToBe( uint8_t *p_out, const uint8_t *p_in, int i_in )
495 for( i = 0; i < i_in/2; i++ )
497 p_out[i*2] = p_in[i*2+1];
498 p_out[i*2+1] = p_in[i*2];
502 static int Buf14To16( uint8_t *p_out, const uint8_t *p_in, int i_in, int i_le )
504 unsigned char tmp, cur = 0;
505 int bits_in, bits_out = 0;
508 for( i = 0; i < i_in; i++ )
517 tmp = p_in[i+i_le] & 0x3F;
523 int need = __MIN( 8 - bits_out, bits_in );
525 cur |= ( tmp >> (bits_in - need) );
526 tmp <<= (8 - bits_in + need);
527 tmp >>= (8 - bits_in + need);
548 static inline int SyncCode( const uint8_t *p_buf )
550 /* 14 bits, little endian version of the bitstream */
551 if( p_buf[0] == 0xff && p_buf[1] == 0x1f &&
552 p_buf[2] == 0x00 && p_buf[3] == 0xe8 &&
553 (p_buf[4] & 0xf0) == 0xf0 && p_buf[5] == 0x07 )
557 /* 14 bits, big endian version of the bitstream */
558 else if( p_buf[0] == 0x1f && p_buf[1] == 0xff &&
559 p_buf[2] == 0xe8 && p_buf[3] == 0x00 &&
560 p_buf[4] == 0x07 && (p_buf[5] & 0xf0) == 0xf0 )
564 /* 16 bits, big endian version of the bitstream */
565 else if( p_buf[0] == 0x7f && p_buf[1] == 0xfe &&
566 p_buf[2] == 0x80 && p_buf[3] == 0x01 )
570 /* 16 bits, little endian version of the bitstream */
571 else if( p_buf[0] == 0xfe && p_buf[1] == 0x7f &&
572 p_buf[2] == 0x01 && p_buf[3] == 0x80 )
577 else if( p_buf[0] == 0x64 && p_buf[1] == 0x58 &&
578 p_buf[2] == 0x20 && p_buf[3] == 0x25 )
586 static int SyncInfo( const uint8_t *p_buf,
588 unsigned int *pi_channels,
589 unsigned int *pi_channels_conf,
590 unsigned int *pi_sample_rate,
591 unsigned int *pi_bit_rate,
592 unsigned int *pi_frame_length )
594 unsigned int i_audio_mode;
595 unsigned int i_frame_size;
597 /* 14 bits, little endian version of the bitstream */
598 if( p_buf[0] == 0xff && p_buf[1] == 0x1f &&
599 p_buf[2] == 0x00 && p_buf[3] == 0xe8 &&
600 (p_buf[4] & 0xf0) == 0xf0 && p_buf[5] == 0x07 )
602 uint8_t conv_buf[DTS_HEADER_SIZE];
603 Buf14To16( conv_buf, p_buf, DTS_HEADER_SIZE, 1 );
604 i_frame_size = SyncInfo16be( conv_buf, &i_audio_mode, pi_sample_rate,
605 pi_bit_rate, pi_frame_length );
606 i_frame_size = i_frame_size * 8 / 14 * 2;
608 /* 14 bits, big endian version of the bitstream */
609 else if( p_buf[0] == 0x1f && p_buf[1] == 0xff &&
610 p_buf[2] == 0xe8 && p_buf[3] == 0x00 &&
611 p_buf[4] == 0x07 && (p_buf[5] & 0xf0) == 0xf0 )
613 uint8_t conv_buf[DTS_HEADER_SIZE];
614 Buf14To16( conv_buf, p_buf, DTS_HEADER_SIZE, 0 );
615 i_frame_size = SyncInfo16be( conv_buf, &i_audio_mode, pi_sample_rate,
616 pi_bit_rate, pi_frame_length );
617 i_frame_size = i_frame_size * 8 / 14 * 2;
619 /* 16 bits, big endian version of the bitstream */
620 else if( p_buf[0] == 0x7f && p_buf[1] == 0xfe &&
621 p_buf[2] == 0x80 && p_buf[3] == 0x01 )
623 i_frame_size = SyncInfo16be( p_buf, &i_audio_mode, pi_sample_rate,
624 pi_bit_rate, pi_frame_length );
626 /* 16 bits, little endian version of the bitstream */
627 else if( p_buf[0] == 0xfe && p_buf[1] == 0x7f &&
628 p_buf[2] == 0x01 && p_buf[3] == 0x80 )
630 uint8_t conv_buf[DTS_HEADER_SIZE];
631 BufLeToBe( conv_buf, p_buf, DTS_HEADER_SIZE );
632 i_frame_size = SyncInfo16be( p_buf, &i_audio_mode, pi_sample_rate,
633 pi_bit_rate, pi_frame_length );
638 assert( p_buf[0] == 0x64 && p_buf[1] == 0x58 &&
639 p_buf[2] == 0x20 && p_buf[3] == 0x25 );
643 bs_init( &s, &p_buf[4], DTS_HEADER_SIZE - 4 );
645 bs_skip( &s, 8 + 2 );
650 i_dts_hd_size = bs_read( &s, 20 ) + 1;
655 i_dts_hd_size = bs_read( &s, 16 ) + 1;
657 //uint16_t s0 = bs_read( &s, 16 );
658 //uint16_t s1 = bs_read( &s, 16 );
659 //fprintf( stderr, "DTS HD=%d : %x %x\n", i_dts_hd_size, s0, s1 );
662 /* As we ignore the stream, do not modify those variables:
664 *pi_channels_conf = ;
669 return i_dts_hd_size;
674 switch( i_audio_mode & 0xFFFF )
679 *pi_channels_conf = AOUT_CHAN_CENTER;
682 /* Dual-mono = stereo + dual-mono */
684 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
692 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
697 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
703 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
704 AOUT_CHAN_REARCENTER;
709 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
710 AOUT_CHAN_CENTER | AOUT_CHAN_REARCENTER;
715 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
716 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
721 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
722 AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT |
729 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
730 AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT |
731 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
736 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
737 AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT |
738 AOUT_CHAN_MIDDLERIGHT | AOUT_CHAN_REARLEFT |
745 *pi_channels_conf = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
746 AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT |
747 AOUT_CHAN_MIDDLERIGHT | AOUT_CHAN_REARLEFT |
748 AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE;
752 if( i_audio_mode <= 63 )
756 *pi_channels_conf = 0;
762 if( i_audio_mode & 0x10000 )
765 *pi_channels_conf |= AOUT_CHAN_LFE;
768 if( *pi_sample_rate >= sizeof( ppi_dts_samplerate ) /
769 sizeof( ppi_dts_samplerate[0] ) )
773 *pi_sample_rate = ppi_dts_samplerate[ *pi_sample_rate ];
774 if( !*pi_sample_rate ) return 0;
776 if( *pi_bit_rate >= sizeof( ppi_dts_bitrate ) /
777 sizeof( ppi_dts_bitrate[0] ) )
781 *pi_bit_rate = ppi_dts_bitrate[ *pi_bit_rate ];
782 if( !*pi_bit_rate ) return 0;
784 *pi_frame_length = (*pi_frame_length + 1) * 32;