46 #include "libavutil/aes.h"
47 #include "libavutil/avassert.h"
48 #include "libavutil/mathematics.h"
50 #include "libavutil/timecode.h"
249 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
250 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
251 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
252 static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
255 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 };
256 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
257 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
258 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 };
259 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
261 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
267 int bytes_num = size & 0x7f;
273 size = size << 8 |
avio_r8(pb);
281 for (i = 0; i < size && !
url_feof(pb); i++) {
285 else if (b != key[i])
299 return klv->
length == -1 ? -1 : 0;
319 const uint8_t *buf_ptr, *end_ptr;
328 data_ptr = pkt->
data;
330 buf_ptr = pkt->
data + 4;
333 uint32_t
sample = bytestream_get_le32(&buf_ptr);
335 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
337 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
347 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
353 uint64_t plaintext_size;
380 if (orig_size < plaintext_size)
384 if (size < 32 || size - 32 < orig_size)
390 if (memcmp(tmpbuf, checkv, 16))
396 else if (size < plaintext_size)
398 size -= plaintext_size;
401 &pkt->
data[plaintext_size], size >> 4, ivec, 1);
414 if (item_len != 18) {
418 if (item_num > 65536) {
435 uint64_t footer_partition;
436 uint32_t nb_essence_containers;
455 memset(partition, 0,
sizeof(*partition));
491 if (footer_partition) {
494 "inconsistent FooterPartition value: %"PRIu64
" != %"PRIu64
"\n",
502 "PartitionPack: ThisPartition = 0x%"PRIX64
503 ", PreviousPartition = 0x%"PRIX64
", "
504 "FooterPartition = 0x%"PRIX64
", IndexSID = %i, BodySID = %i\n",
513 "PreviousPartition points to this partition or forward\n");
517 if (op[12] == 1 && op[13] == 1) mxf->
op =
OP1a;
518 else if (op[12] == 1 && op[13] == 2) mxf->
op =
OP1b;
519 else if (op[12] == 1 && op[13] == 3) mxf->
op =
OP1c;
520 else if (op[12] == 2 && op[13] == 1) mxf->
op =
OP2a;
521 else if (op[12] == 2 && op[13] == 2) mxf->
op =
OP2b;
522 else if (op[12] == 2 && op[13] == 3) mxf->
op =
OP2c;
523 else if (op[12] == 3 && op[13] == 1) mxf->
op =
OP3a;
524 else if (op[12] == 3 && op[13] == 2) mxf->
op =
OP3b;
525 else if (op[12] == 3 && op[13] == 3) mxf->
op =
OP3c;
526 else if (op[12] == 64&& op[13] == 1) mxf->
op =
OPSONYOpt;
527 else if (op[12] == 0x10) {
532 if (nb_essence_containers != 1) {
538 nb_essence_containers, op ==
OP1a ?
"OP1a" :
"OPAtom");
544 av_log(mxf->
fc,
AV_LOG_ERROR,
"unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
629 package->tracks_refs =
av_calloc(package->tracks_count,
sizeof(
UID));
630 if (!package->tracks_refs)
705 package->tracks_refs =
av_calloc(package->tracks_count,
sizeof(
UID));
706 if (!package->tracks_refs)
717 avio_read(pb, package->descriptor_ref, 16);
763 av_dlog(NULL,
"IndexEntryArray found\n");
785 int code,
value, ofs = 0;
791 av_dlog(NULL,
"pixel layout: code %#x\n", code);
794 layout[ofs++] = code;
795 layout[ofs++] =
value;
891 for (i = 0; i <
len; i++) {
892 if (i != 7 && key[i] != uid[i])
900 while (uls->
uid[0]) {
925 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14,
AV_CODEC_ID_MPEG2VIDEO },
926 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,
AV_CODEC_ID_DVVIDEO },
927 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,
AV_CODEC_ID_RAWVIDEO },
928 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
933 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14,
AV_CODEC_ID_MPEG2VIDEO },
934 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
939 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14,
AV_CODEC_ID_H264 },
940 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14,
AV_CODEC_ID_JPEG2000 },
941 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
946 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14,
AV_CODEC_ID_PCM_S16LE },
947 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14,
AV_CODEC_ID_MP2 },
948 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14,
AV_CODEC_ID_PCM_S16LE },
949 { { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0xFF,0x4B,0x46,0x41,0x41,0x00,0x0D,0x4D,0x4F }, 14,
AV_CODEC_ID_PCM_S16LE },
950 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0,
AV_CODEC_ID_NONE },
955 int i, j, nb_segments = 0;
957 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
967 if (!(unsorted_segments =
av_calloc(nb_segments,
sizeof(*unsorted_segments))) ||
968 !(*sorted_segments =
av_calloc(nb_segments,
sizeof(**sorted_segments)))) {
978 *nb_sorted_segments = 0;
981 for (i = 0; i < nb_segments; i++) {
982 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
983 uint64_t best_index_duration = 0;
985 for (j = 0; j < nb_segments; j++) {
1007 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1008 last_body_sid = best_body_sid;
1009 last_index_sid = best_index_sid;
1010 last_index_start = best_index_start;
1024 int64_t offset_in =
offset;
1041 "failed to find absolute offset of %"PRIX64
" in BodySID %i - partial file?\n",
1042 offset_in, body_sid);
1074 int64_t offset_temp = 0;
1098 av_log(mxf->
fc,
AV_LOG_ERROR,
"IndexSID %i segment at %"PRId64
" missing EditUnitByteCount and IndexEntryArray\n",
1104 *edit_unit_out = edit_unit;
1122 int8_t max_temporal_offset = -128;
1148 for (x = 0; x < index_table->
nb_ptses; x++)
1180 int index_delta = 1;
1189 for (j = 0; j <
n; j += index_delta, x++) {
1195 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64
"?\n",
1203 if (index < 0 || index >= index_table->
nb_ptses) {
1205 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1211 max_temporal_offset =
FFMAX(max_temporal_offset, offset);
1215 index_table->
first_dts = -max_temporal_offset;
1226 int i, j, k,
ret, nb_sorted_segments;
1230 nb_sorted_segments <= 0) {
1236 for (i = 0; i < nb_sorted_segments; i++) {
1237 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1239 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1242 goto finish_decoding_index;
1249 goto finish_decoding_index;
1253 for (i = j = 0; i < nb_sorted_segments; i++) {
1254 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1268 goto finish_decoding_index;
1271 if (sorted_segments[i]->index_start_position)
1272 av_log(mxf->
fc,
AV_LOG_WARNING,
"IndexSID %i starts at EditUnit %"PRId64
" - seeking may not work as expected\n",
1280 goto finish_decoding_index;
1288 av_log(mxf->
fc,
AV_LOG_WARNING,
"IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1305 finish_decoding_index:
1336 if (material_package)
break;
1338 if (!material_package) {
1351 UID *essence_container_ul = NULL;
1401 source_package = temp_package;
1405 if (!source_package) {
1406 av_dlog(mxf->
fc,
"material track %d: no corresponding source package found\n", material_track->
track_id);
1416 source_track = temp_track;
1420 if (!source_track) {
1425 if (!source_track || !component)
1455 "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
1474 if (!sub_descriptor) {
1479 descriptor = sub_descriptor;
1500 essence_container_ul = &((
MXFCryptoContext *)metadata)->source_container_ul;
1511 for (k = 0; k < 16; k++) {
1514 if (!(k+1 & 19) || k == 5)
1520 container_ul =
mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1566 container_ul =
mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1578 "found for stream #%d, time base forced to 1/48000\n",
1629 buf_size = size + size/2 + 1;
1649 for (i = 0; i <
sizeof(
UID); i++) {
1650 snprintf(p, 2 + 1,
"%.2x", uid[i]);
1652 if (i == 3 || i == 5 || i == 7 || i == 9) {
1662 struct tm time = {0};
1663 time.tm_year = (timestamp >> 48) - 1900;
1664 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1665 time.tm_mday = (timestamp >> 32 & 0xFF);
1666 time.tm_hour = (timestamp >> 24 & 0xFF);
1667 time.tm_min = (timestamp >> 16 & 0xFF);
1668 time.tm_sec = (timestamp >> 8 & 0xFF);
1671 time.tm_mon =
FFMAX(time.tm_mon, 0);
1672 time.tm_mday =
FFMAX(time.tm_mday, 1);
1677 strftime(*str, 32,
"%Y-%m-%d %H:%M:%S", &time);
1682 #define SET_STR_METADATA(pb, name, str) do { \
1683 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1685 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1688 #define SET_UID_METADATA(pb, name, var, str) do { \
1689 avio_read(pb, var, 16); \
1690 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1692 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1695 #define SET_TS_METADATA(pb, name, var, str) do { \
1696 var = avio_rb64(pb); \
1697 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1699 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1740 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 },
mxf_read_primer_pack },
1741 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 },
mxf_read_partition_pack },
1742 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 },
mxf_read_partition_pack },
1743 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 },
mxf_read_partition_pack },
1744 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 },
mxf_read_partition_pack },
1745 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 },
mxf_read_partition_pack },
1746 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 },
mxf_read_partition_pack },
1747 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 },
mxf_read_partition_pack },
1748 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 },
mxf_read_partition_pack },
1749 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 },
mxf_read_partition_pack },
1750 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 },
mxf_read_partition_pack },
1751 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 },
mxf_read_identification_metadata },
1752 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 },
mxf_read_content_storage, 0,
AnyType },
1753 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 },
mxf_read_source_package,
sizeof(
MXFPackage),
SourcePackage },
1754 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 },
mxf_read_material_package,
sizeof(
MXFPackage),
MaterialPackage },
1755 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 },
mxf_read_sequence,
sizeof(
MXFSequence),
Sequence },
1756 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 },
mxf_read_source_clip,
sizeof(
MXFStructuralComponent),
SourceClip },
1757 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
MultipleDescriptor },
1758 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
1759 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
1760 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
1761 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
1762 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
1763 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 },
mxf_read_generic_descriptor,
sizeof(
MXFDescriptor),
Descriptor },
1764 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 },
mxf_read_track,
sizeof(
MXFTrack),
Track },
1765 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 },
mxf_read_track,
sizeof(
MXFTrack),
Track },
1766 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 },
mxf_read_timecode_component,
sizeof(
MXFTimecodeComponent),
TimecodeComponent },
1767 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 },
mxf_read_cryptographic_context,
sizeof(
MXFCryptoContext),
CryptoContext },
1768 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 },
mxf_read_index_table_segment,
sizeof(
MXFIndexTableSegment),
IndexTableSegment },
1769 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0,
AnyType },
1787 av_dlog(mxf->
fc,
"local tag %#04x size %d\n", tag, size);
1796 if (local_tag == tag) {
1798 av_dlog(mxf->
fc,
"local tag %#04x\n", local_tag);
1803 if (ctx_size && tag == 0x3C0A)
1805 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1815 "local tag %#04x extends past end of local set @ %#"PRIx64
"\n",
1841 av_dlog(mxf->
fc,
"seeking to previous partition\n");
1862 av_dlog(mxf->
fc,
"seeking to last partition\n");
1874 av_log(mxf->
fc,
AV_LOG_ERROR,
"failed to seek to last partition @ 0x%"PRIx64
" (%"PRId64
") - partial file?\n",
1875 mxf->
run_in + offset, ret);
1882 av_dlog(mxf->
fc,
"can't find last partition\n");
1925 "partition %i: bad ThisPartition = %"PRIX64
"\n",
1935 int64_t
ret = (position / kag_size) * kag_size;
1936 return ret == position ? ret : ret + kag_size;
1988 if (length <= 32 || length >=
FFMIN(file_size, INT_MAX))
1993 klv.
length != length - 20)
2007 int64_t essence_offset = 0;
2052 int64_t op1a_essence_offset =
2070 if (!essence_offset)
2071 essence_offset = klv.
offset;
2087 for (metadata = mxf_metadata_read_table; metadata->
read; metadata++) {
2090 if (klv.
key[5] == 0x53) {
2112 if (!metadata->
read)
2116 if (!essence_offset) {
2134 av_log(mxf->
fc,
AV_LOG_INFO,
"got %i index tables - only the first one (IndexSID %i) will be used\n",
2157 int64_t last_ofs = -1, next_ofs = -1;
2170 if (next_ofs <= last_ofs) {
2174 "next_ofs didn't change. not deriving packet timestamps\n");
2178 if (next_ofs > current_offset)
2181 last_ofs = next_ofs;
2194 int i, total = 0, size = 0;
2201 if ((sample_rate.
num / sample_rate.
den) == 48000)
2204 int remainder = (sample_rate.
num * time_base.
num) % (time_base.
den * sample_rate.
den);
2206 av_mul_q(sample_rate, time_base)));
2209 "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2210 stream_index, time_base.
num, time_base.
den, sample_rate.
num, sample_rate.
den);
2261 int64_t next_ofs, next_klv;
2280 if (next_ofs >= 0 && next_klv > next_ofs) {
2284 "OPAtom misinterpreted as OP1a?"
2285 "KLV for edit unit %i extending into "
2292 if (klv.
key[12] == 0x06 && klv.
key[13] == 0x01 && klv.
key[14] == 0x10) {
2339 int64_t ret64, pos, next_pos;
2368 if ((size = next_pos - pos) <= 0) {
2373 if ((ret64 =
avio_seek(s->
pb, pos, SEEK_SET)) < 0)
2459 for (; bufp <
end; bufp++) {
2486 if (sample_time < 0)
2499 sample_time =
FFMAX(sample_time, 0);
2523 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.
static int mxf_parse_structural_metadata(MXFContext *mxf)
void * av_calloc(size_t nmemb, size_t size) av_malloc_attrib
Allocate a block of nmemb * size bytes with alignment suitable for all memory accesses (including vec...
#define AVERROR_PATCHWELCOME
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[]
#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, if possible.
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.
static void mxf_read_random_index_pack(AVFormatContext *s)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
AVCodecContext * codec
Codec context associated with this stream.
int index
stream index in AVFormatContext
#define SET_TS_METADATA(pb, name, var, str)
uint64_t footer_partition
enum MXFMetadataSetType type
void av_aes_crypt(struct 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)
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
static int mxf_is_intra_only(MXFDescriptor *descriptor)
static int mxf_read_header(AVFormatContext *s)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
enum MXFMetadataSetType type
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
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)
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)
static const uint8_t mxf_avid_essence_element_key[]
static const uint8_t offset[511][2]
static av_cold int end(AVCodecContext *avctx)
AVRational index_edit_rate
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
enum AVStreamParseType need_parsing
int id
Format-specific stream ID.
static int mxf_read_close(AVFormatContext *s)
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) av_const
Multiply two rationals.
static const uint8_t mxf_sony_mpeg4_extradata[]
static av_cold int read_close(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
enum AVPixelFormat pix_fmt
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
unsigned int vert_subsampling
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 int mxf_timestamp_to_str(uint64_t timestamp, char **str)
int64_t original_duration
duration before multiplying st->duration by SampleRate/EditRate
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const
Rescale a 64-bit integer by 2 rational numbers.
#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.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
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)
int8_t * temporal_offset_entries
void * priv_data
Format private data.
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[]
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
static const MXFCodecUL mxf_sound_essence_container_uls[]
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
static int64_t round_to_kag(int64_t position, int kag_size)
AVPixelFormat
Pixel format.
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 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 int nb_streams
A list of all streams in the file.
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
MXFPartition * partitions
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.
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str)
unsigned int horiz_subsampling
Opaque data information usually continuous.
int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const
Rescale a 64-bit integer with rounding to nearest.
static const uint8_t mxf_encrypted_triplet_key[]
enum AVPixelFormat pix_fmt
int64_t essence_offset
absolute offset of essence
int width
picture width / height.
static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
int edit_units_per_packet
how many edit units to read at a time (PCM, OPAtom)
int64_t last_forward_tell
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static const uint8_t mxf_header_partition_pack_key[]
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
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
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
preferred ID for MPEG-1/2 video decoding
static int read_header(FFV1Context *f)
int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
#define AV_LOG_INFO
Standard information.
enum AVMediaType codec_type
int sub_descriptors_count
int sample_rate
samples per second
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[]
main external API structure.
#define AV_TIMECODE_STR_SIZE
AVIOContext * pb
I/O context.
static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
rational number numerator/denominator
static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
static const uint8_t mxf_system_item_key[]
unsigned partitions_count
This structure contains the data a format has to probe a file.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
static int64_t klv_decode_ber_length(AVIOContext *pb)
int64_t duration
Decoding: duration of the stream, in stream time base.
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
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[]
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
AVInputFormat ff_mxf_demuxer
AVIndexEntry * fake_index
int structural_components_count
static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
#define AVERROR_INVALIDDATA
uint64_t * stream_offset_entries
int channels
number of audio channels
static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
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_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 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
Decoding: 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.
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.
This structure stores compressed data.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
MXFPartition * current_partition
#define AV_NOPTS_VALUE
Undefined timestamp value.
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
uint64_t previous_partition
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
int64_t header_byte_count