2001-07-22 14:18:56 +00:00
/*
2006-10-23 08:57:54 +00:00
* ASF compatible demuxer
2009-01-19 15:46:40 +00:00
* Copyright ( c ) 2000 , 2001 Fabrice Bellard
2001-07-22 14:18:56 +00:00
*
2006-10-07 15:30:46 +00:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-25 22:34:32 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 15:30:46 +00:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 14:18:56 +00:00
*
2006-10-07 15:30:46 +00:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 14:18:56 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-25 22:34:32 +00:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 14:18:56 +00:00
*
2002-05-25 22:34:32 +00:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 15:30:46 +00:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 22:43:26 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 14:18:56 +00:00
*/
2008-05-09 11:56:36 +00:00
2014-03-10 14:35:59 +00:00
# include <inttypes.h>
2012-08-21 10:40:41 +00:00
# include "libavutil/attributes.h"
2013-02-08 12:54:36 +00:00
# include "libavutil/avassert.h"
2013-02-05 23:44:00 +00:00
# include "libavutil/avstring.h"
2011-05-19 11:31:05 +00:00
# include "libavutil/bswap.h"
2008-05-09 11:56:36 +00:00
# include "libavutil/common.h"
2011-05-22 10:46:29 +00:00
# include "libavutil/dict.h"
2013-03-27 17:36:51 +00:00
# include "libavutil/internal.h"
2011-06-04 11:58:23 +00:00
# include "libavutil/mathematics.h"
2012-04-06 13:54:23 +00:00
# include "libavutil/opt.h"
2001-07-22 14:18:56 +00:00
# include "avformat.h"
2011-03-14 19:38:59 +00:00
# include "avio_internal.h"
2013-02-05 23:44:00 +00:00
# include "avlanguage.h"
2012-06-21 20:17:43 +00:00
# include "id3v2.h"
2013-02-05 23:44:00 +00:00
# include "internal.h"
2006-07-12 00:09:34 +00:00
# include "riff.h"
2004-03-05 21:34:30 +00:00
# include "asf.h"
2007-10-20 14:25:02 +00:00
# include "asfcrypt.h"
2001-07-22 14:18:56 +00:00
2015-06-28 11:05:45 +00:00
typedef struct ASFPayload {
uint8_t type ;
uint16_t size ;
} ASFPayload ;
2015-06-15 12:54:45 +00:00
typedef struct ASFStream {
2015-06-28 11:05:45 +00:00
int num ;
unsigned char seq ;
/* use for reading */
AVPacket pkt ;
int frag_offset ;
int packet_obj_size ;
int timestamp ;
int64_t duration ;
int skip_to_key ;
int pkt_clean ;
2015-06-15 12:54:45 +00:00
2015-06-28 11:05:45 +00:00
int ds_span ; /* descrambling */
int ds_packet_size ;
int ds_chunk_size ;
2015-06-15 12:54:45 +00:00
2015-06-28 11:05:45 +00:00
int64_t packet_pos ;
2011-02-08 20:46:47 +00:00
2015-06-28 11:05:45 +00:00
uint16_t stream_language_index ;
2012-04-06 13:54:23 +00:00
2015-06-28 11:05:45 +00:00
int palette_changed ;
uint32_t palette [ 256 ] ;
2012-04-06 13:54:23 +00:00
2015-06-28 11:05:45 +00:00
int payload_ext_ct ;
ASFPayload payload [ 8 ] ;
} ASFStream ;
2004-03-05 22:10:50 +00:00
2014-09-22 07:19:33 +00:00
typedef struct ASFContext {
2012-04-06 13:54:23 +00:00
const AVClass * class ;
2011-02-08 20:46:47 +00:00
int asfid2avid [ 128 ] ; ///< conversion table from asf ID 2 AVStream ID
ASFStream streams [ 128 ] ; ///< it's max number and it's not that big
uint32_t stream_bitrates [ 128 ] ; ///< max number of streams, bitrate for each (for streaming)
2011-02-09 20:55:53 +00:00
AVRational dar [ 128 ] ;
2011-02-08 20:46:47 +00:00
char stream_languages [ 128 ] [ 6 ] ; ///< max number of streams, language for each (RFC1766, e.g. en-US)
/* non streamed additonnal info */
/* packet filling */
int packet_size_left ;
/* only for reading */
uint64_t data_offset ; ///< beginning of the first data packet
uint64_t data_object_offset ; ///< data object offset (excl. GUID & size)
uint64_t data_object_size ; ///< size of the data object
int index_read ;
ASFMainHeader hdr ;
int packet_flags ;
int packet_property ;
int packet_timestamp ;
int packet_segsizetype ;
int packet_segments ;
int packet_seq ;
int packet_replic_size ;
int packet_key_frame ;
int packet_padsize ;
unsigned int packet_frag_offset ;
unsigned int packet_frag_size ;
int64_t packet_frag_timestamp ;
2014-07-13 01:23:54 +00:00
int ts_is_pts ;
2011-02-08 20:46:47 +00:00
int packet_multi_size ;
int packet_time_delta ;
int packet_time_start ;
int64_t packet_pos ;
int stream_index ;
2013-02-05 23:44:00 +00:00
ASFStream * asf_st ; ///< currently decoded stream
2012-04-06 13:54:23 +00:00
int no_resync_search ;
2015-03-02 18:04:03 +00:00
int export_xmp ;
2011-02-08 20:46:47 +00:00
} ASFContext ;
2012-04-06 13:54:23 +00:00
static const AVOption options [ ] = {
2013-02-05 23:44:00 +00:00
{ " no_resync_search " , " Don't try to resynchronize by looking for a certain optional start code " , offsetof ( ASFContext , no_resync_search ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , 1 , AV_OPT_FLAG_DECODING_PARAM } ,
2015-03-02 18:04:03 +00:00
{ " export_xmp " , " Export full XMP metadata " , offsetof ( ASFContext , export_xmp ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , 1 , AV_OPT_FLAG_DECODING_PARAM } ,
2012-04-06 13:54:23 +00:00
{ NULL } ,
} ;
static const AVClass asf_class = {
. class_name = " asf demuxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2004-01-14 14:45:53 +00:00
# undef NDEBUG
# include <assert.h>
2010-06-24 15:10:06 +00:00
# define ASF_MAX_STREAMS 127
2015-06-29 14:23:15 +00:00
# define FRAME_HEADER_SIZE 6
// Fix Me! FRAME_HEADER_SIZE may be different.
// (7 is known to be too large for GipsyGuitar.wmv)
2004-03-05 22:10:50 +00:00
2011-07-03 14:57:26 +00:00
# ifdef DEBUG
2009-03-18 14:03:40 +00:00
static const ff_asf_guid stream_bitrate_guid = { /* (http://get.to/sdp) */
2007-02-20 23:44:11 +00:00
0xce , 0x75 , 0xf8 , 0x7b , 0x8d , 0x46 , 0xd1 , 0x11 , 0x8d , 0x82 , 0x00 , 0x60 , 0x97 , 0xc9 , 0xa2 , 0xb2
} ;
2001-07-22 14:18:56 +00:00
2013-02-05 23:44:00 +00:00
# define PRINT_IF_GUID(g, cmp) \
if ( ! ff_guidcmp ( g , & cmp ) ) \
2015-03-16 08:57:35 +00:00
av_log ( NULL , AV_LOG_TRACE , " (GUID: %s) " , # cmp )
2003-02-25 13:12:41 +00:00
2013-02-06 13:35:25 +00:00
static void print_guid ( ff_asf_guid * g )
2001-07-22 14:18:56 +00:00
{
int i ;
2009-02-26 16:17:17 +00:00
PRINT_IF_GUID ( g , ff_asf_header ) ;
else PRINT_IF_GUID ( g , ff_asf_file_header ) ;
else PRINT_IF_GUID ( g , ff_asf_stream_header ) ;
else PRINT_IF_GUID ( g , ff_asf_audio_stream ) ;
else PRINT_IF_GUID ( g , ff_asf_audio_conceal_none ) ;
else PRINT_IF_GUID ( g , ff_asf_video_stream ) ;
else PRINT_IF_GUID ( g , ff_asf_video_conceal_none ) ;
else PRINT_IF_GUID ( g , ff_asf_command_stream ) ;
else PRINT_IF_GUID ( g , ff_asf_comment_header ) ;
else PRINT_IF_GUID ( g , ff_asf_codec_comment_header ) ;
else PRINT_IF_GUID ( g , ff_asf_codec_comment1_header ) ;
else PRINT_IF_GUID ( g , ff_asf_data_header ) ;
2012-04-03 07:44:10 +00:00
else PRINT_IF_GUID ( g , ff_asf_simple_index_header ) ;
2009-02-26 16:17:17 +00:00
else PRINT_IF_GUID ( g , ff_asf_head1_guid ) ;
else PRINT_IF_GUID ( g , ff_asf_head2_guid ) ;
else PRINT_IF_GUID ( g , ff_asf_my_guid ) ;
else PRINT_IF_GUID ( g , ff_asf_ext_stream_header ) ;
else PRINT_IF_GUID ( g , ff_asf_extended_content_header ) ;
else PRINT_IF_GUID ( g , ff_asf_ext_stream_embed_stream_header ) ;
else PRINT_IF_GUID ( g , ff_asf_ext_stream_audio_stream ) ;
else PRINT_IF_GUID ( g , ff_asf_metadata_header ) ;
2013-02-06 13:35:27 +00:00
else PRINT_IF_GUID ( g , ff_asf_metadata_library_header ) ;
2010-03-08 13:13:18 +00:00
else PRINT_IF_GUID ( g , ff_asf_marker_header ) ;
2007-02-20 23:44:11 +00:00
else PRINT_IF_GUID ( g , stream_bitrate_guid ) ;
2009-05-12 12:35:46 +00:00
else PRINT_IF_GUID ( g , ff_asf_language_guid ) ;
2003-02-25 13:12:41 +00:00
else
2015-03-16 08:57:35 +00:00
av_log ( NULL , AV_LOG_TRACE , " (GUID: unknown) " ) ;
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < 16 ; i + + )
2015-03-16 08:57:35 +00:00
av_log ( NULL , AV_LOG_TRACE , " 0x%02x, " , ( * g ) [ i ] ) ;
av_log ( NULL , AV_LOG_TRACE , " } \n " ) ;
2001-07-22 14:18:56 +00:00
}
2006-02-12 02:24:37 +00:00
# undef PRINT_IF_GUID
2008-07-13 19:41:07 +00:00
# else
2015-05-06 22:54:06 +00:00
# define print_guid(g) while(0)
2001-07-22 14:18:56 +00:00
# endif
2002-05-20 16:31:13 +00:00
static int asf_probe ( AVProbeData * pd )
{
/* check file header */
2010-12-26 01:26:29 +00:00
if ( ! ff_guidcmp ( pd - > buf , & ff_asf_header ) )
2002-05-20 16:31:13 +00:00
return AVPROBE_SCORE_MAX ;
else
return 0 ;
}
2013-02-06 13:35:26 +00:00
/* size of type 2 (BOOL) is 32bit for "Extended Content Description Object"
* but 16 bit for " Metadata Object " and " Metadata Library Object " */
static int get_value ( AVIOContext * pb , int type , int type2_size )
2013-02-05 23:44:00 +00:00
{
switch ( type ) {
case 2 :
2013-02-06 13:35:26 +00:00
return ( type2_size = = 32 ) ? avio_rl32 ( pb ) : avio_rl16 ( pb ) ;
2013-02-05 23:44:00 +00:00
case 3 :
return avio_rl32 ( pb ) ;
case 4 :
return avio_rl64 ( pb ) ;
case 5 :
return avio_rl16 ( pb ) ;
default :
return INT_MIN ;
2007-01-31 23:32:01 +00:00
}
}
2012-06-21 20:17:43 +00:00
/* MSDN claims that this should be "compatible with the ID3 frame, APIC",
* but in reality this is only loosely similar */
static int asf_read_picture ( AVFormatContext * s , int len )
{
2013-02-05 23:44:00 +00:00
AVPacket pkt = { 0 } ;
2012-06-21 20:17:43 +00:00
const CodecMime * mime = ff_id3v2_mime_tags ;
2013-02-05 23:44:00 +00:00
enum AVCodecID id = AV_CODEC_ID_NONE ;
2012-06-21 20:17:43 +00:00
char mimetype [ 64 ] ;
uint8_t * desc = NULL ;
AVStream * st = NULL ;
int ret , type , picsize , desc_len ;
/* type + picsize + mime + desc */
if ( len < 1 + 4 + 2 + 2 ) {
av_log ( s , AV_LOG_ERROR , " Invalid attached picture size: %d. \n " , len ) ;
return AVERROR_INVALIDDATA ;
}
/* picture type */
type = avio_r8 ( s - > pb ) ;
len - - ;
if ( type > = FF_ARRAY_ELEMS ( ff_id3v2_picture_types ) | | type < 0 ) {
av_log ( s , AV_LOG_WARNING , " Unknown attached picture type: %d. \n " , type ) ;
type = 0 ;
}
/* picture data size */
picsize = avio_rl32 ( s - > pb ) ;
2013-02-05 23:44:00 +00:00
len - = 4 ;
2012-06-21 20:17:43 +00:00
/* picture MIME type */
len - = avio_get_str16le ( s - > pb , len , mimetype , sizeof ( mimetype ) ) ;
2012-08-05 09:11:04 +00:00
while ( mime - > id ! = AV_CODEC_ID_NONE ) {
2012-06-21 20:17:43 +00:00
if ( ! strncmp ( mime - > str , mimetype , sizeof ( mimetype ) ) ) {
id = mime - > id ;
break ;
}
mime + + ;
}
2012-08-05 09:11:04 +00:00
if ( id = = AV_CODEC_ID_NONE ) {
2012-06-21 20:17:43 +00:00
av_log ( s , AV_LOG_ERROR , " Unknown attached picture mimetype: %s. \n " ,
mimetype ) ;
return 0 ;
}
if ( picsize > = len ) {
av_log ( s , AV_LOG_ERROR , " Invalid attached picture data size: %d >= %d. \n " ,
picsize , len ) ;
return AVERROR_INVALIDDATA ;
}
/* picture description */
desc_len = ( len - picsize ) * 2 + 1 ;
desc = av_malloc ( desc_len ) ;
if ( ! desc )
return AVERROR ( ENOMEM ) ;
len - = avio_get_str16le ( s - > pb , len - picsize , desc , desc_len ) ;
ret = av_get_packet ( s - > pb , & pkt , picsize ) ;
if ( ret < 0 )
goto fail ;
2013-02-05 23:44:00 +00:00
st = avformat_new_stream ( s , NULL ) ;
2013-02-08 12:54:36 +00:00
if ( ! st ) {
2012-06-21 20:17:43 +00:00
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2013-02-05 23:44:00 +00:00
st - > disposition | = AV_DISPOSITION_ATTACHED_PIC ;
st - > codec - > codec_type = AVMEDIA_TYPE_VIDEO ;
st - > codec - > codec_id = id ;
st - > attached_pic = pkt ;
2012-06-21 20:17:43 +00:00
st - > attached_pic . stream_index = st - > index ;
2013-02-05 23:44:00 +00:00
st - > attached_pic . flags | = AV_PKT_FLAG_KEY ;
2012-06-21 20:17:43 +00:00
if ( * desc )
av_dict_set ( & st - > metadata , " title " , desc , AV_DICT_DONT_STRDUP_VAL ) ;
else
av_freep ( & desc ) ;
av_dict_set ( & st - > metadata , " comment " , ff_id3v2_picture_types [ type ] , 0 ) ;
return 0 ;
fail :
av_freep ( & desc ) ;
av_free_packet ( & pkt ) ;
return ret ;
}
2013-02-08 10:06:37 +00:00
static void get_id3_tag ( AVFormatContext * s , int len )
{
ID3v2ExtraMeta * id3v2_extra_meta = NULL ;
2014-04-18 04:49:40 +00:00
ff_id3v2_read ( s , ID3v2_DEFAULT_MAGIC , & id3v2_extra_meta , len ) ;
2013-02-08 10:06:37 +00:00
if ( id3v2_extra_meta )
ff_id3v2_parse_apic ( s , & id3v2_extra_meta ) ;
ff_id3v2_free_extra_meta ( & id3v2_extra_meta ) ;
}
2013-02-06 13:35:26 +00:00
static void get_tag ( AVFormatContext * s , const char * key , int type , int len , int type2_size )
2009-02-03 22:12:06 +00:00
{
2015-03-02 18:04:03 +00:00
ASFContext * asf = s - > priv_data ;
char * value = NULL ;
2011-03-03 19:11:45 +00:00
int64_t off = avio_tell ( s - > pb ) ;
2013-03-05 20:56:46 +00:00
# define LEN 22
2009-12-13 20:27:29 +00:00
2013-03-05 20:56:46 +00:00
if ( ( unsigned ) len > = ( UINT_MAX - LEN ) / 2 )
2009-12-13 20:27:29 +00:00
return ;
2015-03-02 18:04:03 +00:00
if ( ! asf - > export_xmp & & ! strncmp ( key , " xmp " , 3 ) )
goto finish ;
2013-03-05 20:56:46 +00:00
value = av_malloc ( 2 * len + LEN ) ;
2009-12-13 20:27:29 +00:00
if ( ! value )
2011-01-27 09:41:49 +00:00
goto finish ;
2009-12-13 20:27:29 +00:00
2015-07-01 22:15:13 +00:00
switch ( type ) {
case ASF_UNICODE :
2013-02-05 23:44:00 +00:00
avio_get_str16le ( s - > pb , len , value , 2 * len + 1 ) ;
2015-07-01 22:15:13 +00:00
break ;
case - 1 : // ASCI
2011-11-13 23:53:50 +00:00
avio_read ( s - > pb , value , len ) ;
2011-10-16 03:04:48 +00:00
value [ len ] = 0 ;
2015-07-01 22:15:13 +00:00
break ;
case ASF_BYTE_ARRAY :
2013-02-08 10:06:37 +00:00
if ( ! strcmp ( key , " WM/Picture " ) ) { // handle cover art
asf_read_picture ( s , len ) ;
} else if ( ! strcmp ( key , " ID3 " ) ) { // handle ID3 tag
get_id3_tag ( s , len ) ;
} else {
av_log ( s , AV_LOG_VERBOSE , " Unsupported byte array in tag %s. \n " , key ) ;
}
goto finish ;
2015-07-01 22:15:13 +00:00
case ASF_BOOL :
case ASF_DWORD :
case ASF_QWORD :
case ASF_WORD : {
2013-02-06 13:35:26 +00:00
uint64_t num = get_value ( s - > pb , type , type2_size ) ;
2013-03-05 20:56:46 +00:00
snprintf ( value , LEN , " % " PRIu64 , num ) ;
2015-07-01 22:15:13 +00:00
break ;
}
case ASF_GUID :
2013-02-06 13:35:27 +00:00
av_log ( s , AV_LOG_DEBUG , " Unsupported GUID value in tag %s. \n " , key ) ;
goto finish ;
2015-07-01 22:15:13 +00:00
default :
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_DEBUG ,
" Unsupported value type %d in tag %s. \n " , type , key ) ;
2011-01-27 09:41:49 +00:00
goto finish ;
2009-02-03 22:12:06 +00:00
}
2011-02-09 20:56:00 +00:00
if ( * value )
2011-05-22 10:46:29 +00:00
av_dict_set ( & s - > metadata , key , value , 0 ) ;
2013-02-05 23:44:00 +00:00
2011-01-27 09:41:49 +00:00
finish :
2010-02-24 18:19:54 +00:00
av_freep ( & value ) ;
2011-02-28 13:57:54 +00:00
avio_seek ( s - > pb , off + len , SEEK_SET ) ;
2009-02-03 22:12:06 +00:00
}
2011-02-09 20:55:55 +00:00
static int asf_read_file_properties ( AVFormatContext * s , int64_t size )
{
ASFContext * asf = s - > priv_data ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:55 +00:00
ff_get_guid ( pb , & asf - > hdr . guid ) ;
2013-02-05 23:44:00 +00:00
asf - > hdr . file_size = avio_rl64 ( pb ) ;
asf - > hdr . create_time = avio_rl64 ( pb ) ;
2011-02-21 15:43:01 +00:00
avio_rl64 ( pb ) ; /* number of packets */
2013-02-05 23:44:00 +00:00
asf - > hdr . play_time = avio_rl64 ( pb ) ;
asf - > hdr . send_time = avio_rl64 ( pb ) ;
asf - > hdr . preroll = avio_rl32 ( pb ) ;
asf - > hdr . ignore = avio_rl32 ( pb ) ;
asf - > hdr . flags = avio_rl32 ( pb ) ;
asf - > hdr . min_pktsize = avio_rl32 ( pb ) ;
asf - > hdr . max_pktsize = avio_rl32 ( pb ) ;
if ( asf - > hdr . min_pktsize > = ( 1U < < 29 ) )
2012-02-17 20:21:22 +00:00
return AVERROR_INVALIDDATA ;
2013-02-05 23:44:00 +00:00
asf - > hdr . max_bitrate = avio_rl32 ( pb ) ;
s - > packet_size = asf - > hdr . max_pktsize ;
2011-02-09 20:55:55 +00:00
return 0 ;
}
2011-02-09 20:55:57 +00:00
static int asf_read_stream_properties ( AVFormatContext * s , int64_t size )
{
ASFContext * asf = s - > priv_data ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:57 +00:00
AVStream * st ;
ASFStream * asf_st ;
ff_asf_guid g ;
enum AVMediaType type ;
int type_specific_size , sizeX ;
unsigned int tag1 ;
int64_t pos1 , pos2 , start_time ;
2013-02-05 23:44:00 +00:00
int test_for_ext_stream_audio , is_dvr_ms_audio = 0 ;
2011-02-09 20:55:57 +00:00
if ( s - > nb_streams = = ASF_MAX_STREAMS ) {
av_log ( s , AV_LOG_ERROR , " too many streams \n " ) ;
return AVERROR ( EINVAL ) ;
}
2011-03-03 19:11:45 +00:00
pos1 = avio_tell ( pb ) ;
2011-02-09 20:55:57 +00:00
2011-06-18 09:43:24 +00:00
st = avformat_new_stream ( s , NULL ) ;
2011-02-09 20:55:57 +00:00
if ( ! st )
return AVERROR ( ENOMEM ) ;
2011-11-29 18:28:15 +00:00
avpriv_set_pts_info ( st , 32 , 1 , 1000 ) ; /* 32 bit pts in ms */
2013-02-05 23:44:00 +00:00
start_time = asf - > hdr . preroll ;
2011-02-09 20:55:57 +00:00
2013-02-05 23:44:00 +00:00
if ( ! ( asf - > hdr . flags & 0x01 ) ) { // if we aren't streaming...
2012-10-23 14:11:38 +00:00
int64_t fsize = avio_size ( pb ) ;
2014-06-21 17:35:06 +00:00
if ( fsize < = 0 | | ( int64_t ) asf - > hdr . file_size < = 0 | |
2015-05-26 11:02:25 +00:00
20 * FFABS ( fsize - ( int64_t ) asf - > hdr . file_size ) < FFMIN ( fsize , asf - > hdr . file_size ) )
2012-10-23 14:11:38 +00:00
st - > duration = asf - > hdr . play_time /
2013-02-05 23:44:00 +00:00
( 10000000 / 1000 ) - start_time ;
2011-02-09 20:55:57 +00:00
}
ff_get_guid ( pb , & g ) ;
test_for_ext_stream_audio = 0 ;
if ( ! ff_guidcmp ( & g , & ff_asf_audio_stream ) ) {
type = AVMEDIA_TYPE_AUDIO ;
} else if ( ! ff_guidcmp ( & g , & ff_asf_video_stream ) ) {
type = AVMEDIA_TYPE_VIDEO ;
} else if ( ! ff_guidcmp ( & g , & ff_asf_jfif_media ) ) {
2013-02-05 23:44:00 +00:00
type = AVMEDIA_TYPE_VIDEO ;
2012-08-05 09:11:04 +00:00
st - > codec - > codec_id = AV_CODEC_ID_MJPEG ;
2011-02-09 20:55:57 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_command_stream ) ) {
type = AVMEDIA_TYPE_DATA ;
} else if ( ! ff_guidcmp ( & g , & ff_asf_ext_stream_embed_stream_header ) ) {
test_for_ext_stream_audio = 1 ;
2013-02-05 23:44:00 +00:00
type = AVMEDIA_TYPE_UNKNOWN ;
2011-02-09 20:55:57 +00:00
} else {
return - 1 ;
}
ff_get_guid ( pb , & g ) ;
2011-06-01 16:26:27 +00:00
avio_skip ( pb , 8 ) ; /* total_size */
2011-02-21 15:43:01 +00:00
type_specific_size = avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
st - > id = avio_rl16 ( pb ) & 0x7f ; /* stream id */
2011-02-09 20:55:57 +00:00
// mapping of asf ID to AV stream ID;
asf - > asfid2avid [ st - > id ] = s - > nb_streams - 1 ;
2013-07-30 00:52:17 +00:00
asf_st = & asf - > streams [ st - > id ] ;
2011-02-09 20:55:57 +00:00
2011-02-21 15:43:01 +00:00
avio_rl32 ( pb ) ;
2011-02-09 20:55:57 +00:00
if ( test_for_ext_stream_audio ) {
ff_get_guid ( pb , & g ) ;
if ( ! ff_guidcmp ( & g , & ff_asf_ext_stream_audio_stream ) ) {
2013-02-05 23:44:00 +00:00
type = AVMEDIA_TYPE_AUDIO ;
is_dvr_ms_audio = 1 ;
2011-02-09 20:55:57 +00:00
ff_get_guid ( pb , & g ) ;
2011-02-21 15:43:01 +00:00
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
2011-02-09 20:55:57 +00:00
ff_get_guid ( pb , & g ) ;
2011-02-21 15:43:01 +00:00
avio_rl32 ( pb ) ;
2011-02-09 20:55:57 +00:00
}
}
st - > codec - > codec_type = type ;
if ( type = = AVMEDIA_TYPE_AUDIO ) {
2014-12-17 11:04:37 +00:00
int ret = ff_get_wav_header ( pb , st - > codec , type_specific_size , 0 ) ;
2011-04-12 15:44:20 +00:00
if ( ret < 0 )
return ret ;
2011-02-09 20:55:57 +00:00
if ( is_dvr_ms_audio ) {
// codec_id and codec_tag are unreliable in dvr_ms
// files. Set them later by probing stream.
2013-02-06 13:10:26 +00:00
st - > request_probe = 1 ;
2011-02-09 20:55:57 +00:00
st - > codec - > codec_tag = 0 ;
}
2013-02-05 23:44:00 +00:00
if ( st - > codec - > codec_id = = AV_CODEC_ID_AAC )
2011-02-09 20:55:57 +00:00
st - > need_parsing = AVSTREAM_PARSE_NONE ;
2013-02-05 23:44:00 +00:00
else
2011-02-09 20:55:57 +00:00
st - > need_parsing = AVSTREAM_PARSE_FULL ;
/* We have to init the frame size at some point .... */
2011-03-03 19:11:45 +00:00
pos2 = avio_tell ( pb ) ;
2011-02-09 20:55:57 +00:00
if ( size > = ( pos2 + 8 - pos1 + 24 ) ) {
2013-02-05 23:44:00 +00:00
asf_st - > ds_span = avio_r8 ( pb ) ;
2011-02-21 15:43:01 +00:00
asf_st - > ds_packet_size = avio_rl16 ( pb ) ;
2013-02-05 23:44:00 +00:00
asf_st - > ds_chunk_size = avio_rl16 ( pb ) ;
avio_rl16 ( pb ) ; // ds_data_size
avio_r8 ( pb ) ; // ds_silence_data
2011-02-09 20:55:57 +00:00
}
if ( asf_st - > ds_span > 1 ) {
2013-02-05 23:44:00 +00:00
if ( ! asf_st - > ds_chunk_size | |
( asf_st - > ds_packet_size / asf_st - > ds_chunk_size < = 1 ) | |
asf_st - > ds_packet_size % asf_st - > ds_chunk_size )
asf_st - > ds_span = 0 ; // disable descrambling
2011-02-09 20:55:57 +00:00
}
} else if ( type = = AVMEDIA_TYPE_VIDEO & &
2013-02-05 23:44:00 +00:00
size - ( avio_tell ( pb ) - pos1 + 24 ) > = 51 ) {
2011-02-21 15:43:01 +00:00
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avio_r8 ( pb ) ;
avio_rl16 ( pb ) ; /* size */
2013-02-05 23:44:00 +00:00
sizeX = avio_rl32 ( pb ) ; /* size */
st - > codec - > width = avio_rl32 ( pb ) ;
2011-02-21 15:43:01 +00:00
st - > codec - > height = avio_rl32 ( pb ) ;
2011-02-09 20:55:57 +00:00
/* not available for asf */
2011-02-21 15:43:01 +00:00
avio_rl16 ( pb ) ; /* panes */
st - > codec - > bits_per_coded_sample = avio_rl16 ( pb ) ; /* depth */
2013-02-05 23:44:00 +00:00
tag1 = avio_rl32 ( pb ) ;
2011-03-15 08:14:38 +00:00
avio_skip ( pb , 20 ) ;
2011-02-09 20:55:57 +00:00
if ( sizeX > 40 ) {
2012-12-02 19:37:09 +00:00
st - > codec - > extradata_size = ffio_limit ( pb , sizeX - 40 ) ;
2013-02-05 23:44:00 +00:00
st - > codec - > extradata = av_mallocz ( st - > codec - > extradata_size +
FF_INPUT_BUFFER_PADDING_SIZE ) ;
2013-09-09 12:09:31 +00:00
if ( ! st - > codec - > extradata )
return AVERROR ( ENOMEM ) ;
2011-02-21 15:43:01 +00:00
avio_read ( pb , st - > codec - > extradata , st - > codec - > extradata_size ) ;
2011-02-09 20:55:57 +00:00
}
/* Extract palette from extradata if bpp <= 8 */
/* This code assumes that extradata contains only palette */
2011-10-30 17:02:42 +00:00
/* This is true for all paletted codecs implemented in libavcodec */
2011-02-09 20:55:57 +00:00
if ( st - > codec - > extradata_size & & ( st - > codec - > bits_per_coded_sample < = 8 ) ) {
# if HAVE_BIGENDIAN
2012-02-10 14:10:42 +00:00
int i ;
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < FFMIN ( st - > codec - > extradata_size , AVPALETTE_SIZE ) / 4 ; i + + )
asf_st - > palette [ i ] = av_bswap32 ( ( ( uint32_t * ) st - > codec - > extradata ) [ i ] ) ;
2011-02-09 20:55:57 +00:00
# else
2011-04-09 13:49:51 +00:00
memcpy ( asf_st - > palette , st - > codec - > extradata ,
FFMIN ( st - > codec - > extradata_size , AVPALETTE_SIZE ) ) ;
2011-02-09 20:55:57 +00:00
# endif
2011-04-09 13:49:51 +00:00
asf_st - > palette_changed = 1 ;
2011-02-09 20:55:57 +00:00
}
st - > codec - > codec_tag = tag1 ;
2013-02-05 23:44:00 +00:00
st - > codec - > codec_id = ff_codec_get_id ( ff_codec_bmp_tags , tag1 ) ;
if ( tag1 = = MKTAG ( ' D ' , ' V ' , ' R ' , ' ' ) ) {
2011-02-09 20:55:57 +00:00
st - > need_parsing = AVSTREAM_PARSE_FULL ;
2013-02-05 23:44:00 +00:00
/* issue658 contains wrong w/h and MS even puts a fake seq header
* with wrong w / h in extradata while a correct one is in the stream .
* maximum lameness */
st - > codec - > width =
2011-02-09 20:55:57 +00:00
st - > codec - > height = 0 ;
av_freep ( & st - > codec - > extradata ) ;
2013-02-05 23:44:00 +00:00
st - > codec - > extradata_size = 0 ;
2011-02-09 20:55:57 +00:00
}
2013-02-05 23:44:00 +00:00
if ( st - > codec - > codec_id = = AV_CODEC_ID_H264 )
2011-02-09 20:55:57 +00:00
st - > need_parsing = AVSTREAM_PARSE_FULL_ONCE ;
2014-06-03 12:44:46 +00:00
if ( st - > codec - > codec_id = = AV_CODEC_ID_MPEG4 )
st - > need_parsing = AVSTREAM_PARSE_FULL_ONCE ;
2011-02-09 20:55:57 +00:00
}
2011-03-03 19:11:45 +00:00
pos2 = avio_tell ( pb ) ;
2011-03-15 08:14:38 +00:00
avio_skip ( pb , size - ( pos2 - pos1 + 24 ) ) ;
2011-02-09 20:55:57 +00:00
return 0 ;
}
2011-02-09 20:55:55 +00:00
static int asf_read_ext_stream_properties ( AVFormatContext * s , int64_t size )
{
ASFContext * asf = s - > priv_data ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:55 +00:00
ff_asf_guid g ;
int ext_len , payload_ext_ct , stream_ct , i ;
2011-06-01 16:26:27 +00:00
uint32_t leak_rate , stream_num ;
2011-02-09 20:55:55 +00:00
unsigned int stream_languageid_index ;
2011-02-21 15:43:01 +00:00
avio_rl64 ( pb ) ; // starttime
avio_rl64 ( pb ) ; // endtime
leak_rate = avio_rl32 ( pb ) ; // leak-datarate
avio_rl32 ( pb ) ; // bucket-datasize
avio_rl32 ( pb ) ; // init-bucket-fullness
avio_rl32 ( pb ) ; // alt-leak-datarate
avio_rl32 ( pb ) ; // alt-bucket-datasize
avio_rl32 ( pb ) ; // alt-init-bucket-fullness
avio_rl32 ( pb ) ; // max-object-size
avio_rl32 ( pb ) ; // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
stream_num = avio_rl16 ( pb ) ; // stream-num
stream_languageid_index = avio_rl16 ( pb ) ; // stream-language-id-index
2011-02-09 20:55:55 +00:00
if ( stream_num < 128 )
asf - > streams [ stream_num ] . stream_language_index = stream_languageid_index ;
2011-02-21 15:43:01 +00:00
avio_rl64 ( pb ) ; // avg frametime in 100ns units
2013-02-05 23:44:00 +00:00
stream_ct = avio_rl16 ( pb ) ; // stream-name-count
payload_ext_ct = avio_rl16 ( pb ) ; // payload-extension-system-count
2011-02-09 20:55:55 +00:00
2012-11-03 04:35:35 +00:00
if ( stream_num < 128 ) {
2011-02-09 20:55:55 +00:00
asf - > stream_bitrates [ stream_num ] = leak_rate ;
2012-11-03 04:35:35 +00:00
asf - > streams [ stream_num ] . payload_ext_ct = 0 ;
}
2011-02-09 20:55:55 +00:00
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < stream_ct ; i + + ) {
2011-02-21 15:43:01 +00:00
avio_rl16 ( pb ) ;
ext_len = avio_rl16 ( pb ) ;
2011-03-15 08:14:38 +00:00
avio_skip ( pb , ext_len ) ;
2011-02-09 20:55:55 +00:00
}
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < payload_ext_ct ; i + + ) {
2012-11-03 04:35:35 +00:00
int size ;
2011-02-09 20:55:55 +00:00
ff_get_guid ( pb , & g ) ;
2012-11-03 04:35:35 +00:00
size = avio_rl16 ( pb ) ;
2013-02-05 23:44:00 +00:00
ext_len = avio_rl32 ( pb ) ;
2011-03-15 08:14:38 +00:00
avio_skip ( pb , ext_len ) ;
2012-11-03 04:35:35 +00:00
if ( stream_num < 128 & & i < FF_ARRAY_ELEMS ( asf - > streams [ stream_num ] . payload ) ) {
ASFPayload * p = & asf - > streams [ stream_num ] . payload [ i ] ;
p - > type = g [ 0 ] ;
p - > size = size ;
av_log ( s , AV_LOG_DEBUG , " Payload extension %x %d \n " , g [ 0 ] , p - > size ) ;
asf - > streams [ stream_num ] . payload_ext_ct + + ;
}
2011-02-09 20:55:55 +00:00
}
return 0 ;
}
static int asf_read_content_desc ( AVFormatContext * s , int64_t size )
{
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:55 +00:00
int len1 , len2 , len3 , len4 , len5 ;
2011-02-21 15:43:01 +00:00
len1 = avio_rl16 ( pb ) ;
len2 = avio_rl16 ( pb ) ;
len3 = avio_rl16 ( pb ) ;
len4 = avio_rl16 ( pb ) ;
len5 = avio_rl16 ( pb ) ;
2013-02-06 13:35:26 +00:00
get_tag ( s , " title " , 0 , len1 , 32 ) ;
get_tag ( s , " author " , 0 , len2 , 32 ) ;
get_tag ( s , " copyright " , 0 , len3 , 32 ) ;
get_tag ( s , " comment " , 0 , len4 , 32 ) ;
2011-03-15 08:14:38 +00:00
avio_skip ( pb , len5 ) ;
2011-02-09 20:55:55 +00:00
return 0 ;
}
static int asf_read_ext_content_desc ( AVFormatContext * s , int64_t size )
{
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:55 +00:00
ASFContext * asf = s - > priv_data ;
int desc_count , i , ret ;
2011-02-21 15:43:01 +00:00
desc_count = avio_rl16 ( pb ) ;
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < desc_count ; i + + ) {
int name_len , value_type , value_len ;
2011-02-09 20:55:55 +00:00
char name [ 1024 ] ;
2011-02-21 15:43:01 +00:00
name_len = avio_rl16 ( pb ) ;
2013-02-05 23:44:00 +00:00
if ( name_len % 2 ) // must be even, broken lavf versions wrote len-1
2011-02-09 20:55:55 +00:00
name_len + = 1 ;
if ( ( ret = avio_get_str16le ( pb , name_len , name , sizeof ( name ) ) ) < name_len )
2011-03-15 08:14:38 +00:00
avio_skip ( pb , name_len - ret ) ;
2011-02-21 15:43:01 +00:00
value_type = avio_rl16 ( pb ) ;
value_len = avio_rl16 ( pb ) ;
2013-02-05 23:44:00 +00:00
if ( ! value_type & & value_len % 2 )
2011-02-09 20:55:55 +00:00
value_len + = 1 ;
2013-02-05 23:44:00 +00:00
/* My sample has that stream set to 0 maybe that mean the container.
* ASF stream count starts at 1. I am using 0 to the container value
* since it ' s unused . */
if ( ! strcmp ( name , " AspectRatioX " ) )
2013-02-06 13:35:26 +00:00
asf - > dar [ 0 ] . num = get_value ( s - > pb , value_type , 32 ) ;
2013-02-05 23:44:00 +00:00
else if ( ! strcmp ( name , " AspectRatioY " ) )
2013-02-06 13:35:26 +00:00
asf - > dar [ 0 ] . den = get_value ( s - > pb , value_type , 32 ) ;
2013-02-05 23:44:00 +00:00
else
2013-02-06 13:35:26 +00:00
get_tag ( s , name , value_type , value_len , 32 ) ;
2011-02-09 20:55:55 +00:00
}
return 0 ;
}
static int asf_read_language_list ( AVFormatContext * s , int64_t size )
{
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:55 +00:00
ASFContext * asf = s - > priv_data ;
int j , ret ;
2011-02-21 15:43:01 +00:00
int stream_count = avio_rl16 ( pb ) ;
2013-02-05 23:44:00 +00:00
for ( j = 0 ; j < stream_count ; j + + ) {
2011-02-09 20:55:55 +00:00
char lang [ 6 ] ;
2011-02-21 15:43:01 +00:00
unsigned int lang_len = avio_r8 ( pb ) ;
2013-02-05 23:44:00 +00:00
if ( ( ret = avio_get_str16le ( pb , lang_len , lang ,
sizeof ( lang ) ) ) < lang_len )
2011-03-15 08:14:38 +00:00
avio_skip ( pb , lang_len - ret ) ;
2011-02-09 20:55:55 +00:00
if ( j < 128 )
2013-02-05 23:44:00 +00:00
av_strlcpy ( asf - > stream_languages [ j ] , lang ,
sizeof ( * asf - > stream_languages ) ) ;
2011-02-09 20:55:55 +00:00
}
return 0 ;
}
static int asf_read_metadata ( AVFormatContext * s , int64_t size )
{
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:55 +00:00
ASFContext * asf = s - > priv_data ;
2015-07-01 21:46:30 +00:00
int n , stream_num , name_len_utf16 , name_len_utf8 , value_len ;
2011-02-09 20:55:55 +00:00
int ret , i ;
2011-02-21 15:43:01 +00:00
n = avio_rl16 ( pb ) ;
2011-02-09 20:55:55 +00:00
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < n ; i + + ) {
2015-07-01 21:46:30 +00:00
uint8_t * name ;
2013-02-06 13:35:26 +00:00
int value_type ;
2011-02-09 20:55:55 +00:00
2013-02-05 23:44:00 +00:00
avio_rl16 ( pb ) ; // lang_list_index
stream_num = avio_rl16 ( pb ) ;
2015-07-01 21:46:30 +00:00
name_len_utf16 = avio_rl16 ( pb ) ;
2012-08-21 10:40:41 +00:00
value_type = avio_rl16 ( pb ) ; /* value_type */
2013-02-05 23:44:00 +00:00
value_len = avio_rl32 ( pb ) ;
2011-02-09 20:55:55 +00:00
2015-07-01 21:46:30 +00:00
name_len_utf8 = 2 * name_len_utf16 + 1 ;
name = av_malloc ( name_len_utf8 ) ;
if ( ! name )
return AVERROR ( ENOMEM ) ;
if ( ( ret = avio_get_str16le ( pb , name_len_utf16 , name , name_len_utf8 ) ) < name_len_utf16 )
avio_skip ( pb , name_len_utf16 - ret ) ;
2015-03-16 08:57:35 +00:00
av_log ( s , AV_LOG_TRACE , " %d stream %d name_len %2d type %d len %4d <%s> \n " ,
2015-07-01 21:46:30 +00:00
i , stream_num , name_len_utf16 , value_type , value_len , name ) ;
2013-02-06 13:35:26 +00:00
if ( ! strcmp ( name , " AspectRatioX " ) ) {
int aspect_x = get_value ( s - > pb , value_type , 16 ) ;
if ( stream_num < 128 )
asf - > dar [ stream_num ] . num = aspect_x ;
} else if ( ! strcmp ( name , " AspectRatioY " ) ) {
int aspect_y = get_value ( s - > pb , value_type , 16 ) ;
if ( stream_num < 128 )
asf - > dar [ stream_num ] . den = aspect_y ;
} else {
get_tag ( s , name , value_type , value_len , 16 ) ;
2011-02-09 20:55:55 +00:00
}
2015-07-02 07:23:35 +00:00
av_freep ( & name ) ;
2011-02-09 20:55:55 +00:00
}
return 0 ;
}
static int asf_read_marker ( AVFormatContext * s , int64_t size )
{
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2013-09-19 15:50:34 +00:00
ASFContext * asf = s - > priv_data ;
2011-02-09 20:55:55 +00:00
int i , count , name_len , ret ;
char name [ 1024 ] ;
2011-02-21 15:43:01 +00:00
avio_rl64 ( pb ) ; // reserved 16 bytes
avio_rl64 ( pb ) ; // ...
count = avio_rl32 ( pb ) ; // markers count
avio_rl16 ( pb ) ; // reserved 2 bytes
name_len = avio_rl16 ( pb ) ; // name length
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < name_len ; i + + )
2011-02-21 15:43:01 +00:00
avio_r8 ( pb ) ; // skip the name
2011-02-09 20:55:55 +00:00
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < count ; i + + ) {
2011-02-09 20:55:55 +00:00
int64_t pres_time ;
int name_len ;
2011-02-21 15:43:01 +00:00
avio_rl64 ( pb ) ; // offset, 8 bytes
pres_time = avio_rl64 ( pb ) ; // presentation time
2013-09-19 15:50:34 +00:00
pres_time - = asf - > hdr . preroll * 10000 ;
2011-02-21 15:43:01 +00:00
avio_rl16 ( pb ) ; // entry length
avio_rl32 ( pb ) ; // send time
avio_rl32 ( pb ) ; // flags
name_len = avio_rl32 ( pb ) ; // name length
2013-02-05 23:44:00 +00:00
if ( ( ret = avio_get_str16le ( pb , name_len * 2 , name ,
sizeof ( name ) ) ) < name_len )
2011-03-15 08:14:38 +00:00
avio_skip ( pb , name_len - ret ) ;
2013-02-05 23:44:00 +00:00
avpriv_new_chapter ( s , i , ( AVRational ) { 1 , 10000000 } , pres_time ,
AV_NOPTS_VALUE , name ) ;
2011-02-09 20:55:55 +00:00
}
return 0 ;
}
2012-01-12 12:20:36 +00:00
static int asf_read_header ( AVFormatContext * s )
2001-07-22 14:18:56 +00:00
{
2002-05-20 16:31:13 +00:00
ASFContext * asf = s - > priv_data ;
2009-03-18 14:03:40 +00:00
ff_asf_guid g ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2011-02-09 20:55:56 +00:00
int i ;
2003-02-11 16:35:48 +00:00
int64_t gsize ;
2001-07-22 14:18:56 +00:00
2010-12-26 01:26:29 +00:00
ff_get_guid ( pb , & g ) ;
if ( ff_guidcmp ( & g , & ff_asf_header ) )
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2011-02-21 15:43:01 +00:00
avio_rl64 ( pb ) ;
avio_rl32 ( pb ) ;
avio_r8 ( pb ) ;
avio_r8 ( pb ) ;
2002-08-08 22:04:01 +00:00
memset ( & asf - > asfid2avid , - 1 , sizeof ( asf - > asfid2avid ) ) ;
2013-07-30 00:52:17 +00:00
for ( i = 0 ; i < 128 ; i + + )
asf - > streams [ i ] . stream_language_index = 128 ; // invalid stream index means no language info
2013-02-05 23:44:00 +00:00
for ( ; ; ) {
uint64_t gpos = avio_tell ( pb ) ;
2015-07-01 21:21:53 +00:00
int ret = 0 ;
2010-12-26 01:26:29 +00:00
ff_get_guid ( pb , & g ) ;
2011-02-21 15:43:01 +00:00
gsize = avio_rl64 ( pb ) ;
2001-07-22 14:18:56 +00:00
print_guid ( & g ) ;
2010-12-26 01:26:29 +00:00
if ( ! ff_guidcmp ( & g , & ff_asf_data_header ) ) {
2011-03-03 19:11:45 +00:00
asf - > data_object_offset = avio_tell ( pb ) ;
2013-02-05 23:44:00 +00:00
/* If not streaming, gsize is not unlimited (how?),
* and there is enough space in the file . . */
if ( ! ( asf - > hdr . flags & 0x01 ) & & gsize > = 100 )
2007-03-11 03:36:17 +00:00
asf - > data_object_size = gsize - 24 ;
2013-02-05 23:44:00 +00:00
else
2007-03-11 03:36:17 +00:00
asf - > data_object_size = ( uint64_t ) - 1 ;
break ;
}
2001-07-22 14:18:56 +00:00
if ( gsize < 24 )
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2010-12-26 01:26:29 +00:00
if ( ! ff_guidcmp ( & g , & ff_asf_file_header ) ) {
2015-07-01 21:21:53 +00:00
ret = asf_read_file_properties ( s , gsize ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_stream_header ) ) {
2015-07-01 21:21:53 +00:00
ret = asf_read_stream_properties ( s , gsize ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_comment_header ) ) {
2011-02-09 20:55:55 +00:00
asf_read_content_desc ( s , gsize ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_language_guid ) ) {
2011-02-09 20:55:55 +00:00
asf_read_language_list ( s , gsize ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_extended_content_header ) ) {
2011-02-09 20:55:55 +00:00
asf_read_ext_content_desc ( s , gsize ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_metadata_header ) ) {
2011-02-09 20:55:55 +00:00
asf_read_metadata ( s , gsize ) ;
2013-02-06 13:35:27 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_metadata_library_header ) ) {
asf_read_metadata ( s , gsize ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_ext_stream_header ) ) {
2011-02-09 20:55:55 +00:00
asf_read_ext_stream_properties ( s , gsize ) ;
2006-01-20 23:48:16 +00:00
// there could be a optional stream properties object to follow
// if so the next iteration will pick it up
2010-06-23 02:04:55 +00:00
continue ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_head1_guid ) ) {
ff_get_guid ( pb , & g ) ;
2011-06-01 16:26:27 +00:00
avio_skip ( pb , 6 ) ;
2010-06-23 02:04:55 +00:00
continue ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_marker_header ) ) {
2011-02-09 20:55:55 +00:00
asf_read_marker ( s , gsize ) ;
2014-08-07 20:12:41 +00:00
} else if ( avio_feof ( pb ) ) {
2012-06-14 00:30:55 +00:00
return AVERROR_EOF ;
2001-07-22 14:18:56 +00:00
} else {
2009-10-11 23:09:33 +00:00
if ( ! s - > keylen ) {
2010-12-26 01:26:29 +00:00
if ( ! ff_guidcmp ( & g , & ff_asf_content_encryption ) ) {
2011-10-16 03:04:48 +00:00
unsigned int len ;
AVPacket pkt ;
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_WARNING ,
" DRM protected stream detected, decoding will likely fail! \n " ) ;
2011-10-16 03:04:48 +00:00
len = avio_rl32 ( pb ) ;
av_log ( s , AV_LOG_DEBUG , " Secret data: \n " ) ;
2015-01-17 19:39:43 +00:00
if ( ( ret = av_get_packet ( pb , & pkt , len ) ) < 0 )
return ret ;
av_hex_dump_log ( s , AV_LOG_DEBUG , pkt . data , pkt . size ) ;
av_free_packet ( & pkt ) ;
2011-10-16 03:04:48 +00:00
len = avio_rl32 ( pb ) ;
2013-02-10 11:18:50 +00:00
get_tag ( s , " ASF_Protection_Type " , - 1 , len , 32 ) ;
2011-10-16 03:04:48 +00:00
len = avio_rl32 ( pb ) ;
2013-02-10 11:18:50 +00:00
get_tag ( s , " ASF_Key_ID " , - 1 , len , 32 ) ;
2011-10-16 03:04:48 +00:00
len = avio_rl32 ( pb ) ;
2013-02-10 11:18:50 +00:00
get_tag ( s , " ASF_License_URL " , - 1 , len , 32 ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_ext_content_encryption ) ) {
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_WARNING ,
" Ext DRM protected stream detected, decoding will likely fail! \n " ) ;
2011-10-16 02:41:11 +00:00
av_dict_set ( & s - > metadata , " encryption " , " ASF Extended Content Encryption " , 0 ) ;
2010-12-26 01:26:29 +00:00
} else if ( ! ff_guidcmp ( & g , & ff_asf_digital_signature ) ) {
2011-10-16 02:44:42 +00:00
av_log ( s , AV_LOG_INFO , " Digital signature detected! \n " ) ;
2009-10-11 23:09:33 +00:00
}
}
2001-07-22 14:18:56 +00:00
}
2015-07-01 21:21:53 +00:00
if ( ret < 0 )
return ret ;
2013-02-05 23:44:00 +00:00
if ( avio_tell ( pb ) ! = gpos + gsize )
av_log ( s , AV_LOG_DEBUG ,
" gpos mismatch our pos=% " PRIu64 " , end=% " PRId64 " \n " ,
avio_tell ( pb ) - gpos , gsize ) ;
2011-02-28 13:57:54 +00:00
avio_seek ( pb , gpos + gsize , SEEK_SET ) ;
2001-07-22 14:18:56 +00:00
}
2010-12-26 01:26:29 +00:00
ff_get_guid ( pb , & g ) ;
2011-02-21 15:43:01 +00:00
avio_rl64 ( pb ) ;
avio_r8 ( pb ) ;
avio_r8 ( pb ) ;
2014-08-07 20:12:41 +00:00
if ( avio_feof ( pb ) )
2012-06-14 00:30:55 +00:00
return AVERROR_EOF ;
2013-02-05 23:44:00 +00:00
asf - > data_offset = avio_tell ( pb ) ;
2001-07-22 14:18:56 +00:00
asf - > packet_size_left = 0 ;
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < 128 ; i + + ) {
int stream_num = asf - > asfid2avid [ i ] ;
if ( stream_num > = 0 ) {
2008-08-23 23:43:20 +00:00
AVStream * st = s - > streams [ stream_num ] ;
if ( ! st - > codec - > bit_rate )
2011-02-09 20:55:54 +00:00
st - > codec - > bit_rate = asf - > stream_bitrates [ i ] ;
2013-02-05 23:44:00 +00:00
if ( asf - > dar [ i ] . num > 0 & & asf - > dar [ i ] . den > 0 ) {
2012-11-03 04:39:19 +00:00
av_reduce ( & st - > sample_aspect_ratio . num ,
& st - > sample_aspect_ratio . den ,
2011-02-09 20:55:53 +00:00
asf - > dar [ i ] . num , asf - > dar [ i ] . den , INT_MAX ) ;
2013-02-05 23:44:00 +00:00
} else if ( ( asf - > dar [ 0 ] . num > 0 ) & & ( asf - > dar [ 0 ] . den > 0 ) & &
// Use ASF container value if the stream doesn't set AR.
( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) )
2012-11-03 04:39:19 +00:00
av_reduce ( & st - > sample_aspect_ratio . num ,
& st - > sample_aspect_ratio . den ,
2011-02-09 20:55:53 +00:00
asf - > dar [ 0 ] . num , asf - > dar [ 0 ] . den , INT_MAX ) ;
2010-09-23 03:40:06 +00:00
2015-03-16 08:57:35 +00:00
av_log ( s , AV_LOG_TRACE , " i=%d, st->codec->codec_type:%d, asf->dar %d:%d sar=%d:%d \n " ,
2012-08-21 10:40:41 +00:00
i , st - > codec - > codec_type , asf - > dar [ i ] . num , asf - > dar [ i ] . den ,
st - > sample_aspect_ratio . num , st - > sample_aspect_ratio . den ) ;
2009-05-12 12:35:46 +00:00
// copy and convert language codes to the frontend
if ( asf - > streams [ i ] . stream_language_index < 128 ) {
const char * rfc1766 = asf - > stream_languages [ asf - > streams [ i ] . stream_language_index ] ;
if ( rfc1766 & & strlen ( rfc1766 ) > 1 ) {
const char primary_tag [ 3 ] = { rfc1766 [ 0 ] , rfc1766 [ 1 ] , ' \0 ' } ; // ignore country code if any
2013-02-05 23:44:00 +00:00
const char * iso6392 = av_convert_lang_to ( primary_tag ,
AV_LANG_ISO639_2_BIBL ) ;
2009-05-12 12:35:46 +00:00
if ( iso6392 )
2011-05-22 10:46:29 +00:00
av_dict_set ( & st - > metadata , " language " , iso6392 , 0 ) ;
2009-05-12 12:35:46 +00:00
}
}
2007-01-31 23:32:01 +00:00
}
}
2010-10-16 13:20:41 +00:00
ff_metadata_conv ( & s - > metadata , NULL , ff_asf_metadata_conv ) ;
2010-10-15 19:04:25 +00:00
2001-07-22 14:18:56 +00:00
return 0 ;
}
2013-02-05 23:44:00 +00:00
# define DO_2BITS(bits, var, defval) \
switch ( bits & 3 ) { \
case 3 : \
var = avio_rl32 ( pb ) ; \
rsize + = 4 ; \
break ; \
case 2 : \
var = avio_rl16 ( pb ) ; \
rsize + = 2 ; \
break ; \
case 1 : \
var = avio_r8 ( pb ) ; \
rsize + + ; \
break ; \
default : \
var = defval ; \
break ; \
2002-08-08 16:43:47 +00:00
}
2009-06-09 20:58:32 +00:00
/**
* Load a single ASF packet into the demuxer .
* @ param s demux context
* @ param pb context to read data from
2010-03-30 15:50:57 +00:00
* @ return 0 on success , < 0 on error
2009-06-09 20:58:32 +00:00
*/
2013-04-20 19:47:15 +00:00
static int asf_get_packet ( AVFormatContext * s , AVIOContext * pb )
2001-07-22 14:18:56 +00:00
{
ASFContext * asf = s - > priv_data ;
2002-08-08 16:43:47 +00:00
uint32_t packet_length , padsize ;
2007-03-30 16:20:40 +00:00
int rsize = 8 ;
2007-01-23 21:25:06 +00:00
int c , d , e , off ;
2009-07-03 11:18:07 +00:00
// if we do not know packet size, allow skipping up to 32 kB
2013-02-05 23:44:00 +00:00
off = 32768 ;
2012-04-06 13:54:23 +00:00
if ( asf - > no_resync_search )
off = 3 ;
else if ( s - > packet_size > 0 )
2015-02-06 13:53:40 +00:00
off = ( avio_tell ( pb ) - s - > internal - > data_offset ) % s - > packet_size + 3 ;
2013-02-05 23:44:00 +00:00
c = d = e = - 1 ;
while ( off - - > 0 ) {
c = d ;
d = e ;
e = avio_r8 ( pb ) ;
if ( c = = 0x82 & & ! d & & ! e )
2007-01-23 21:25:06 +00:00
break ;
}
2005-12-17 18:14:38 +00:00
2002-08-09 13:06:27 +00:00
if ( c ! = 0x82 ) {
2013-02-05 23:44:00 +00:00
/* This code allows handling of -EAGAIN at packet boundaries (i.e.
2009-07-26 19:09:35 +00:00
* if the packet sync code above triggers - EAGAIN ) . This does not
* imply complete - EAGAIN handling support at random positions in
2013-02-05 23:44:00 +00:00
* the stream . */
2011-03-14 19:38:55 +00:00
if ( pb - > error = = AVERROR ( EAGAIN ) )
2009-07-26 19:09:35 +00:00
return AVERROR ( EAGAIN ) ;
2014-08-07 20:12:41 +00:00
if ( ! avio_feof ( pb ) )
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_ERROR ,
" ff asf bad header %x at:% " PRId64 " \n " , c , avio_tell ( pb ) ) ;
2002-08-08 16:43:47 +00:00
}
2007-03-30 16:20:40 +00:00
if ( ( c & 0x8f ) = = 0x82 ) {
2007-01-23 21:25:06 +00:00
if ( d | | e ) {
2014-08-07 20:12:41 +00:00
if ( ! avio_feof ( pb ) )
2005-12-22 01:10:11 +00:00
av_log ( s , AV_LOG_ERROR , " ff asf bad non zero \n " ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2005-12-22 01:10:11 +00:00
}
2013-02-05 23:44:00 +00:00
c = avio_r8 ( pb ) ;
d = avio_r8 ( pb ) ;
rsize + = 3 ;
2014-08-07 20:12:41 +00:00
} else if ( ! avio_feof ( pb ) ) {
2013-02-05 23:44:00 +00:00
avio_seek ( pb , - 1 , SEEK_CUR ) ; // FIXME
2001-07-22 14:18:56 +00:00
}
2002-08-08 16:43:47 +00:00
2007-03-30 16:20:40 +00:00
asf - > packet_flags = c ;
asf - > packet_property = d ;
2002-08-08 16:43:47 +00:00
2009-06-24 23:04:05 +00:00
DO_2BITS ( asf - > packet_flags > > 5 , packet_length , s - > packet_size ) ;
2002-08-08 16:43:47 +00:00
DO_2BITS ( asf - > packet_flags > > 1 , padsize , 0 ) ; // sequence ignored
DO_2BITS ( asf - > packet_flags > > 3 , padsize , 0 ) ; // padding length
2013-02-05 23:44:00 +00:00
// the following checks prevent overflows and infinite loops
if ( ! packet_length | | packet_length > = ( 1U < < 29 ) ) {
av_log ( s , AV_LOG_ERROR ,
2014-03-10 14:35:59 +00:00
" invalid packet_length % " PRIu32 " at:% " PRId64 " \n " ,
2013-02-05 23:44:00 +00:00
packet_length , avio_tell ( pb ) ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2006-09-27 21:19:47 +00:00
}
2013-02-05 23:44:00 +00:00
if ( padsize > = packet_length ) {
av_log ( s , AV_LOG_ERROR ,
2014-03-10 14:35:59 +00:00
" invalid padsize % " PRIu32 " at:% " PRId64 " \n " , padsize , avio_tell ( pb ) ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2006-09-27 21:19:47 +00:00
}
2011-02-21 15:43:01 +00:00
asf - > packet_timestamp = avio_rl32 ( pb ) ;
avio_rl16 ( pb ) ; /* duration */
2002-08-08 22:04:01 +00:00
// rsize has at least 11 bytes which have to be present
2002-08-08 16:43:47 +00:00
if ( asf - > packet_flags & 0x01 ) {
2013-02-05 23:44:00 +00:00
asf - > packet_segsizetype = avio_r8 ( pb ) ;
rsize + + ;
2002-08-08 16:43:47 +00:00
asf - > packet_segments = asf - > packet_segsizetype & 0x3f ;
} else {
2013-02-05 23:44:00 +00:00
asf - > packet_segments = 1 ;
2002-08-08 16:43:47 +00:00
asf - > packet_segsizetype = 0x80 ;
}
2012-02-17 20:21:18 +00:00
if ( rsize > packet_length - padsize ) {
asf - > packet_size_left = 0 ;
av_log ( s , AV_LOG_ERROR ,
2014-03-10 14:35:59 +00:00
" invalid packet header length %d for pktlen % " PRIu32 " -% " PRIu32 " at % " PRId64 " \n " ,
2012-02-17 20:21:18 +00:00
rsize , packet_length , padsize , avio_tell ( pb ) ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2012-02-17 20:21:18 +00:00
}
2002-08-08 16:43:47 +00:00
asf - > packet_size_left = packet_length - padsize - rsize ;
2002-11-05 17:16:41 +00:00
if ( packet_length < asf - > hdr . min_pktsize )
padsize + = asf - > hdr . min_pktsize - packet_length ;
2002-08-08 16:43:47 +00:00
asf - > packet_padsize = padsize ;
2015-03-16 08:57:35 +00:00
av_log ( s , AV_LOG_TRACE , " packet: size=%d padsize=%d left=%d \n " ,
2013-02-05 23:44:00 +00:00
s - > packet_size , asf - > packet_padsize , asf - > packet_size_left ) ;
2001-07-22 14:18:56 +00:00
return 0 ;
}
2007-01-22 12:55:23 +00:00
/**
*
* @ return < 0 if error
*/
2013-02-05 23:44:00 +00:00
static int asf_read_frame_header ( AVFormatContext * s , AVIOContext * pb )
{
2007-01-22 12:55:23 +00:00
ASFContext * asf = s - > priv_data ;
2012-11-03 04:37:18 +00:00
ASFStream * asfst ;
2013-02-05 23:44:00 +00:00
int rsize = 1 ;
int num = avio_r8 ( pb ) ;
2012-11-03 04:37:18 +00:00
int i ;
2011-11-15 12:06:36 +00:00
int64_t ts0 , ts1 av_unused ;
2007-01-22 12:55:23 +00:00
asf - > packet_segments - - ;
asf - > packet_key_frame = num > > 7 ;
2013-02-05 23:44:00 +00:00
asf - > stream_index = asf - > asfid2avid [ num & 0x7f ] ;
2013-02-06 13:10:26 +00:00
asfst = & asf - > streams [ num & 0x7f ] ;
2007-01-22 12:55:23 +00:00
// sequence should be ignored!
DO_2BITS ( asf - > packet_property > > 4 , asf - > packet_seq , 0 ) ;
DO_2BITS ( asf - > packet_property > > 2 , asf - > packet_frag_offset , 0 ) ;
DO_2BITS ( asf - > packet_property , asf - > packet_replic_size , 0 ) ;
2015-03-16 08:57:35 +00:00
av_log ( asf , AV_LOG_TRACE , " key:%d stream:%d seq:%d offset:%d replic_size:%d \n " ,
2012-08-21 10:40:41 +00:00
asf - > packet_key_frame , asf - > stream_index , asf - > packet_seq ,
asf - > packet_frag_offset , asf - > packet_replic_size ) ;
2013-01-31 02:36:59 +00:00
if ( rsize + ( int64_t ) asf - > packet_replic_size > asf - > packet_size_left ) {
2011-10-31 21:42:45 +00:00
av_log ( s , AV_LOG_ERROR , " packet_replic_size %d is invalid \n " , asf - > packet_replic_size ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2011-10-31 21:42:45 +00:00
}
2007-01-22 12:55:23 +00:00
if ( asf - > packet_replic_size > = 8 ) {
2012-11-03 04:37:18 +00:00
int64_t end = avio_tell ( pb ) + asf - > packet_replic_size ;
2012-11-03 04:38:12 +00:00
AVRational aspect ;
2013-07-30 01:12:28 +00:00
asfst - > packet_obj_size = avio_rl32 ( pb ) ;
2015-06-29 02:57:51 +00:00
if ( asfst - > packet_obj_size > = ( 1 < < 24 ) | | asfst - > packet_obj_size < 0 ) {
2015-06-29 02:55:06 +00:00
av_log ( s , AV_LOG_ERROR , " packet_obj_size %d invalid \n " , asfst - > packet_obj_size ) ;
2013-07-30 01:12:28 +00:00
asfst - > packet_obj_size = 0 ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2007-01-22 12:55:23 +00:00
}
2011-02-21 15:43:01 +00:00
asf - > packet_frag_timestamp = avio_rl32 ( pb ) ; // timestamp
2012-11-03 04:37:18 +00:00
2013-02-06 13:10:26 +00:00
for ( i = 0 ; i < asfst - > payload_ext_ct ; i + + ) {
2012-11-03 04:37:18 +00:00
ASFPayload * p = & asfst - > payload [ i ] ;
int size = p - > size ;
int64_t payend ;
2013-02-06 13:10:26 +00:00
if ( size = = 0xFFFF )
2012-11-03 04:37:18 +00:00
size = avio_rl16 ( pb ) ;
payend = avio_tell ( pb ) + size ;
if ( payend > end ) {
av_log ( s , AV_LOG_ERROR , " too long payload \n " ) ;
break ;
}
2013-02-06 13:10:26 +00:00
switch ( p - > type ) {
2012-11-03 04:37:18 +00:00
case 0x50 :
// duration = avio_rl16(pb);
break ;
2012-11-03 04:38:12 +00:00
case 0x54 :
aspect . num = avio_r8 ( pb ) ;
aspect . den = avio_r8 ( pb ) ;
2012-11-03 04:58:12 +00:00
if ( aspect . num > 0 & & aspect . den > 0 & & asf - > stream_index > = 0 ) {
2012-11-03 04:38:12 +00:00
s - > streams [ asf - > stream_index ] - > sample_aspect_ratio = aspect ;
}
break ;
2012-11-03 04:37:18 +00:00
case 0x2A :
avio_skip ( pb , 8 ) ;
2013-02-06 13:10:26 +00:00
ts0 = avio_rl64 ( pb ) ;
ts1 = avio_rl64 ( pb ) ;
if ( ts0 ! = - 1 ) asf - > packet_frag_timestamp = ts0 / 10000 ;
else asf - > packet_frag_timestamp = AV_NOPTS_VALUE ;
2014-07-13 01:23:54 +00:00
asf - > ts_is_pts = 1 ;
2012-11-03 04:37:18 +00:00
break ;
case 0x5B :
case 0xB7 :
case 0xCC :
case 0xC0 :
case 0xA0 :
//unknown
break ;
}
avio_seek ( pb , payend , SEEK_SET ) ;
}
avio_seek ( pb , end , SEEK_SET ) ;
2007-01-22 12:55:23 +00:00
rsize + = asf - > packet_replic_size ; // FIXME - check validity
2013-02-05 23:44:00 +00:00
} else if ( asf - > packet_replic_size = = 1 ) {
2007-12-23 18:08:00 +00:00
// multipacket - frag_offset is beginning timestamp
2013-02-05 23:44:00 +00:00
asf - > packet_time_start = asf - > packet_frag_offset ;
asf - > packet_frag_offset = 0 ;
2007-01-22 12:55:23 +00:00
asf - > packet_frag_timestamp = asf - > packet_timestamp ;
2011-02-21 15:43:01 +00:00
asf - > packet_time_delta = avio_r8 ( pb ) ;
2007-01-22 12:55:23 +00:00
rsize + + ;
2013-02-05 23:44:00 +00:00
} else if ( asf - > packet_replic_size ! = 0 ) {
av_log ( s , AV_LOG_ERROR , " unexpected packet_replic_size of %d \n " ,
asf - > packet_replic_size ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2007-01-22 12:55:23 +00:00
}
if ( asf - > packet_flags & 0x01 ) {
DO_2BITS ( asf - > packet_segsizetype > > 6 , asf - > packet_frag_size , 0 ) ; // 0 is illegal
2011-05-12 14:20:27 +00:00
if ( rsize > asf - > packet_size_left ) {
av_log ( s , AV_LOG_ERROR , " packet_replic_size is invalid \n " ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2013-02-05 23:44:00 +00:00
} else if ( asf - > packet_frag_size > asf - > packet_size_left - rsize ) {
2011-04-27 22:42:16 +00:00
if ( asf - > packet_frag_size > asf - > packet_size_left - rsize + asf - > packet_padsize ) {
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_ERROR , " packet_frag_size is invalid (%d-%d) \n " ,
asf - > packet_size_left , rsize ) ;
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2011-04-27 22:42:16 +00:00
} else {
int diff = asf - > packet_frag_size - ( asf - > packet_size_left - rsize ) ;
asf - > packet_size_left + = diff ;
asf - > packet_padsize - = diff ;
}
2007-01-22 21:17:54 +00:00
}
2007-01-22 12:55:23 +00:00
} else {
asf - > packet_frag_size = asf - > packet_size_left - rsize ;
}
if ( asf - > packet_replic_size = = 1 ) {
asf - > packet_multi_size = asf - > packet_frag_size ;
if ( asf - > packet_multi_size > asf - > packet_size_left )
2012-06-14 00:30:55 +00:00
return AVERROR_INVALIDDATA ;
2007-01-22 12:55:23 +00:00
}
asf - > packet_size_left - = rsize ;
return 0 ;
}
2009-06-09 20:58:32 +00:00
/**
* Parse data from individual ASF packets ( which were previously loaded
* with asf_get_packet ( ) ) .
* @ param s demux context
* @ param pb context to read data from
* @ param pkt pointer to store packet data into
2010-03-30 15:50:57 +00:00
* @ return 0 if data was stored in pkt , < 0 on error or 1 if more ASF
2009-06-09 20:58:32 +00:00
* packets need to be loaded ( through asf_get_packet ( ) )
*/
2013-04-20 19:47:15 +00:00
static int asf_parse_packet ( AVFormatContext * s , AVIOContext * pb , AVPacket * pkt )
2001-07-22 14:18:56 +00:00
{
2013-02-05 23:44:00 +00:00
ASFContext * asf = s - > priv_data ;
2002-08-08 16:43:47 +00:00
ASFStream * asf_st = 0 ;
for ( ; ; ) {
2010-12-11 21:41:47 +00:00
int ret ;
2014-08-07 20:12:41 +00:00
if ( avio_feof ( pb ) )
2009-04-16 00:41:31 +00:00
return AVERROR_EOF ;
2014-07-13 23:16:08 +00:00
if ( asf - > packet_size_left < FRAME_HEADER_SIZE | |
asf - > packet_segments < 1 & & asf - > packet_time_start = = 0 ) {
2005-12-22 01:10:11 +00:00
int ret = asf - > packet_size_left + asf - > packet_padsize ;
2012-10-20 15:15:57 +00:00
2015-06-28 21:09:53 +00:00
if ( asf - > packet_size_left & & asf - > packet_size_left < FRAME_HEADER_SIZE )
av_log ( s , AV_LOG_WARNING , " Skip due to FRAME_HEADER_SIZE \n " ) ;
2012-10-20 15:15:57 +00:00
assert ( ret > = 0 ) ;
2005-12-22 01:10:11 +00:00
/* fail safe */
2011-03-15 08:14:38 +00:00
avio_skip ( pb , ret ) ;
2007-01-22 12:52:49 +00:00
2013-02-05 23:44:00 +00:00
asf - > packet_pos = avio_tell ( pb ) ;
2006-07-29 16:07:19 +00:00
if ( asf - > data_object_size ! = ( uint64_t ) - 1 & &
( asf - > packet_pos - asf - > data_object_offset > = asf - > data_object_size ) )
2013-02-05 23:44:00 +00:00
return AVERROR_EOF ; /* Do not exceed the size of the data object */
2008-12-13 17:18:11 +00:00
return 1 ;
2005-12-22 01:10:11 +00:00
}
if ( asf - > packet_time_start = = 0 ) {
2012-10-20 15:15:57 +00:00
if ( asf_read_frame_header ( s , pb ) < 0 ) {
2013-11-24 19:32:31 +00:00
asf - > packet_time_start = asf - > packet_segments = 0 ;
2007-01-21 23:03:09 +00:00
continue ;
2004-01-14 21:27:59 +00:00
}
2012-10-20 15:15:57 +00:00
if ( asf - > stream_index < 0 | |
s - > streams [ asf - > stream_index ] - > discard > = AVDISCARD_ALL | |
( ! asf - > packet_key_frame & &
2013-07-30 13:09:13 +00:00
( s - > streams [ asf - > stream_index ] - > discard > = AVDISCARD_NONKEY | | asf - > streams [ s - > streams [ asf - > stream_index ] - > id ] . skip_to_key ) ) ) {
2002-08-09 13:06:27 +00:00
asf - > packet_time_start = 0 ;
2005-12-22 01:10:11 +00:00
/* unhandled packet (should not happen) */
2011-03-15 08:14:38 +00:00
avio_skip ( pb , asf - > packet_frag_size ) ;
2005-12-22 01:10:11 +00:00
asf - > packet_size_left - = asf - > packet_frag_size ;
2012-10-20 15:15:57 +00:00
if ( asf - > stream_index < 0 )
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_ERROR , " ff asf skip %d (unknown stream) \n " ,
asf - > packet_frag_size ) ;
2002-08-09 13:06:27 +00:00
continue ;
2005-12-22 01:10:11 +00:00
}
2013-07-30 00:52:17 +00:00
asf - > asf_st = & asf - > streams [ s - > streams [ asf - > stream_index ] - > id ] ;
2015-07-01 14:08:05 +00:00
if ( ! asf - > packet_frag_offset )
asf - > asf_st - > skip_to_key = 0 ;
2005-12-22 01:10:11 +00:00
}
asf_st = asf - > asf_st ;
2013-02-08 12:54:36 +00:00
av_assert0 ( asf_st ) ;
2005-12-22 01:10:11 +00:00
2014-02-11 12:01:38 +00:00
if ( ! asf_st - > frag_offset & & asf - > packet_frag_offset ) {
2015-03-16 08:57:35 +00:00
av_log ( s , AV_LOG_TRACE , " skipping asf data pkt with fragment offset for "
2014-02-11 12:01:38 +00:00
" stream:%d, expected:%d but got %d from pkt) \n " ,
asf - > stream_index , asf_st - > frag_offset ,
asf - > packet_frag_offset ) ;
avio_skip ( pb , asf - > packet_frag_size ) ;
asf - > packet_size_left - = asf - > packet_frag_size ;
continue ;
}
2005-12-22 01:10:11 +00:00
if ( asf - > packet_replic_size = = 1 ) {
2007-12-23 18:08:00 +00:00
// frag_offset is here used as the beginning timestamp
2005-12-22 01:10:11 +00:00
asf - > packet_frag_timestamp = asf - > packet_time_start ;
2012-10-20 15:15:57 +00:00
asf - > packet_time_start + = asf - > packet_time_delta ;
2013-07-30 01:12:28 +00:00
asf_st - > packet_obj_size = asf - > packet_frag_size = avio_r8 ( pb ) ;
2005-12-22 01:10:11 +00:00
asf - > packet_size_left - - ;
2002-08-08 22:04:01 +00:00
asf - > packet_multi_size - - ;
2013-07-30 01:12:28 +00:00
if ( asf - > packet_multi_size < asf_st - > packet_obj_size ) {
2005-12-22 01:10:11 +00:00
asf - > packet_time_start = 0 ;
2011-03-15 08:14:38 +00:00
avio_skip ( pb , asf - > packet_multi_size ) ;
2005-12-22 01:10:11 +00:00
asf - > packet_size_left - = asf - > packet_multi_size ;
2002-08-08 22:04:01 +00:00
continue ;
2005-12-22 01:10:11 +00:00
}
2013-07-30 01:12:28 +00:00
asf - > packet_multi_size - = asf_st - > packet_obj_size ;
2005-12-22 01:10:11 +00:00
}
2007-07-27 00:29:33 +00:00
2013-07-30 01:12:28 +00:00
if ( asf_st - > pkt . size ! = asf_st - > packet_obj_size | |
2013-02-05 23:44:00 +00:00
// FIXME is this condition sufficient?
2012-10-20 15:15:57 +00:00
asf_st - > frag_offset + asf - > packet_frag_size > asf_st - > pkt . size ) {
2014-08-20 16:27:25 +00:00
int ret ;
2012-10-20 15:15:57 +00:00
if ( asf_st - > pkt . data ) {
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_INFO ,
" freeing incomplete packet size %d, new %d \n " ,
2013-07-30 01:12:28 +00:00
asf_st - > pkt . size , asf_st - > packet_obj_size ) ;
2007-01-22 17:01:01 +00:00
asf_st - > frag_offset = 0 ;
av_free_packet ( & asf_st - > pkt ) ;
}
2005-12-22 01:10:11 +00:00
/* new packet */
2014-08-20 16:27:25 +00:00
if ( ( ret = av_new_packet ( & asf_st - > pkt , asf_st - > packet_obj_size ) ) < 0 )
return ret ;
2012-10-20 15:15:57 +00:00
asf_st - > seq = asf - > packet_seq ;
2014-07-13 01:23:54 +00:00
if ( asf - > ts_is_pts ) {
asf_st - > pkt . pts = asf - > packet_frag_timestamp - asf - > hdr . preroll ;
} else
asf_st - > pkt . dts = asf - > packet_frag_timestamp - asf - > hdr . preroll ;
2005-12-22 01:10:11 +00:00
asf_st - > pkt . stream_index = asf - > stream_index ;
2012-10-20 15:15:57 +00:00
asf_st - > pkt . pos = asf_st - > packet_pos = asf - > packet_pos ;
2013-12-13 21:31:49 +00:00
asf_st - > pkt_clean = 0 ;
2012-10-20 15:15:57 +00:00
2011-04-09 13:49:51 +00:00
if ( asf_st - > pkt . data & & asf_st - > palette_changed ) {
uint8_t * pal ;
2011-12-20 04:16:51 +00:00
pal = av_packet_new_side_data ( & asf_st - > pkt , AV_PKT_DATA_PALETTE ,
2011-04-09 13:49:51 +00:00
AVPALETTE_SIZE ) ;
if ( ! pal ) {
av_log ( s , AV_LOG_ERROR , " Cannot append palette to packet \n " ) ;
} else {
memcpy ( pal , asf_st - > palette , AVPALETTE_SIZE ) ;
asf_st - > palette_changed = 0 ;
}
}
2015-03-16 08:57:35 +00:00
av_log ( asf , AV_LOG_TRACE , " new packet: stream:%d key:%d packet_key:%d audio:%d size:%d \n " ,
2012-08-21 10:40:41 +00:00
asf - > stream_index , asf - > packet_key_frame ,
asf_st - > pkt . flags & AV_PKT_FLAG_KEY ,
s - > streams [ asf - > stream_index ] - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ,
2013-07-30 01:12:28 +00:00
asf_st - > packet_obj_size ) ;
2010-03-30 23:30:55 +00:00
if ( s - > streams [ asf - > stream_index ] - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO )
2005-12-22 01:10:11 +00:00
asf - > packet_key_frame = 1 ;
if ( asf - > packet_key_frame )
2010-03-31 12:29:58 +00:00
asf_st - > pkt . flags | = AV_PKT_FLAG_KEY ;
2005-12-22 01:10:11 +00:00
}
/* read data */
2015-03-16 08:57:35 +00:00
av_log ( asf , AV_LOG_TRACE , " READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p \n " ,
2012-08-21 10:40:41 +00:00
s - > packet_size , asf_st - > pkt . size , asf - > packet_frag_offset ,
asf_st - > frag_offset , asf - > packet_frag_size , asf_st - > pkt . data ) ;
2005-12-22 01:10:11 +00:00
asf - > packet_size_left - = asf - > packet_frag_size ;
if ( asf - > packet_size_left < 0 )
2002-08-08 22:04:01 +00:00
continue ;
2007-01-22 16:37:45 +00:00
2012-10-20 15:15:57 +00:00
if ( asf - > packet_frag_offset > = asf_st - > pkt . size | |
asf - > packet_frag_size > asf_st - > pkt . size - asf - > packet_frag_offset ) {
2013-02-05 23:44:00 +00:00
av_log ( s , AV_LOG_ERROR ,
" packet fragment position invalid %u,%u not in %u \n " ,
asf - > packet_frag_offset , asf - > packet_frag_size ,
asf_st - > pkt . size ) ;
2007-01-22 16:37:45 +00:00
continue ;
}
2013-12-13 21:31:49 +00:00
if ( asf - > packet_frag_offset ! = asf_st - > frag_offset & & ! asf_st - > pkt_clean ) {
memset ( asf_st - > pkt . data + asf_st - > frag_offset , 0 , asf_st - > pkt . size - asf_st - > frag_offset ) ;
asf_st - > pkt_clean = 1 ;
}
2011-02-21 15:43:01 +00:00
ret = avio_read ( pb , asf_st - > pkt . data + asf - > packet_frag_offset ,
2012-10-20 15:15:57 +00:00
asf - > packet_frag_size ) ;
2010-12-18 13:18:52 +00:00
if ( ret ! = asf - > packet_frag_size ) {
if ( ret < 0 | | asf - > packet_frag_offset + ret = = 0 )
return ret < 0 ? ret : AVERROR_EOF ;
2012-10-20 15:15:57 +00:00
2010-12-18 13:18:52 +00:00
if ( asf_st - > ds_span > 1 ) {
// scrambling, we can either drop it completely or fill the remainder
// TODO: should we fill the whole packet instead of just the current
// fragment?
memset ( asf_st - > pkt . data + asf - > packet_frag_offset + ret , 0 ,
asf - > packet_frag_size - ret ) ;
ret = asf - > packet_frag_size ;
2012-10-20 15:15:57 +00:00
} else {
2010-12-18 13:18:52 +00:00
// no scrambling, so we can return partial packets
av_shrink_packet ( & asf_st - > pkt , asf - > packet_frag_offset + ret ) ;
2012-10-20 15:15:57 +00:00
}
2010-12-18 13:18:52 +00:00
}
2007-10-20 14:25:02 +00:00
if ( s - > key & & s - > keylen = = 20 )
ff_asfcrypt_dec ( s - > key , asf_st - > pkt . data + asf - > packet_frag_offset ,
2010-12-18 13:18:52 +00:00
ret ) ;
asf_st - > frag_offset + = ret ;
2005-12-22 01:10:11 +00:00
/* test if whole packet is read */
if ( asf_st - > frag_offset = = asf_st - > pkt . size ) {
2013-02-05 23:44:00 +00:00
// workaround for macroshit radio DVR-MS files
2012-10-20 15:15:57 +00:00
if ( s - > streams [ asf - > stream_index ] - > codec - > codec_id = = AV_CODEC_ID_MPEG2VIDEO & &
asf_st - > pkt . size > 100 ) {
2007-09-02 15:58:43 +00:00
int i ;
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < asf_st - > pkt . size & & ! asf_st - > pkt . data [ i ] ; i + + )
;
2012-10-20 15:15:57 +00:00
if ( i = = asf_st - > pkt . size ) {
2007-09-02 15:58:43 +00:00
av_log ( s , AV_LOG_DEBUG , " discarding ms fart \n " ) ;
asf_st - > frag_offset = 0 ;
av_free_packet ( & asf_st - > pkt ) ;
continue ;
}
}
2005-12-22 01:10:11 +00:00
/* return packet */
if ( asf_st - > ds_span > 1 ) {
2013-02-05 23:44:00 +00:00
if ( asf_st - > pkt . size ! = asf_st - > ds_packet_size * asf_st - > ds_span ) {
av_log ( s , AV_LOG_ERROR ,
" pkt.size != ds_packet_size * ds_span (%d %d %d) \n " ,
asf_st - > pkt . size , asf_st - > ds_packet_size ,
asf_st - > ds_span ) ;
2012-10-20 15:15:57 +00:00
} else {
/* packet descrambling */
2012-10-31 07:53:18 +00:00
AVBufferRef * buf = av_buffer_alloc ( asf_st - > pkt . size +
FF_INPUT_BUFFER_PADDING_SIZE ) ;
if ( buf ) {
uint8_t * newdata = buf - > data ;
2012-10-20 15:15:57 +00:00
int offset = 0 ;
2013-02-05 23:44:00 +00:00
memset ( newdata + asf_st - > pkt . size , 0 ,
FF_INPUT_BUFFER_PADDING_SIZE ) ;
2012-10-20 15:15:57 +00:00
while ( offset < asf_st - > pkt . size ) {
int off = offset / asf_st - > ds_chunk_size ;
int row = off / asf_st - > ds_span ;
int col = off % asf_st - > ds_span ;
int idx = row + col * asf_st - > ds_packet_size / asf_st - > ds_chunk_size ;
assert ( offset + asf_st - > ds_chunk_size < = asf_st - > pkt . size ) ;
2013-02-05 23:44:00 +00:00
assert ( idx + 1 < = asf_st - > pkt . size / asf_st - > ds_chunk_size ) ;
2012-10-20 15:15:57 +00:00
memcpy ( newdata + offset ,
asf_st - > pkt . data + idx * asf_st - > ds_chunk_size ,
asf_st - > ds_chunk_size ) ;
offset + = asf_st - > ds_chunk_size ;
}
2012-10-31 07:53:18 +00:00
av_buffer_unref ( & asf_st - > pkt . buf ) ;
asf_st - > pkt . buf = buf ;
asf_st - > pkt . data = buf - > data ;
2005-12-22 01:10:11 +00:00
}
}
}
2012-10-20 15:15:57 +00:00
asf_st - > frag_offset = 0 ;
* pkt = asf_st - > pkt ;
2012-10-31 07:53:18 +00:00
# if FF_API_DESTRUCT_PACKET
2013-03-27 17:36:51 +00:00
FF_DISABLE_DEPRECATION_WARNINGS
2012-10-31 07:53:18 +00:00
asf_st - > pkt . destruct = NULL ;
2013-03-27 17:36:51 +00:00
FF_ENABLE_DEPRECATION_WARNINGS
2012-10-31 07:53:18 +00:00
# endif
asf_st - > pkt . buf = 0 ;
2012-10-20 15:15:57 +00:00
asf_st - > pkt . size = 0 ;
asf_st - > pkt . data = 0 ;
2012-03-21 23:10:37 +00:00
asf_st - > pkt . side_data_elems = 0 ;
2012-10-20 15:15:57 +00:00
asf_st - > pkt . side_data = NULL ;
2005-12-22 01:10:11 +00:00
break ; // packet completed
}
2001-07-22 14:18:56 +00:00
}
return 0 ;
}
2008-12-13 17:18:11 +00:00
static int asf_read_packet ( AVFormatContext * s , AVPacket * pkt )
{
ASFContext * asf = s - > priv_data ;
for ( ; ; ) {
int ret ;
/* parse cached packets, if any */
2013-04-20 19:47:15 +00:00
if ( ( ret = asf_parse_packet ( s , s - > pb , pkt ) ) < = 0 )
2008-12-13 17:18:11 +00:00
return ret ;
2013-04-20 19:47:15 +00:00
if ( ( ret = asf_get_packet ( s , s - > pb ) ) < 0 )
2013-02-05 23:44:00 +00:00
assert ( asf - > packet_size_left < FRAME_HEADER_SIZE | |
asf - > packet_segments < 1 ) ;
2008-12-13 17:18:11 +00:00
asf - > packet_time_start = 0 ;
}
}
2004-01-14 13:32:49 +00:00
// Added to support seeking after packets have been read
// If information is not reset, read_packet fails due to
// leftover information from previous reads
static void asf_reset_header ( AVFormatContext * s )
{
ASFContext * asf = s - > priv_data ;
2004-01-14 18:18:47 +00:00
ASFStream * asf_st ;
int i ;
2004-01-14 13:32:49 +00:00
2013-02-05 23:44:00 +00:00
asf - > packet_size_left = 0 ;
asf - > packet_flags = 0 ;
asf - > packet_property = 0 ;
asf - > packet_timestamp = 0 ;
asf - > packet_segsizetype = 0 ;
asf - > packet_segments = 0 ;
asf - > packet_seq = 0 ;
asf - > packet_replic_size = 0 ;
asf - > packet_key_frame = 0 ;
asf - > packet_padsize = 0 ;
asf - > packet_frag_offset = 0 ;
asf - > packet_frag_size = 0 ;
2004-01-14 13:32:49 +00:00
asf - > packet_frag_timestamp = 0 ;
2013-02-05 23:44:00 +00:00
asf - > packet_multi_size = 0 ;
asf - > packet_time_delta = 0 ;
asf - > packet_time_start = 0 ;
2005-12-17 18:14:38 +00:00
2013-07-30 00:52:17 +00:00
for ( i = 0 ; i < 128 ; i + + ) {
asf_st = & asf - > streams [ i ] ;
2004-01-14 18:18:47 +00:00
av_free_packet ( & asf_st - > pkt ) ;
2013-07-30 01:12:28 +00:00
asf_st - > packet_obj_size = 0 ;
2013-02-05 23:44:00 +00:00
asf_st - > frag_offset = 0 ;
asf_st - > seq = 0 ;
2004-01-14 18:18:47 +00:00
}
2013-02-05 23:44:00 +00:00
asf - > asf_st = NULL ;
2004-01-14 13:32:49 +00:00
}
2013-07-30 13:09:13 +00:00
static void skip_to_key ( AVFormatContext * s )
{
ASFContext * asf = s - > priv_data ;
int i ;
for ( i = 0 ; i < 128 ; i + + ) {
int j = asf - > asfid2avid [ i ] ;
ASFStream * asf_st = & asf - > streams [ i ] ;
if ( j < 0 | | s - > streams [ j ] - > codec - > codec_type ! = AVMEDIA_TYPE_VIDEO )
continue ;
asf_st - > skip_to_key = 1 ;
}
}
2007-10-14 17:44:38 +00:00
static int asf_read_close ( AVFormatContext * s )
{
asf_reset_header ( s ) ;
2011-04-17 17:48:27 +00:00
2007-10-14 17:44:38 +00:00
return 0 ;
}
2013-02-05 23:44:00 +00:00
static int64_t asf_read_pts ( AVFormatContext * s , int stream_index ,
int64_t * ppos , int64_t pos_limit )
2004-01-14 13:32:49 +00:00
{
2013-07-30 00:52:17 +00:00
ASFContext * asf = s - > priv_data ;
2004-01-14 13:32:49 +00:00
AVPacket pkt1 , * pkt = & pkt1 ;
2004-01-14 18:18:47 +00:00
ASFStream * asf_st ;
2004-01-14 14:45:53 +00:00
int64_t pts ;
2013-02-05 23:44:00 +00:00
int64_t pos = * ppos ;
2004-01-17 18:06:52 +00:00
int i ;
2010-06-24 15:10:06 +00:00
int64_t start_pos [ ASF_MAX_STREAMS ] ;
2005-12-17 18:14:38 +00:00
2013-02-05 23:44:00 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + )
start_pos [ i ] = pos ;
2005-12-17 18:14:38 +00:00
2009-07-03 11:18:07 +00:00
if ( s - > packet_size > 0 )
2015-02-06 13:53:40 +00:00
pos = ( pos + s - > packet_size - 1 - s - > internal - > data_offset ) /
2013-02-05 23:44:00 +00:00
s - > packet_size * s - > packet_size +
2015-02-06 13:53:40 +00:00
s - > internal - > data_offset ;
2013-02-05 23:44:00 +00:00
* ppos = pos ;
2011-09-12 02:06:55 +00:00
if ( avio_seek ( s - > pb , pos , SEEK_SET ) < 0 )
return AV_NOPTS_VALUE ;
2005-12-17 18:14:38 +00:00
2013-08-12 20:52:23 +00:00
ff_read_frame_flush ( s ) ;
2004-01-14 18:18:47 +00:00
asf_reset_header ( s ) ;
2013-02-05 23:44:00 +00:00
for ( ; ; ) {
2013-02-06 13:10:26 +00:00
if ( av_read_frame ( s , pkt ) < 0 ) {
2007-01-22 21:31:40 +00:00
av_log ( s , AV_LOG_INFO , " asf_read_pts failed \n " ) ;
2005-12-22 01:10:11 +00:00
return AV_NOPTS_VALUE ;
2004-01-14 18:18:47 +00:00
}
2005-12-17 18:14:38 +00:00
2011-11-15 02:56:37 +00:00
pts = pkt - > dts ;
2004-01-14 14:45:53 +00:00
av_free_packet ( pkt ) ;
2013-02-05 23:44:00 +00:00
if ( pkt - > flags & AV_PKT_FLAG_KEY ) {
i = pkt - > stream_index ;
2004-01-17 18:06:52 +00:00
2013-07-30 00:52:17 +00:00
asf_st = & asf - > streams [ s - > streams [ i ] - > id ] ;
2004-01-17 18:06:52 +00:00
2009-06-24 23:04:05 +00:00
// assert((asf_st->packet_pos - s->data_offset) % s->packet_size == 0);
2013-02-05 23:44:00 +00:00
pos = asf_st - > packet_pos ;
2015-07-01 14:41:26 +00:00
av_assert1 ( pkt - > pos = = asf_st - > packet_pos ) ;
2004-01-14 18:40:29 +00:00
2013-02-05 23:44:00 +00:00
av_add_index_entry ( s - > streams [ i ] , pos , pts , pkt - > size ,
pos - start_pos [ i ] + 1 , AVINDEX_KEYFRAME ) ;
start_pos [ i ] = asf_st - > packet_pos + 1 ;
2005-12-17 18:14:38 +00:00
2013-02-05 23:44:00 +00:00
if ( pkt - > stream_index = = stream_index )
break ;
2004-01-17 18:06:52 +00:00
}
}
2013-02-05 23:44:00 +00:00
* ppos = pos ;
2004-01-14 14:45:53 +00:00
return pts ;
2004-01-14 13:32:49 +00:00
}
2014-02-11 14:13:31 +00:00
static int asf_build_simple_index ( AVFormatContext * s , int stream_index )
2006-08-23 17:07:01 +00:00
{
2009-03-18 14:03:40 +00:00
ff_asf_guid g ;
2013-02-05 23:44:00 +00:00
ASFContext * asf = s - > priv_data ;
int64_t current_pos = avio_tell ( s - > pb ) ;
2015-02-20 18:29:12 +00:00
int64_t ret ;
2006-08-23 17:07:01 +00:00
2014-02-12 16:10:26 +00:00
if ( ( ret = avio_seek ( s - > pb , asf - > data_object_offset + asf - > data_object_size , SEEK_SET ) ) < 0 ) {
return ret ;
2011-09-12 19:35:32 +00:00
}
2011-09-12 02:06:55 +00:00
2014-02-11 14:13:31 +00:00
if ( ( ret = ff_get_guid ( s - > pb , & g ) ) < 0 )
goto end ;
2010-12-03 07:49:07 +00:00
/* the data object can be followed by other top-level objects,
2013-02-05 23:44:00 +00:00
* skip them until the simple index object is reached */
2012-04-03 07:44:10 +00:00
while ( ff_guidcmp ( & g , & ff_asf_simple_index_header ) ) {
2013-02-05 23:44:00 +00:00
int64_t gsize = avio_rl64 ( s - > pb ) ;
2014-08-07 20:12:41 +00:00
if ( gsize < 24 | | avio_feof ( s - > pb ) ) {
2014-02-11 14:13:31 +00:00
goto end ;
2010-12-03 07:49:07 +00:00
}
2013-02-05 23:44:00 +00:00
avio_skip ( s - > pb , gsize - 24 ) ;
2014-02-11 14:13:31 +00:00
if ( ( ret = ff_get_guid ( s - > pb , & g ) ) < 0 )
goto end ;
2010-12-03 07:49:07 +00:00
}
{
2013-02-05 23:44:00 +00:00
int64_t itime , last_pos = - 1 ;
2009-04-17 12:37:39 +00:00
int pct , ict ;
2012-01-15 19:18:22 +00:00
int i ;
2013-02-05 23:44:00 +00:00
int64_t av_unused gsize = avio_rl64 ( s - > pb ) ;
2014-02-11 14:13:31 +00:00
if ( ( ret = ff_get_guid ( s - > pb , & g ) ) < 0 )
goto end ;
2013-02-05 23:44:00 +00:00
itime = avio_rl64 ( s - > pb ) ;
pct = avio_rl32 ( s - > pb ) ;
ict = avio_rl32 ( s - > pb ) ;
av_log ( s , AV_LOG_DEBUG ,
" itime:0x% " PRIx64 " , pct:%d, ict:%d \n " , itime , pct , ict ) ;
for ( i = 0 ; i < ict ; i + + ) {
int pktnum = avio_rl32 ( s - > pb ) ;
int pktct = avio_rl16 ( s - > pb ) ;
2015-02-06 13:53:40 +00:00
int64_t pos = s - > internal - > data_offset + s - > packet_size * ( int64_t ) pktnum ;
2013-02-05 23:44:00 +00:00
int64_t index_pts = FFMAX ( av_rescale ( itime , i , 10000 ) - asf - > hdr . preroll , 0 ) ;
if ( pos ! = last_pos ) {
av_log ( s , AV_LOG_DEBUG , " pktnum:%d, pktct:%d pts: % " PRId64 " \n " ,
pktnum , pktct , index_pts ) ;
av_add_index_entry ( s - > streams [ stream_index ] , pos , index_pts ,
s - > packet_size , 0 , AVINDEX_KEYFRAME ) ;
last_pos = pos ;
2009-12-16 21:24:04 +00:00
}
2006-08-23 17:07:01 +00:00
}
2013-02-06 13:10:26 +00:00
asf - > index_read = ict > 1 ;
2006-08-23 17:07:01 +00:00
}
2014-02-11 14:13:31 +00:00
end :
2014-08-07 20:12:41 +00:00
// if (avio_feof(s->pb)) {
2014-02-12 15:00:37 +00:00
// ret = 0;
// }
2011-02-28 13:57:54 +00:00
avio_seek ( s - > pb , current_pos , SEEK_SET ) ;
2014-02-11 14:13:31 +00:00
return ret ;
2006-08-23 17:07:01 +00:00
}
2013-02-05 23:44:00 +00:00
static int asf_read_seek ( AVFormatContext * s , int stream_index ,
int64_t pts , int flags )
2002-08-08 16:43:47 +00:00
{
2003-11-10 18:49:58 +00:00
ASFContext * asf = s - > priv_data ;
2013-02-05 23:44:00 +00:00
AVStream * st = s - > streams [ stream_index ] ;
2014-02-12 15:00:37 +00:00
int ret = 0 ;
2005-12-17 18:14:38 +00:00
2009-06-24 23:04:05 +00:00
if ( s - > packet_size < = 0 )
2004-01-14 13:32:49 +00:00
return - 1 ;
2007-12-17 09:28:46 +00:00
/* Try using the protocol's read_seek if available */
2013-02-05 23:44:00 +00:00
if ( s - > pb ) {
2015-02-20 18:29:12 +00:00
int64_t ret = avio_seek_time ( s - > pb , stream_index , pts , flags ) ;
2013-02-05 23:44:00 +00:00
if ( ret > = 0 )
2007-12-17 09:28:46 +00:00
asf_reset_header ( s ) ;
2007-12-20 00:25:18 +00:00
if ( ret ! = AVERROR ( ENOSYS ) )
2007-12-20 00:26:53 +00:00
return ret ;
2007-12-17 09:28:46 +00:00
}
2014-02-02 23:05:58 +00:00
/* explicitly handle the case of seeking to 0 */
if ( ! pts ) {
asf_reset_header ( s ) ;
2015-02-06 13:53:40 +00:00
avio_seek ( s - > pb , s - > internal - > data_offset , SEEK_SET ) ;
2014-02-02 23:05:58 +00:00
return 0 ;
}
2014-02-12 15:00:37 +00:00
if ( ! asf - > index_read ) {
2014-02-11 14:13:31 +00:00
ret = asf_build_simple_index ( s , stream_index ) ;
2014-02-12 15:00:37 +00:00
if ( ret < 0 )
asf - > index_read = - 1 ;
}
2006-08-23 17:07:01 +00:00
2014-02-12 15:00:37 +00:00
if ( asf - > index_read > 0 & & st - > index_entries ) {
2013-02-06 13:10:26 +00:00
int index = av_index_search_timestamp ( st , pts , flags ) ;
2013-02-05 23:44:00 +00:00
if ( index > = 0 ) {
2011-05-12 08:26:32 +00:00
/* find the position */
2012-01-15 19:18:22 +00:00
uint64_t pos = st - > index_entries [ index ] . pos ;
2006-08-23 17:07:01 +00:00
2011-05-12 08:26:32 +00:00
/* do the seek */
av_log ( s , AV_LOG_DEBUG , " SEEKTO: % " PRId64 " \n " , pos ) ;
2011-09-12 02:06:55 +00:00
if ( avio_seek ( s - > pb , pos , SEEK_SET ) < 0 )
return - 1 ;
2011-05-12 08:26:32 +00:00
asf_reset_header ( s ) ;
2013-07-30 13:09:13 +00:00
skip_to_key ( s ) ;
2011-05-12 08:26:32 +00:00
return 0 ;
2011-05-12 08:25:54 +00:00
}
2006-08-23 17:07:01 +00:00
}
2011-05-12 08:25:54 +00:00
/* no index or seeking by index failed */
2011-10-16 13:03:30 +00:00
if ( ff_seek_frame_binary ( s , stream_index , pts , flags ) < 0 )
2011-05-12 08:25:54 +00:00
return - 1 ;
2004-01-14 13:32:49 +00:00
asf_reset_header ( s ) ;
2013-07-30 13:09:13 +00:00
skip_to_key ( s ) ;
2004-01-14 13:32:49 +00:00
return 0 ;
2002-08-08 16:43:47 +00:00
}
2011-01-25 22:03:28 +00:00
AVInputFormat ff_asf_demuxer = {
2011-07-16 20:18:12 +00:00
. name = " asf " ,
2012-07-24 01:23:48 +00:00
. long_name = NULL_IF_CONFIG_SMALL ( " ASF (Advanced / Active Streaming Format) " ) ,
2011-07-16 20:18:12 +00:00
. priv_data_size = sizeof ( ASFContext ) ,
. read_probe = asf_probe ,
. read_header = asf_read_header ,
. read_packet = asf_read_packet ,
. read_close = asf_read_close ,
. read_seek = asf_read_seek ,
. read_timestamp = asf_read_pts ,
2012-04-06 14:50:48 +00:00
. flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH ,
2012-04-06 13:54:23 +00:00
. priv_class = & asf_class ,
2002-05-20 16:31:13 +00:00
} ;