68 uint32_t palette[256];
78 uint32_t stream_bitrates[128];
80 char stream_languages[128][6];
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) {
332 if (!asf->
export_xmp && !strncmp(key,
"xmp", 3))
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;
435 (10000000 / 1000) - start_time;
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)) {
511 size - (
avio_tell(pb) - pos1 + 24) >= 51) {
525 if (size < sizeX - 40)
552 if (tag1 ==
MKTAG(
'D',
'V',
'R',
' ')) {
568 avio_skip(pb, size - (pos2 - pos1 + 24));
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;
643 get_tag(s,
"title", 0, len1, 32);
644 get_tag(s,
"author", 0, len2, 32);
645 get_tag(s,
"copyright", 0, len3, 32);
646 get_tag(s,
"comment", 0, len4, 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"))
680 get_tag(s, name, value_type, value_len, 32);
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;
732 if ((ret =
avio_get_str16le(pb, name_len_utf16, name, name_len_utf8)) < name_len_utf16)
735 i, stream_num, name_len_utf16, value_type, value_len, name);
737 if (!strcmp(name,
"AspectRatioX")){
740 asf->
dar[stream_num].
num = aspect_x;
741 }
else if(!strcmp(name,
"AspectRatioY")){
744 asf->
dar[stream_num].
den = aspect_y;
746 get_tag(s, name, value_type, value_len, 16);
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)
878 get_tag(s,
"ASF_Protection_Type", -1, len, 32);
881 if (len > UINT16_MAX)
883 get_tag(s,
"ASF_Key_ID", -1, len, 32);
886 if (len > UINT16_MAX)
888 get_tag(s,
"ASF_License_URL", -1, len, 32);
891 "Ext DRM protected stream detected, decoding will likely fail!\n");
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) &&
933 av_log(s,
AV_LOG_TRACE,
"i=%d, st->codecpar->codec_type:%d, asf->dar %d:%d sar=%d:%d\n",
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 >= (1
U << 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",
1284 "stream:%d, expected:%d but got %d from pkt)\n",
1315 "freeing incomplete packet size %d, new %d\n",
1343 av_log(asf,
AV_LOG_TRACE,
"new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
1365 "packet fragment position invalid %u,%u not in %u\n",
1379 if (ret < 0 || asf->packet_frag_offset + ret == 0)
1418 "pkt.size != ds_packet_size * ds_span (%d %d %d)\n",
1428 memset(newdata + asf_st->
pkt.
size, 0,
1430 while (offset < asf_st->pkt.
size) {
1432 int row = off / asf_st->
ds_span;
1433 int col = off % asf_st->
ds_span;
1437 memcpy(newdata + offset,
1504 for (i = 0; i < 128; i++) {
1519 for (i = 0; i < 128; i++) {
1537 int64_t *ppos, int64_t pos_limit)
1543 int64_t
pos = *ppos;
1620 int64_t itime, last_pos = -1;
1630 "itime:0x%"PRIx64
", pct:%d, ict:%d\n", itime, pct, ict);
1632 for (i = 0; i < ict; i++) {
1643 if (pos != last_pos) {
1645 pktnum, pktct, index_pts);
1727 .priv_class = &asf_class,
const ff_asf_guid ff_asf_header
discard all frames except keyframes
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size)
int64_t avio_size(AVIOContext *s)
Get the filesize.
#define DO_2BITS(bits, var, defval)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
const ff_asf_guid ff_asf_ext_stream_audio_stream
const ff_asf_guid ff_asf_ext_content_encryption
static void skip_to_key(AVFormatContext *s)
static int asf_read_language_list(AVFormatContext *s, int64_t size)
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
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
int64_t pos
byte position in stream, -1 if unknown
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
#define avpriv_request_sample(...)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
uint64_t data_offset
beginning of the first data packet
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int index
stream index in AVFormatContext
static int asf_read_file_properties(AVFormatContext *s, int64_t size)
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
const char * av_default_item_name(void *ptr)
Return the context name.
AVFormatInternal * internal
An opaque field for libavformat internal usage.
int64_t packet_frag_timestamp
const ff_asf_guid ff_asf_command_stream
static int asf_probe(const AVProbeData *pd)
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
#define FF_ARRAY_ELEMS(a)
const ff_asf_guid ff_asf_ext_stream_header
static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
uint32_t min_pktsize
size of a data packet invalid if broadcasting
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.
Macro definitions for various function/variable attributes.
const ff_asf_guid ff_asf_data_header
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ffio_limit(AVIOContext *s, int size)
static int64_t start_time
uint32_t flags
0x01 - broadcast 0x02 - seekable rest is reserved should be 0
Opaque data information usually continuous.
const ff_asf_guid ff_asf_audio_stream
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
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
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
enum AVStreamParseType need_parsing
int id
Format-specific stream ID.
GLsizei GLboolean const GLfloat * value
ASFStream streams[128]
it's max number and it's not that big
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
AVStream ** streams
A list of all streams in the file.
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
uint64_t send_time
time to send file, in 100-nanosecond units invalid if broadcasting (could be ignored) ...
#define AVERROR_EOF
End of file.
static av_cold int read_close(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
static int asf_read_marker(AVFormatContext *s, int64_t size)
int asfid2avid[128]
conversion table from asf ID 2 AVStream ID
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
uint64_t file_size
in bytes invalid if broadcasting
ff_asf_guid guid
generated by client computer
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static int asf_read_metadata(AVFormatContext *s, int64_t size)
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
#define FRAME_HEADER_SIZE
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVDictionary * metadata
Metadata that applies to the whole file.
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
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.
static const AVOption options[]
static int asf_build_simple_index(AVFormatContext *s, int stream_index)
const ff_asf_guid ff_asf_simple_index_header
const ff_asf_guid ff_asf_head2_guid
unsigned int avio_rl32(AVIOContext *s)
const char * ff_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. ...
static int asf_read_picture(AVFormatContext *s, int len)
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.
enum AVMediaType codec_type
General type of the encoded data.
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
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
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
static int asf_read_content_desc(AVFormatContext *s, int64_t size)
static const AVClass asf_class
uint64_t data_object_size
size of the data object
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.
int flags
A combination of AV_PKT_FLAG values.
int extradata_size
Size of the extradata content in bytes.
int avio_r8(AVIOContext *s)
uint32_t max_pktsize
shall be the same as for min_pktsize invalid if broadcasting
static int asf_read_close(AVFormatContext *s)
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
const CodecMime ff_id3v2_mime_tags[]
common internal API header
static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
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_digital_signature
static void get_id3_tag(AVFormatContext *s, int len)
const AVCodecTag ff_codec_bmp_tags[]
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
char stream_languages[128][6]
max number of streams, language for each (RFC1766, e.g. en-US)
const ff_asf_guid ff_asf_extended_content_header
ASFStream * asf_st
currently decoded stream
unsigned int packet_frag_size
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
const ff_asf_guid ff_asf_ext_stream_embed_stream_header
const ff_asf_guid ff_asf_my_guid
Usually treated as AVMEDIA_TYPE_DATA.
static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb)
preferred ID for MPEG-1/2 video decoding
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
static int read_header(FFV1Context *f)
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
uint32_t ignore
preroll is 64 bits - 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)
uint64_t create_time
time of creation, in 100-nanosecond units since 1.1.1601 invalid if broadcasting
AVStreamInternal * internal
An opaque field for libavformat internal usage.
const ff_asf_guid ff_asf_file_header
uint64_t play_time
play time, in 100-nanosecond units invalid if broadcasting
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
AVIOContext * pb
I/O context.
const ff_asf_guid ff_asf_video_stream
AVInputFormat ff_asf_demuxer
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
uint8_t * data
The data buffer.
uint16_t stream_language_index
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
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.
Rational number (pair of numerator and denominator).
const ff_asf_guid ff_asf_stream_header
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
unsigned int packet_frag_offset
const AVMetadataConv ff_asf_metadata_conv[]
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 void get_tag(AVFormatContext *s, const char *key, int type, int len, int type2_size)
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
const ff_asf_guid ff_asf_comment_header
#define flags(name, subs,...)
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
unsigned int avio_rl16(AVIOContext *s)
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
const ff_asf_guid ff_asf_jfif_media
common internal and external API header
static int asf_read_header(AVFormatContext *s)
int disposition
AV_DISPOSITION_* bit field.
const ff_asf_guid ff_asf_codec_comment1_header
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.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
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.
const ff_asf_guid ff_asf_content_encryption
static av_always_inline int diff(const uint32_t a, const uint32_t b)
void * priv_data
Format private data.
int bits_per_coded_sample
The number of bits per sample in the codedwords.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
AVCodecParameters * codecpar
Codec parameters associated with this stream.
const char *const ff_id3v2_picture_types[21]
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
static int64_t fsize(FILE *f)
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 int asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Parse data from individual ASF packets (which were previously loaded with asf_get_packet()).
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
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
#define MKTAG(a, b, c, d)
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)
This structure stores compressed data.
uint64_t avio_rl64(AVIOContext *s)
uint32_t max_bitrate
bandwidth of stream in bps should be the sum of bitrates of the individual media streams ...
static int asf_get_packet(AVFormatContext *s, AVIOContext *pb)
Load a single ASF packet into the demuxer.
const ff_asf_guid ff_asf_metadata_library_header
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size)
static int get_value(AVIOContext *pb, int type, int type2_size)
#define AV_NOPTS_VALUE
Undefined timestamp value.
static void asf_reset_header(AVFormatContext *s)