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"
53 enum MXFMetadataSetType type
;
54 UID source_container_ul
;
59 enum MXFMetadataSetType type
;
60 UID source_package_uid
;
61 UID data_definition_ul
;
63 int64_t start_position
;
65 } MXFStructuralComponent
;
69 enum MXFMetadataSetType type
;
70 UID data_definition_ul
;
71 UID
*structural_components_refs
;
72 int structural_components_count
;
78 enum MXFMetadataSetType type
;
79 MXFSequence
*sequence
; /* mandatory, and only one */
82 uint8_t track_number
[4];
88 enum MXFMetadataSetType type
;
89 UID essence_container_ul
;
91 AVRational sample_rate
;
92 AVRational aspect_ratio
;
97 UID
*sub_descriptors_refs
;
98 int sub_descriptors_count
;
106 enum MXFMetadataSetType type
;
110 MXFDescriptor
*descriptor
; /* only one */
116 enum MXFMetadataSetType type
;
122 MXFMetadataSet
**metadata_sets
;
123 int metadata_sets_count
;
127 int local_tags_count
;
130 enum MXFWrappingScheme
{
139 enum MXFMetadataSetType type
;
140 } MXFMetadataReadTableEntry
;
142 /* partial keys to match */
143 static const uint8_t mxf_header_partition_pack_key
[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
144 static const uint8_t mxf_essence_element_key
[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
145 static const uint8_t mxf_klv_key
[] = { 0x06,0x0e,0x2b,0x34 };
146 /* complete keys to match */
147 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 };
148 static const uint8_t mxf_encrypted_triplet_key
[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
149 static const uint8_t mxf_encrypted_essence_container
[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
150 static const uint8_t mxf_sony_mpeg4_extradata
[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
152 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
154 static int64_t klv_decode_ber_length(ByteIOContext
*pb
)
156 uint64_t size
= get_byte(pb
);
157 if (size
& 0x80) { /* long form */
158 int bytes_num
= size
& 0x7f;
159 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
164 size
= size
<< 8 | get_byte(pb
);
169 static int mxf_read_sync(ByteIOContext
*pb
, const uint8_t *key
, unsigned size
)
172 for (i
= 0; i
< size
&& !url_feof(pb
); i
++) {
176 else if (b
!= key
[i
])
182 static int klv_read_packet(KLVPacket
*klv
, ByteIOContext
*pb
)
184 if (!mxf_read_sync(pb
, mxf_klv_key
, 4))
186 klv
->offset
= url_ftell(pb
) - 4;
187 memcpy(klv
->key
, mxf_klv_key
, 4);
188 get_buffer(pb
, klv
->key
+ 4, 12);
189 klv
->length
= klv_decode_ber_length(pb
);
190 return klv
->length
== -1 ? -1 : 0;
193 static int mxf_get_stream_index(AVFormatContext
*s
, KLVPacket
*klv
)
197 for (i
= 0; i
< s
->nb_streams
; i
++) {
198 MXFTrack
*track
= s
->streams
[i
]->priv_data
;
200 if (!memcmp(klv
->key
+ sizeof(mxf_essence_element_key
), track
->track_number
, sizeof(track
->track_number
)))
203 /* return 0 if only one stream, for OP Atom files with 0 as track number */
204 return s
->nb_streams
== 1 ? 0 : -1;
207 /* XXX: use AVBitStreamFilter */
208 static int mxf_get_d10_aes3_packet(ByteIOContext
*pb
, AVStream
*st
, AVPacket
*pkt
, int64_t length
)
210 uint8_t buffer
[61444];
211 const uint8_t *buf_ptr
, *end_ptr
;
215 if (length
> 61444) /* worst case PAL 1920 samples 8 channels */
217 get_buffer(pb
, buffer
, length
);
218 av_new_packet(pkt
, length
);
219 data_ptr
= pkt
->data
;
220 end_ptr
= buffer
+ length
;
221 buf_ptr
= buffer
+ 4; /* skip SMPTE 331M header */
222 for (; buf_ptr
< end_ptr
; ) {
223 for (i
= 0; i
< st
->codec
->channels
; i
++) {
224 uint32_t sample
= bytestream_get_le32(&buf_ptr
);
225 if (st
->codec
->bits_per_coded_sample
== 24)
226 bytestream_put_le24(&data_ptr
, (sample
>> 4) & 0xffffff);
228 bytestream_put_le16(&data_ptr
, (sample
>> 12) & 0xffff);
230 buf_ptr
+= 32 - st
->codec
->channels
*4; // always 8 channels stored SMPTE 331M
232 pkt
->size
= data_ptr
- pkt
->data
;
236 static int mxf_decrypt_triplet(AVFormatContext
*s
, AVPacket
*pkt
, KLVPacket
*klv
)
238 static const uint8_t checkv
[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
239 MXFContext
*mxf
= s
->priv_data
;
240 ByteIOContext
*pb
= s
->pb
;
241 offset_t end
= url_ftell(pb
) + klv
->length
;
244 uint64_t plaintext_size
;
249 if (!mxf
->aesc
&& s
->key
&& s
->keylen
== 16) {
250 mxf
->aesc
= av_malloc(av_aes_size
);
253 av_aes_init(mxf
->aesc
, s
->key
, 128, 1);
256 url_fskip(pb
, klv_decode_ber_length(pb
));
258 klv_decode_ber_length(pb
);
259 plaintext_size
= get_be64(pb
);
261 klv_decode_ber_length(pb
);
262 get_buffer(pb
, klv
->key
, 16);
263 if (!IS_KLV_KEY(klv
, mxf_essence_element_key
))
265 index
= mxf_get_stream_index(s
, klv
);
269 klv_decode_ber_length(pb
);
270 orig_size
= get_be64(pb
);
271 if (orig_size
< plaintext_size
)
274 size
= klv_decode_ber_length(pb
);
275 if (size
< 32 || size
- 32 < orig_size
)
277 get_buffer(pb
, ivec
, 16);
278 get_buffer(pb
, tmpbuf
, 16);
280 av_aes_crypt(mxf
->aesc
, tmpbuf
, tmpbuf
, 1, ivec
, 1);
281 if (memcmp(tmpbuf
, checkv
, 16))
282 av_log(s
, AV_LOG_ERROR
, "probably incorrect decryption key\n");
284 av_get_packet(pb
, pkt
, size
);
285 size
-= plaintext_size
;
287 av_aes_crypt(mxf
->aesc
, &pkt
->data
[plaintext_size
],
288 &pkt
->data
[plaintext_size
], size
>> 4, ivec
, 1);
289 pkt
->size
= orig_size
;
290 pkt
->stream_index
= index
;
291 url_fskip(pb
, end
- url_ftell(pb
));
295 static int mxf_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
299 while (!url_feof(s
->pb
)) {
300 if (klv_read_packet(&klv
, s
->pb
) < 0)
302 PRINT_KEY(s
, "read packet", klv
.key
);
303 if (IS_KLV_KEY(klv
.key
, mxf_encrypted_triplet_key
)) {
304 int res
= mxf_decrypt_triplet(s
, pkt
, &klv
);
306 av_log(s
, AV_LOG_ERROR
, "invalid encoded triplet\n");
311 if (IS_KLV_KEY(klv
.key
, mxf_essence_element_key
)) {
312 int index
= mxf_get_stream_index(s
, &klv
);
314 av_log(s
, AV_LOG_ERROR
, "error getting stream index %d\n", AV_RB32(klv
.key
+12));
317 if (s
->streams
[index
]->discard
== AVDISCARD_ALL
)
319 /* check for 8 channels AES3 element */
320 if (klv
.key
[12] == 0x06 && klv
.key
[13] == 0x01 && klv
.key
[14] == 0x10) {
321 if (mxf_get_d10_aes3_packet(s
->pb
, s
->streams
[index
], pkt
, klv
.length
) < 0) {
322 av_log(s
, AV_LOG_ERROR
, "error reading D-10 aes3 frame\n");
326 av_get_packet(s
->pb
, pkt
, klv
.length
);
327 pkt
->stream_index
= index
;
328 pkt
->pos
= klv
.offset
;
332 url_fskip(s
->pb
, klv
.length
);
337 static int mxf_read_primer_pack(MXFContext
*mxf
)
339 ByteIOContext
*pb
= mxf
->fc
->pb
;
340 int item_num
= get_be32(pb
);
341 int item_len
= get_be32(pb
);
343 if (item_len
!= 18) {
344 av_log(mxf
->fc
, AV_LOG_ERROR
, "unsupported primer pack item length\n");
347 if (item_num
> UINT_MAX
/ item_len
)
349 mxf
->local_tags_count
= item_num
;
350 mxf
->local_tags
= av_malloc(item_num
*item_len
);
351 if (!mxf
->local_tags
)
353 get_buffer(pb
, mxf
->local_tags
, item_num
*item_len
);
357 static int mxf_add_metadata_set(MXFContext
*mxf
, void *metadata_set
)
359 mxf
->metadata_sets
= av_realloc(mxf
->metadata_sets
, (mxf
->metadata_sets_count
+ 1) * sizeof(*mxf
->metadata_sets
));
360 if (!mxf
->metadata_sets
)
362 mxf
->metadata_sets
[mxf
->metadata_sets_count
] = metadata_set
;
363 mxf
->metadata_sets_count
++;
367 static int mxf_read_cryptographic_context(MXFCryptoContext
*cryptocontext
, ByteIOContext
*pb
, int tag
, int size
, UID uid
)
371 if (IS_KLV_KEY(uid
, mxf_crypto_source_container_ul
))
372 get_buffer(pb
, cryptocontext
->source_container_ul
, 16);
376 static int mxf_read_content_storage(MXFContext
*mxf
, ByteIOContext
*pb
, int tag
)
380 mxf
->packages_count
= get_be32(pb
);
381 if (mxf
->packages_count
>= UINT_MAX
/ sizeof(UID
))
383 mxf
->packages_refs
= av_malloc(mxf
->packages_count
* sizeof(UID
));
384 if (!mxf
->packages_refs
)
386 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
387 get_buffer(pb
, (uint8_t *)mxf
->packages_refs
, mxf
->packages_count
* sizeof(UID
));
393 static int mxf_read_source_clip(MXFStructuralComponent
*source_clip
, ByteIOContext
*pb
, int tag
)
397 source_clip
->duration
= get_be64(pb
);
400 source_clip
->start_position
= get_be64(pb
);
403 /* UMID, only get last 16 bytes */
405 get_buffer(pb
, source_clip
->source_package_uid
, 16);
408 source_clip
->source_track_id
= get_be32(pb
);
414 static int mxf_read_material_package(MXFPackage
*package
, ByteIOContext
*pb
, int tag
)
418 package
->tracks_count
= get_be32(pb
);
419 if (package
->tracks_count
>= UINT_MAX
/ sizeof(UID
))
421 package
->tracks_refs
= av_malloc(package
->tracks_count
* sizeof(UID
));
422 if (!package
->tracks_refs
)
424 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
425 get_buffer(pb
, (uint8_t *)package
->tracks_refs
, package
->tracks_count
* sizeof(UID
));
431 static int mxf_read_track(MXFTrack
*track
, ByteIOContext
*pb
, int tag
)
435 track
->track_id
= get_be32(pb
);
438 get_buffer(pb
, track
->track_number
, 4);
441 track
->edit_rate
.den
= get_be32(pb
);
442 track
->edit_rate
.num
= get_be32(pb
);
445 get_buffer(pb
, track
->sequence_ref
, 16);
451 static int mxf_read_sequence(MXFSequence
*sequence
, ByteIOContext
*pb
, int tag
)
455 sequence
->duration
= get_be64(pb
);
458 get_buffer(pb
, sequence
->data_definition_ul
, 16);
461 sequence
->structural_components_count
= get_be32(pb
);
462 if (sequence
->structural_components_count
>= UINT_MAX
/ sizeof(UID
))
464 sequence
->structural_components_refs
= av_malloc(sequence
->structural_components_count
* sizeof(UID
));
465 if (!sequence
->structural_components_refs
)
467 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
468 get_buffer(pb
, (uint8_t *)sequence
->structural_components_refs
, sequence
->structural_components_count
* sizeof(UID
));
474 static int mxf_read_source_package(MXFPackage
*package
, ByteIOContext
*pb
, int tag
)
478 package
->tracks_count
= get_be32(pb
);
479 if (package
->tracks_count
>= UINT_MAX
/ sizeof(UID
))
481 package
->tracks_refs
= av_malloc(package
->tracks_count
* sizeof(UID
));
482 if (!package
->tracks_refs
)
484 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
485 get_buffer(pb
, (uint8_t *)package
->tracks_refs
, package
->tracks_count
* sizeof(UID
));
488 /* UMID, only get last 16 bytes */
490 get_buffer(pb
, package
->package_uid
, 16);
493 get_buffer(pb
, package
->descriptor_ref
, 16);
499 static void mxf_read_pixel_layout(ByteIOContext
*pb
, MXFDescriptor
*descriptor
)
505 dprintf(NULL
, "pixel layout: code 0x%x\n", code
);
508 descriptor
->bits_per_sample
+= get_byte(pb
);
511 descriptor
->bits_per_sample
+= get_byte(pb
);
514 descriptor
->bits_per_sample
+= get_byte(pb
);
519 } while (code
!= 0); /* SMPTE 377M E.2.46 */
522 static int mxf_read_generic_descriptor(MXFDescriptor
*descriptor
, ByteIOContext
*pb
, int tag
, int size
, UID uid
)
526 descriptor
->sub_descriptors_count
= get_be32(pb
);
527 if (descriptor
->sub_descriptors_count
>= UINT_MAX
/ sizeof(UID
))
529 descriptor
->sub_descriptors_refs
= av_malloc(descriptor
->sub_descriptors_count
* sizeof(UID
));
530 if (!descriptor
->sub_descriptors_refs
)
532 url_fskip(pb
, 4); /* useless size of objects, always 16 according to specs */
533 get_buffer(pb
, (uint8_t *)descriptor
->sub_descriptors_refs
, descriptor
->sub_descriptors_count
* sizeof(UID
));
536 get_buffer(pb
, descriptor
->essence_container_ul
, 16);
539 descriptor
->linked_track_id
= get_be32(pb
);
541 case 0x3201: /* PictureEssenceCoding */
542 get_buffer(pb
, descriptor
->essence_codec_ul
, 16);
545 descriptor
->width
= get_be32(pb
);
548 descriptor
->height
= get_be32(pb
);
551 descriptor
->aspect_ratio
.num
= get_be32(pb
);
552 descriptor
->aspect_ratio
.den
= get_be32(pb
);
555 descriptor
->sample_rate
.num
= get_be32(pb
);
556 descriptor
->sample_rate
.den
= get_be32(pb
);
558 case 0x3D06: /* SoundEssenceCompression */
559 get_buffer(pb
, descriptor
->essence_codec_ul
, 16);
562 descriptor
->channels
= get_be32(pb
);
565 descriptor
->bits_per_sample
= get_be32(pb
);
568 mxf_read_pixel_layout(pb
, descriptor
);
571 /* Private uid used by SONY C0023S01.mxf */
572 if (IS_KLV_KEY(uid
, mxf_sony_mpeg4_extradata
)) {
573 descriptor
->extradata
= av_malloc(size
);
574 if (!descriptor
->extradata
)
576 descriptor
->extradata_size
= size
;
577 get_buffer(pb
, descriptor
->extradata
, size
);
585 * Match an uid independently of the version byte and up to len common bytes
588 static int mxf_match_uid(const UID key
, const UID uid
, int len
)
591 for (i
= 0; i
< len
; i
++) {
592 if (i
!= 7 && key
[i
] != uid
[i
])
598 static const MXFCodecUL
*mxf_get_codec_ul(const MXFCodecUL
*uls
, UID
*uid
)
600 while (uls
->id
!= CODEC_ID_NONE
) {
601 if(mxf_match_uid(uls
->uid
, *uid
, uls
->matching_len
))
608 static enum CodecType
mxf_get_codec_type(const MXFDataDefinitionUL
*uls
, UID
*uid
)
610 while (uls
->type
!= CODEC_TYPE_DATA
) {
611 if(mxf_match_uid(uls
->uid
, *uid
, 16))
618 static void *mxf_resolve_strong_ref(MXFContext
*mxf
, UID
*strong_ref
, enum MXFMetadataSetType type
)
624 for (i
= 0; i
< mxf
->metadata_sets_count
; i
++) {
625 if (!memcmp(*strong_ref
, mxf
->metadata_sets
[i
]->uid
, 16) &&
626 (type
== AnyType
|| mxf
->metadata_sets
[i
]->type
== type
)) {
627 return mxf
->metadata_sets
[i
];
633 static const MXFCodecUL mxf_essence_container_uls
[] = {
634 // video essence container uls
635 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, CODEC_ID_MPEG2VIDEO
}, /* MPEG-ES Frame wrapped */
636 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, CODEC_ID_DVVIDEO
}, /* DV 625 25mbps */
637 // sound essence container uls
638 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, CODEC_ID_PCM_S16LE
}, /* BWF Frame wrapped */
639 { { 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 */
640 { { 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 */
641 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE
},
644 static int mxf_parse_structural_metadata(MXFContext
*mxf
)
646 MXFPackage
*material_package
= NULL
;
647 MXFPackage
*temp_package
= NULL
;
650 dprintf(mxf
->fc
, "metadata sets count %d\n", mxf
->metadata_sets_count
);
651 /* TODO: handle multiple material packages (OP3x) */
652 for (i
= 0; i
< mxf
->packages_count
; i
++) {
653 material_package
= mxf_resolve_strong_ref(mxf
, &mxf
->packages_refs
[i
], MaterialPackage
);
654 if (material_package
) break;
656 if (!material_package
) {
657 av_log(mxf
->fc
, AV_LOG_ERROR
, "no material package found\n");
661 for (i
= 0; i
< material_package
->tracks_count
; i
++) {
662 MXFPackage
*source_package
= NULL
;
663 MXFTrack
*material_track
= NULL
;
664 MXFTrack
*source_track
= NULL
;
665 MXFTrack
*temp_track
= NULL
;
666 MXFDescriptor
*descriptor
= NULL
;
667 MXFStructuralComponent
*component
= NULL
;
668 UID
*essence_container_ul
= NULL
;
669 const MXFCodecUL
*codec_ul
= NULL
;
670 const MXFCodecUL
*container_ul
= NULL
;
673 if (!(material_track
= mxf_resolve_strong_ref(mxf
, &material_package
->tracks_refs
[i
], Track
))) {
674 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve material track strong ref\n");
678 if (!(material_track
->sequence
= mxf_resolve_strong_ref(mxf
, &material_track
->sequence_ref
, Sequence
))) {
679 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve material track sequence strong ref\n");
683 /* TODO: handle multiple source clips */
684 for (j
= 0; j
< material_track
->sequence
->structural_components_count
; j
++) {
685 /* TODO: handle timecode component */
686 component
= mxf_resolve_strong_ref(mxf
, &material_track
->sequence
->structural_components_refs
[j
], SourceClip
);
690 for (k
= 0; k
< mxf
->packages_count
; k
++) {
691 temp_package
= mxf_resolve_strong_ref(mxf
, &mxf
->packages_refs
[k
], SourcePackage
);
694 if (!memcmp(temp_package
->package_uid
, component
->source_package_uid
, 16)) {
695 source_package
= temp_package
;
699 if (!source_package
) {
700 av_log(mxf
->fc
, AV_LOG_ERROR
, "material track %d: no corresponding source package found\n", material_track
->track_id
);
703 for (k
= 0; k
< source_package
->tracks_count
; k
++) {
704 if (!(temp_track
= mxf_resolve_strong_ref(mxf
, &source_package
->tracks_refs
[k
], Track
))) {
705 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve source track strong ref\n");
708 if (temp_track
->track_id
== component
->source_track_id
) {
709 source_track
= temp_track
;
714 av_log(mxf
->fc
, AV_LOG_ERROR
, "material track %d: no corresponding source track found\n", material_track
->track_id
);
721 st
= av_new_stream(mxf
->fc
, source_track
->track_id
);
723 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not allocate stream\n");
726 st
->priv_data
= source_track
;
727 st
->duration
= component
->duration
;
728 if (st
->duration
== -1)
729 st
->duration
= AV_NOPTS_VALUE
;
730 st
->start_time
= component
->start_position
;
731 av_set_pts_info(st
, 64, material_track
->edit_rate
.num
, material_track
->edit_rate
.den
);
733 if (!(source_track
->sequence
= mxf_resolve_strong_ref(mxf
, &source_track
->sequence_ref
, Sequence
))) {
734 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve source track sequence strong ref\n");
738 PRINT_KEY(mxf
->fc
, "data definition ul", source_track
->sequence
->data_definition_ul
);
739 st
->codec
->codec_type
= mxf_get_codec_type(ff_mxf_data_definition_uls
, &source_track
->sequence
->data_definition_ul
);
741 source_package
->descriptor
= mxf_resolve_strong_ref(mxf
, &source_package
->descriptor_ref
, AnyType
);
742 if (source_package
->descriptor
) {
743 if (source_package
->descriptor
->type
== MultipleDescriptor
) {
744 for (j
= 0; j
< source_package
->descriptor
->sub_descriptors_count
; j
++) {
745 MXFDescriptor
*sub_descriptor
= mxf_resolve_strong_ref(mxf
, &source_package
->descriptor
->sub_descriptors_refs
[j
], Descriptor
);
747 if (!sub_descriptor
) {
748 av_log(mxf
->fc
, AV_LOG_ERROR
, "could not resolve sub descriptor strong ref\n");
751 if (sub_descriptor
->linked_track_id
== source_track
->track_id
) {
752 descriptor
= sub_descriptor
;
756 } else if (source_package
->descriptor
->type
== Descriptor
)
757 descriptor
= source_package
->descriptor
;
760 av_log(mxf
->fc
, AV_LOG_INFO
, "source track %d: stream %d, no descriptor found\n", source_track
->track_id
, st
->index
);
763 PRINT_KEY(mxf
->fc
, "essence codec ul", descriptor
->essence_codec_ul
);
764 PRINT_KEY(mxf
->fc
, "essence container ul", descriptor
->essence_container_ul
);
765 essence_container_ul
= &descriptor
->essence_container_ul
;
766 /* HACK: replacing the original key with mxf_encrypted_essence_container
767 * is not allowed according to s429-6, try to find correct information anyway */
768 if (IS_KLV_KEY(essence_container_ul
, mxf_encrypted_essence_container
)) {
769 av_log(mxf
->fc
, AV_LOG_INFO
, "broken encrypted mxf file\n");
770 for (k
= 0; k
< mxf
->metadata_sets_count
; k
++) {
771 MXFMetadataSet
*metadata
= mxf
->metadata_sets
[k
];
772 if (metadata
->type
== CryptoContext
) {
773 essence_container_ul
= &((MXFCryptoContext
*)metadata
)->source_container_ul
;
778 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
779 codec_ul
= mxf_get_codec_ul(ff_mxf_codec_uls
, &descriptor
->essence_codec_ul
);
780 st
->codec
->codec_id
= codec_ul
->id
;
781 if (descriptor
->extradata
) {
782 st
->codec
->extradata
= descriptor
->extradata
;
783 st
->codec
->extradata_size
= descriptor
->extradata_size
;
785 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
786 container_ul
= mxf_get_codec_ul(mxf_essence_container_uls
, essence_container_ul
);
787 if (st
->codec
->codec_id
== CODEC_ID_NONE
)
788 st
->codec
->codec_id
= container_ul
->id
;
789 st
->codec
->width
= descriptor
->width
;
790 st
->codec
->height
= descriptor
->height
;
791 st
->codec
->bits_per_coded_sample
= descriptor
->bits_per_sample
; /* Uncompressed */
792 st
->sample_aspect_ratio
= descriptor
->aspect_ratio
;
793 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
794 } else if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
795 container_ul
= mxf_get_codec_ul(mxf_essence_container_uls
, essence_container_ul
);
796 if (st
->codec
->codec_id
== CODEC_ID_NONE
)
797 st
->codec
->codec_id
= container_ul
->id
;
798 st
->codec
->channels
= descriptor
->channels
;
799 st
->codec
->bits_per_coded_sample
= descriptor
->bits_per_sample
;
800 st
->codec
->sample_rate
= descriptor
->sample_rate
.num
/ descriptor
->sample_rate
.den
;
801 /* TODO: implement CODEC_ID_RAWAUDIO */
802 if (st
->codec
->codec_id
== CODEC_ID_PCM_S16LE
) {
803 if (descriptor
->bits_per_sample
== 24)
804 st
->codec
->codec_id
= CODEC_ID_PCM_S24LE
;
805 else if (descriptor
->bits_per_sample
== 32)
806 st
->codec
->codec_id
= CODEC_ID_PCM_S32LE
;
807 } else if (st
->codec
->codec_id
== CODEC_ID_PCM_S16BE
) {
808 if (descriptor
->bits_per_sample
== 24)
809 st
->codec
->codec_id
= CODEC_ID_PCM_S24BE
;
810 else if (descriptor
->bits_per_sample
== 32)
811 st
->codec
->codec_id
= CODEC_ID_PCM_S32BE
;
812 } else if (st
->codec
->codec_id
== CODEC_ID_MP2
) {
813 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
816 if (st
->codec
->codec_type
!= CODEC_TYPE_DATA
&& (*essence_container_ul
)[15] > 0x01) {
817 av_log(mxf
->fc
, AV_LOG_WARNING
, "only frame wrapped mappings are correctly supported\n");
818 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
824 static const MXFMetadataReadTableEntry mxf_metadata_read_table
[] = {
825 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack
},
826 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage
, 0, AnyType
},
827 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package
, sizeof(MXFPackage
), SourcePackage
},
828 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package
, sizeof(MXFPackage
), MaterialPackage
},
829 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence
, sizeof(MXFSequence
), Sequence
},
830 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip
, sizeof(MXFStructuralComponent
), SourceClip
},
831 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), MultipleDescriptor
},
832 { { 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 */
833 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* CDCI */
834 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* RGBA */
835 { { 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 */
836 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* Wave */
837 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor
, sizeof(MXFDescriptor
), Descriptor
}, /* AES3 */
838 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track
, sizeof(MXFTrack
), Track
}, /* Static Track */
839 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track
, sizeof(MXFTrack
), Track
}, /* Generic Track */
840 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context
, sizeof(MXFCryptoContext
), CryptoContext
},
841 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL
, 0, AnyType
},
844 static int mxf_read_local_tags(MXFContext
*mxf
, KLVPacket
*klv
, int (*read_child
)(), int ctx_size
, enum MXFMetadataSetType type
)
846 ByteIOContext
*pb
= mxf
->fc
->pb
;
847 MXFMetadataSet
*ctx
= ctx_size
? av_mallocz(ctx_size
) : mxf
;
848 uint64_t klv_end
= url_ftell(pb
) + klv
->length
;
852 while (url_ftell(pb
) + 4 < klv_end
) {
853 int tag
= get_be16(pb
);
854 int size
= get_be16(pb
); /* KLV specified by 0x53 */
855 uint64_t next
= url_ftell(pb
) + size
;
858 if (!size
) { /* ignore empty tag, needed for some files with empty UMID tag */
859 av_log(mxf
->fc
, AV_LOG_ERROR
, "local tag 0x%04X with 0 size\n", tag
);
862 if (tag
> 0x7FFF) { /* dynamic tag */
864 for (i
= 0; i
< mxf
->local_tags_count
; i
++) {
865 int local_tag
= AV_RB16(mxf
->local_tags
+i
*18);
866 if (local_tag
== tag
) {
867 memcpy(uid
, mxf
->local_tags
+i
*18+2, 16);
868 dprintf(mxf
->fc
, "local tag 0x%04X\n", local_tag
);
869 PRINT_KEY(mxf
->fc
, "uid", uid
);
873 if (ctx_size
&& tag
== 0x3C0A)
874 get_buffer(pb
, ctx
->uid
, 16);
875 else if (read_child(ctx
, pb
, tag
, size
, uid
) < 0)
878 url_fseek(pb
, next
, SEEK_SET
);
880 if (ctx_size
) ctx
->type
= type
;
881 return ctx_size
? mxf_add_metadata_set(mxf
, ctx
) : 0;
884 static int mxf_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
886 MXFContext
*mxf
= s
->priv_data
;
889 if (!mxf_read_sync(s
->pb
, mxf_header_partition_pack_key
, 14)) {
890 av_log(s
, AV_LOG_ERROR
, "could not find header partition pack key\n");
893 url_fseek(s
->pb
, -14, SEEK_CUR
);
895 while (!url_feof(s
->pb
)) {
896 const MXFMetadataReadTableEntry
*metadata
;
898 if (klv_read_packet(&klv
, s
->pb
) < 0)
900 PRINT_KEY(s
, "read header", klv
.key
);
901 if (IS_KLV_KEY(klv
.key
, mxf_encrypted_triplet_key
) ||
902 IS_KLV_KEY(klv
.key
, mxf_essence_element_key
)) {
903 /* FIXME avoid seek */
904 url_fseek(s
->pb
, klv
.offset
, SEEK_SET
);
908 for (metadata
= mxf_metadata_read_table
; metadata
->read
; metadata
++) {
909 if (IS_KLV_KEY(klv
.key
, metadata
->key
)) {
910 int (*read
)() = klv
.key
[5] == 0x53 ? mxf_read_local_tags
: metadata
->read
;
911 if (read(mxf
, &klv
, metadata
->read
, metadata
->ctx_size
, metadata
->type
) < 0) {
912 av_log(s
, AV_LOG_ERROR
, "error reading header metadata\n");
919 url_fskip(s
->pb
, klv
.length
);
921 return mxf_parse_structural_metadata(mxf
);
924 static int mxf_read_close(AVFormatContext
*s
)
926 MXFContext
*mxf
= s
->priv_data
;
929 av_freep(&mxf
->packages_refs
);
930 for (i
= 0; i
< mxf
->metadata_sets_count
; i
++) {
931 switch (mxf
->metadata_sets
[i
]->type
) {
932 case MultipleDescriptor
:
933 av_freep(&((MXFDescriptor
*)mxf
->metadata_sets
[i
])->sub_descriptors_refs
);
936 av_freep(&((MXFSequence
*)mxf
->metadata_sets
[i
])->structural_components_refs
);
939 case MaterialPackage
:
940 av_freep(&((MXFPackage
*)mxf
->metadata_sets
[i
])->tracks_refs
);
943 mxf
->metadata_sets
[i
] = NULL
; /* will be freed later */
948 av_freep(&mxf
->metadata_sets
[i
]);
950 av_freep(&mxf
->metadata_sets
);
951 av_freep(&mxf
->aesc
);
952 av_freep(&mxf
->local_tags
);
956 static int mxf_probe(AVProbeData
*p
) {
957 uint8_t *bufp
= p
->buf
;
958 uint8_t *end
= p
->buf
+ p
->buf_size
;
960 if (p
->buf_size
< sizeof(mxf_header_partition_pack_key
))
963 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
964 end
-= sizeof(mxf_header_partition_pack_key
);
965 for (; bufp
< end
; bufp
++) {
966 if (IS_KLV_KEY(bufp
, mxf_header_partition_pack_key
))
967 return AVPROBE_SCORE_MAX
;
972 /* rudimentary byte seek */
973 /* XXX: use MXF Index */
974 static int mxf_read_seek(AVFormatContext
*s
, int stream_index
, int64_t sample_time
, int flags
)
976 AVStream
*st
= s
->streams
[stream_index
];
983 seconds
= av_rescale(sample_time
, st
->time_base
.num
, st
->time_base
.den
);
984 url_fseek(s
->pb
, (s
->bit_rate
* seconds
) >> 3, SEEK_SET
);
985 av_update_cur_dts(s
, st
, sample_time
);
989 AVInputFormat mxf_demuxer
= {
991 NULL_IF_CONFIG_SMALL("Material eXchange Format"),