2009-08-21 08:34:19 +00:00
/*
2010-12-29 18:48:32 +00:00
* IEC 61937 muxer
2009-08-21 08:34:19 +00:00
* Copyright ( c ) 2009 Bartlomiej Wolowiec
2010-11-27 18:10:20 +00:00
* Copyright ( c ) 2010 Anssi Hannula
* Copyright ( c ) 2010 Carl Eugen Hoyos
2009-08-21 08:34:19 +00:00
*
2011-03-18 17:35:10 +00:00
* This file is part of Libav .
2009-08-21 08:34:19 +00:00
*
2011-03-18 17:35:10 +00:00
* Libav is free software ; you can redistribute it and / or
2009-08-21 08:34:19 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
2011-03-18 17:35:10 +00:00
* Libav is distributed in the hope that it will be useful ,
2009-08-21 08:34:19 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
2011-03-18 17:35:10 +00:00
* License along with Libav ; if not , write to the Free Software
2009-08-21 08:34:19 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
/**
2010-04-20 14:45:34 +00:00
* @ file
2009-08-21 08:34:19 +00:00
* IEC - 61937 encapsulation of various formats , used by S / PDIF
* @ author Bartlomiej Wolowiec
2010-12-29 16:30:07 +00:00
* @ author Anssi Hannula
* @ author Carl Eugen Hoyos
2009-08-21 08:34:19 +00:00
*/
/*
* Terminology used in specification :
2010-12-29 18:48:32 +00:00
* data - burst - IEC61937 frame , contains header and encapsuled frame
* burst - preambule - IEC61937 frame header , contains 16 - bits words named Pa , Pb , Pc and Pd
2009-08-21 08:34:19 +00:00
* burst - payload - encapsuled frame
* Pa , Pb - syncword - 0xF872 , 0x4E1F
* Pc - burst - info , contains data - type ( bits 0 - 6 ) , error flag ( bit 7 ) , data - type - dependent info ( bits 8 - 12 )
* and bitstream number ( bits 13 - 15 )
* data - type - determines type of encapsuled frames
* Pd - length code ( number of bits or bytes of encapsuled frame - according to data_type )
*
2010-12-29 18:48:32 +00:00
* IEC 61937 frames at normal usage start every specific count of bytes ,
2009-08-21 08:34:19 +00:00
* dependent from data - type ( spaces between packets are filled by zeros )
*/
# include "avformat.h"
2011-02-21 20:46:45 +00:00
# include "avio_internal.h"
2010-11-10 00:04:12 +00:00
# include "spdif.h"
2009-08-21 08:34:19 +00:00
# include "libavcodec/ac3.h"
# include "libavcodec/dca.h"
2011-01-29 01:36:30 +00:00
# include "libavcodec/dcadata.h"
2010-07-12 18:52:03 +00:00
# include "libavcodec/aacadtsdec.h"
2011-01-29 01:36:30 +00:00
# include "libavutil/opt.h"
2009-08-21 08:34:19 +00:00
2010-12-29 18:48:32 +00:00
typedef struct IEC61937Context {
2011-01-29 01:36:30 +00:00
const AVClass * av_class ;
2010-12-29 18:48:32 +00:00
enum IEC61937DataType data_type ; ///< burst info - reference to type of payload of the data-burst
2010-11-17 12:22:59 +00:00
int length_code ; ///< length code in bits or bytes, depending on data type
2009-08-21 08:34:19 +00:00
int pkt_offset ; ///< data burst repetition period in bytes
uint8_t * buffer ; ///< allocated buffer, used for swap bytes
int buffer_size ; ///< size of allocated buffer
2010-11-17 12:22:59 +00:00
uint8_t * out_buf ; ///< pointer to the outgoing data before byte-swapping
int out_bytes ; ///< amount of outgoing bytes
2010-12-29 23:42:27 +00:00
int use_preamble ; ///< preamble enabled (disabled for exactly pre-padded DTS)
2010-12-29 16:34:47 +00:00
int extra_bswap ; ///< extra bswap for payload (for LE DTS => standard BE DTS)
2010-11-17 12:22:59 +00:00
uint8_t * hd_buf ; ///< allocated buffer to concatenate hd audio frames
int hd_buf_size ; ///< size of the hd audio buffer
int hd_buf_count ; ///< number of frames in the hd audio buffer
int hd_buf_filled ; ///< amount of bytes in the hd audio buffer
2011-01-29 01:36:30 +00:00
int dtshd_skip ; ///< counter used for skipping DTS-HD frames
/* AVOptions: */
int dtshd_rate ;
int dtshd_fallback ;
2011-02-12 13:57:01 +00:00
# define SPDIF_FLAG_BIGENDIAN 0x01
int spdif_flags ;
2011-01-29 01:36:30 +00:00
2009-08-21 08:34:19 +00:00
/// function, which generates codec dependent header information.
2010-11-17 12:22:59 +00:00
/// Sets data_type and pkt_offset, and length_code, out_bytes, out_buf if necessary
2009-08-21 08:34:19 +00:00
int ( * header_info ) ( AVFormatContext * s , AVPacket * pkt ) ;
2010-12-29 18:48:32 +00:00
} IEC61937Context ;
2009-08-21 08:34:19 +00:00
2011-01-29 01:36:30 +00:00
static const AVOption options [ ] = {
2011-10-04 05:38:01 +00:00
{ " spdif_flags " , " IEC 61937 encapsulation flags " , offsetof ( IEC61937Context , spdif_flags ) , AV_OPT_TYPE_FLAGS , { . dbl = 0 } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " spdif_flags " } ,
{ " be " , " output in big-endian format (for use as s16be) " , 0 , AV_OPT_TYPE_CONST , { . dbl = SPDIF_FLAG_BIGENDIAN } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " spdif_flags " } ,
{ " dtshd_rate " , " mux complete DTS frames in HD mode at the specified IEC958 rate (in Hz, default 0=disabled) " , offsetof ( IEC61937Context , dtshd_rate ) , AV_OPT_TYPE_INT , { . dbl = 0 } , 0 , 768000 , AV_OPT_FLAG_ENCODING_PARAM } ,
{ " dtshd_fallback_time " , " min secs to strip HD for after an overflow (-1: till the end, default 60) " , offsetof ( IEC61937Context , dtshd_fallback ) , AV_OPT_TYPE_INT , { . dbl = 60 } , - 1 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM } ,
2011-01-29 01:36:30 +00:00
{ NULL } ,
} ;
2011-04-29 09:30:02 +00:00
static const AVClass class = {
. class_name = " spdif " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2009-08-21 08:34:19 +00:00
static int spdif_header_ac3 ( AVFormatContext * s , AVPacket * pkt )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2010-12-29 16:48:40 +00:00
int bitstream_mode = pkt - > data [ 5 ] & 0x7 ;
2009-08-21 08:34:19 +00:00
2010-12-29 18:48:32 +00:00
ctx - > data_type = IEC61937_AC3 | ( bitstream_mode < < 8 ) ;
2009-08-21 08:34:19 +00:00
ctx - > pkt_offset = AC3_FRAME_SIZE < < 2 ;
return 0 ;
}
2010-11-17 12:22:59 +00:00
static int spdif_header_eac3 ( AVFormatContext * s , AVPacket * pkt )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2010-11-17 12:22:59 +00:00
static const uint8_t eac3_repeat [ 4 ] = { 6 , 3 , 2 , 1 } ;
int repeat = 1 ;
if ( ( pkt - > data [ 4 ] & 0xc0 ) ! = 0xc0 ) /* fscod */
repeat = eac3_repeat [ ( pkt - > data [ 4 ] & 0x30 ) > > 4 ] ; /* numblkscod */
ctx - > hd_buf = av_fast_realloc ( ctx - > hd_buf , & ctx - > hd_buf_size , ctx - > hd_buf_filled + pkt - > size ) ;
if ( ! ctx - > hd_buf )
return AVERROR ( ENOMEM ) ;
memcpy ( & ctx - > hd_buf [ ctx - > hd_buf_filled ] , pkt - > data , pkt - > size ) ;
ctx - > hd_buf_filled + = pkt - > size ;
if ( + + ctx - > hd_buf_count < repeat ) {
ctx - > pkt_offset = 0 ;
return 0 ;
}
2010-12-29 18:48:32 +00:00
ctx - > data_type = IEC61937_EAC3 ;
2010-11-17 12:22:59 +00:00
ctx - > pkt_offset = 24576 ;
ctx - > out_buf = ctx - > hd_buf ;
ctx - > out_bytes = ctx - > hd_buf_filled ;
ctx - > length_code = ctx - > hd_buf_filled ;
ctx - > hd_buf_count = 0 ;
ctx - > hd_buf_filled = 0 ;
return 0 ;
}
2011-01-29 01:36:30 +00:00
/*
* DTS type IV ( DTS - HD ) can be transmitted with various frame repetition
* periods ; longer repetition periods allow for longer packets and therefore
* higher bitrate . Longer repetition periods mean that the constant bitrate of
* the outputted IEC 61937 stream is higher .
* The repetition period is measured in IEC 60958 frames ( 4 bytes ) .
*/
static int spdif_dts4_subtype ( int period )
{
switch ( period ) {
2011-02-13 16:18:07 +00:00
case 512 : return 0x0 ;
case 1024 : return 0x1 ;
case 2048 : return 0x2 ;
case 4096 : return 0x3 ;
case 8192 : return 0x4 ;
case 16384 : return 0x5 ;
2011-01-29 01:36:30 +00:00
}
return - 1 ;
}
static int spdif_header_dts4 ( AVFormatContext * s , AVPacket * pkt , int core_size ,
int sample_rate , int blocks )
{
IEC61937Context * ctx = s - > priv_data ;
static const char dtshd_start_code [ 10 ] = { 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0xfe , 0xfe } ;
int pkt_size = pkt - > size ;
int period ;
int subtype ;
if ( ! core_size ) {
av_log ( s , AV_LOG_ERROR , " HD mode not supported for this format \n " ) ;
return AVERROR ( EINVAL ) ;
}
if ( ! sample_rate ) {
av_log ( s , AV_LOG_ERROR , " Unknown DTS sample rate for HD \n " ) ;
return AVERROR_INVALIDDATA ;
}
period = ctx - > dtshd_rate * ( blocks < < 5 ) / sample_rate ;
subtype = spdif_dts4_subtype ( period ) ;
if ( subtype < 0 ) {
av_log ( s , AV_LOG_ERROR , " Specified HD rate of %d Hz would require an "
" impossible repetition period of %d for the current DTS stream "
" (blocks = %d, sample rate = %d) \n " , ctx - > dtshd_rate , period ,
blocks < < 5 , sample_rate ) ;
return AVERROR ( EINVAL ) ;
}
/* set pkt_offset and DTS IV subtype according to the requested output
* rate */
ctx - > pkt_offset = period * 4 ;
ctx - > data_type = IEC61937_DTSHD | subtype < < 8 ;
/* If the bitrate is too high for transmitting at the selected
* repetition period setting , strip DTS - HD until a good amount
* of consecutive non - overflowing HD frames have been observed .
* This generally only happens if the caller is cramming a Master
* Audio stream into 192 kHz IEC 60958 ( which may or may not fit ) . */
if ( sizeof ( dtshd_start_code ) + 2 + pkt_size
> ctx - > pkt_offset - BURST_HEADER_SIZE & & core_size ) {
if ( ! ctx - > dtshd_skip )
av_log ( s , AV_LOG_WARNING , " DTS-HD bitrate too high, "
" temporarily sending core only \n " ) ;
if ( ctx - > dtshd_fallback > 0 )
ctx - > dtshd_skip = sample_rate * ctx - > dtshd_fallback / ( blocks < < 5 ) ;
else
2011-02-13 16:18:07 +00:00
/* skip permanently (dtshd_fallback == -1) or just once
* ( dtshd_fallback = = 0 ) */
2011-01-29 01:36:30 +00:00
ctx - > dtshd_skip = 1 ;
}
if ( ctx - > dtshd_skip & & core_size ) {
pkt_size = core_size ;
if ( ctx - > dtshd_fallback > = 0 )
- - ctx - > dtshd_skip ;
}
ctx - > out_bytes = sizeof ( dtshd_start_code ) + 2 + pkt_size ;
2011-12-30 20:48:18 +00:00
/* Align so that (length_code & 0xf) == 0x8. This is reportedly needed
* with some receivers , but the exact requirement is unconfirmed . */
ctx - > length_code = FFALIGN ( ctx - > out_bytes + 0x8 , 0x10 ) - 0x8 ;
2011-01-29 01:36:30 +00:00
2011-02-13 16:18:07 +00:00
av_fast_malloc ( & ctx - > hd_buf , & ctx - > hd_buf_size , ctx - > out_bytes ) ;
2011-01-29 01:36:30 +00:00
if ( ! ctx - > hd_buf )
return AVERROR ( ENOMEM ) ;
ctx - > out_buf = ctx - > hd_buf ;
memcpy ( ctx - > hd_buf , dtshd_start_code , sizeof ( dtshd_start_code ) ) ;
AV_WB16 ( ctx - > hd_buf + sizeof ( dtshd_start_code ) , pkt_size ) ;
memcpy ( ctx - > hd_buf + sizeof ( dtshd_start_code ) + 2 , pkt - > data , pkt_size ) ;
return 0 ;
}
2009-08-21 08:34:19 +00:00
static int spdif_header_dts ( AVFormatContext * s , AVPacket * pkt )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2009-08-21 08:34:19 +00:00
uint32_t syncword_dts = AV_RB32 ( pkt - > data ) ;
int blocks ;
2011-01-29 01:36:30 +00:00
int sample_rate = 0 ;
int core_size = 0 ;
if ( pkt - > size < 9 )
return AVERROR_INVALIDDATA ;
2009-08-21 08:34:19 +00:00
switch ( syncword_dts ) {
case DCA_MARKER_RAW_BE :
blocks = ( AV_RB16 ( pkt - > data + 4 ) > > 2 ) & 0x7f ;
2011-01-29 01:36:30 +00:00
core_size = ( ( AV_RB24 ( pkt - > data + 5 ) > > 4 ) & 0x3fff ) + 1 ;
sample_rate = dca_sample_rates [ ( pkt - > data [ 8 ] > > 2 ) & 0x0f ] ;
2009-08-21 08:34:19 +00:00
break ;
case DCA_MARKER_RAW_LE :
blocks = ( AV_RL16 ( pkt - > data + 4 ) > > 2 ) & 0x7f ;
2010-12-29 16:34:47 +00:00
ctx - > extra_bswap = 1 ;
2009-08-21 08:34:19 +00:00
break ;
case DCA_MARKER_14B_BE :
blocks =
( ( ( pkt - > data [ 5 ] & 0x07 ) < < 4 ) | ( ( pkt - > data [ 6 ] & 0x3f ) > > 2 ) ) ;
break ;
case DCA_MARKER_14B_LE :
blocks =
( ( ( pkt - > data [ 4 ] & 0x07 ) < < 4 ) | ( ( pkt - > data [ 7 ] & 0x3f ) > > 2 ) ) ;
2010-12-29 16:34:47 +00:00
ctx - > extra_bswap = 1 ;
2009-08-21 08:34:19 +00:00
break ;
2011-01-29 01:36:30 +00:00
case DCA_HD_MARKER :
/* We only handle HD frames that are paired with core. However,
sometimes DTS - HD streams with core have a stray HD frame without
core in the beginning of the stream . */
av_log ( s , AV_LOG_ERROR , " stray DTS-HD frame \n " ) ;
return AVERROR_INVALIDDATA ;
2009-08-21 08:34:19 +00:00
default :
av_log ( s , AV_LOG_ERROR , " bad DTS syncword 0x%x \n " , syncword_dts ) ;
2010-12-29 16:42:14 +00:00
return AVERROR_INVALIDDATA ;
2009-08-21 08:34:19 +00:00
}
blocks + + ;
2011-01-29 01:36:30 +00:00
if ( ctx - > dtshd_rate )
/* DTS type IV output requested */
return spdif_header_dts4 ( s , pkt , core_size , sample_rate , blocks ) ;
2009-08-21 08:34:19 +00:00
switch ( blocks ) {
2010-12-29 18:48:32 +00:00
case 512 > > 5 : ctx - > data_type = IEC61937_DTS1 ; break ;
case 1024 > > 5 : ctx - > data_type = IEC61937_DTS2 ; break ;
case 2048 > > 5 : ctx - > data_type = IEC61937_DTS3 ; break ;
2009-08-21 08:34:19 +00:00
default :
av_log ( s , AV_LOG_ERROR , " %i samples in DTS frame not supported \n " ,
blocks < < 5 ) ;
2010-12-29 16:42:14 +00:00
return AVERROR ( ENOSYS ) ;
2009-08-21 08:34:19 +00:00
}
2011-01-29 01:36:30 +00:00
/* discard extraneous data by default */
if ( core_size & & core_size < pkt - > size ) {
ctx - > out_bytes = core_size ;
ctx - > length_code = core_size < < 3 ;
}
2009-08-21 08:34:19 +00:00
ctx - > pkt_offset = blocks < < 7 ;
2010-12-29 23:42:27 +00:00
if ( ctx - > out_bytes = = ctx - > pkt_offset ) {
/* The DTS stream fits exactly into the output stream, so skip the
* preamble as it would not fit in there . This is the case for dts
* discs and dts - in - wav . */
ctx - > use_preamble = 0 ;
2011-01-29 01:36:30 +00:00
} else if ( ctx - > out_bytes > ctx - > pkt_offset - BURST_HEADER_SIZE ) {
av_log_ask_for_sample ( s , " Unrecognized large DTS frame. " ) ;
/* This will fail with a "bitrate too high" in the caller */
2010-12-29 23:42:27 +00:00
}
2009-08-21 08:34:19 +00:00
return 0 ;
}
2010-12-29 18:48:32 +00:00
static const enum IEC61937DataType mpeg_data_type [ 2 ] [ 3 ] = {
2009-08-21 08:34:19 +00:00
// LAYER1 LAYER2 LAYER3
2010-12-29 18:48:32 +00:00
{ IEC61937_MPEG2_LAYER1_LSF , IEC61937_MPEG2_LAYER2_LSF , IEC61937_MPEG2_LAYER3_LSF } , //MPEG2 LSF
{ IEC61937_MPEG1_LAYER1 , IEC61937_MPEG1_LAYER23 , IEC61937_MPEG1_LAYER23 } , //MPEG1
2009-08-21 08:34:19 +00:00
} ;
static int spdif_header_mpeg ( AVFormatContext * s , AVPacket * pkt )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2009-08-21 08:34:19 +00:00
int version = ( pkt - > data [ 1 ] > > 3 ) & 3 ;
int layer = 3 - ( ( pkt - > data [ 1 ] > > 1 ) & 3 ) ;
int extension = pkt - > data [ 2 ] & 1 ;
if ( layer = = 3 | | version = = 1 ) {
av_log ( s , AV_LOG_ERROR , " Wrong MPEG file format \n " ) ;
2010-12-29 16:42:14 +00:00
return AVERROR_INVALIDDATA ;
2009-08-21 08:34:19 +00:00
}
av_log ( s , AV_LOG_DEBUG , " version: %i layer: %i extension: %i \n " , version , layer , extension ) ;
if ( version = = 2 & & extension ) {
2010-12-29 18:48:32 +00:00
ctx - > data_type = IEC61937_MPEG2_EXT ;
2009-08-21 08:34:19 +00:00
ctx - > pkt_offset = 4608 ;
} else {
ctx - > data_type = mpeg_data_type [ version & 1 ] [ layer ] ;
2010-11-10 00:04:12 +00:00
ctx - > pkt_offset = spdif_mpeg_pkt_offset [ version & 1 ] [ layer ] ;
2009-08-21 08:34:19 +00:00
}
// TODO Data type dependant info (normal/karaoke, dynamic range control)
return 0 ;
}
static int spdif_header_aac ( AVFormatContext * s , AVPacket * pkt )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2009-08-21 08:34:19 +00:00
AACADTSHeaderInfo hdr ;
GetBitContext gbc ;
int ret ;
init_get_bits ( & gbc , pkt - > data , AAC_ADTS_HEADER_SIZE * 8 ) ;
2011-10-17 07:22:04 +00:00
ret = avpriv_aac_parse_header ( & gbc , & hdr ) ;
2009-08-21 08:34:19 +00:00
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Wrong AAC file format \n " ) ;
2010-12-29 16:42:14 +00:00
return AVERROR_INVALIDDATA ;
2009-08-21 08:34:19 +00:00
}
ctx - > pkt_offset = hdr . samples < < 2 ;
switch ( hdr . num_aac_frames ) {
case 1 :
2010-12-29 18:48:32 +00:00
ctx - > data_type = IEC61937_MPEG2_AAC ;
2009-08-21 08:34:19 +00:00
break ;
case 2 :
2010-12-29 18:48:32 +00:00
ctx - > data_type = IEC61937_MPEG2_AAC_LSF_2048 ;
2009-08-21 08:34:19 +00:00
break ;
case 4 :
2010-12-29 18:48:32 +00:00
ctx - > data_type = IEC61937_MPEG2_AAC_LSF_4096 ;
2009-08-21 08:34:19 +00:00
break ;
default :
av_log ( s , AV_LOG_ERROR , " %i samples in AAC frame not supported \n " ,
hdr . samples ) ;
2010-12-29 16:42:14 +00:00
return AVERROR ( EINVAL ) ;
2009-08-21 08:34:19 +00:00
}
//TODO Data type dependent info (LC profile/SBR)
return 0 ;
}
2010-11-27 18:08:01 +00:00
/*
* It seems Dolby TrueHD frames have to be encapsulated in MAT frames before
* they can be encapsulated in IEC 61937.
* Here we encapsulate 24 TrueHD frames in a single MAT frame , padding them
* to achieve constant rate .
* The actual format of a MAT frame is unknown , but the below seems to work .
* However , it seems it is not actually necessary for the 24 TrueHD frames to
* be in an exact alignment with the MAT frame .
*/
# define MAT_FRAME_SIZE 61424
# define TRUEHD_FRAME_OFFSET 2560
# define MAT_MIDDLE_CODE_OFFSET -4
static int spdif_header_truehd ( AVFormatContext * s , AVPacket * pkt )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2010-11-27 18:08:01 +00:00
int mat_code_length = 0 ;
const char mat_end_code [ 16 ] = { 0xC3 , 0xC2 , 0xC0 , 0xC4 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x97 , 0x11 } ;
if ( ! ctx - > hd_buf_count ) {
const char mat_start_code [ 20 ] = { 0x07 , 0x9E , 0x00 , 0x03 , 0x84 , 0x01 , 0x01 , 0x01 , 0x80 , 0x00 , 0x56 , 0xA5 , 0x3B , 0xF4 , 0x81 , 0x83 , 0x49 , 0x80 , 0x77 , 0xE0 } ;
mat_code_length = sizeof ( mat_start_code ) + BURST_HEADER_SIZE ;
memcpy ( ctx - > hd_buf , mat_start_code , sizeof ( mat_start_code ) ) ;
} else if ( ctx - > hd_buf_count = = 12 ) {
const char mat_middle_code [ 12 ] = { 0xC3 , 0xC1 , 0x42 , 0x49 , 0x3B , 0xFA , 0x82 , 0x83 , 0x49 , 0x80 , 0x77 , 0xE0 } ;
mat_code_length = sizeof ( mat_middle_code ) + MAT_MIDDLE_CODE_OFFSET ;
memcpy ( & ctx - > hd_buf [ 12 * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + MAT_MIDDLE_CODE_OFFSET ] ,
mat_middle_code , sizeof ( mat_middle_code ) ) ;
}
if ( pkt - > size > TRUEHD_FRAME_OFFSET - mat_code_length ) {
/* if such frames exist, we'd need some more complex logic to
* distribute the TrueHD frames in the MAT frame */
av_log ( s , AV_LOG_ERROR , " TrueHD frame too big, %d bytes \n " , pkt - > size ) ;
av_log_ask_for_sample ( s , NULL ) ;
2010-12-29 16:42:14 +00:00
return AVERROR_INVALIDDATA ;
2010-11-27 18:08:01 +00:00
}
memcpy ( & ctx - > hd_buf [ ctx - > hd_buf_count * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + mat_code_length ] ,
pkt - > data , pkt - > size ) ;
memset ( & ctx - > hd_buf [ ctx - > hd_buf_count * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + mat_code_length + pkt - > size ] ,
0 , TRUEHD_FRAME_OFFSET - pkt - > size - mat_code_length ) ;
if ( + + ctx - > hd_buf_count < 24 ) {
ctx - > pkt_offset = 0 ;
return 0 ;
}
memcpy ( & ctx - > hd_buf [ MAT_FRAME_SIZE - sizeof ( mat_end_code ) ] , mat_end_code , sizeof ( mat_end_code ) ) ;
ctx - > hd_buf_count = 0 ;
2010-12-29 18:48:32 +00:00
ctx - > data_type = IEC61937_TRUEHD ;
2010-11-27 18:08:01 +00:00
ctx - > pkt_offset = 61440 ;
ctx - > out_buf = ctx - > hd_buf ;
ctx - > out_bytes = MAT_FRAME_SIZE ;
ctx - > length_code = MAT_FRAME_SIZE ;
return 0 ;
}
2009-08-21 08:34:19 +00:00
static int spdif_write_header ( AVFormatContext * s )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2009-08-21 08:34:19 +00:00
switch ( s - > streams [ 0 ] - > codec - > codec_id ) {
case CODEC_ID_AC3 :
ctx - > header_info = spdif_header_ac3 ;
break ;
2010-11-17 12:22:59 +00:00
case CODEC_ID_EAC3 :
ctx - > header_info = spdif_header_eac3 ;
break ;
2009-08-21 08:34:19 +00:00
case CODEC_ID_MP1 :
case CODEC_ID_MP2 :
case CODEC_ID_MP3 :
ctx - > header_info = spdif_header_mpeg ;
break ;
case CODEC_ID_DTS :
ctx - > header_info = spdif_header_dts ;
break ;
case CODEC_ID_AAC :
ctx - > header_info = spdif_header_aac ;
break ;
2010-11-27 18:08:01 +00:00
case CODEC_ID_TRUEHD :
ctx - > header_info = spdif_header_truehd ;
ctx - > hd_buf = av_malloc ( MAT_FRAME_SIZE ) ;
if ( ! ctx - > hd_buf )
return AVERROR ( ENOMEM ) ;
break ;
2009-08-21 08:34:19 +00:00
default :
av_log ( s , AV_LOG_ERROR , " codec not supported \n " ) ;
2010-12-29 16:42:14 +00:00
return AVERROR_PATCHWELCOME ;
2009-08-21 08:34:19 +00:00
}
return 0 ;
}
static int spdif_write_trailer ( AVFormatContext * s )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2009-08-21 08:34:19 +00:00
av_freep ( & ctx - > buffer ) ;
2010-11-17 12:22:59 +00:00
av_freep ( & ctx - > hd_buf ) ;
2009-08-21 08:34:19 +00:00
return 0 ;
}
2011-02-12 13:57:01 +00:00
static av_always_inline void spdif_put_16 ( IEC61937Context * ctx ,
2011-02-20 10:04:12 +00:00
AVIOContext * pb , unsigned int val )
2011-02-12 13:57:01 +00:00
{
if ( ctx - > spdif_flags & SPDIF_FLAG_BIGENDIAN )
2011-02-21 18:28:17 +00:00
avio_wb16 ( pb , val ) ;
2011-02-12 13:57:01 +00:00
else
2011-02-21 18:28:17 +00:00
avio_wl16 ( pb , val ) ;
2011-02-12 13:57:01 +00:00
}
2009-08-21 08:34:19 +00:00
static int spdif_write_packet ( struct AVFormatContext * s , AVPacket * pkt )
{
2010-12-29 18:48:32 +00:00
IEC61937Context * ctx = s - > priv_data ;
2009-08-21 08:34:19 +00:00
int ret , padding ;
2010-11-17 23:23:25 +00:00
ctx - > out_buf = pkt - > data ;
2010-11-17 12:22:59 +00:00
ctx - > out_bytes = pkt - > size ;
ctx - > length_code = FFALIGN ( pkt - > size , 2 ) < < 3 ;
2010-12-29 23:42:27 +00:00
ctx - > use_preamble = 1 ;
2010-12-29 16:34:47 +00:00
ctx - > extra_bswap = 0 ;
2010-11-17 12:22:59 +00:00
2009-08-21 08:34:19 +00:00
ret = ctx - > header_info ( s , pkt ) ;
if ( ret < 0 )
2010-12-29 16:42:14 +00:00
return ret ;
2010-11-17 12:22:59 +00:00
if ( ! ctx - > pkt_offset )
return 0 ;
2009-08-21 08:34:19 +00:00
2011-01-02 10:46:50 +00:00
padding = ( ctx - > pkt_offset - ctx - > use_preamble * BURST_HEADER_SIZE - ctx - > out_bytes ) & ~ 1 ;
2009-08-21 08:34:19 +00:00
if ( padding < 0 ) {
av_log ( s , AV_LOG_ERROR , " bitrate is too high \n " ) ;
2010-12-29 16:42:14 +00:00
return AVERROR ( EINVAL ) ;
2009-08-21 08:34:19 +00:00
}
2010-12-29 23:42:27 +00:00
if ( ctx - > use_preamble ) {
2011-02-12 13:57:01 +00:00
spdif_put_16 ( ctx , s - > pb , SYNCWORD1 ) ; //Pa
spdif_put_16 ( ctx , s - > pb , SYNCWORD2 ) ; //Pb
spdif_put_16 ( ctx , s - > pb , ctx - > data_type ) ; //Pc
spdif_put_16 ( ctx , s - > pb , ctx - > length_code ) ; //Pd
2010-12-29 23:42:27 +00:00
}
2009-08-21 08:34:19 +00:00
2011-02-12 13:57:01 +00:00
if ( ctx - > extra_bswap ^ ( ctx - > spdif_flags & SPDIF_FLAG_BIGENDIAN ) ) {
2011-02-21 18:28:17 +00:00
avio_write ( s - > pb , ctx - > out_buf , ctx - > out_bytes & ~ 1 ) ;
2010-12-29 16:34:47 +00:00
} else {
2010-11-17 12:22:59 +00:00
av_fast_malloc ( & ctx - > buffer , & ctx - > buffer_size , ctx - > out_bytes + FF_INPUT_BUFFER_PADDING_SIZE ) ;
2009-08-21 08:34:19 +00:00
if ( ! ctx - > buffer )
return AVERROR ( ENOMEM ) ;
2010-11-17 12:22:59 +00:00
ff_spdif_bswap_buf16 ( ( uint16_t * ) ctx - > buffer , ( uint16_t * ) ctx - > out_buf , ctx - > out_bytes > > 1 ) ;
2011-02-21 18:28:17 +00:00
avio_write ( s - > pb , ctx - > buffer , ctx - > out_bytes & ~ 1 ) ;
2010-12-29 16:34:47 +00:00
}
2009-08-21 08:34:19 +00:00
2011-02-12 13:57:01 +00:00
/* a final lone byte has to be MSB aligned */
2010-11-17 12:22:59 +00:00
if ( ctx - > out_bytes & 1 )
2011-02-12 13:57:01 +00:00
spdif_put_16 ( ctx , s - > pb , ctx - > out_buf [ ctx - > out_bytes - 1 ] < < 8 ) ;
2009-08-21 08:34:19 +00:00
2011-02-21 19:02:20 +00:00
ffio_fill ( s - > pb , 0 , padding ) ;
2009-08-21 08:34:19 +00:00
av_log ( s , AV_LOG_DEBUG , " type=%x len=%i pkt_offset=%i \n " ,
2010-11-17 12:22:59 +00:00
ctx - > data_type , ctx - > out_bytes , ctx - > pkt_offset ) ;
2009-08-21 08:34:19 +00:00
2011-03-14 19:39:06 +00:00
avio_flush ( s - > pb ) ;
2009-08-21 08:34:19 +00:00
return 0 ;
}
2011-01-25 22:03:28 +00:00
AVOutputFormat ff_spdif_muxer = {
2011-07-16 20:18:12 +00:00
. name = " spdif " ,
. long_name = NULL_IF_CONFIG_SMALL ( " IEC 61937 (used on S/PDIF - IEC958) " ) ,
. extensions = " spdif " ,
. priv_data_size = sizeof ( IEC61937Context ) ,
. audio_codec = CODEC_ID_AC3 ,
. video_codec = CODEC_ID_NONE ,
. write_header = spdif_write_header ,
. write_packet = spdif_write_packet ,
. write_trailer = spdif_write_trailer ,
2012-04-06 14:50:48 +00:00
. flags = AVFMT_NOTIMESTAMPS ,
. priv_class = & class ,
2009-08-21 08:34:19 +00:00
} ;