136 #define ASF_MAX_STREAMS 127
137 #define FRAME_HEADER_SIZE 6
143 0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2
146 static const ff_asf_guid asf_audio_conceal_none = {
149 0x00, 0x57, 0xfb, 0x20, 0x55, 0x5B, 0xCF, 0x11, 0xa8, 0xfd, 0x00, 0x80, 0x5f, 0x5c, 0x44, 0x2b
152 #define PRINT_IF_GUID(g, cmp) \
153 if (!ff_guidcmp(g, &cmp)) \
154 av_log(NULL, AV_LOG_TRACE, "(GUID: %s) ", # cmp)
163 else PRINT_IF_GUID(
g, asf_audio_conceal_none);
182 else PRINT_IF_GUID(
g, stream_bitrate_guid);
186 for (
i = 0;
i < 16;
i++)
192 #define print_guid(g) while(0)
232 int ret,
type, picsize, desc_len;
235 if (
len < 1 + 4 + 2 + 2) {
255 if (!strncmp(mime->
str, mimetype,
sizeof(mimetype))) {
267 if (picsize >=
len) {
274 desc_len = (
len - picsize) * 2 + 1;
316 if (id3v2_extra_meta) {
348 if (!strcmp(
key,
"WM/Picture")) {
350 }
else if (!strcmp(
key,
"ID3")) {
369 "Unsupported value type %d in tag %s.\n",
type,
key);
412 int type_specific_size, sizeX;
415 int test_for_ext_stream_audio, is_dvr_ms_audio = 0;
439 test_for_ext_stream_audio = 0;
450 test_for_ext_stream_audio = 1;
466 if (test_for_ext_stream_audio) {
485 if (is_dvr_ms_audio) {
497 if (
size >= (pos2 + 8 - pos1 + 24)) {
552 if (tag1 ==
MKTAG(
'D',
'V',
'R',
' ')) {
578 int ext_len, payload_ext_ct, stream_ct,
i;
579 uint32_t leak_rate, stream_num;
580 unsigned int stream_languageid_index;
595 if (stream_num < 128)
602 if (stream_num < 128) {
607 for (
i = 0;
i < stream_ct;
i++) {
613 for (
i = 0;
i < payload_ext_ct;
i++) {
636 int len1, len2, len3, len4, len5;
645 get_tag(
s,
"copyright", 0, len3, 32);
656 int desc_count,
i, ret;
659 for (
i = 0;
i < desc_count;
i++) {
660 int name_len, value_type, value_len;
670 if (!value_type && value_len % 2)
675 if (!strcmp(
name,
"AspectRatioX"))
677 else if (!strcmp(
name,
"AspectRatioY"))
692 for (j = 0; j < stream_count; j++) {
694 unsigned int lang_len =
avio_r8(pb);
696 sizeof(lang))) < lang_len)
710 int n, stream_num, name_len_utf16, name_len_utf8, value_len;
714 for (
i = 0;
i < n;
i++) {
724 if (value_len < 0 || value_len > UINT16_MAX)
727 name_len_utf8 = 2*name_len_utf16 + 1;
735 i, stream_num, name_len_utf16, value_type, value_len,
name);
737 if (!strcmp(
name,
"AspectRatioX")){
738 int aspect_x =
get_value(
s->pb, value_type, 16);
740 asf->
dar[stream_num].
num = aspect_x;
741 }
else if(!strcmp(
name,
"AspectRatioY")){
742 int aspect_y =
get_value(
s->pb, value_type, 16);
744 asf->
dar[stream_num].
den = aspect_y;
758 int i, count, name_len, ret;
768 for (
i = 0;
i < count;
i++) {
782 if ((
unsigned)name_len > INT_MAX / 2)
785 sizeof(
name))) < name_len)
811 for (
i = 0;
i<128;
i++)
824 if (!(asf->
hdr.
flags & 0x01) && gsize >= 100)
866 "DRM protected stream detected, decoding will likely fail!\n");
876 if (
len > UINT16_MAX)
881 if (
len > UINT16_MAX)
886 if (
len > UINT16_MAX)
891 "Ext DRM protected stream detected, decoding will likely fail!\n");
892 av_dict_set(&
s->metadata,
"encryption",
"ASF Extended Content Encryption", 0);
903 "gpos mismatch our pos=%"PRIu64
", end=%"PRId64
"\n",
916 for (
i = 0;
i < 128;
i++) {
918 if (stream_num >= 0) {
926 }
else if ((asf->
dar[0].
num > 0) && (asf->
dar[0].
den > 0) &&
940 if (rfc1766 && strlen(rfc1766) > 1) {
941 const char primary_tag[3] = { rfc1766[0], rfc1766[1],
'\0' };
956 #define DO_2BITS(bits, var, defval) \
957 switch (bits & 3) { \
959 var = avio_rl32(pb); \
963 var = avio_rl16(pb); \
984 uint32_t packet_length, padsize;
1001 if (
c == 0x82 && !d && !e)
1014 "ff asf bad header %x at:%"PRId64
"\n",
c,
avio_tell(pb));
1016 if ((
c & 0x8f) == 0x82) {
1059 if (!packet_length || packet_length >= (1U << 29)) {
1061 "invalid packet_length %"PRIu32
" at:%"PRId64
"\n",
1065 if (padsize >= packet_length) {
1067 "invalid padsize %"PRIu32
" at:%"PRId64
"\n", padsize,
avio_tell(pb));
1083 if (rsize > packet_length - padsize) {
1086 "invalid packet header length %d for pktlen %"PRIu32
"-%"PRIu32
" at %"PRId64
"\n",
1087 rsize, packet_length, padsize,
avio_tell(pb));
1091 if (packet_length < asf->hdr.min_pktsize)
1115 asfst = &asf->
streams[num & 0x7f];
1120 av_log(asf,
AV_LOG_TRACE,
"key:%d stream:%d seq:%d offset:%d replic_size:%d num:%X packet_property %X\n",
1157 s->streams[asf->
stream_index]->sample_aspect_ratio = aspect;
1284 "stream:%d, expected:%d but got %d from pkt)\n",
1315 "freeing incomplete packet size %d, new %d\n",
1345 av_log(asf,
AV_LOG_TRACE,
"new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
1367 "packet fragment position invalid %u,%u not in %u\n",
1381 if (ret < 0 || asf->packet_frag_offset + ret == 0)
1396 if (
s->key &&
s->keylen == 20)
1420 "pkt.size != ds_packet_size * ds_span (%d %d %d)\n",
1430 memset(newdata + asf_st->
pkt.
size, 0,
1432 while (offset < asf_st->
pkt.
size) {
1434 int row = off / asf_st->
ds_span;
1435 int col = off % asf_st->
ds_span;
1506 for (
i = 0;
i < 128;
i++) {
1521 for (
i = 0;
i < 128;
i++) {
1539 int64_t *ppos, int64_t pos_limit)
1545 int64_t
pos = *ppos;
1549 for (
i = 0;
i <
s->nb_streams;
i++)
1552 if (
s->packet_size > 0)
1553 pos = (
pos +
s->packet_size - 1 -
s->internal->data_offset) /
1554 s->packet_size *
s->packet_size +
1555 s->internal->data_offset;
1573 asf_st = &asf->
streams[
s->streams[
i]->id];
1622 int64_t itime, last_pos = -1;
1632 "itime:0x%"PRIx64
", pct:%d, ict:%d\n", itime, pct, ict);
1634 for (
i = 0;
i < ict;
i++) {
1637 int64_t
pos =
s->internal->data_offset +
s->packet_size * (int64_t)pktnum;
1645 if (
pos != last_pos) {
1647 pktnum, pktct, index_pts);
1667 AVStream *st =
s->streams[stream_index];
1670 if (
s->packet_size <= 0)
1685 avio_seek(
s->pb,
s->internal->data_offset, SEEK_SET);
const ff_asf_guid ff_asf_video_conceal_none
const ff_asf_guid ff_asf_codec_comment1_header
const ff_asf_guid ff_asf_video_stream
const ff_asf_guid ff_asf_ext_stream_header
const AVMetadataConv ff_asf_metadata_conv[]
const ff_asf_guid ff_asf_stream_header
const ff_asf_guid ff_asf_command_stream
const ff_asf_guid ff_asf_ext_stream_audio_stream
const ff_asf_guid ff_asf_language_guid
const ff_asf_guid ff_asf_header
const ff_asf_guid ff_asf_audio_stream
const ff_asf_guid ff_asf_simple_index_header
const ff_asf_guid ff_asf_ext_stream_embed_stream_header
const ff_asf_guid ff_asf_content_encryption
const ff_asf_guid ff_asf_extended_content_header
const ff_asf_guid ff_asf_head1_guid
const ff_asf_guid ff_asf_head2_guid
const ff_asf_guid ff_asf_marker_header
const ff_asf_guid ff_asf_metadata_library_header
const ff_asf_guid ff_asf_data_header
const ff_asf_guid ff_asf_jfif_media
const ff_asf_guid ff_asf_digital_signature
const ff_asf_guid ff_asf_ext_content_encryption
const ff_asf_guid ff_asf_codec_comment_header
const ff_asf_guid ff_asf_my_guid
const ff_asf_guid ff_asf_file_header
const ff_asf_guid ff_asf_comment_header
const ff_asf_guid ff_asf_metadata_header
void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len)
static int asf_read_picture(AVFormatContext *s, int len)
static void get_id3_tag(AVFormatContext *s, int len)
static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb)
static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
static void asf_reset_header(AVFormatContext *s)
static const AVOption options[]
static int asf_read_header(AVFormatContext *s)
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
static int asf_read_marker(AVFormatContext *s, int64_t size)
static int asf_read_language_list(AVFormatContext *s, int64_t size)
static void get_tag(AVFormatContext *s, const char *key, int type, int len, int type2_size)
static const AVClass asf_class
#define DO_2BITS(bits, var, defval)
#define FRAME_HEADER_SIZE
static int asf_build_simple_index(AVFormatContext *s, int stream_index)
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()).
static int get_value(AVIOContext *pb, int type, int type2_size)
static void skip_to_key(AVFormatContext *s)
static int asf_get_packet(AVFormatContext *s, AVIOContext *pb)
Load a single ASF packet into the demuxer.
static int asf_probe(const AVProbeData *pd)
static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size)
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size)
static int asf_read_close(AVFormatContext *s)
static int asf_read_metadata(AVFormatContext *s, int64_t size)
static int asf_read_file_properties(AVFormatContext *s, int64_t size)
AVInputFormat ff_asf_demuxer
static int asf_read_content_desc(AVFormatContext *s, int64_t size)
Macro definitions for various function/variable attributes.
static int64_t fsize(FILE *f)
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
int64_t avio_size(AVIOContext *s)
Get the filesize.
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
unsigned int avio_rl16(AVIOContext *s)
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
unsigned int avio_rl32(AVIOContext *s)
int64_t avio_seek_time(AVIOContext *h, int stream_index, int64_t timestamp, int flags)
Seek to a given timestamp relative to some component stream.
int avio_r8(AVIOContext *s)
uint64_t avio_rl64(AVIOContext *s)
int ffio_limit(AVIOContext *s, int size)
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t size)
#define flags(name, subs,...)
common internal and external API header
#define MKTAG(a, b, c, d)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static int64_t start_time
static int read_header(FFV1Context *f)
AVCodecID
Identify the syntax and semantics of the bitstream.
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
@ AVDISCARD_ALL
discard all
@ AVDISCARD_NONKEY
discard all frames except keyframes
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
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.
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.
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
AVBufferRef * av_buffer_alloc(buffer_size_t size)
Allocate an AVBuffer of the given size using av_malloc().
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AVERROR_EOF
End of file.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
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.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define LIBAVUTIL_VERSION_INT
void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
Read an ID3v2 tag, including supported extra metadata.
const char *const ff_id3v2_picture_types[21]
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header.
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
const CodecMime ff_id3v2_mime_tags[]
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static av_cold int read_close(AVFormatContext *ctx)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
const AVCodecTag ff_codec_bmp_tags[]
internal header for RIFF based (de)muxers do NOT include this in end user applications
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
#define FF_ARRAY_ELEMS(a)
char stream_languages[128][6]
max number of streams, language for each (RFC1766, e.g. en-US)
unsigned int packet_frag_size
ASFStream * asf_st
currently decoded stream
ASFStream streams[128]
it's max number and it's not that big
int64_t packet_frag_timestamp
uint64_t data_offset
beginning of the first data packet
uint64_t data_object_offset
data object offset (excl. GUID & size)
int asfid2avid[128]
conversion table from asf ID 2 AVStream ID
int64_t packet_time_start
uint32_t stream_bitrates[128]
max number of streams, bitrate for each (for streaming)
unsigned int packet_frag_offset
uint64_t data_object_size
size of the data object
uint64_t create_time
time of creation, in 100-nanosecond units since 1.1.1601 invalid if broadcasting
uint32_t min_pktsize
size of a data packet invalid if broadcasting
uint32_t ignore
preroll is 64 bits - but let's just ignore it
ff_asf_guid guid
generated by client computer
uint32_t max_pktsize
shall be the same as for min_pktsize invalid if broadcasting
uint64_t send_time
time to send file, in 100-nanosecond units invalid if broadcasting (could be ignored)
uint32_t max_bitrate
bandwidth of stream in bps should be the sum of bitrates of the individual media streams
uint32_t flags
0x01 - broadcast 0x02 - seekable rest is reserved should be 0
uint64_t file_size
in bytes invalid if broadcasting
uint64_t play_time
play time, in 100-nanosecond units invalid if broadcasting
uint32_t preroll
timestamp of the first packet, in milliseconds if nonzero - subtract from time
uint16_t stream_language_index
A reference to a data buffer.
uint8_t * data
The data buffer.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int extradata_size
Size of the extradata content in bytes.
int bits_per_coded_sample
The number of bits per sample in the codedwords.
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
enum AVMediaType codec_type
General type of the encoded data.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
int error
contains the error code or 0 if no error happened
This structure stores compressed data.
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
int flags
A combination of AV_PKT_FLAG values.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
int64_t pos
byte position in stream, -1 if unknown
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
This structure contains the data a format has to probe a file.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Rational number (pair of numerator and denominator).
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
AVCodecParameters * codecpar
Codec parameters associated with this stream.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int64_t duration
Decoding: duration of the stream, in stream time base.
int id
Format-specific stream ID.
int index
stream index in AVFormatContext
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
enum AVStreamParseType need_parsing
AVStreamInternal * internal
An opaque field for libavformat internal usage.
int disposition
AV_DISPOSITION_* bit field.
#define avpriv_request_sample(...)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const uint8_t offset[127][2]