283 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
284 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
285 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
286 static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
289 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
290 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
291 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
292 static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
293 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
294 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
295 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
296 static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
297 static const uint8_t mxf_indirect_value_utf16be[] = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
299 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
304 switch ((*ctx)->type) {
343 int bytes_num = size & 0x7f;
349 size = size << 8 |
avio_r8(pb);
357 for (i = 0; i < size && !
avio_feof(pb); i++) {
361 else if (b != key[i])
375 return klv->
length == -1 ? -1 : 0;
395 const uint8_t *buf_ptr, *end_ptr;
404 data_ptr = pkt->
data;
406 buf_ptr = pkt->
data + 4;
409 uint32_t
sample = bytestream_get_le32(&buf_ptr);
411 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
413 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
423 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
429 uint64_t plaintext_size;
456 if (orig_size < plaintext_size)
460 if (size < 32 || size - 32 < orig_size)
466 if (memcmp(tmpbuf, checkv, 16))
472 else if (size < plaintext_size)
474 size -= plaintext_size;
477 &pkt->
data[plaintext_size], size >> 4, ivec, 1);
490 if (item_len != 18) {
494 if (item_num > 65536 || item_num < 0) {
515 uint64_t footer_partition;
516 uint32_t nb_essence_containers;
535 memset(partition, 0,
sizeof(*partition));
577 "PreviousPartition equal to ThisPartition %"PRIx64
"\n",
590 "Overriding PreviousPartition with %"PRIx64
"\n",
595 if (footer_partition) {
598 "inconsistent FooterPartition value: %"PRIu64
" != %"PRIu64
"\n",
606 "PartitionPack: ThisPartition = 0x%"PRIX64
607 ", PreviousPartition = 0x%"PRIX64
", "
608 "FooterPartition = 0x%"PRIX64
", IndexSID = %i, BodySID = %i\n",
618 "PreviousPartition points to this partition or forward\n");
622 if (op[12] == 1 && op[13] == 1) mxf->
op =
OP1a;
623 else if (op[12] == 1 && op[13] == 2) mxf->
op =
OP1b;
624 else if (op[12] == 1 && op[13] == 3) mxf->
op =
OP1c;
625 else if (op[12] == 2 && op[13] == 1) mxf->
op =
OP2a;
626 else if (op[12] == 2 && op[13] == 2) mxf->
op =
OP2b;
627 else if (op[12] == 2 && op[13] == 3) mxf->
op =
OP2c;
628 else if (op[12] == 3 && op[13] == 1) mxf->
op =
OP3a;
629 else if (op[12] == 3 && op[13] == 2) mxf->
op =
OP3b;
630 else if (op[12] == 3 && op[13] == 3) mxf->
op =
OP3c;
631 else if (op[12] == 64&& op[13] == 1) mxf->
op =
OPSONYOpt;
632 else if (op[12] == 0x10) {
637 if (nb_essence_containers != 1) {
643 "\"OPAtom\" with %"PRIu32
" ECs - assuming %s\n",
644 nb_essence_containers,
645 op ==
OP1a ?
"OP1a" :
"OPAtom");
651 av_log(mxf->
fc,
AV_LOG_ERROR,
"unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
832 buf_size = size + size / 2 + 1;
850 #define READ_STR16(type, big_endian) \
851 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
853 return mxf_read_utf16_string(pb, size, str, big_endian); \
865 &package->tracks_count);
872 avio_read(pb, package->descriptor_ref, 16);
875 return mxf_read_utf16be_string(pb, size, &package->name);
878 &package->comment_count);
952 int code,
value, ofs = 0;
961 layout[ofs++] = code;
962 layout[ofs++] =
value;
1068 return mxf_read_utf16le_string(pb, size - 17, &tagged_value->
value);
1070 return mxf_read_utf16be_string(pb, size - 17, &tagged_value->
value);
1080 return mxf_read_utf16be_string(pb, size, &tagged_value->
name);
1094 for (i = 0; i <
len; i++) {
1095 if (i != 7 && key[i] != uid[i])
1103 while (uls->
uid[0]) {
1128 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14,
AV_CODEC_ID_JPEG2000 },
1129 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14,
AV_CODEC_ID_H264 },
1130 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14,
AV_CODEC_ID_VC1 },
1131 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14,
AV_CODEC_ID_MPEG2VIDEO },
1132 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14,
AV_CODEC_ID_MPEG2VIDEO },
1133 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,
AV_CODEC_ID_DVVIDEO },
1134 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,
AV_CODEC_ID_RAWVIDEO },
1135 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14,
AV_CODEC_ID_RAWVIDEO },
1136 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1141 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14,
AV_CODEC_ID_MPEG2VIDEO },
1142 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1147 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14,
AV_CODEC_ID_H264 },
1148 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14,
AV_CODEC_ID_JPEG2000 },
1149 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1154 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14,
AV_CODEC_ID_PCM_S16LE },
1155 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14,
AV_CODEC_ID_MP2 },
1156 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14,
AV_CODEC_ID_PCM_S16LE },
1157 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4F }, 14,
AV_CODEC_ID_PCM_S16LE },
1158 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14,
AV_CODEC_ID_AAC },
1159 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1163 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1164 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1168 "vbi_vanc_smpte_436M",
1173 int i, j, nb_segments = 0;
1175 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1185 if (!(unsorted_segments =
av_calloc(nb_segments,
sizeof(*unsorted_segments))) ||
1186 !(*sorted_segments =
av_calloc(nb_segments,
sizeof(**sorted_segments)))) {
1196 *nb_sorted_segments = 0;
1199 for (i = 0; i < nb_segments; i++) {
1200 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1201 uint64_t best_index_duration = 0;
1203 for (j = 0; j < nb_segments; j++) {
1225 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1226 last_body_sid = best_body_sid;
1227 last_index_sid = best_index_sid;
1228 last_index_start = best_index_start;
1242 int64_t offset_in =
offset;
1259 "failed to find absolute offset of %"PRIX64
" in BodySID %i - partial file?\n",
1260 offset_in, body_sid);
1292 int64_t offset_temp = 0;
1316 av_log(mxf->
fc,
AV_LOG_ERROR,
"IndexSID %i segment at %"PRId64
" missing EditUnitByteCount and IndexEntryArray\n",
1322 *edit_unit_out = edit_unit;
1340 int8_t max_temporal_offset = -128;
1371 for (x = 0; x < index_table->
nb_ptses; x++)
1403 int index_delta = 1;
1412 for (j = 0; j <
n; j += index_delta, x++) {
1418 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64
"?\n",
1425 if (index < 0 || index >= index_table->
nb_ptses) {
1427 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1434 max_temporal_offset =
FFMAX(max_temporal_offset, offset);
1439 for (x = 0; x < index_table->
nb_ptses; x++) {
1446 index_table->
first_dts = -max_temporal_offset;
1457 int i, j, k, ret, nb_sorted_segments;
1461 nb_sorted_segments <= 0) {
1467 for (i = 0; i < nb_sorted_segments; i++) {
1468 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1470 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1473 goto finish_decoding_index;
1482 goto finish_decoding_index;
1486 for (i = j = 0; i < nb_sorted_segments; i++) {
1487 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1503 " pointer array\n");
1505 goto finish_decoding_index;
1508 if (sorted_segments[i]->index_start_position)
1509 av_log(mxf->
fc,
AV_LOG_WARNING,
"IndexSID %i starts at EditUnit %"PRId64
" - seeking may not work as expected\n",
1517 goto finish_decoding_index;
1525 av_log(mxf->
fc,
AV_LOG_WARNING,
"IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1542 finish_decoding_index:
1562 for (i = 0; i <
sizeof(
UID); i++) {
1563 snprintf(p, 2 + 1,
"%.2x", uid[i]);
1565 if (i == 3 || i == 5 || i == 7 || i == 9) {
1582 for (i = 0; i <
sizeof(
UID); i++) {
1587 for (i = 0; i <
sizeof(
UID); i++) {
1588 snprintf(p, 2 + 1,
"%.2X", uid[i]);
1623 switch (component->
type) {
1641 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1645 if (!memcmp(package->package_uid, package_uid, 16))
1663 if (!sub_descriptor) {
1668 return sub_descriptor;
1711 switch (component->
type) {
1733 size = strlen(tag->
name) + 8 + 1;
1753 int64_t start_position;
1766 if (physical_package->
name && physical_package->
name[0])
1786 "Invalid edit rate (%d/%d) found on structural"
1787 " component #%d, defaulting to 25/1\n",
1823 if (material_package)
break;
1825 if (!material_package) {
1831 if (material_package->
name && material_package->
name[0])
1843 UID *essence_container_ul =
NULL;
1889 if (!source_package) {
1900 source_track = temp_track;
1904 if (!source_track) {
1909 if (!source_track || !component)
1950 "Invalid edit rate (%d/%d) found on stream #%d, "
1951 "defaulting to 25/1\n",
1980 essence_container_ul = &((
MXFCryptoContext *)metadata)->source_container_ul;
1996 for (k = 0; k < 16; k++) {
1999 if (!(k+1 & 19) || k == 5)
2005 if (source_package->
name && source_package->
name[0])
2012 container_ul =
mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2041 "Field dominance %d support",
2083 container_ul =
mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2095 "found for stream #%d, time base forced to 1/48000\n",
2123 essence_container_ul)->
id;
2124 if (codec_id >= 0 &&
2127 mxf_data_essence_descriptor[codec_id], 0);
2152 struct tm time = { 0 };
2153 time.tm_year = (timestamp >> 48) - 1900;
2154 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2155 time.tm_mday = (timestamp >> 32 & 0xFF);
2156 time.tm_hour = (timestamp >> 24 & 0xFF);
2157 time.tm_min = (timestamp >> 16 & 0xFF);
2158 time.tm_sec = (timestamp >> 8 & 0xFF);
2163 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2164 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2165 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2166 time.tm_min = av_clip(time.tm_min, 0, 59);
2167 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2172 if (!strftime(*str, 32,
"%Y-%m-%d %H:%M:%S", &time))
2178 #define SET_STR_METADATA(pb, name, str) do { \
2179 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2181 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2184 #define SET_UID_METADATA(pb, name, var, str) do { \
2185 avio_read(pb, var, 16); \
2186 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2188 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2191 #define SET_TS_METADATA(pb, name, var, str) do { \
2192 var = avio_rb64(pb); \
2193 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
2195 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2249 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 },
mxf_read_primer_pack },
2250 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 },
mxf_read_partition_pack },
2251 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 },
mxf_read_partition_pack },
2252 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 },
mxf_read_partition_pack },
2253 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 },
mxf_read_partition_pack },
2254 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 },
mxf_read_partition_pack },
2255 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 },
mxf_read_partition_pack },
2256 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 },
mxf_read_partition_pack },
2257 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 },
mxf_read_partition_pack },
2258 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 },
mxf_read_partition_pack },
2259 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 },
mxf_read_partition_pack },
2260 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 },
mxf_read_preface_metadata },
2261 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 },
mxf_read_identification_metadata },
2262 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 },
mxf_read_content_storage, 0,
AnyType },
2263 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 },
mxf_read_package,
sizeof(
MXFPackage),
SourcePackage },
2264 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 },
mxf_read_package,
sizeof(
MXFPackage),
MaterialPackage },
2265 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 },
mxf_read_sequence,
sizeof(
MXFSequence),
Sequence },
2266 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 },
mxf_read_essence_group,
sizeof(
MXFEssenceGroup),
EssenceGroup},
2267 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 },
mxf_read_source_clip,
sizeof(
MXFStructuralComponent),
SourceClip },
2268 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 },
mxf_read_tagged_value,
sizeof(
MXFTaggedValue),
TaggedValue },
2269 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
MultipleDescriptor },
2270 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2271 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2272 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2273 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2274 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2275 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2276 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2277 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2278 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2279 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 },
mxf_read_track,
sizeof(
MXFTrack),
Track },
2280 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 },
mxf_read_track,
sizeof(
MXFTrack),
Track },
2281 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 },
mxf_read_timecode_component,
sizeof(
MXFTimecodeComponent),
TimecodeComponent },
2282 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 },
mxf_read_pulldown_component,
sizeof(
MXFPulldownComponent),
PulldownComponent },
2283 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 },
mxf_read_cryptographic_context,
sizeof(
MXFCryptoContext),
CryptoContext },
2284 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 },
mxf_read_index_table_segment,
sizeof(
MXFIndexTableSegment),
IndexTableSegment },
2285 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
NULL, 0,
AnyType },
2327 if (local_tag == tag) {
2334 if (ctx_size && tag == 0x3C0A) {
2336 }
else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2350 "local tag %#04x extends past end of local set @ %#"PRIx64
"\n",
2371 key[13] >= 2 && key[13] <= 4;
2383 if (klv.
key[5] == 0x53) {
2413 int64_t current_partition_ofs;
2444 if (klv.
offset >= current_partition_ofs) {
2446 PRIx64
" indirectly points to itself\n", current_partition_ofs);
2486 "failed to seek to FooterPartition @ 0x%" PRIx64
2487 " (%"PRId64
") - partial file?\n",
2535 "partition %i: bad ThisPartition = %"PRIX64
"\n",
2545 int64_t ret = (position / kag_size) * kag_size;
2546 return ret == position ? ret : ret + kag_size;
2594 int essence_partition_count = 0;
2617 essence_partition_count++;
2621 if (essence_partition_count != 1)
2624 if (!(segment =
av_mallocz(
sizeof(*segment))))
2647 int64_t file_size, max_rip_length, min_rip_length;
2663 max_rip_length = ((file_size - mxf->
run_in) / 105) * 12 + 28;
2664 max_rip_length =
FFMIN(max_rip_length, INT_MAX);
2667 min_rip_length = 16+1+24+4;
2678 klv.
length != length - 20)
2698 int64_t essence_offset = 0;
2743 int64_t op1a_essence_offset =
2761 if (!essence_offset)
2762 essence_offset = klv.
offset;
2777 for (metadata = mxf_metadata_read_table; metadata->
read; metadata++) {
2787 if (!metadata->
read)
2791 if (!essence_offset) {
2811 av_log(mxf->
fc,
AV_LOG_INFO,
"got %i index tables - only the first one (IndexSID %i) will be used\n",
2834 int64_t last_ofs = -1, next_ofs = -1;
2847 if (next_ofs <= last_ofs) {
2851 "next_ofs didn't change. not deriving packet timestamps\n");
2855 if (next_ofs > current_offset)
2858 last_ofs = next_ofs;
2870 uint64_t *sample_count)
2872 int i, total = 0, size = 0;
2879 if ((sample_rate.
num / sample_rate.
den) == 48000)
2882 int remainder = (sample_rate.
num * time_base.
num) %
2883 (time_base.
den * sample_rate.
den);
2885 av_mul_q(sample_rate, time_base)));
2888 "seeking detected on stream #%d with time base (%d/%d) and "
2889 "sample rate (%d/%d), audio pts won't be accurate.\n",
2890 stream_index, time_base.
num, time_base.
den,
2891 sample_rate.
num, sample_rate.
den);
2916 if (!bits_per_sample)
2922 || bits_per_sample <= 0
2923 || codec->
channels * (int64_t)bits_per_sample < 8)
2949 int64_t next_ofs, next_klv;
2956 "error getting stream index %"PRIu32
"\n",
2970 if (next_ofs >= 0 && next_klv > next_ofs) {
2974 "OPAtom misinterpreted as OP1a?"
2975 "KLV for edit unit %i extending into "
2982 if (klv.
key[12] == 0x06 && klv.
key[13] == 0x01 && klv.
key[14] == 0x10) {
3033 int64_t ret64, pos, next_pos;
3066 if ((size = next_pos - pos) <= 0) {
3071 if ((ret64 =
avio_seek(s->
pb, pos, SEEK_SET)) < 0)
3135 for (; bufp <
end;) {
3136 if (!((bufp[13] - 1) & 0xF2)){
3170 if (sample_time < 0)
3185 sample_time =
FFMAX(sample_time, 0);
3192 sample_time += t->
offsets[sample_time];
3211 uint64_t current_sample_count = 0;
static const uint8_t mxf_crypto_source_container_ul[]
static void mxf_compute_essence_containers(MXFContext *mxf)
Figures out the proper offset and length of the essence container in each partition.
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
enum MXFMetadataSetType type
static int mxf_parse_structural_metadata(MXFContext *mxf)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int64_t avio_size(AVIOContext *s)
Get the filesize.
unsigned int component_depth
KLVPacket current_klv_data
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
int structural_components_count
#define PRINT_KEY(pc, s, x)
static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
UID * structural_components_refs
#define AV_LOG_WARNING
Something somehow does not look correct.
static int mxf_seek_to_previous_partition(MXFContext *mxf)
Seeks to the previous partition and parses it, if possible.
enum MXFMetadataSetType type
int64_t pos
byte position in stream, -1 if unknown
static int mxf_probe(AVProbeData *p)
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
UID * structural_components_refs
static void mxf_read_random_index_pack(AVFormatContext *s)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
int index
stream index in AVFormatContext
#define SET_TS_METADATA(pb, name, var, str)
uint64_t footer_partition
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
enum MXFMetadataSetType type
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
static int mxf_uid_to_str(UID uid, char **str)
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static int mxf_umid_to_str(UID ul, UID uid, char **str)
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
unsigned int avio_rb16(AVIOContext *s)
static int mxf_is_intra_only(MXFDescriptor *descriptor)
static int mxf_read_header(AVFormatContext *s)
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.
static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read, int ctx_size, enum MXFMetadataSetType type)
Parses a metadata KLV.
enum MXFMetadataSetType type
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function...
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
static int is_pcm(enum AVCodecID codec_id)
static int mxf_handle_missing_index_segment(MXFContext *mxf)
Deal with the case where OPAtom files does not have any IndexTableSegments.
static const uint8_t mxf_indirect_value_utf16le[]
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
const MXFSamplesPerFrame * ff_mxf_get_samples_per_frame(AVFormatContext *s, AVRational time_base)
Opaque data information usually continuous.
static const uint8_t mxf_avid_essence_element_key[]
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
unsigned int avio_rb32(AVIOContext *s)
static av_cold int end(AVCodecContext *avctx)
AVRational index_edit_rate
enum AVStreamParseType need_parsing
int id
Format-specific stream ID.
static int mxf_read_close(AVFormatContext *s)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
AVStream ** streams
A list of all streams in the file.
static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
Computes the absolute file offset of the given essence container offset.
static const uint8_t mxf_klv_key[]
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static double av_q2d(AVRational a)
Convert rational to double.
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
MXFIndexTableSegment ** segments
const MXFCodecUL ff_mxf_codec_uls[]
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
static const uint8_t mxf_sony_mpeg4_extradata[]
#define AVERROR_EOF
End of file.
static const uint8_t mxf_avid_project_name[]
static av_cold int read_close(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str, int be)
uint64_t avio_rb64(AVIOContext *s)
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
unsigned int vert_subsampling
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
static const uint8_t mxf_random_index_pack_key[]
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
static MXFDescriptor * mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
int64_t original_duration
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
#define SET_UID_METADATA(pb, name, var, str)
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int last_forward_partition
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
AVDictionary * metadata
Metadata that applies to the whole file.
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
int8_t * temporal_offset_entries
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, int64_t *edit_unit_out, int64_t *offset_out, int nag)
MXFDescriptor * descriptor
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
uint64_t index_start_position
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[]
static const MXFCodecUL mxf_sound_essence_container_uls[]
simple assert() macros that are a bit more flexible than ISO C assert().
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
static int64_t round_to_kag(int64_t position, int kag_size)
static const uint8_t offset[127][2]
static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_match_uid(const UID key, const UID uid, int len)
int avio_r8(AVIOContext *s)
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
AVCodecContext * codec
Codec context associated with this stream.
int buf_size
Size of buf except extra allocated bytes.
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
const MXFCodecUL ff_mxf_pixel_format_uls[]
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
static const uint8_t mxf_jp2k_rsiz[]
MXFPartition * partitions
enum MXFMetadataSetType type
static const uint8_t mxf_essence_element_key[]
static void * mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
unsigned int horiz_subsampling
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
static MXFStructuralComponent * mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
static const uint8_t mxf_encrypted_triplet_key[]
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
enum AVPixelFormat pix_fmt
int64_t essence_offset
absolute offset of essence
int width
picture width / height.
static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
int edit_units_per_packet
how many edit units to read at a time (PCM, OPAtom)
GLsizei GLboolean const GLfloat * value
int64_t last_forward_tell
static const uint8_t mxf_header_partition_pack_key[]
static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
static void mxf_handle_small_eubc(AVFormatContext *s)
Deal with the case where for some audio atoms EditUnitByteCount is very small (2, 4...
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
UID * sub_descriptors_refs
static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
preferred ID for MPEG-1/2 video decoding
#define FF_ARRAY_ELEMS(a)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
static int read_header(FFV1Context *f)
#define FF_PROFILE_JPEG2000_DCINEMA_4K
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static const char *const mxf_data_essence_descriptor[]
static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
#define AV_LOG_INFO
Standard information.
enum AVMediaType codec_type
int sub_descriptors_count
int sample_rate
samples per second
AVIOContext * pb
I/O context.
static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static const uint8_t mxf_encrypted_essence_container[]
static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
main external API structure.
enum MXFMetadataSetType type
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
static const MXFCodecUL mxf_data_essence_container_uls[]
rational number numerator/denominator
static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
static const uint8_t mxf_system_item_key[]
static MXFPackage * mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
unsigned partitions_count
enum MXFMetadataSetType type
This structure contains the data a format has to probe a file.
void * av_calloc(size_t nmemb, size_t size)
Allocate a block of nmemb * size bytes with alignment suitable for all memory accesses (including vec...
#define READ_STR16(type, big_endian)
static const uint8_t mxf_indirect_value_utf16be[]
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
static int64_t klv_decode_ber_length(AVIOContext *pb)
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
#define FF_PROFILE_JPEG2000_DCINEMA_2K
static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
int64_t duration
Decoding: duration of the stream, in stream time base.
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static const MXFCodecUL mxf_picture_essence_container_uls[]
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
MXFMetadataReadFunc * read
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
AVInputFormat ff_mxf_demuxer
AVIndexEntry * fake_index
int64_t pack_ofs
absolute offset of pack in file, including run-in
int structural_components_count
static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
const MXFCodecUL ff_mxf_codec_tag_uls[]
uint64_t * stream_offset_entries
static int mxf_is_partition_pack_key(UID key)
Matches any partition pack key, in other words:
static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
int channels
number of audio channels
static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
void * priv_data
Format private data.
static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
Returns the end position of the essence container with given BodySID, or zero if unknown.
static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
#define SET_STR_METADATA(pb, name, str)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
static void * av_mallocz_array(size_t nmemb, size_t size)
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
Sets mxf->current_edit_unit based on what offset we're currently at.
int bit_rate
Total stream bitrate in bit/s, 0 if not available.
MXFMetadataSet ** metadata_sets
static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
enum AVFieldOrder field_order
Field order.
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
MXFIndexTable * index_tables
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
AVPixelFormat
Pixel format.
This structure stores compressed data.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
enum MXFMetadataSetType type
MXFPartition * current_partition
#define AV_NOPTS_VALUE
Undefined timestamp value.
uint64_t previous_partition
#define AV_TIMECODE_STR_SIZE
int64_t header_byte_count