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
2016-04-27 17:45:23 +00:00
* burst - preamble - IEC61937 frame header , contains 16 - bit 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 )
*/
2014-03-10 14:35:59 +00:00
# include <inttypes.h>
2009-08-21 08:34:19 +00:00
# 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"
2015-02-25 12:50:15 +00:00
# include "libavcodec/dca_syncwords.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 [ ] = {
2012-08-31 09:52:18 +00:00
{ " spdif_flags " , " IEC 61937 encapsulation flags " , offsetof ( IEC61937Context , spdif_flags ) , AV_OPT_TYPE_FLAGS , { . i64 = 0 } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " spdif_flags " } ,
2012-08-31 09:45:52 +00:00
{ " be " , " output in big-endian format (for use as s16be) " , 0 , AV_OPT_TYPE_CONST , { . i64 = SPDIF_FLAG_BIGENDIAN } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " spdif_flags " } ,
2012-08-31 10:22:31 +00:00
{ " 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 , { . i64 = 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 , { . i64 = 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
2016-04-27 17:45:23 +00:00
* the output IEC 61937 stream is higher .
2011-01-29 01:36:30 +00:00
* 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 ) {
2015-02-25 12:50:15 +00:00
case DCA_SYNCWORD_CORE_BE :
2009-08-21 08:34:19 +00:00
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 ;
2012-08-01 09:12:08 +00:00
sample_rate = avpriv_dca_sample_rates [ ( pkt - > data [ 8 ] > > 2 ) & 0x0f ] ;
2009-08-21 08:34:19 +00:00
break ;
2015-02-25 12:50:15 +00:00
case DCA_SYNCWORD_CORE_LE :
2009-08-21 08:34:19 +00:00
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 ;
2015-02-25 12:50:15 +00:00
case DCA_SYNCWORD_CORE_14B_BE :
2009-08-21 08:34:19 +00:00
blocks =
( ( ( pkt - > data [ 5 ] & 0x07 ) < < 4 ) | ( ( pkt - > data [ 6 ] & 0x3f ) > > 2 ) ) ;
break ;
2015-02-25 12:50:15 +00:00
case DCA_SYNCWORD_CORE_14B_LE :
2009-08-21 08:34:19 +00:00
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 ;
2015-02-25 12:50:15 +00:00
case DCA_SYNCWORD_SUBSTREAM :
2011-01-29 01:36:30 +00:00
/* 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 :
2014-03-10 14:35:59 +00:00
av_log ( s , AV_LOG_ERROR , " bad DTS syncword 0x% " PRIx32 " \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 ) {
2013-02-25 22:54:28 +00:00
avpriv_request_sample ( s , " Unrecognized large DTS frame " ) ;
2011-01-29 01:36:30 +00:00
/* 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
2016-04-27 17:45:23 +00:00
{ IEC61937_MPEG2_LAYER1_LSF , IEC61937_MPEG2_LAYER2_LSF , IEC61937_MPEG2_LAYER3_LSF } , // MPEG-2 LSF
{ IEC61937_MPEG1_LAYER1 , IEC61937_MPEG1_LAYER23 , IEC61937_MPEG1_LAYER23 } , // MPEG-1
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
}
2012-12-19 17:48:21 +00:00
// TODO Data type dependent info (normal/karaoke, dynamic range control)
2009-08-21 08:34:19 +00:00
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 :
2014-03-10 14:35:59 +00:00
av_log ( s , AV_LOG_ERROR ,
" % " PRIu32 " 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 ;
2015-11-11 16:38:43 +00:00
static const char mat_end_code [ 16 ] = { 0xC3 , 0xC2 , 0xC0 , 0xC4 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x97 , 0x11 } ;
2010-11-27 18:08:01 +00:00
if ( ! ctx - > hd_buf_count ) {
2015-11-11 16:38:43 +00:00
static 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 } ;
2010-11-27 18:08:01 +00:00
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 ) {
2015-11-11 16:38:43 +00:00
static const char mat_middle_code [ 12 ] = { 0xC3 , 0xC1 , 0x42 , 0x49 , 0x3B , 0xFA , 0x82 , 0x83 , 0x49 , 0x80 , 0x77 , 0xE0 } ;
2010-11-27 18:08:01 +00:00
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 */
2013-02-25 22:54:28 +00:00
avpriv_request_sample ( s , " Too large TrueHD frame of %d bytes " ,
pkt - > size ) ;
2012-12-23 17:10:05 +00:00
return AVERROR_PATCHWELCOME ;
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
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
switch ( s - > streams [ 0 ] - > codecpar - > codec_id ) {
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_AC3 :
2009-08-21 08:34:19 +00:00
ctx - > header_info = spdif_header_ac3 ;
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_EAC3 :
2010-11-17 12:22:59 +00:00
ctx - > header_info = spdif_header_eac3 ;
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_MP1 :
case AV_CODEC_ID_MP2 :
case AV_CODEC_ID_MP3 :
2009-08-21 08:34:19 +00:00
ctx - > header_info = spdif_header_mpeg ;
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_DTS :
2009-08-21 08:34:19 +00:00
ctx - > header_info = spdif_header_dts ;
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_AAC :
2009-08-21 08:34:19 +00:00
ctx - > header_info = spdif_header_aac ;
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_TRUEHD :
2010-11-27 18:08:01 +00:00
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 :
2015-12-16 17:01:34 +00:00
avpriv_report_missing_feature ( s , " Codec %d " ,
s - > streams [ 0 ] - > codecpar - > codec_id ) ;
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 {
2015-06-29 21:48:34 +00:00
av_fast_malloc ( & ctx - > buffer , & ctx - > buffer_size , ctx - > out_bytes + AV_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
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 ) ,
2012-08-05 09:11:04 +00:00
. audio_codec = AV_CODEC_ID_AC3 ,
. video_codec = AV_CODEC_ID_NONE ,
2011-07-16 20:18:12 +00:00
. 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
} ;