3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25 * SMPTE 377M MXF File Format Specifications
26 * SMPTE 378M Operational Pattern 1a
27 * SMPTE 379M MXF Generic Container
28 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
33 * Search for Track numbers which will identify essence element KLV packets.
34 * Search for SourcePackage which define tracks which contains Track numbers.
35 * Material Package contains tracks with reference to SourcePackage tracks.
36 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37 * Assign Descriptors to correct Tracks.
39 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40 * Metadata parsing resolves Strong References to objects.
42 * Simple demuxer, only OP1A supported and some files might not work at all.
43 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
48 #include "libavutil/aes.h"
49 #include "libavcodec/bytestream.h"
55 enum MXFMetadataSetType type
;
56 UID source_container_ul
;
61 enum MXFMetadataSetType type
;
62 UID source_package_uid
;
63 UID data_definition_ul
;
65 int64_t start_position
;
67 } MXFStructuralComponent
;
71 enum MXFMetadataSetType type
;
72 UID data_definition_ul
;
73 UID
*structural_components_refs
;
74 int structural_components_count
;
80 enum MXFMetadataSetType type
;
81 MXFSequence
*sequence
; /* mandatory, and only one */
84 uint8_t track_number
[4];
90 enum MXFMetadataSetType type
;
91 UID essence_container_ul
;
93 AVRational sample_rate
;
94 AVRational aspect_ratio
;
99 UID
*sub_descriptors_refs
;
100 int sub_descriptors_count
;
108 enum MXFMetadataSetType type
;
109 } MXFIndexTableSegment
;
113 enum MXFMetadataSetType type
;
117 MXFDescriptor
*descriptor
; /* only one */
123 enum MXFMetadataSetType type
;
129 MXFMetadataSet
**metadata_sets
;
130 int metadata_sets_count
;
134 int local_tags_count
;
137 enum MXFWrappingScheme
{
146 enum MXFMetadataSetType type
;
147 } MXFMetadataReadTableEntry
;
149 /* partial keys to match */
150 static const uint8_t mxf_header_partition_pack_key
[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
151 static const uint8_t mxf_essence_element_key
[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
152 static const uint8_t mxf_klv_key
[] = { 0x06,0x0e,0x2b,0x34 };
153 /* complete keys to match */
154 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 };
155 static const uint8_t mxf_encrypted_triplet_key
[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
156 static const uint8_t mxf_encrypted_essence_container
[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
157 static const uint8_t mxf_sony_mpeg4_extradata
[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
159 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
161 static int64_t klv_decode_ber_length(ByteIOContext
*pb
)
163 uint64_t size
= get_byte(pb
);
164 if (size
& 0x80) { /* long form */
165 int bytes_num
= size
& 0x7f;
166 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
171 size
= size
<< 8 | get_byte(pb
);
176 static int mxf_read_sync(ByteIOContext
*pb
, const uint8_t *key
, unsigned size
)
179 for (i
= 0; i
< size
&& !url_feof(pb
); i
++) {
183 else if (b
!= key
[i
])
189 static int klv_read_packet(KLVPacket
*klv
, ByteIOContext
*pb
)
191 if (!mxf_read_sync(pb
, mxf_klv_key
, 4))
193 klv
->offset
= url_ftell(pb
) - 4;
194 memcpy(klv
->key
, mxf_klv_key
, 4);
195 get_buffer(pb
, klv
->key
+ 4, 12);
196 klv
->length
= klv_decode_ber_length(pb
);
197 return klv
->length
== -1 ? -1 : 0;
200 static int mxf_get_stream_index(AVFormatContext
*s
, KLVPacket
*klv
)
204 for (i
= 0; i
< s
->nb_streams
; i
++) {
205 MXFTrack
*track
= s
->streams
[i
]->priv_data
;
207 if (!memcmp(klv
->key
+ sizeof(mxf_essence_element_key
), track
->track_number
, sizeof(track
->track_number
)))
210 /* return 0 if only one stream, for OP Atom files with 0 as track number */
211 return s
->nb_streams
== 1 ? 0 : -1;
214 /* XXX: use AVBitStreamFilter */
215 static int mxf_get_d10_aes3_packet(ByteIOContext
*pb
, AVStream
*st
, AVPacket
*pkt
, int64_t length
)
217 uint8_t buffer
[61444];
218 const uint8_t *buf_ptr
, *end_ptr
;
222 if (length
> 61444) /* worst case PAL 1920 samples 8 channels */
224 get_buffer(pb
, buffer
, length
);
225 av_new_packet(pkt
, length
);
226 data_ptr
= pkt
->data
;
227 end_ptr
= buffer
+ length
;
228 buf_ptr
= buffer
+ 4; /* skip SMPTE 331M header */
229 for (; buf_ptr
< end_ptr
; ) {
230 for (i
= 0; i
< st
->codec
->channels
; i
++) {
231 uint32_t sample
= bytestream_get_le32(&buf_ptr
);
232 if (st
->codec
->bits_per_coded_sample
== 24)
233 bytestream_put_le24(&data_ptr
, (sample
>> 4) & 0xffffff);
235 bytestream_put_le16(&data_ptr
, (sample
>> 12) & 0xffff);
237 buf_ptr
+= 32 - st
->codec
->channels
*4; // always 8 channels stored SMPTE 331M
239 pkt
->size
= data_ptr
- pkt
->data
;
243 static int mxf_decrypt_triplet(AVFormatContext
*s
, AVPacket
*pkt
, KLVPacket
*klv
)
245 static const uint8_t checkv
[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
246 MXFContext
*mxf
= s
->priv_data
;
247 ByteIOContext
*pb
= s
->pb
;
248 int64_t end
= url_ftell(pb
) + klv
->length
;
251 uint64_t plaintext_size
;
256 if (!mxf
->aesc
&& s
->key
&& s
->keylen
== 16) {
257 mxf
->aesc
= av_malloc(av_aes_size
);
260 av_aes_init(mxf
->aesc
, s
->key
, 128, 1);
263 url_fskip(pb
, klv_decode_ber_length(pb
));
265 klv_decode_ber_length(pb
);
266 plaintext_size
= get_be64(pb
);
268 klv_decode_ber_length(pb
);
269 get_buffer(pb
, klv
->key
, 16);
270 if (!IS_KLV_KEY(klv
, mxf_essence_element_key
))
272 index
= mxf_get_stream_index(s
, klv
);
276 klv_decode_ber_length(pb
);
277 orig_size
= get_be64(pb
);
278 if (orig_size
< plaintext_size
)
281 size
= klv_decode_ber_length(pb
);
282 if (size
< 32 || size
- 32 < orig_size
)
284 get_buffer(pb
, ivec
, 16);
285 get_buffer(pb
, tmpbuf
, 16);
287 av_aes_crypt(mxf
->aesc
, tmpbuf
, tmpbuf
, 1, ivec
, 1);
288 if (memcmp(tmpbuf
, checkv
, 16))
289 av_log(s
, AV_LOG_ERROR
, "probably incorrect decryption key\n");
291 av_get_packet(pb
, pkt
, size
);
292 size
-= plaintext_size
;
294 av_aes_crypt(mxf
->aesc
, &pkt
->data
[plaintext_size
],
295 &pkt
->data
[plaintext_size
], size
>> 4, ivec
, 1);
296 pkt
->size
= orig_size
;
297 pkt
->stream_index
= index
;
298 url_fskip(pb
, end
- url_ftell(pb
));
302 static int mxf_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
306 while (!url_feof(s
->pb
)) {
307 if (klv_read_packet(&klv
, s
->pb
) < 0)
309 PRINT_KEY(s
, "read packet", klv
.key
);
310 dprintf(s
, "size %lld offset %#llx\n", klv
.length
, klv
.offset
);
311 if (IS_KLV_KEY(klv
.key
, mxf_encrypted_triplet_key
)) {
312 int res
= mxf_decrypt_triplet(s
, pkt
, &klv
);
314 av_log(s
, AV_LOG_ERROR
, "invalid encoded triplet\n");
319 if (IS_KLV_KEY(klv
.key
, mxf_essence_element_key
)) {
320 int index
= mxf_get_stream_index(s
, &klv
);
322 av_log(s
, AV_LOG_ERROR
, "error getting stream index %d\n", AV_RB32(klv
.key
+12));
325 if (s
->streams
[index
]->discard
== AVDISCARD_ALL
)
327 /* check for 8 channels AES3 element */
328 if (klv
.key
[12] == 0x06 && klv
.key
[13] == 0x01 && klv
.key
[14] == 0x10) {
329 if (mxf_get_d10_aes3_packet(s
->pb
, s
->streams
[index
], pkt
, klv
.length
) < 0) {
330 av_log(s
, AV_LOG_ERROR
, "error reading D-10 aes3 frame\n");
334 av_get_packet(s
->pb
, pkt
, klv
.length
);
335 pkt
->stream_index
= index
;
336 pkt
->pos
= klv
.offset
;
340 url_fskip(s
->pb
, klv
.length
);
345 static int mxf_read_primer_pack(MXFContext
*mxf
)
347 ByteIOContext
*pb
= mxf
->fc
->pb
;
348 int item_num
= get_be32(pb
);
349 int item_len
= get_be32(pb
);
351 if (item_len
!= 18) {
352 av_log(mxf
->fc
, AV_LOG_ERROR
, "unsupported primer pack item length\n");
355 if (item_num
> UINT_MAX
/ item_len
)
357 mxf
->local_tags_count
= item_num
;
358 mxf
->local_tags
= av_malloc(item_num
*item_len
);
359 if (!mxf
->local_tags
)
361 get_buffer(pb
, mxf
->local_tags
, item_num
*item_len
);
365 static int mxf_add_metadata_set(MXFContext
*mxf
, void *metadata_set
)
367 mxf
->metadata_sets
= av_realloc(mxf
->metadata_sets
, (mxf
->metadata_sets_count
+ 1) * sizeof(*mxf
->metadata_sets
));
368 if (!mxf
->metadata_sets
)
370 mxf
->metadata_sets
[mxf
->metadata_sets_count
] = metadata_set
;
371 mxf
->metadata_sets_count
++;
375 static int mxf_read_cryptographic_context(MXFCryptoContext
*cryptocontext
, ByteIOContext
*pb
, int tag
, int size
, UID uid
)
379 if (IS_KLV_KEY(uid
, mxf_crypto_source_container_ul
))
380 get_buffer(pb
, cryptocontext
->source_container_ul
, 16);
384 static int mxf_read_content_storage(MXFContext
*mxf
, ByteIOContext
*pb
, int tag
)
388 mxf
->packages_count
= get_be32(pb
);
389 if (mxf
->packages_count
>= UINT_MAX
/ sizeof(UID
))
391 mxf
->packages_refs
= av_malloc(mxf
->packages_count
* sizeof(UID
));
392 if (!mxf
->packages_refs
)
394 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
395 get_buffer(pb
, (uint8_t *)mxf
->packages_refs
, mxf
->packages_count
* sizeof(UID
));
401 static int mxf_read_source_clip(MXFStructuralComponent
*source_clip
, ByteIOContext
*pb
, int tag
)
405 source_clip
->duration
= get_be64(pb
);
408 source_clip
->start_position
= get_be64(pb
);
411 /* UMID, only get last 16 bytes */
413 get_buffer(pb
, source_clip
->source_package_uid
, 16);
416 source_clip
->source_track_id
= get_be32(pb
);
422 static int mxf_read_material_package(MXFPackage
*package
, ByteIOContext
*pb
, int tag
)
426 package
->tracks_count
= get_be32(pb
);
427 if (package
->tracks_count
>= UINT_MAX
/ sizeof(UID
))
429 package
->tracks_refs
= av_malloc(package
->tracks_count
* sizeof(UID
));
430 if (!package
->tracks_refs
)
432 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
433 get_buffer(pb
, (uint8_t *)package
->tracks_refs
, package
->tracks_count
* sizeof(UID
));
439 static int mxf_read_track(MXFTrack
*track
, ByteIOContext
*pb
, int tag
)
443 track
->track_id
= get_be32(pb
);
446 get_buffer(pb
, track
->track_number
, 4);
449 track
->edit_rate
.den
= get_be32(pb
);
450 track
->edit_rate
.num
= get_be32(pb
);
453 get_buffer(pb
, track
->sequence_ref
, 16);
459 static int mxf_read_sequence(MXFSequence
*sequence
, ByteIOContext
*pb
, int tag
)
463 sequence
->duration
= get_be64(pb
);
466 get_buffer(pb
, sequence
->data_definition_ul
, 16);
469 sequence
->structural_components_count
= get_be32(pb
);
470 if (sequence
->structural_components_count
>= UINT_MAX
/ sizeof(UID
))
472 sequence
->structural_components_refs
= av_malloc(sequence
->structural_components_count
* sizeof(UID
));
473 if (!sequence
->structural_components_refs
)
475 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
476 get_buffer(pb
, (uint8_t *)sequence
->structural_components_refs
, sequence
->structural_components_count
* sizeof(UID
));
482 static int mxf_read_source_package(MXFPackage
*package
, ByteIOContext
*pb
, int tag
)
486 package
->tracks_count
= get_be32(pb
);
487 if (package
->tracks_count
>= UINT_MAX
/ sizeof(UID
))
489 package
->tracks_refs
= av_malloc(package
->tracks_count
* sizeof(UID
));
490 if (!package
->tracks_refs
)
492 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
493 get_buffer(pb
, (uint8_t *)package
->tracks_refs
, package
->tracks_count
* sizeof(UID
));
496 /* UMID, only get last 16 bytes */
498 get_buffer(pb
, package
->package_uid
, 16);
501 get_buffer(pb
, package
->descriptor_ref
, 16);
507 static int mxf_read_index_table_segment(MXFIndexTableSegment
*segment
, ByteIOContext
*pb
, int tag
)
510 case 0x3F05: dprintf(NULL
, "EditUnitByteCount %d\n", get_be32(pb
)); break;
511 case 0x3F06: dprintf(NULL
, "IndexSID %d\n", get_be32(pb
)); break;
512 case 0x3F07: dprintf(NULL
, "BodySID %d\n", get_be32(pb
)); break;
513 case 0x3F0B: dprintf(NULL
, "IndexEditRate %d/%d\n", get_be32(pb
), get_be32(pb
)); break;
514 case 0x3F0C: dprintf(NULL
, "IndexStartPosition %lld\n", get_be64(pb
)); break;
515 case 0x3F0D: dprintf(NULL
, "IndexDuration %lld\n", get_be64(pb
)); break;
520 static void mxf_read_pixel_layout(ByteIOContext
*pb
, MXFDescriptor
*descriptor
)
526 dprintf(NULL
, "pixel layout: code %#x\n", code
);
529 descriptor
->bits_per_sample
+= get_byte(pb
);
532 descriptor
->bits_per_sample
+= get_byte(pb
);
535 descriptor
->bits_per_sample
+= get_byte(pb
);
540 } while (code
!= 0); /* SMPTE 377M E.2.46 */
543 static int mxf_read_generic_descriptor(MXFDescriptor
*descriptor
, ByteIOContext
*pb
, int tag
, int size
, UID uid
)
547 descriptor
->sub_descriptors_count
= get_be32(pb
);
548 if (descriptor
->sub_descriptors_count
>= UINT_MAX
/ sizeof(UID
))
550 descriptor
->sub_descriptors_refs
= av_malloc(descriptor
->sub_descriptors_count
* sizeof(UID
));
551 if (!descriptor
->sub_descriptors_refs
)
553 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
554 get_buffer(pb
, (uint8_t *)descriptor
->sub_descriptors_refs
, descriptor
->sub_descriptors_count
* sizeof(UID
));
557 get_buffer(pb
, descriptor
->essence_container_ul
, 16);
560 descriptor
->linked_track_id
= get_be32(pb
);
562 case 0x3201: /* PictureEssenceCoding */
563 get_buffer(pb
, descriptor
->essence_codec_ul
, 16);
566 descriptor
->width
= get_be32(pb
);
569 descriptor
->height
= get_be32(pb
);
572 descriptor
->aspect_ratio
.num
= get_be32(pb
);
573 descriptor
->aspect_ratio
.den
= get_be32(pb
);
576 descriptor
->sample_rate
.num
= get_be32(pb
);
577 descriptor
->sample_rate
.den
= get_be32(pb
);
579 case 0x3D06: /* SoundEssenceCompression */
580 get_buffer(pb
, descriptor
->essence_codec_ul
, 16);
583 descriptor
->channels
= get_be32(pb
);
586 descriptor
->bits_per_sample
= get_be32(pb
);
589 mxf_read_pixel_layout(pb
, descriptor
);
592 /* Private uid used by SONY C0023S01.mxf */
593 if (IS_KLV_KEY(uid
, mxf_sony_mpeg4_extradata
)) {
594 descriptor
->extradata
= av_malloc(size
);
595 if (!descriptor
->extradata
)
597 descriptor
->extradata_size
= size
;
598 get_buffer(pb
, descriptor
->extradata
, size
);
606 * Match an uid independently of the version byte and up to len common bytes
609 static int mxf_match_uid(const UID key
, const UID uid
, int len
)
612 for (i
= 0; i
< len
; i
++) {
613 if (i
!= 7 && key
[i
] != uid
[i
])
619 static const MXFCodecUL
*mxf_get_codec_ul(const MXFCodecUL
*uls
, UID
*uid
)
621 while (uls
->uid
[0]) {
622 if(mxf_match_uid(uls
->uid
, *uid
, uls
->matching_len
))
629 static void *mxf_resolve_strong_ref(MXFContext
*mxf
, UID
*strong_ref
, enum MXFMetadataSetType type
)
635 for (i
= 0; i
< mxf
->metadata_sets_count
; i
++) {
636 if (!memcmp(*strong_ref
, mxf
->metadata_sets
[i
]->uid
, 16) &&
637 (type
== AnyType
|| mxf
->metadata_sets
[i
]->type
== type
)) {
638 return mxf
->metadata_sets
[i
];
644 static const MXFCodecUL mxf_essence_container_uls
[] = {
645 // video essence container uls
646 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, CODEC_ID_MPEG2VIDEO
}, /* MPEG-ES Frame wrapped */
647 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, CODEC_ID_DVVIDEO
}, /* DV 625 25mbps */
648 // sound essence container uls
649 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, CODEC_ID_PCM_S16LE
}, /* BWF Frame wrapped */
650 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, CODEC_ID_MP2
}, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */
651 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, CODEC_ID_PCM_S16LE
}, /* D-10 Mapping 50Mbps PAL Extended Template */
652 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE
},
655 static int mxf_parse_structural_metadata(MXFContext
*mxf
)
657 MXFPackage
*material_package
= NULL
;
658 MXFPackage
*temp_package
= NULL
;
661 dprintf(mxf
->fc
, "metadata sets count %d\n", mxf
->metadata_sets_count
);
662 /* TODO: handle multiple material packages (OP3x) */
663 for (i
= 0; i
< mxf
->packages_count
; i
++) {
664 material_package
= mxf_resolve_strong_ref(mxf
, &mxf
->packages_refs
[i
], MaterialPackage
);
665 if (material_package
) break;
667 if (!material_package
) {
668 av_log(mxf
->fc
, AV_LOG_ERROR
, "no material package found\n");
672 for (i
= 0; i
< material_package
->tracks_count
; i
++) {
673 MXFPackage
*source_package
= NULL
;
674 MXFTrack
*material_track
= NULL
;
675 MXFTrack
*source_track
= NULL
;
676 MXFTrack
*temp_track
= NULL
;
677 MXFDescriptor
*descriptor
= NULL
;
678 MXFStructuralComponent
*component
= NULL
;
679 UID
*essence_container_ul
= NULL
;
680 const MXFCodecUL
*codec_ul
= NULL
;
681 const MXFCodecUL
*container_ul
= NULL
;
684 if (!(material_track
= mxf_resolve_strong_ref(mxf
, &material_package
->tracks_refs
[i
], Track
))) {
685 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve material track strong ref\n");
689 if (!(material_track
->sequence
= mxf_resolve_strong_ref(mxf
, &material_track
->sequence_ref
, Sequence
))) {
690 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve material track sequence strong ref\n");
694 /* TODO: handle multiple source clips */
695 for (j
= 0; j
< material_track
->sequence
->structural_components_count
; j
++) {
696 /* TODO: handle timecode component */
697 component
= mxf_resolve_strong_ref(mxf
, &material_track
->sequence
->structural_components_refs
[j
], SourceClip
);
701 for (k
= 0; k
< mxf
->packages_count
; k
++) {
702 temp_package
= mxf_resolve_strong_ref(mxf
, &mxf
->packages_refs
[k
], SourcePackage
);
705 if (!memcmp(temp_package
->package_uid
, component
->source_package_uid
, 16)) {
706 source_package
= temp_package
;
710 if (!source_package
) {
711 av_log(mxf
->fc
, AV_LOG_ERROR
, "material track %d: no corresponding source package found\n", material_track
->track_id
);
714 for (k
= 0; k
< source_package
->tracks_count
; k
++) {
715 if (!(temp_track
= mxf_resolve_strong_ref(mxf
, &source_package
->tracks_refs
[k
], Track
))) {
716 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve source track strong ref\n");
719 if (temp_track
->track_id
== component
->source_track_id
) {
720 source_track
= temp_track
;
725 av_log(mxf
->fc
, AV_LOG_ERROR
, "material track %d: no corresponding source track found\n", material_track
->track_id
);
732 st
= av_new_stream(mxf
->fc
, source_track
->track_id
);
734 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not allocate stream\n");
737 st
->priv_data
= source_track
;
738 st
->duration
= component
->duration
;
739 if (st
->duration
== -1)
740 st
->duration
= AV_NOPTS_VALUE
;
741 st
->start_time
= component
->start_position
;
742 av_set_pts_info(st
, 64, material_track
->edit_rate
.num
, material_track
->edit_rate
.den
);
744 if (!(source_track
->sequence
= mxf_resolve_strong_ref(mxf
, &source_track
->sequence_ref
, Sequence
))) {
745 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve source track sequence strong ref\n");
749 PRINT_KEY(mxf
->fc
, "data definition ul", source_track
->sequence
->data_definition_ul
);
750 codec_ul
= mxf_get_codec_ul(ff_mxf_data_definition_uls
, &source_track
->sequence
->data_definition_ul
);
751 st
->codec
->codec_type
= codec_ul
->id
;
753 source_package
->descriptor
= mxf_resolve_strong_ref(mxf
, &source_package
->descriptor_ref
, AnyType
);
754 if (source_package
->descriptor
) {
755 if (source_package
->descriptor
->type
== MultipleDescriptor
) {
756 for (j
= 0; j
< source_package
->descriptor
->sub_descriptors_count
; j
++) {
757 MXFDescriptor
*sub_descriptor
= mxf_resolve_strong_ref(mxf
, &source_package
->descriptor
->sub_descriptors_refs
[j
], Descriptor
);
759 if (!sub_descriptor
) {
760 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve sub descriptor strong ref\n");
763 if (sub_descriptor
->linked_track_id
== source_track
->track_id
) {
764 descriptor
= sub_descriptor
;
768 } else if (source_package
->descriptor
->type
== Descriptor
)
769 descriptor
= source_package
->descriptor
;
772 av_log(mxf
->fc
, AV_LOG_INFO
, "source track %d: stream %d, no descriptor found\n", source_track
->track_id
, st
->index
);
775 PRINT_KEY(mxf
->fc
, "essence codec ul", descriptor
->essence_codec_ul
);
776 PRINT_KEY(mxf
->fc
, "essence container ul", descriptor
->essence_container_ul
);
777 essence_container_ul
= &descriptor
->essence_container_ul
;
778 /* HACK: replacing the original key with mxf_encrypted_essence_container
779 * is not allowed according to s429-6, try to find correct information anyway */
780 if (IS_KLV_KEY(essence_container_ul
, mxf_encrypted_essence_container
)) {
781 av_log(mxf
->fc
, AV_LOG_INFO
, "broken encrypted mxf file\n");
782 for (k
= 0; k
< mxf
->metadata_sets_count
; k
++) {
783 MXFMetadataSet
*metadata
= mxf
->metadata_sets
[k
];
784 if (metadata
->type
== CryptoContext
) {
785 essence_container_ul
= &((MXFCryptoContext
*)metadata
)->source_container_ul
;
790 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
791 codec_ul
= mxf_get_codec_ul(ff_mxf_codec_uls
, &descriptor
->essence_codec_ul
);
792 st
->codec
->codec_id
= codec_ul
->id
;
793 if (descriptor
->extradata
) {
794 st
->codec
->extradata
= descriptor
->extradata
;
795 st
->codec
->extradata_size
= descriptor
->extradata_size
;
797 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
798 container_ul
= mxf_get_codec_ul(mxf_essence_container_uls
, essence_container_ul
);
799 if (st
->codec
->codec_id
== CODEC_ID_NONE
)
800 st
->codec
->codec_id
= container_ul
->id
;
801 st
->codec
->width
= descriptor
->width
;
802 st
->codec
->height
= descriptor
->height
;
803 st
->codec
->bits_per_coded_sample
= descriptor
->bits_per_sample
; /* Uncompressed */
804 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
805 } else if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
806 container_ul
= mxf_get_codec_ul(mxf_essence_container_uls
, essence_container_ul
);
807 if (st
->codec
->codec_id
== CODEC_ID_NONE
)
808 st
->codec
->codec_id
= container_ul
->id
;
809 st
->codec
->channels
= descriptor
->channels
;
810 st
->codec
->bits_per_coded_sample
= descriptor
->bits_per_sample
;
811 st
->codec
->sample_rate
= descriptor
->sample_rate
.num
/ descriptor
->sample_rate
.den
;
812 /* TODO: implement CODEC_ID_RAWAUDIO */
813 if (st
->codec
->codec_id
== CODEC_ID_PCM_S16LE
) {
814 if (descriptor
->bits_per_sample
== 24)
815 st
->codec
->codec_id
= CODEC_ID_PCM_S24LE
;
816 else if (descriptor
->bits_per_sample
== 32)
817 st
->codec
->codec_id
= CODEC_ID_PCM_S32LE
;
818 } else if (st
->codec
->codec_id
== CODEC_ID_PCM_S16BE
) {
819 if (descriptor
->bits_per_sample
== 24)
820 st
->codec
->codec_id
= CODEC_ID_PCM_S24BE
;
821 else if (descriptor
->bits_per_sample
== 32)
822 st
->codec
->codec_id
= CODEC_ID_PCM_S32BE
;
823 } else if (st
->codec
->codec_id
== CODEC_ID_MP2
) {
824 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
827 if (st
->codec
->codec_type
!= CODEC_TYPE_DATA
&& (*essence_container_ul
)[15] > 0x01) {
828 av_log(mxf
->fc
, AV_LOG_WARNING
, "only frame wrapped mappings are correctly supported\n");
829 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
835 static const MXFMetadataReadTableEntry mxf_metadata_read_table
[] = {
836 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack
},
837 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage
, 0, AnyType
},
838 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package
, sizeof(MXFPackage
), SourcePackage
},
839 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package
, sizeof(MXFPackage
), MaterialPackage
},
840 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence
, sizeof(MXFSequence
), Sequence
},
841 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip
, sizeof(MXFStructuralComponent
), SourceClip
},
842 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), MultipleDescriptor
},
843 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* Generic Sound */
844 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* CDCI */
845 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* RGBA */
846 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* MPEG 2 Video */
847 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* Wave */
848 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* AES3 */
849 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track
, sizeof(MXFTrack
), Track
}, /* Static Track */
850 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track
, sizeof(MXFTrack
), Track
}, /* Generic Track */
851 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context
, sizeof(MXFCryptoContext
), CryptoContext
},
852 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment
, sizeof(MXFIndexTableSegment
), IndexTableSegment
},
853 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL
, 0, AnyType
},
856 static int mxf_read_local_tags(MXFContext
*mxf
, KLVPacket
*klv
, int (*read_child
)(), int ctx_size
, enum MXFMetadataSetType type
)
858 ByteIOContext
*pb
= mxf
->fc
->pb
;
859 MXFMetadataSet
*ctx
= ctx_size
? av_mallocz(ctx_size
) : mxf
;
860 uint64_t klv_end
= url_ftell(pb
) + klv
->length
;
864 while (url_ftell(pb
) + 4 < klv_end
) {
865 int tag
= get_be16(pb
);
866 int size
= get_be16(pb
); /* KLV specified by 0x53 */
867 uint64_t next
= url_ftell(pb
) + size
;
870 dprintf(mxf
->fc
, "local tag %#04x size %d\n", tag
, size
);
871 if (!size
) { /* ignore empty tag, needed for some files with empty UMID tag */
872 av_log(mxf
->fc
, AV_LOG_ERROR
, "local tag %#04x with 0 size\n", tag
);
875 if (tag
> 0x7FFF) { /* dynamic tag */
877 for (i
= 0; i
< mxf
->local_tags_count
; i
++) {
878 int local_tag
= AV_RB16(mxf
->local_tags
+i
*18);
879 if (local_tag
== tag
) {
880 memcpy(uid
, mxf
->local_tags
+i
*18+2, 16);
881 dprintf(mxf
->fc
, "local tag %#04x\n", local_tag
);
882 PRINT_KEY(mxf
->fc
, "uid", uid
);
886 if (ctx_size
&& tag
== 0x3C0A)
887 get_buffer(pb
, ctx
->uid
, 16);
888 else if (read_child(ctx
, pb
, tag
, size
, uid
) < 0)
891 url_fseek(pb
, next
, SEEK_SET
);
893 if (ctx_size
) ctx
->type
= type
;
894 return ctx_size
? mxf_add_metadata_set(mxf
, ctx
) : 0;
897 static int mxf_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
899 MXFContext
*mxf
= s
->priv_data
;
902 if (!mxf_read_sync(s
->pb
, mxf_header_partition_pack_key
, 14)) {
903 av_log(s
, AV_LOG_ERROR
, "could not find header partition pack key\n");
906 url_fseek(s
->pb
, -14, SEEK_CUR
);
908 while (!url_feof(s
->pb
)) {
909 const MXFMetadataReadTableEntry
*metadata
;
911 if (klv_read_packet(&klv
, s
->pb
) < 0)
913 PRINT_KEY(s
, "read header", klv
.key
);
914 dprintf(s
, "size %lld offset %#llx\n", klv
.length
, klv
.offset
);
915 if (IS_KLV_KEY(klv
.key
, mxf_encrypted_triplet_key
) ||
916 IS_KLV_KEY(klv
.key
, mxf_essence_element_key
)) {
917 /* FIXME avoid seek */
918 url_fseek(s
->pb
, klv
.offset
, SEEK_SET
);
922 for (metadata
= mxf_metadata_read_table
; metadata
->read
; metadata
++) {
923 if (IS_KLV_KEY(klv
.key
, metadata
->key
)) {
924 int (*read
)() = klv
.key
[5] == 0x53 ? mxf_read_local_tags
: metadata
->read
;
925 if (read(mxf
, &klv
, metadata
->read
, metadata
->ctx_size
, metadata
->type
) < 0) {
926 av_log(s
, AV_LOG_ERROR
, "error reading header metadata\n");
933 url_fskip(s
->pb
, klv
.length
);
935 return mxf_parse_structural_metadata(mxf
);
938 static int mxf_read_close(AVFormatContext
*s
)
940 MXFContext
*mxf
= s
->priv_data
;
943 av_freep(&mxf
->packages_refs
);
944 for (i
= 0; i
< mxf
->metadata_sets_count
; i
++) {
945 switch (mxf
->metadata_sets
[i
]->type
) {
946 case MultipleDescriptor
:
947 av_freep(&((MXFDescriptor
*)mxf
->metadata_sets
[i
])->sub_descriptors_refs
);
950 av_freep(&((MXFSequence
*)mxf
->metadata_sets
[i
])->structural_components_refs
);
953 case MaterialPackage
:
954 av_freep(&((MXFPackage
*)mxf
->metadata_sets
[i
])->tracks_refs
);
957 mxf
->metadata_sets
[i
] = NULL
; /* will be freed later */
962 av_freep(&mxf
->metadata_sets
[i
]);
964 av_freep(&mxf
->metadata_sets
);
965 av_freep(&mxf
->aesc
);
966 av_freep(&mxf
->local_tags
);
970 static int mxf_probe(AVProbeData
*p
) {
971 uint8_t *bufp
= p
->buf
;
972 uint8_t *end
= p
->buf
+ p
->buf_size
;
974 if (p
->buf_size
< sizeof(mxf_header_partition_pack_key
))
977 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
978 end
-= sizeof(mxf_header_partition_pack_key
);
979 for (; bufp
< end
; bufp
++) {
980 if (IS_KLV_KEY(bufp
, mxf_header_partition_pack_key
))
981 return AVPROBE_SCORE_MAX
;
986 /* rudimentary byte seek */
987 /* XXX: use MXF Index */
988 static int mxf_read_seek(AVFormatContext
*s
, int stream_index
, int64_t sample_time
, int flags
)
990 AVStream
*st
= s
->streams
[stream_index
];
997 seconds
= av_rescale(sample_time
, st
->time_base
.num
, st
->time_base
.den
);
998 url_fseek(s
->pb
, (s
->bit_rate
* seconds
) >> 3, SEEK_SET
);
999 av_update_cur_dts(s
, st
, sample_time
);
1003 AVInputFormat mxf_demuxer
= {
1005 NULL_IF_CONFIG_SMALL("Material eXchange Format"),