Go to the documentation of this file.
137 #define ASF_MAX_STREAMS 127
138 #define FRAME_HEADER_SIZE 6
144 0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2
147 static const ff_asf_guid asf_audio_conceal_none = {
150 0x00, 0x57, 0xfb, 0x20, 0x55, 0x5B, 0xCF, 0x11, 0xa8, 0xfd, 0x00, 0x80, 0x5f, 0x5c, 0x44, 0x2b
153 #define PRINT_IF_GUID(g, cmp) \
154 if (!ff_guidcmp(g, &(cmp))) \
155 av_log(NULL, AV_LOG_TRACE, "(GUID: %s) ", # cmp)
164 else PRINT_IF_GUID(
g, asf_audio_conceal_none);
183 else PRINT_IF_GUID(
g, stream_bitrate_guid);
187 for (
i = 0;
i < 16;
i++)
193 #define print_guid(g) while(0)
264 "Unsupported value type %d in tag %s.\n",
type,
key);
308 int type_specific_size, sizeX;
311 int test_for_ext_stream_audio, is_dvr_ms_audio = 0;
336 test_for_ext_stream_audio = 0;
347 test_for_ext_stream_audio = 1;
363 if (test_for_ext_stream_audio) {
382 if (is_dvr_ms_audio) {
394 if (
size >= (pos2 + 8 - pos1 + 24)) {
451 if (tag1 ==
MKTAG(
'D',
'V',
'R',
' ')) {
479 int ext_len, payload_ext_ct, stream_ct,
i;
480 uint32_t leak_rate, stream_num;
481 unsigned int stream_languageid_index;
496 if (stream_num < 128)
503 if (stream_num < 128) {
508 for (
i = 0;
i < stream_ct;
i++) {
514 for (
i = 0;
i < payload_ext_ct;
i++) {
537 int len1, len2, len3, len4, len5;
546 get_tag(
s,
"copyright", 0, len3, 32);
557 int desc_count,
i,
ret;
560 for (
i = 0;
i < desc_count;
i++) {
561 int name_len, value_type, value_len;
571 if (!value_type && value_len % 2)
576 if (!strcmp(
name,
"AspectRatioX"))
578 else if (!strcmp(
name,
"AspectRatioY"))
593 for (j = 0; j < stream_count; j++) {
595 unsigned int lang_len =
avio_r8(pb);
597 sizeof(lang))) < lang_len)
611 int n, stream_num, name_len_utf16, name_len_utf8, value_len;
615 for (
i = 0;
i < n;
i++) {
625 if (value_len < 0 || value_len > UINT16_MAX)
628 name_len_utf8 = 2*name_len_utf16 + 1;
636 i, stream_num, name_len_utf16, value_type, value_len,
name);
638 if (!strcmp(
name,
"AspectRatioX")){
639 int aspect_x =
get_value(
s->pb, value_type, 16);
641 asf->
dar[stream_num].
num = aspect_x;
642 }
else if(!strcmp(
name,
"AspectRatioY")){
643 int aspect_y =
get_value(
s->pb, value_type, 16);
645 asf->
dar[stream_num].
den = aspect_y;
659 int i, count, name_len,
ret;
669 for (
i = 0;
i < count;
i++) {
683 if ((
unsigned)name_len > INT_MAX / 2)
686 sizeof(
name))) < name_len)
712 for (
i = 0;
i<128;
i++)
725 if (!(asf->
hdr.
flags & 0x01) && gsize >= 100)
767 "DRM protected stream detected, decoding will likely fail!\n");
777 if (
len > UINT16_MAX)
782 if (
len > UINT16_MAX)
787 if (
len > UINT16_MAX)
792 "Ext DRM protected stream detected, decoding will likely fail!\n");
793 av_dict_set(&
s->metadata,
"encryption",
"ASF Extended Content Encryption", 0);
804 "gpos mismatch our pos=%"PRIu64
", end=%"PRId64
"\n",
817 for (
i = 0;
i < 128;
i++) {
819 if (stream_num >= 0) {
827 }
else if ((asf->
dar[0].
num > 0) && (asf->
dar[0].
den > 0) &&
841 if (rfc1766 && strlen(rfc1766) > 1) {
842 const char primary_tag[3] = { rfc1766[0], rfc1766[1],
'\0' };
857 #define DO_2BITS(bits, var, defval) \
858 switch (bits & 3) { \
860 var = avio_rl32(pb); \
864 var = avio_rl16(pb); \
885 uint32_t packet_length, padsize;
902 if (
c == 0x82 && !d && !e)
915 "ff asf bad header %x at:%"PRId64
"\n",
c,
avio_tell(pb));
917 if ((
c & 0x8f) == 0x82) {
960 if (!packet_length || packet_length >= (1
U << 29)) {
962 "invalid packet_length %"PRIu32
" at:%"PRId64
"\n",
966 if (padsize >= packet_length) {
968 "invalid padsize %"PRIu32
" at:%"PRId64
"\n", padsize,
avio_tell(pb));
984 if (rsize > packet_length - padsize) {
987 "invalid packet header length %d for pktlen %"PRIu32
"-%"PRIu32
" at %"PRId64
"\n",
988 rsize, packet_length, padsize,
avio_tell(pb));
992 if (packet_length < asf->hdr.min_pktsize)
1016 asfst = &asf->
streams[num & 0x7f];
1021 av_log(asf,
AV_LOG_TRACE,
"key:%d stream:%d seq:%d offset:%d replic_size:%d num:%X packet_property %X\n",
1058 s->streams[asf->
stream_index]->sample_aspect_ratio = aspect;
1185 "stream:%d, expected:%d but got %d from pkt)\n",
1216 "freeing incomplete packet size %d, new %d\n",
1246 av_log(asf,
AV_LOG_TRACE,
"new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
1268 "packet fragment position invalid %u,%u not in %u\n",
1282 if (ret < 0 || asf->packet_frag_offset +
ret == 0)
1297 if (
s->key &&
s->keylen == 20)
1321 "pkt.size != ds_packet_size * ds_span (%d %d %d)\n",
1329 uint8_t *newdata = buf->
data;
1331 memset(newdata + asf_st->
pkt.
size, 0,
1333 while (offset < asf_st->
pkt.
size) {
1335 int row = off / asf_st->
ds_span;
1336 int col = off % asf_st->
ds_span;
1407 for (
i = 0;
i < 128;
i++) {
1422 for (
i = 0;
i < 128;
i++) {
1451 for (
i = 0;
i <
s->nb_streams;
i++)
1454 if (
s->packet_size > 0)
1456 s->packet_size *
s->packet_size +
1475 asf_st = &asf->
streams[
s->streams[
i]->id];
1534 "itime:0x%"PRIx64
", pct:%d, ict:%d\n", itime, pct, ict);
1536 for (
i = 0;
i < ict;
i++) {
1547 if (
pos != last_pos) {
1549 pktnum, pktct, index_pts);
1569 AVStream *st =
s->streams[stream_index];
1573 if (
s->packet_size <= 0)
AVChapter * avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
static const AVClass asf_class
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
#define AV_LOG_WARNING
Something somehow does not look correct.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and FFInputFormat.read_timestamp().
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
enum AVMediaType codec_type
General type of the encoded data.
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
uint64_t send_time
time to send file, in 100-nanosecond units invalid if broadcasting (could be ignored)
#define AVERROR_EOF
End of file.
uint8_t * data
The data buffer.
const ff_asf_guid ff_asf_audio_stream
static void skip_to_key(AVFormatContext *s)
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()).
const ff_asf_guid ff_asf_simple_index_header
static int asf_read_ext_stream_properties(AVFormatContext *s)
uint32_t preroll
timestamp of the first packet, in milliseconds if nonzero - subtract from time
static int asf_build_simple_index(AVFormatContext *s, int stream_index)
int error
contains the error code or 0 if no error happened
int ff_get_wav_header(void *logctx, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
#define AV_LOG_VERBOSE
Detailed information.
const AVCodecTag ff_codec_bmp_tags_unofficial[]
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
uint64_t data_offset
beginning of the first data packet
int64_t avio_size(AVIOContext *s)
Get the filesize.
static int asf_read_content_desc(AVFormatContext *s)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static int asf_read_file_properties(AVFormatContext *s)
static int asf_get_packet(AVFormatContext *s, AVIOContext *pb)
Load a single ASF packet into the demuxer.
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
unsigned int packet_frag_size
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
uint32_t flags
0x01 - broadcast 0x02 - seekable rest is reserved should be 0
uint32_t stream_bitrates[128]
max number of streams, bitrate for each (for streaming)
ASFStream streams[128]
it's max number and it's not that big
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.
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
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.
uint64_t data_object_size
size of the data object
static av_cold int read_close(AVFormatContext *ctx)
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
const FFInputFormat ff_asf_demuxer
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
int64_t duration
Decoding: duration of the stream, in stream time base.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
unsigned int avio_rl16(AVIOContext *s)
uint64_t create_time
time of creation, in 100-nanosecond units since 1.1.1601 invalid if broadcasting
const ff_asf_guid ff_asf_ext_stream_header
static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int get_value(AVIOContext *pb, int type, int type2_size)
#define FF_ARRAY_ELEMS(a)
static int asf_read_close(AVFormatContext *s)
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
ASFStream * asf_st
currently decoded stream
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.
int64_t packet_frag_timestamp
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
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_language_guid
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
const ff_asf_guid ff_asf_video_stream
#define DO_2BITS(bits, var, defval)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static int asf_probe(const AVProbeData *pd)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
unsigned int packet_frag_offset
int64_t data_offset
offset of the first packet
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
static int asf_read_marker(AVFormatContext *s)
const ff_asf_guid ff_asf_codec_comment1_header
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
static int64_t fsize(FILE *f)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
enum AVStreamParseType need_parsing
@ AVDISCARD_ALL
discard all
const ff_asf_guid ff_asf_extended_content_header
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
#define LIBAVUTIL_VERSION_INT
static int read_header(FFV1Context *f)
Describe the class of an AVClass context structure.
ff_asf_guid guid
generated by client computer
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
const AVMetadataConv ff_asf_metadata_conv[]
Rational number (pair of numerator and denominator).
const ff_asf_guid ff_asf_head1_guid
const char * av_default_item_name(void *ptr)
Return the context name.
uint32_t ignore
preroll is 64 bits - but let's just ignore it
This structure contains the data a format has to probe a file.
char stream_languages[128][6]
max number of streams, language for each (RFC1766, e.g. en-US)
uint64_t play_time
play time, in 100-nanosecond units invalid if broadcasting
const ff_asf_guid ff_asf_data_header
int ff_asf_handle_byte_array(AVFormatContext *s, const char *name, int val_len)
Handles both attached pictures as well as id3 tags.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int extradata_size
Size of the extradata content in bytes.
static const AVOption options[]
const ff_asf_guid ff_asf_file_header
const ff_asf_guid ff_asf_video_conceal_none
unsigned int avio_rl32(AVIOContext *s)
@ AVDISCARD_NONKEY
discard all frames except keyframes
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
static int64_t start_time
#define AV_NOPTS_VALUE
Undefined timestamp value.
uint32_t min_pktsize
size of a data packet invalid if broadcasting
uint32_t max_pktsize
shall be the same as for min_pktsize invalid if broadcasting
#define FRAME_HEADER_SIZE
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
int avio_r8(AVIOContext *s)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int flags
A combination of AV_PKT_FLAG values.
uint64_t data_object_offset
data object offset (excl. GUID & size)
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
const ff_asf_guid ff_asf_digital_signature
#define AV_LOG_INFO
Standard information.
int64_t packet_time_start
int ffio_limit(AVIOContext *s, int size)
const ff_asf_guid ff_asf_comment_header
const ff_asf_guid ff_asf_jfif_media
const ff_asf_guid ff_asf_ext_stream_audio_stream
static int asf_read_ext_content_desc(AVFormatContext *s)
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
const ff_asf_guid ff_asf_ext_stream_embed_stream_header
const ff_asf_guid ff_asf_my_guid
const ff_asf_guid ff_asf_codec_comment_header
uint16_t stream_language_index
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
const ff_asf_guid ff_asf_content_encryption
static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
const ff_asf_guid ff_asf_head2_guid
int id
Format-specific stream ID.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
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.
uint64_t file_size
in bytes invalid if broadcasting
const ff_asf_guid ff_asf_stream_header
static int asf_read_metadata(AVFormatContext *s)
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
#define AV_INPUT_BUFFER_PADDING_SIZE
int asfid2avid[128]
conversion table from asf ID 2 AVStream ID
const AVCodecTag ff_codec_bmp_tags[]
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
static void asf_reset_header(AVFormatContext *s)
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
static int read_probe(const AVProbeData *p)
int bits_per_coded_sample
The number of bits per sample in the codedwords.
const ff_asf_guid ff_asf_marker_header
A reference to a data buffer.
uint32_t max_bitrate
bandwidth of stream in bps should be the sum of bitrates of the individual media streams
#define avpriv_request_sample(...)
static void get_tag(AVFormatContext *s, const char *key, int type, int len, int type2_size)
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
const ff_asf_guid ff_asf_ext_content_encryption
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
This structure stores compressed data.
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
int64_t pos
byte position in stream, -1 if unknown
const ff_asf_guid ff_asf_metadata_library_header
uint64_t avio_rl64(AVIOContext *s)
const ff_asf_guid ff_asf_metadata_header
#define flags(name, subs,...)
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.
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define MKTAG(a, b, c, d)
static int64_t read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
const ff_asf_guid ff_asf_header
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
static int asf_read_language_list(AVFormatContext *s)
void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len)
static int asf_read_header(AVFormatContext *s)
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_command_stream
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.