22 #include "libavutil/attributes.h"
23 #include "libavutil/avassert.h"
24 #include "libavutil/avstring.h"
25 #include "libavutil/bswap.h"
26 #include "libavutil/common.h"
27 #include "libavutil/dict.h"
29 #include "libavutil/mathematics.h"
30 #include "libavutil/opt.h"
44 uint32_t stream_bitrates[128];
46 char stream_languages[128][6];
97 #define ASF_MAX_STREAMS 127
98 #define FRAME_HEADER_SIZE 16
103 0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2
106 #define PRINT_IF_GUID(g, cmp) \
107 if (!ff_guidcmp(g, &cmp)) \
108 av_dlog(NULL, "(GUID: %s) ", # cmp)
136 else PRINT_IF_GUID(g, stream_bitrate_guid);
139 av_dlog(NULL,
"(GUID: unknown) ");
140 for (i = 0; i < 16; i++)
141 av_dlog(NULL,
" 0x%02x,", (*g)[i]);
146 #define print_guid(g)
186 int ret,
type, picsize, desc_len;
189 if (len < 1 + 4 + 2 + 2) {
209 if (!strncmp(mime->
str, mimetype,
sizeof(mimetype))) {
221 if (picsize >= len) {
228 desc_len = (len - picsize) * 2 + 1;
270 if (id3v2_extra_meta)
281 if ((
unsigned)len >= (UINT_MAX -
LEN) / 2)
290 }
else if (type == -1) {
293 }
else if (type == 1) {
294 if (!strcmp(key,
"WM/Picture")) {
296 }
else if (!strcmp(key,
"ID3")) {
302 }
else if (type > 1 && type <= 5) {
305 }
else if (type == 6) {
310 "Unsupported value type %d in tag %s.\n", type, key);
353 int type_specific_size, sizeX;
356 int test_for_ext_stream_audio, is_dvr_ms_audio = 0;
375 (10000000 / 1000) - start_time;
379 test_for_ext_stream_audio = 0;
390 test_for_ext_stream_audio = 1;
406 if (test_for_ext_stream_audio) {
425 if (is_dvr_ms_audio) {
437 if (size >= (pos2 + 8 - pos1 + 24)) {
451 size - (
avio_tell(pb) - pos1 + 24) >= 51) {
490 if (tag1 ==
MKTAG(
'D',
'V',
'R',
' ')) {
504 avio_skip(pb, size - (pos2 - pos1 + 24));
514 int ext_len, payload_ext_ct, stream_ct, i;
515 uint32_t leak_rate, stream_num;
516 unsigned int stream_languageid_index;
531 if (stream_num < 128)
538 if (stream_num < 128) {
543 for (i = 0; i < stream_ct; i++) {
549 for (i = 0; i < payload_ext_ct; i++) {
570 int len1, len2, len3, len4, len5;
577 get_tag(s,
"title", 0, len1, 32);
578 get_tag(s,
"author", 0, len2, 32);
579 get_tag(s,
"copyright", 0, len3, 32);
580 get_tag(s,
"comment", 0, len4, 32);
590 int desc_count, i,
ret;
593 for (i = 0; i < desc_count; i++) {
594 int name_len, value_type, value_len;
604 if (!value_type && value_len % 2)
609 if (!strcmp(name,
"AspectRatioX"))
611 else if (!strcmp(name,
"AspectRatioY"))
614 get_tag(s, name, value_type, value_len, 32);
626 for (j = 0; j < stream_count; j++) {
628 unsigned int lang_len =
avio_r8(pb);
630 sizeof(lang))) < lang_len)
644 int n, stream_num, name_len, value_len;
648 for (i = 0; i <
n; i++) {
660 av_dlog(s,
"%d stream %d name_len %2d type %d len %4d <%s>\n",
661 i, stream_num, name_len, value_type, value_len, name);
663 if (!strcmp(name,
"AspectRatioX")){
666 asf->
dar[stream_num].
num = aspect_x;
667 }
else if(!strcmp(name,
"AspectRatioY")){
670 asf->
dar[stream_num].
den = aspect_y;
672 get_tag(s, name, value_type, value_len, 16);
691 for (i = 0; i < name_len; i++)
694 for (i = 0; i <
count; i++) {
706 sizeof(name))) < name_len)
732 for (i = 0; i<128; i++)
744 if (!(asf->
hdr.
flags & 0x01) && gsize >= 100)
790 "DRM protected stream detected, decoding will likely fail!\n");
795 get_tag(s,
"ASF_Protection_Type", -1, len, 32);
797 get_tag(s,
"ASF_Key_ID", -1, len, 32);
799 get_tag(s,
"ASF_License_URL", -1, len, 32);
802 "Ext DRM protected stream detected, decoding will likely fail!\n");
811 "gpos mismatch our pos=%"PRIu64
", end=%"PRId64
"\n",
824 for (i = 0; i < 128; i++) {
826 if (stream_num >= 0) {
834 }
else if ((asf->
dar[0].
num > 0) && (asf->
dar[0].
den > 0) &&
841 av_dlog(s,
"i=%d, st->codec->codec_type:%d, asf->dar %d:%d sar=%d:%d\n",
848 if (rfc1766 && strlen(rfc1766) > 1) {
849 const char primary_tag[3] = { rfc1766[0], rfc1766[1],
'\0' };
864 #define DO_2BITS(bits, var, defval) \
865 switch (bits & 3) { \
867 var = avio_rl32(pb); \
871 var = avio_rl16(pb); \
892 uint32_t packet_length, padsize;
908 if (c == 0x82 && !d && !e)
921 "ff asf bad header %x at:%"PRId64
"\n", c,
avio_tell(pb));
923 if ((c & 0x8f) == 0x82) {
944 if (!packet_length || packet_length >= (1
U << 29)) {
946 "invalid packet_length %d at:%"PRId64
"\n",
950 if (padsize >= packet_length) {
952 "invalid padsize %d at:%"PRId64
"\n", padsize,
avio_tell(pb));
968 if (rsize > packet_length - padsize) {
971 "invalid packet header length %d for pktlen %d-%d at %"PRId64
"\n",
972 rsize, packet_length, padsize,
avio_tell(pb));
976 if (packet_length < asf->hdr.min_pktsize)
979 av_dlog(s,
"packet: size=%d padsize=%d left=%d\n",
1000 asfst = &asf->
streams[num & 0x7f];
1005 av_dlog(asf,
"key:%d stream:%d seq:%d offset:%d replic_size:%d\n",
1184 "freeing incomplete packet size %d, new %d\n",
1207 av_dlog(asf,
"new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
1219 av_dlog(asf,
"READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n",
1229 "packet fragment position invalid %u,%u not in %u\n",
1238 if (ret < 0 || asf->packet_frag_offset + ret == 0)
1277 "pkt.size != ds_packet_size * ds_span (%d %d %d)\n",
1287 memset(newdata + asf_st->
pkt.
size, 0,
1289 while (offset < asf_st->pkt.
size) {
1291 int row = off / asf_st->
ds_span;
1292 int col = off % asf_st->
ds_span;
1296 memcpy(newdata + offset,
1309 #if FF_API_DESTRUCT_PACKET
1369 for (i = 0; i < 128; i++) {
1384 for (i = 0; i < 128; i++) {
1402 int64_t *ppos, int64_t pos_limit)
1408 int64_t pos = *ppos;
1482 int64_t itime, last_pos = -1;
1491 "itime:0x%"PRIx64
", pct:%d, ict:%d\n", itime, pct, ict);
1493 for (i = 0; i < ict; i++) {
1499 if (pos != last_pos) {
1501 pktnum, pktct, index_pts);
1513 int64_t pts,
int flags)
1567 .priv_class = &asf_class,
#define FRAME_HEADER_SIZE
const ff_asf_guid ff_asf_header
discard all frames except keyframes
static int asf_read_marker(AVFormatContext *s, int64_t size)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
void av_free_packet(AVPacket *pkt)
Free a packet.
const ff_asf_guid ff_asf_ext_stream_audio_stream
const ff_asf_guid ff_asf_ext_content_encryption
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
const ff_asf_guid ff_asf_codec_comment_header
const ff_asf_guid ff_asf_metadata_header
static void get_id3_tag(AVFormatContext *s, int len)
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
int64_t pos
byte position in stream, -1 if unknown
static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size)
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
static const AVClass asf_class
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
uint64_t data_offset
beginning of the first data packet
AVCodecContext * codec
Codec context associated with this stream.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
static int asf_read_metadata(AVFormatContext *s, int64_t size)
int index
stream index in AVFormatContext
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
int64_t packet_frag_timestamp
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
const ff_asf_guid ff_asf_command_stream
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
const ff_asf_guid ff_asf_ext_stream_header
int64_t data_offset
offset of the first packet
uint32_t min_pktsize
size of a data packet invalid if broadcasting
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static int asf_read_file_properties(AVFormatContext *s, int64_t size)
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
const ff_asf_guid ff_asf_data_header
int ffio_limit(AVIOContext *s, int size)
static int64_t start_time
const char * av_default_item_name(void *ctx)
Return the context name.
uint32_t flags
0x01 - broadcast 0x02 - seekable rest is reserved should be 0
const ff_asf_guid ff_asf_audio_stream
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
attribute_deprecated void(* destruct)(struct AVPacket *)
static const uint8_t offset[511][2]
static av_cold int end(AVCodecContext *avctx)
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
enum AVStreamParseType need_parsing
int id
Format-specific stream ID.
ASFStream streams[128]
it's max number and it's not that big
#define DO_2BITS(bits, var, defval)
ASFStream * asf_st
currently decoded stream
uint64_t send_time
time to send file, in 100-nanosecond units invalid if broadcasting (could be ignored) ...
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
static av_cold int read_close(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
struct AVPacket::@25 * side_data
Additional packet data that can be provided by the container.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
int asfid2avid[128]
conversion table from asf ID 2 AVStream ID
const OptionDef options[]
uint64_t file_size
in bytes invalid if broadcasting
ff_asf_guid guid
generated by client computer
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
const ff_asf_guid ff_asf_audio_conceal_none
static int asf_read_picture(AVFormatContext *s, int len)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const ff_asf_guid ff_asf_head1_guid
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
const ff_asf_guid ff_asf_simple_index_header
const ff_asf_guid ff_asf_head2_guid
void * priv_data
Format private data.
int ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size)
const char * av_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
const ff_asf_guid ff_asf_video_conceal_none
uint64_t data_object_size
size of the data object
#define av_unused
Disable warnings about deprecated features This is useful for sections of code kept for backward comp...
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
const char * ff_id3v2_picture_types[21]
int flags
A combination of AV_PKT_FLAG values.
static int asf_get_packet(AVFormatContext *s, AVIOContext *pb)
Load a single ASF packet into the demuxer.
static int asf_read_header(AVFormatContext *s)
uint32_t max_pktsize
shall be the same as for min_pktsize invalid if broadcasting
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
const CodecMime ff_id3v2_mime_tags[]
common internal API header
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
unsigned int nb_streams
A list of all streams in the file.
#define FF_ARRAY_ELEMS(a)
int bit_rate
the average bitrate
uint8_t * data
The data buffer.
Opaque data information usually continuous.
int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const
Rescale a 64-bit integer with rounding to nearest.
const ff_asf_guid ff_asf_digital_signature
const AVCodecTag ff_codec_bmp_tags[]
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() and chilren.
char stream_languages[128][6]
max number of streams, language for each (RFC1766, e.g. en-US)
int width
picture width / height.
const ff_asf_guid ff_asf_extended_content_header
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
unsigned int packet_frag_size
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
const ff_asf_guid ff_asf_ext_stream_embed_stream_header
const ff_asf_guid ff_asf_my_guid
static int asf_probe(AVProbeData *pd)
preferred ID for MPEG-1/2 video decoding
void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag, including supported extra metadata.
static int read_header(FFV1Context *f)
static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
uint32_t ignore
preroll is 64bit - but let's just ignore it
#define AV_LOG_INFO
Standard information.
uint32_t stream_bitrates[128]
max number of streams, bitrate for each (for streaming)
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
uint64_t create_time
time of creation, in 100-nanosecond units since 1.1.1601 invalid if broadcasting
enum AVMediaType codec_type
const ff_asf_guid ff_asf_file_header
uint64_t play_time
play time, in 100-nanosecond units invalid if broadcasting
static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
const ff_asf_guid ff_asf_video_stream
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
uint16_t stream_language_index
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
AVInputFormat ff_asf_demuxer
AVIOContext * pb
I/O context.
static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Describe the class of an AVClass context structure.
#define MKTAG(a, b, c, d)
rational number numerator/denominator
const ff_asf_guid ff_asf_stream_header
unsigned int packet_frag_offset
static void asf_build_simple_index(AVFormatContext *s, int stream_index)
static int asf_read_close(AVFormatContext *s)
const AVMetadataConv ff_asf_metadata_conv[]
static void skip_to_key(AVFormatContext *s)
Usually treated as AVMEDIA_TYPE_DATA.
uint64_t data_object_offset
data object offset (excl. GUID & size)
int error
contains the error code or 0 if no error happened
This structure contains the data a format has to probe a file.
static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size)
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb)
static int asf_read_content_desc(AVFormatContext *s, int64_t size)
const ff_asf_guid ff_asf_comment_header
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
int64_t duration
Decoding: duration of the stream, in stream time base.
uint32_t preroll
timestamp of the first packet, in milliseconds if nonzero - subtract from time
A reference to a data buffer.
const ff_asf_guid ff_asf_language_guid
const ff_asf_guid ff_asf_jfif_media
#define FF_DISABLE_DEPRECATION_WARNINGS
int disposition
AV_DISPOSITION_* bit field.
const ff_asf_guid ff_asf_codec_comment1_header
void ff_get_guid(AVIOContext *s, ff_asf_guid *g)
const ff_asf_guid ff_asf_content_encryption
#define AVERROR_INVALIDDATA
#define FF_ENABLE_DEPRECATION_WARNINGS
static int asf_read_language_list(AVFormatContext *s, int64_t size)
static int get_value(AVIOContext *pb, int type, int type2_size)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
static int asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Parse data from individual ASF packets (which were previously loaded with asf_get_packet()).
#define av_assert0(cond)
assert() equivalent, that is always enabled.
const ff_asf_guid ff_asf_marker_header
void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
Send a nice hexadecimal dump of a buffer to the log.
static void get_tag(AVFormatContext *s, const char *key, int type, int len, int type2_size)
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
static void asf_reset_header(AVFormatContext *s)
This structure stores compressed data.
uint32_t max_bitrate
bandwidth of stream in bps should be the sum of bitrates of the individual media streams ...
const ff_asf_guid ff_asf_metadata_library_header
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
#define AV_NOPTS_VALUE
Undefined timestamp value.
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...