62 #define MXF_MAX_CHUNK_SIZE (32 << 20)
63 #define RUN_IN_MAX (65535+1)
197 #define MXF_FIELD_DOMINANCE_DEFAULT 0
198 #define MXF_FIELD_DOMINANCE_FF 1
199 #define MXF_FIELD_DOMINANCE_FL 2
320 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
321 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
322 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
323 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
324 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
325 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
327 static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
329 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 };
330 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
331 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
332 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
333 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
334 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
335 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 };
336 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 };
337 static const uint8_t mxf_apple_coll_max_cll[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x01 };
338 static const uint8_t mxf_apple_coll_max_fall[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x02 };
348 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
353 switch ((*ctx)->type) {
397 int bytes_num =
size & 0x7f;
405 if (
size > INT64_MAX)
417 else if (
b !=
key[
i])
439 if (
pos > INT64_MAX - length)
449 for (
i = 0;
i <
s->nb_streams;
i++) {
456 return s->nb_streams == 1 &&
s->streams[0]->priv_data ? 0 : -1;
485 int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
486 int line_num, sample_coding, sample_count;
487 int did, sdid, data_length;
493 for (
i = 0;
i < count;
i++) {
502 length -= 6 + 8 + sample_count;
503 if (line_num != 9 && line_num != 11)
505 if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
517 if (did != 0x61 || sdid != 1) {
522 if (cdp_identifier != 0x9669) {
531 if (ccdata_id != 0x72) {
539 if (cdp_length - 9 - 4 < cc_count * 3) {
543 avio_skip(
s->pb, data_length - 9 - 4 - cc_count * 3);
545 if (cdp_footer_id != 0x74) {
560 const uint8_t *buf_ptr, *end_ptr;
578 uint32_t
sample = bytestream_get_le32(&buf_ptr);
580 bytestream_put_le24(&data_ptr, (
sample >> 4) & 0xffffff);
582 bytestream_put_le16(&data_ptr, (
sample >> 12) & 0xffff);
592 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
598 uint64_t plaintext_size;
604 if (!mxf->
aesc &&
s->key &&
s->keylen == 16) {
631 if (orig_size < plaintext_size)
635 if (
size < 32 ||
size - 32 < orig_size || (
int)orig_size != orig_size)
642 if (memcmp(tmpbuf, checkv, 16))
648 else if (
size < plaintext_size)
650 size -= plaintext_size;
666 if (item_len != 18) {
670 if (item_num > 65536 || item_num < 0) {
692 uint64_t footer_partition;
693 uint32_t nb_essence_containers;
715 memset(partition, 0,
sizeof(*partition));
766 "PreviousPartition equal to ThisPartition %"PRIx64
"\n",
779 "Overriding PreviousPartition with %"PRIx64
"\n",
784 if (footer_partition) {
787 "inconsistent FooterPartition value: %"PRIu64
" != %"PRIu64
"\n",
795 "PartitionPack: ThisPartition = 0x%"PRIX64
796 ", PreviousPartition = 0x%"PRIX64
", "
797 "FooterPartition = 0x%"PRIX64
", IndexSID = %i, BodySID = %i\n",
807 "PreviousPartition points to this partition or forward\n");
811 if (
op[12] == 1 &&
op[13] == 1) mxf->
op =
OP1a;
812 else if (
op[12] == 1 &&
op[13] == 2) mxf->
op =
OP1b;
813 else if (
op[12] == 1 &&
op[13] == 3) mxf->
op =
OP1c;
814 else if (
op[12] == 2 &&
op[13] == 1) mxf->
op =
OP2a;
815 else if (
op[12] == 2 &&
op[13] == 2) mxf->
op =
OP2b;
816 else if (
op[12] == 2 &&
op[13] == 3) mxf->
op =
OP2c;
817 else if (
op[12] == 3 &&
op[13] == 1) mxf->
op =
OP3a;
818 else if (
op[12] == 3 &&
op[13] == 2) mxf->
op =
OP3b;
819 else if (
op[12] == 3 &&
op[13] == 3) mxf->
op =
OP3c;
821 else if (
op[12] == 0x10) {
826 if (nb_essence_containers != 1) {
832 "\"OPAtom\" with %"PRIu32
" ECs - assuming %s\n",
833 nb_essence_containers,
834 op ==
OP1a ?
"OP1a" :
"OPAtom");
890 if (
c > INT_MAX /
sizeof(
UID))
902 if (ret != *count *
sizeof(
UID)) {
903 *count = ret < 0 ? 0 : ret /
sizeof(
UID);
915 if (size < 0 || size > INT_MAX/2)
937 #define READ_STR16(type, big_endian) \
938 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
940 return mxf_read_utf16_string(pb, size, str, big_endian); \
1021 mxf_read_utf16be_string(pb,
size, &track->
name);
1074 &package->tracks_count);
1078 avio_read(pb, package->package_uid, 16);
1081 avio_read(pb, package->descriptor_ref, 16);
1084 return mxf_read_utf16be_string(pb,
size, &package->name);
1087 &package->comment_count);
1115 if (
segment->temporal_offset_entries)
1121 if(
segment->nb_index_entries && length < 11)
1132 for (
i = 0;
i <
segment->nb_index_entries;
i++) {
1166 if (
segment->index_edit_rate.num <= 0 ||
1167 segment->index_edit_rate.den <= 0)
1170 segment->index_edit_rate.den);
1199 }
while (
code != 0);
1207 int entry_count, entry_size;
1240 if (entry_size == 4) {
1241 if (entry_count > 0)
1245 if (entry_count > 1)
1328 for (
int i = 0;
i < 3;
i++) {
1358 if (!descriptor->
coll) {
1360 if (!descriptor->
coll)
1387 return mxf_read_utf16le_string(pb,
size - 17, &tagged_value->
value);
1389 return mxf_read_utf16be_string(pb,
size - 17, &tagged_value->
value);
1399 return mxf_read_utf16be_string(pb,
size, &tagged_value->
name);
1413 for (
i = 0;
i <
len;
i++) {
1422 while (uls->
uid[0]) {
1447 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14,
AV_CODEC_ID_JPEG2000,
NULL, 14 },
1448 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14,
AV_CODEC_ID_H264,
NULL, 15 },
1449 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14,
AV_CODEC_ID_DNXHD,
NULL, 14 },
1450 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14,
AV_CODEC_ID_VC1,
NULL, 14 },
1451 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14,
AV_CODEC_ID_TIFF,
NULL, 14 },
1452 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14,
AV_CODEC_ID_DIRAC,
NULL, 14 },
1453 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1b,0x01,0x00 }, 14,
AV_CODEC_ID_CFHD,
NULL, 14 },
1454 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14,
AV_CODEC_ID_PRORES,
NULL, 14 },
1455 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14,
AV_CODEC_ID_MPEG2VIDEO,
NULL, 15 },
1456 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14,
AV_CODEC_ID_MPEG2VIDEO,
NULL, 15,
D10D11Wrap },
1457 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,
AV_CODEC_ID_DVVIDEO,
NULL, 15 },
1458 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,
AV_CODEC_ID_RAWVIDEO,
NULL, 15,
RawVWrap },
1459 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15,
AV_CODEC_ID_HQ_HQA },
1460 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15,
AV_CODEC_ID_HQX },
1461 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x15,0x00,0x04,0x02,0x10,0x00,0x01 }, 16,
AV_CODEC_ID_HEVC,
NULL, 15 },
1462 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14,
AV_CODEC_ID_RAWVIDEO },
1463 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1468 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14,
AV_CODEC_ID_MPEG2VIDEO },
1469 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1474 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14,
AV_CODEC_ID_H264 },
1475 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14,
AV_CODEC_ID_JPEG2000 },
1476 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1481 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1482 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1483 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1484 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1485 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1490 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14,
AV_CODEC_ID_PCM_S16LE,
NULL, 14,
RawAWrap },
1491 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14,
AV_CODEC_ID_MP2,
NULL, 15 },
1492 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14,
AV_CODEC_ID_PCM_S16LE,
NULL, 13 },
1493 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4F }, 14,
AV_CODEC_ID_PCM_S16LE },
1494 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14,
AV_CODEC_ID_AAC },
1495 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1499 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16,
AV_CODEC_ID_NONE,
"vbi_smpte_436M", 11 },
1500 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16,
AV_CODEC_ID_NONE,
"vbi_vanc_smpte_436M", 11 },
1501 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16,
AV_CODEC_ID_TTML },
1502 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
1518 val = (*essence_container_ul)[
codec_ul->wrapping_indicator_pos];
1519 switch (
codec_ul->wrapping_indicator_type) {
1524 if (
val == 0x03 ||
val == 0x04)
1541 int i, j, nb_segments = 0;
1543 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1553 if (!(unsorted_segments =
av_calloc(nb_segments,
sizeof(*unsorted_segments))) ||
1554 !(*sorted_segments =
av_calloc(nb_segments,
sizeof(**sorted_segments)))) {
1563 if (
s->edit_unit_byte_count ||
s->nb_index_entries)
1564 unsorted_segments[nb_segments++] =
s;
1566 av_log(mxf->
fc,
AV_LOG_WARNING,
"IndexSID %i segment at %"PRId64
" missing EditUnitByteCount and IndexEntryArray\n",
1567 s->index_sid,
s->index_start_position);
1577 *nb_sorted_segments = 0;
1580 for (
i = 0;
i < nb_segments;
i++) {
1581 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1582 uint64_t best_index_duration = 0;
1584 for (j = 0; j < nb_segments; j++) {
1592 s->body_sid > last_body_sid ||
1593 s->body_sid == last_body_sid &&
s->index_sid > last_index_sid ||
1594 s->body_sid == last_body_sid &&
s->index_sid == last_index_sid &&
s->index_start_position > last_index_start) &&
1596 s->body_sid < best_body_sid ||
1597 s->body_sid == best_body_sid &&
s->index_sid < best_index_sid ||
1598 s->body_sid == best_body_sid &&
s->index_sid == best_index_sid &&
s->index_start_position < best_index_start ||
1599 s->body_sid == best_body_sid &&
s->index_sid == best_index_sid &&
s->index_start_position == best_index_start &&
s->index_duration > best_index_duration)) {
1601 best_body_sid =
s->body_sid;
1602 best_index_sid =
s->index_sid;
1603 best_index_start =
s->index_start_position;
1604 best_index_duration =
s->index_duration;
1612 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1613 last_body_sid = best_body_sid;
1614 last_index_sid = best_index_sid;
1615 last_index_start = best_index_start;
1638 m0 = m = (
a +
b) >> 1;
1640 while (m < b && mxf->partitions[m].body_sid != body_sid)
1643 if (m < b && mxf->partitions[m].body_offset <=
offset)
1655 *partition_out = last_p;
1660 "failed to find absolute offset of %"PRIX64
" in BodySID %i - partial file?\n",
1697 edit_unit =
FFMAX(edit_unit,
s->index_start_position);
1699 if (edit_unit < s->index_start_position +
s->index_duration) {
1702 if (
s->edit_unit_byte_count) {
1703 if (
index > INT64_MAX /
s->edit_unit_byte_count ||
1704 s->edit_unit_byte_count *
index > INT64_MAX - offset_temp)
1707 offset_temp +=
s->edit_unit_byte_count *
index;
1709 if (
s->nb_index_entries == 2 *
s->index_duration + 1)
1712 if (index < 0 || index >=
s->nb_index_entries) {
1718 offset_temp =
s->stream_offset_entries[
index];
1722 *edit_unit_out =
av_rescale_q(edit_unit, edit_rate,
s->index_edit_rate);
1727 if (
s->edit_unit_byte_count && (
s->index_duration > INT64_MAX /
s->edit_unit_byte_count ||
1728 s->edit_unit_byte_count *
s->index_duration > INT64_MAX - offset_temp)
1732 offset_temp +=
s->edit_unit_byte_count *
s->index_duration;
1745 int8_t max_temporal_offset = -128;
1752 if (!
s->nb_index_entries) {
1757 if (
s->index_duration > INT_MAX -
index_table->nb_ptses) {
1814 int index_delta = 1;
1815 int n =
s->nb_index_entries;
1817 if (
s->nb_index_entries == 2 *
s->index_duration + 1) {
1823 for (j = 0; j < n; j += index_delta, x++) {
1824 int offset =
s->temporal_offset_entries[j] / index_delta;
1829 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64
"?\n",
1830 s->nb_index_entries,
s->index_duration);
1836 if (index < 0 || index >=
index_table->nb_ptses) {
1838 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1845 max_temporal_offset =
FFMAX(max_temporal_offset,
offset);
1868 int i, j, k, ret, nb_sorted_segments;
1872 nb_sorted_segments <= 0) {
1878 for (
i = 0;
i < nb_sorted_segments;
i++) {
1879 if (
i == 0 || sorted_segments[
i-1]->index_sid != sorted_segments[
i]->index_sid)
1881 else if (sorted_segments[
i-1]->body_sid != sorted_segments[
i]->body_sid) {
1884 goto finish_decoding_index;
1893 goto finish_decoding_index;
1897 for (
i = j = 0;
i < nb_sorted_segments;
i++) {
1898 if (
i != 0 && sorted_segments[
i-1]->index_sid != sorted_segments[
i]->index_sid) {
1915 " pointer array\n");
1917 goto finish_decoding_index;
1920 if (sorted_segments[
i]->index_start_position)
1921 av_log(mxf->
fc,
AV_LOG_WARNING,
"IndexSID %i starts at EditUnit %"PRId64
" - seeking may not work as expected\n",
1929 goto finish_decoding_index;
1952 av_log(mxf->
fc,
AV_LOG_WARNING,
"IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1969 finish_decoding_index:
1989 for (
i = 0;
i <
sizeof(
UID);
i++) {
1992 if (
i == 3 ||
i == 5 ||
i == 7 ||
i == 9) {
2009 for (
i = 0;
i <
sizeof(
UID);
i++) {
2014 for (
i = 0;
i <
sizeof(
UID);
i++) {
2022 uint16_t patch, uint16_t release,
char **
str)
2059 switch (component->
type) {
2077 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2081 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2099 if (!sub_descriptor) {
2104 return sub_descriptor;
2147 switch (component->
type) {
2200 if (physical_package->
name && physical_package->
name[0])
2220 "Invalid edit rate (%d/%d) found on structural"
2221 " component #%d, defaulting to 25/1\n",
2322 if (material_package)
break;
2324 if (!material_package) {
2330 if (material_package->
name && material_package->
name[0])
2342 UID *essence_container_ul =
NULL;
2392 if (!source_package) {
2403 source_track = temp_track;
2407 if (!source_track) {
2426 if(source_track && component)
2429 if (!source_track || !component || !source_package) {
2473 "Invalid edit rate (%d/%d) found on stream #%d, "
2474 "defaulting to 25/1\n",
2506 essence_container_ul = &((
MXFCryptoContext *)metadata)->source_container_ul;
2522 for (k = 0; k < 16; k++) {
2525 if (!(k+1 & 19) || k == 5)
2531 if (source_package->
name && source_package->
name[0])
2533 if (material_track->
name && material_track->
name[0])
2581 "Field dominance %d support",
2595 "Field dominance %d support",
2660 if (descriptor->
coll) {
2680 "found for stream #%d, time base forced to 1/48000\n",
2755 "with different wrapping\n",
i, j, track1->
body_sid);
2768 struct tm time = { 0 };
2770 time.tm_year = (timestamp >> 48) - 1900;
2771 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2772 time.tm_mday = (timestamp >> 32 & 0xFF);
2773 time.tm_hour = (timestamp >> 24 & 0xFF);
2774 time.tm_min = (timestamp >> 16 & 0xFF);
2775 time.tm_sec = (timestamp >> 8 & 0xFF);
2776 msecs = (timestamp & 0xFF) * 4;
2779 time.tm_mon =
av_clip(time.tm_mon, 0, 11);
2780 time.tm_mday =
av_clip(time.tm_mday, 1, 31);
2781 time.tm_hour =
av_clip(time.tm_hour, 0, 23);
2782 time.tm_min =
av_clip(time.tm_min, 0, 59);
2783 time.tm_sec =
av_clip(time.tm_sec, 0, 59);
2784 msecs =
av_clip(msecs, 0, 999);
2789 #define SET_STR_METADATA(pb, name, str) do { \
2790 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2792 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2795 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
2796 major = avio_rb16(pb); \
2797 minor = avio_rb16(pb); \
2798 tertiary = avio_rb16(pb); \
2799 patch = avio_rb16(pb); \
2800 release = avio_rb16(pb); \
2801 if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
2803 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2806 #define SET_UID_METADATA(pb, name, var, str) do { \
2807 avio_read(pb, var, 16); \
2808 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2810 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2813 #define SET_TS_METADATA(pb, name, var, str) do { \
2814 var = avio_rb64(pb); \
2815 if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2827 uint16_t
major,
minor, tertiary, patch, release;
2877 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 },
mxf_read_primer_pack },
2878 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 },
mxf_read_partition_pack },
2879 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 },
mxf_read_partition_pack },
2880 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 },
mxf_read_partition_pack },
2881 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 },
mxf_read_partition_pack },
2882 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 },
mxf_read_partition_pack },
2883 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 },
mxf_read_partition_pack },
2884 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 },
mxf_read_partition_pack },
2885 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 },
mxf_read_partition_pack },
2886 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 },
mxf_read_partition_pack },
2887 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 },
mxf_read_partition_pack },
2888 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 },
mxf_read_preface_metadata },
2889 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 },
mxf_read_identification_metadata },
2890 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 },
mxf_read_content_storage, 0,
AnyType },
2891 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 },
mxf_read_package,
sizeof(
MXFPackage),
SourcePackage },
2892 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 },
mxf_read_package,
sizeof(
MXFPackage),
MaterialPackage },
2893 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 },
mxf_read_sequence,
sizeof(
MXFSequence),
Sequence },
2894 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 },
mxf_read_essence_group,
sizeof(
MXFEssenceGroup),
EssenceGroup},
2895 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 },
mxf_read_source_clip,
sizeof(
MXFStructuralComponent),
SourceClip },
2896 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 },
mxf_read_tagged_value,
sizeof(
MXFTaggedValue),
TaggedValue },
2897 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
MultipleDescriptor },
2898 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2899 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2900 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2901 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2902 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2903 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2904 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5b,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2905 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2906 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2907 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x64,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
2908 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 },
mxf_read_track,
sizeof(
MXFTrack),
Track },
2909 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 },
mxf_read_track,
sizeof(
MXFTrack),
Track },
2910 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 },
mxf_read_timecode_component,
sizeof(
MXFTimecodeComponent),
TimecodeComponent },
2911 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 },
mxf_read_pulldown_component,
sizeof(
MXFPulldownComponent),
PulldownComponent },
2912 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 },
mxf_read_cryptographic_context,
sizeof(
MXFCryptoContext),
CryptoContext },
2913 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 },
mxf_read_index_table_segment,
sizeof(
MXFIndexTableSegment),
IndexTableSegment },
2914 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 },
mxf_read_essence_container_data,
sizeof(
MXFEssenceContainerData),
EssenceContainerData },
2915 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
NULL, 0,
AnyType },
2956 if (next < 0 || next > INT64_MAX -
size) {
2973 if (local_tag ==
tag) {
2980 if (meta &&
tag == 0x3C0A) {
2982 }
else if ((ret = read_child(
ctx, pb,
tag,
size,
uid, -1)) < 0) {
2997 "local tag %#04x extends past end of local set @ %#"PRIx64
"\n",
3017 key[13] >= 2 &&
key[13] <= 4;
3029 if (klv.
key[5] == 0x53) {
3059 int64_t current_partition_ofs;
3090 if (klv.
offset >= current_partition_ofs) {
3092 PRIx64
" indirectly points to itself\n", current_partition_ofs);
3132 "failed to seek to FooterPartition @ 0x%" PRIx64
3133 " (%"PRId64
") - partial file?\n",
3156 for (
int i = 0;
i <
s->nb_streams;
i++) {
3192 if (x < mxf->partitions_count - 1)
3199 "partition %i: bad ThisPartition = %"PRIX64
"\n",
3262 int essence_partition_count = 0;
3263 int edit_unit_byte_count = 0;
3285 essence_partition_count++;
3289 if (essence_partition_count != 1)
3298 if (edit_unit_byte_count <= 0)
3316 segment->edit_unit_byte_count = edit_unit_byte_count;
3317 segment->index_start_position = 0;
3329 int64_t file_size, max_rip_length, min_rip_length;
3345 max_rip_length = ((file_size - mxf->
run_in) / 105) * 12 + 28;
3346 max_rip_length =
FFMIN(max_rip_length, INT_MAX);
3349 min_rip_length = 16+1+24+4;
3355 if (length < min_rip_length || length > max_rip_length)
3357 avio_seek(
s->pb, file_size - length, SEEK_SET);
3432 if (!essence_offset)
3433 essence_offset = klv.
offset;
3455 if (!metadata->
read) {
3462 if (!essence_offset) {
3474 for (
int i = 0;
i <
s->nb_streams;
i++)
3482 av_log(mxf->
fc,
AV_LOG_INFO,
"got %i index tables - only the first one (IndexSID %i) will be used\n",
3492 for (
int i = 0;
i <
s->nb_streams;
i++)
3514 m = (
a + (uint64_t)
b) >> 1;
3517 if (
offset < current_offset)
3546 "seeking detected on stream #%d with time base (%d/%d) and "
3547 "sample rate (%d/%d), audio pts won't be accurate.\n",
3577 if (next_ofs > current_offset)
3592 av_log(mxf->
fc,
AV_LOG_WARNING,
"edit unit sync lost on stream %d, jumping from %"PRId64
" to %"PRId64
"\n", st->
index, edit_unit, new_edit_unit);
3604 if (!bits_per_sample)
3610 || bits_per_sample <= 0
3664 max_data_size = klv.
length;
3691 "error getting stream index %"PRIu32
"\n",
3707 if (next_ofs <= 0) {
3715 if ((
size = next_ofs -
pos) <= 0) {
3721 if (
size > max_data_size)
3722 size = max_data_size;
3732 if (klv.
key[12] == 0x06 && klv.
key[13] == 0x01 && klv.
key[14] == 0x10) {
3784 for (
i = 0;
i <
s->nb_streams;
i++)
3785 s->streams[
i]->priv_data =
NULL;
3819 for (; bufp < end;) {
3820 if (!((bufp[13] - 1) & 0xF2)){
3838 AVStream *st =
s->streams[stream_index];
3857 if (sample_time < 0)
3861 seekpos =
avio_seek(
s->pb, (
s->bit_rate * seconds) >> 3, SEEK_SET);
3873 for (
i = 0;
i <
s->nb_streams;
i++) {
3874 MXFTrack *new_source_track =
s->streams[
i]->priv_data;
3877 source_track = new_source_track;
3882 if (
i ==
s->nb_streams)
3888 sample_time =
FFMAX(sample_time, 0);
3897 sample_time < t->ptses[0] &&
3899 sample_time = t->
ptses[0];
3905 sample_time += t->
offsets[sample_time];
3921 if (seekpos < klv.next_klv - klv.length || seekpos >= klv.
next_klv) {
3933 for (
i = 0;
i <
s->nb_streams;
i++) {
3937 int64_t track_edit_unit = sample_time;
3947 {
"eia608_extract",
"extract eia 608 captions from s436m track",
static double val(void *priv, double ch)
simple assert() macros that are a bit more flexible than ISO C assert().
#define FF_PROFILE_JPEG2000_DCINEMA_2K
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define FF_PROFILE_JPEG2000_DCINEMA_4K
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
uint64_t avio_rb64(AVIOContext *s)
int64_t avio_size(AVIOContext *s)
Get the filesize.
unsigned int avio_rb16(AVIOContext *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.
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.
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_rb32(AVIOContext *s)
int avio_r8(AVIOContext *s)
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
char * av_asprintf(const char *fmt,...)
#define flags(name, subs,...)
#define MKTAG(a, b, c, d)
static int read_header(FFV1Context *f)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
AVCodecID
Identify the syntax and semantics of the bitstream.
@ AV_CODEC_ID_PCM_S24DAUD
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
@ AVDISCARD_ALL
discard all
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as stream side data.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
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.
#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 AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
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.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#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.
static AVRational av_make_q(int num, int den)
Create an AVRational.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define LIBAVUTIL_VERSION_INT
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.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
static av_cold int read_close(AVFormatContext *ctx)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
@ AV_CLASS_CATEGORY_DEMUXER
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
const uint8_t ff_mxf_random_index_pack_key[16]
const MXFCodecUL ff_mxf_pixel_format_uls[]
const MXFCodecUL ff_mxf_color_space_uls[]
const MXFCodecUL ff_mxf_color_trc_uls[]
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
const MXFCodecUL ff_mxf_codec_tag_uls[]
const MXFCodecUL ff_mxf_codec_uls[]
const MXFCodecUL ff_mxf_color_primaries_uls[]
#define FF_MXF_MasteringDisplayMinimumLuminance
#define PRINT_KEY(pc, s, x)
#define FF_MXF_MasteringDisplayPrimaries
#define FF_MXF_MasteringDisplayWhitePointChromaticity
#define FF_MXF_MASTERING_CHROMA_DEN
#define FF_MXF_MASTERING_LUMA_DEN
#define FF_MXF_MasteringDisplay_PREFIX
#define FF_MXF_MasteringDisplayMaximumLuminance
static int mxf_read_package(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_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_uid_to_str(UID uid, char **str)
static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
static const uint8_t mxf_canopus_essence_element_key[]
static const MXFCodecUL mxf_picture_essence_container_uls[]
static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
static MXFStructuralComponent * mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
static MXFPackage * mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
static int mxf_read_essence_container_data(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 void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
static const uint8_t mxf_crypto_source_container_ul[]
static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static const uint8_t mxf_apple_coll_max_fall[]
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
#define MXF_FIELD_DOMINANCE_FF
static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
static int mxf_parse_structural_metadata(MXFContext *mxf)
static const AVOption options[]
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
Make sure track->sample_count is correct based on what offset we're currently at.
static const uint8_t mxf_klv_key[]
static const uint8_t mxf_encrypted_triplet_key[]
static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
static const uint8_t mxf_header_partition_pack_key[]
#define MXF_FIELD_DOMINANCE_DEFAULT
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
static int64_t klv_decode_ber_length(AVIOContext *pb)
static const MXFCodecUL mxf_intra_only_picture_coded_width[]
static const MXFCodecUL mxf_data_essence_container_uls[]
static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
#define SET_TS_METADATA(pb, name, var, str)
static MXFDescriptor * mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
#define SET_UID_METADATA(pb, name, var, str)
static const uint8_t mxf_sony_mpeg4_extradata[]
static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
static const uint8_t mxf_indirect_value_utf16le[]
static MXFIndexTable * mxf_find_index_table(MXFContext *mxf, int index_sid)
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
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_match_uid(const UID key, const UID uid, int len)
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_mastering_display_prefix[13]
static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static const uint8_t mxf_avid_essence_element_key[]
#define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str)
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
#define SET_STR_METADATA(pb, name, str)
#define MXF_MAX_CHUNK_SIZE
static const uint8_t mxf_mastering_display_uls[4][16]
static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st, int64_t edit_unit)
#define READ_STR16(type, big_endian)
static int mxf_read_header(AVFormatContext *s)
static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
Deal with the case where for some audio atoms EditUnitByteCount is very small (2, 4....
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
static void * mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
Computes the absolute file offset of the given essence container offset.
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_read_close(AVFormatContext *s)
static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par, AVPacket *pkt)
static const AVClass demuxer_class
static int is_pcm(enum AVCodecID codec_id)
static int mxf_seek_to_previous_partition(MXFContext *mxf)
Seeks to the previous partition and parses it, if possible.
static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
static int mxf_is_partition_pack_key(UID key)
Matches any partition pack key, in other words:
static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read, int ctx_size, enum MXFMetadataSetType type)
Parses a metadata KLV.
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static const uint8_t mxf_avid_project_name[]
static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set)
static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
static void mxf_read_random_index_pack(AVFormatContext *s)
static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
static const uint8_t mxf_apple_coll_max_cll[]
static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary, uint16_t patch, uint16_t release, char **str)
static int mxf_probe(const AVProbeData *p)
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
static const uint8_t mxf_essence_element_key[]
static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[]
static const uint8_t mxf_indirect_value_utf16be[]
#define MXF_FIELD_DOMINANCE_FL
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
static const uint8_t mxf_apple_coll_prefix[]
static const MXFCodecUL mxf_sound_essence_container_uls[]
static const uint8_t mxf_jp2k_rsiz[]
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static void mxf_compute_essence_containers(AVFormatContext *s)
Figures out the proper offset and length of the essence container in each partition.
static int mxf_umid_to_str(UID ul, UID uid, char **str)
AVInputFormat ff_mxf_demuxer
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str, int be)
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
static const uint8_t mxf_system_item_key_gc[]
static int mxf_is_intra_only(MXFDescriptor *descriptor)
static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
static const uint8_t mxf_system_item_key_cp[]
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
AVColorRange
Visual content value range.
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
@ AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_JPEG
Full range content.
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
static const uint8_t index_table[8]
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...
This struct describes the properties of an encoded stream.
enum AVColorSpace color_space
enum AVFieldOrder field_order
Video only.
int bits_per_coded_sample
The number of bits per sample in the codedwords.
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).
enum AVColorPrimaries color_primaries
int sample_rate
Audio only.
enum AVColorTransferCharacteristic color_trc
enum AVColorRange color_range
Video only.
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
unsigned MaxFALL
Max average light level per frame (cd/m^2).
unsigned MaxCLL
Max content light level (cd/m^2).
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
AVIOContext * pb
I/O context.
AVDictionary * metadata
Metadata that applies to the whole file.
AVStream ** streams
A list of all streams in the file.
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
This structure stores compressed data.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
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
This structure contains the data a format has to probe a file.
int buf_size
Size of buf except extra allocated bytes.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Rational number (pair of numerator and denominator).
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
int64_t duration
Decoding: duration of the stream, in stream time base.
int id
Format-specific stream ID.
int index
stream index in AVFormatContext
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
enum AVStreamParseType need_parsing
AVStreamInternal * internal
An opaque field for libavformat internal usage.
MXFPartition * partitions
MXFIndexTable * index_tables
int64_t last_forward_tell
uint64_t footer_partition
int last_forward_partition
KLVPacket current_klv_data
MXFPartition * current_partition
int essence_container_data_count
unsigned partitions_count
MXFMetadataSet ** metadata_sets
UID * essence_container_data_refs
enum MXFMetadataSetType type
unsigned int component_depth
enum AVPixelFormat pix_fmt
unsigned int horiz_subsampling
unsigned int black_ref_level
unsigned int vert_subsampling
unsigned int white_ref_level
int sub_descriptors_count
enum MXFMetadataSetType type
UID * sub_descriptors_refs
AVMasteringDisplayMetadata * mastering
AVContentLightMetadata * coll
enum MXFMetadataSetType type
UID * structural_components_refs
int structural_components_count
uint64_t * stream_offset_entries
unsigned edit_unit_byte_count
uint64_t index_start_position
AVRational index_edit_rate
int8_t * temporal_offset_entries
enum MXFMetadataSetType type
AVIndexEntry * fake_index
MXFIndexTableSegment ** segments
enum MXFMetadataSetType type
MXFMetadataReadFunc * read
enum MXFMetadataSetType type
MXFDescriptor * descriptor
uint64_t previous_partition
int64_t pack_ofs
absolute offset of pack in file, including run-in
int64_t essence_offset
absolute offset of essence
KLVPacket first_essence_klv
int64_t header_byte_count
UID * structural_components_refs
enum MXFMetadataSetType type
int structural_components_count
enum MXFMetadataSetType type
enum MXFMetadataSetType type
int64_t original_duration
int edit_units_per_packet
MXFWrappingScheme wrapping
#define av_malloc_array(a, b)
#define avpriv_request_sample(...)
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
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 AV_TIMECODE_STR_SIZE
@ AV_TIMECODE_FLAG_DROPFRAME
timecode is drop frame
static const uint8_t offset[127][2]