1/* 2 * MXF demuxer. 3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com> 4 * 5 * This file is part of FFmpeg. 6 * 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. 11 * 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. 16 * 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 20 */ 21 22/* 23 * References 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 31 * 32 * Principle 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. 38 * 39 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext. 40 * Metadata parsing resolves Strong References to objects. 41 * 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 44 */ 45 46#include <inttypes.h> 47 48#include "libavutil/aes.h" 49#include "libavutil/avassert.h" 50#include "libavutil/mathematics.h" 51#include "libavcodec/bytestream.h" 52#include "libavutil/intreadwrite.h" 53#include "libavutil/timecode.h" 54#include "avformat.h" 55#include "internal.h" 56#include "mxf.h" 57 58typedef enum { 59 Header, 60 BodyPartition, 61 Footer 62} MXFPartitionType; 63 64typedef enum { 65 OP1a = 1, 66 OP1b, 67 OP1c, 68 OP2a, 69 OP2b, 70 OP2c, 71 OP3a, 72 OP3b, 73 OP3c, 74 OPAtom, 75 OPSONYOpt, /* FATE sample, violates the spec in places */ 76} MXFOP; 77 78typedef struct { 79 int closed; 80 int complete; 81 MXFPartitionType type; 82 uint64_t previous_partition; 83 int index_sid; 84 int body_sid; 85 int64_t this_partition; 86 int64_t essence_offset; ///< absolute offset of essence 87 int64_t essence_length; 88 int32_t kag_size; 89 int64_t header_byte_count; 90 int64_t index_byte_count; 91 int pack_length; 92} MXFPartition; 93 94typedef struct { 95 UID uid; 96 enum MXFMetadataSetType type; 97 UID source_container_ul; 98} MXFCryptoContext; 99 100typedef struct { 101 UID uid; 102 enum MXFMetadataSetType type; 103 UID source_package_uid; 104 UID data_definition_ul; 105 int64_t duration; 106 int64_t start_position; 107 int source_track_id; 108} MXFStructuralComponent; 109 110typedef struct { 111 UID uid; 112 enum MXFMetadataSetType type; 113 UID data_definition_ul; 114 UID *structural_components_refs; 115 int structural_components_count; 116 int64_t duration; 117} MXFSequence; 118 119typedef struct { 120 UID uid; 121 enum MXFMetadataSetType type; 122 int drop_frame; 123 int start_frame; 124 struct AVRational rate; 125 AVTimecode tc; 126} MXFTimecodeComponent; 127 128typedef struct { 129 UID uid; 130 enum MXFMetadataSetType type; 131 MXFSequence *sequence; /* mandatory, and only one */ 132 UID sequence_ref; 133 int track_id; 134 uint8_t track_number[4]; 135 AVRational edit_rate; 136 int intra_only; 137 uint64_t sample_count; 138 int64_t original_duration; /* st->duration in SampleRate/EditRate units */ 139} MXFTrack; 140 141typedef struct { 142 UID uid; 143 enum MXFMetadataSetType type; 144 UID essence_container_ul; 145 UID essence_codec_ul; 146 AVRational sample_rate; 147 AVRational aspect_ratio; 148 int width; 149 int height; /* Field height, not frame height */ 150 int frame_layout; /* See MXFFrameLayout enum */ 151#define MXF_TFF 1 152#define MXF_BFF 2 153 int field_dominance; 154 int channels; 155 int bits_per_sample; 156 unsigned int component_depth; 157 unsigned int horiz_subsampling; 158 unsigned int vert_subsampling; 159 UID *sub_descriptors_refs; 160 int sub_descriptors_count; 161 int linked_track_id; 162 uint8_t *extradata; 163 int extradata_size; 164 enum AVPixelFormat pix_fmt; 165} MXFDescriptor; 166 167typedef struct { 168 UID uid; 169 enum MXFMetadataSetType type; 170 int edit_unit_byte_count; 171 int index_sid; 172 int body_sid; 173 AVRational index_edit_rate; 174 uint64_t index_start_position; 175 uint64_t index_duration; 176 int8_t *temporal_offset_entries; 177 int *flag_entries; 178 uint64_t *stream_offset_entries; 179 int nb_index_entries; 180} MXFIndexTableSegment; 181 182typedef struct { 183 UID uid; 184 enum MXFMetadataSetType type; 185 UID package_uid; 186 UID *tracks_refs; 187 int tracks_count; 188 MXFDescriptor *descriptor; /* only one */ 189 UID descriptor_ref; 190} MXFPackage; 191 192typedef struct { 193 UID uid; 194 enum MXFMetadataSetType type; 195} MXFMetadataSet; 196 197/* decoded index table */ 198typedef struct { 199 int index_sid; 200 int body_sid; 201 int nb_ptses; /* number of PTSes or total duration of index */ 202 int64_t first_dts; /* DTS = EditUnit + first_dts */ 203 int64_t *ptses; /* maps EditUnit -> PTS */ 204 int nb_segments; 205 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */ 206 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */ 207} MXFIndexTable; 208 209typedef struct { 210 MXFPartition *partitions; 211 unsigned partitions_count; 212 MXFOP op; 213 UID *packages_refs; 214 int packages_count; 215 MXFMetadataSet **metadata_sets; 216 int metadata_sets_count; 217 AVFormatContext *fc; 218 struct AVAES *aesc; 219 uint8_t *local_tags; 220 int local_tags_count; 221 uint64_t last_partition; 222 uint64_t footer_partition; 223 KLVPacket current_klv_data; 224 int current_klv_index; 225 int run_in; 226 MXFPartition *current_partition; 227 int parsing_backward; 228 int64_t last_forward_tell; 229 int last_forward_partition; 230 int current_edit_unit; 231 int nb_index_tables; 232 MXFIndexTable *index_tables; 233 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom) 234} MXFContext; 235 236enum MXFWrappingScheme { 237 Frame, 238 Clip, 239}; 240 241/* NOTE: klv_offset is not set (-1) for local keys */ 242typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset); 243 244typedef struct { 245 const UID key; 246 MXFMetadataReadFunc *read; 247 int ctx_size; 248 enum MXFMetadataSetType type; 249} MXFMetadataReadTableEntry; 250 251static int mxf_read_close(AVFormatContext *s); 252 253/* partial keys to match */ 254static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 }; 255static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 }; 256static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 }; 257static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 }; 258static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 }; 259/* complete keys to match */ 260static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 }; 261static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 }; 262static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 }; 263static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 }; 264static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 }; 265 266#define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y))) 267 268static int64_t klv_decode_ber_length(AVIOContext *pb) 269{ 270 uint64_t size = avio_r8(pb); 271 if (size & 0x80) { /* long form */ 272 int bytes_num = size & 0x7f; 273 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */ 274 if (bytes_num > 8) 275 return AVERROR_INVALIDDATA; 276 size = 0; 277 while (bytes_num--) 278 size = size << 8 | avio_r8(pb); 279 } 280 return size; 281} 282 283static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size) 284{ 285 int i, b; 286 for (i = 0; i < size && !url_feof(pb); i++) { 287 b = avio_r8(pb); 288 if (b == key[0]) 289 i = 0; 290 else if (b != key[i]) 291 i = -1; 292 } 293 return i == size; 294} 295 296static int klv_read_packet(KLVPacket *klv, AVIOContext *pb) 297{ 298 if (!mxf_read_sync(pb, mxf_klv_key, 4)) 299 return AVERROR_INVALIDDATA; 300 klv->offset = avio_tell(pb) - 4; 301 memcpy(klv->key, mxf_klv_key, 4); 302 avio_read(pb, klv->key + 4, 12); 303 klv->length = klv_decode_ber_length(pb); 304 return klv->length == -1 ? -1 : 0; 305} 306 307static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv) 308{ 309 int i; 310 311 for (i = 0; i < s->nb_streams; i++) { 312 MXFTrack *track = s->streams[i]->priv_data; 313 /* SMPTE 379M 7.3 */ 314 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number))) 315 return i; 316 } 317 /* return 0 if only one stream, for OP Atom files with 0 as track number */ 318 return s->nb_streams == 1 ? 0 : -1; 319} 320 321/* XXX: use AVBitStreamFilter */ 322static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length) 323{ 324 const uint8_t *buf_ptr, *end_ptr; 325 uint8_t *data_ptr; 326 int i; 327 328 if (length > 61444) /* worst case PAL 1920 samples 8 channels */ 329 return AVERROR_INVALIDDATA; 330 length = av_get_packet(pb, pkt, length); 331 if (length < 0) 332 return length; 333 data_ptr = pkt->data; 334 end_ptr = pkt->data + length; 335 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */ 336 for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) { 337 for (i = 0; i < st->codec->channels; i++) { 338 uint32_t sample = bytestream_get_le32(&buf_ptr); 339 if (st->codec->bits_per_coded_sample == 24) 340 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff); 341 else 342 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff); 343 } 344 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M 345 } 346 av_shrink_packet(pkt, data_ptr - pkt->data); 347 return 0; 348} 349 350static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv) 351{ 352 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b}; 353 MXFContext *mxf = s->priv_data; 354 AVIOContext *pb = s->pb; 355 int64_t end = avio_tell(pb) + klv->length; 356 int64_t size; 357 uint64_t orig_size; 358 uint64_t plaintext_size; 359 uint8_t ivec[16]; 360 uint8_t tmpbuf[16]; 361 int index; 362 363 if (!mxf->aesc && s->key && s->keylen == 16) { 364 mxf->aesc = av_aes_alloc(); 365 if (!mxf->aesc) 366 return AVERROR(ENOMEM); 367 av_aes_init(mxf->aesc, s->key, 128, 1); 368 } 369 // crypto context 370 avio_skip(pb, klv_decode_ber_length(pb)); 371 // plaintext offset 372 klv_decode_ber_length(pb); 373 plaintext_size = avio_rb64(pb); 374 // source klv key 375 klv_decode_ber_length(pb); 376 avio_read(pb, klv->key, 16); 377 if (!IS_KLV_KEY(klv, mxf_essence_element_key)) 378 return AVERROR_INVALIDDATA; 379 index = mxf_get_stream_index(s, klv); 380 if (index < 0) 381 return AVERROR_INVALIDDATA; 382 // source size 383 klv_decode_ber_length(pb); 384 orig_size = avio_rb64(pb); 385 if (orig_size < plaintext_size) 386 return AVERROR_INVALIDDATA; 387 // enc. code 388 size = klv_decode_ber_length(pb); 389 if (size < 32 || size - 32 < orig_size) 390 return AVERROR_INVALIDDATA; 391 avio_read(pb, ivec, 16); 392 avio_read(pb, tmpbuf, 16); 393 if (mxf->aesc) 394 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1); 395 if (memcmp(tmpbuf, checkv, 16)) 396 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n"); 397 size -= 32; 398 size = av_get_packet(pb, pkt, size); 399 if (size < 0) 400 return size; 401 else if (size < plaintext_size) 402 return AVERROR_INVALIDDATA; 403 size -= plaintext_size; 404 if (mxf->aesc) 405 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size], 406 &pkt->data[plaintext_size], size >> 4, ivec, 1); 407 av_shrink_packet(pkt, orig_size); 408 pkt->stream_index = index; 409 avio_skip(pb, end - avio_tell(pb)); 410 return 0; 411} 412 413static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 414{ 415 MXFContext *mxf = arg; 416 int item_num = avio_rb32(pb); 417 int item_len = avio_rb32(pb); 418 419 if (item_len != 18) { 420 avpriv_request_sample(pb, "Primer pack item length %d", item_len); 421 return AVERROR_PATCHWELCOME; 422 } 423 if (item_num > 65536) { 424 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num); 425 return AVERROR_INVALIDDATA; 426 } 427 mxf->local_tags = av_calloc(item_num, item_len); 428 if (!mxf->local_tags) 429 return AVERROR(ENOMEM); 430 mxf->local_tags_count = item_num; 431 avio_read(pb, mxf->local_tags, item_num*item_len); 432 return 0; 433} 434 435static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 436{ 437 MXFContext *mxf = arg; 438 MXFPartition *partition, *tmp_part; 439 UID op; 440 uint64_t footer_partition; 441 uint32_t nb_essence_containers; 442 443 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions)); 444 if (!tmp_part) 445 return AVERROR(ENOMEM); 446 mxf->partitions = tmp_part; 447 448 if (mxf->parsing_backward) { 449 /* insert the new partition pack in the middle 450 * this makes the entries in mxf->partitions sorted by offset */ 451 memmove(&mxf->partitions[mxf->last_forward_partition+1], 452 &mxf->partitions[mxf->last_forward_partition], 453 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions)); 454 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition]; 455 } else { 456 mxf->last_forward_partition++; 457 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count]; 458 } 459 460 memset(partition, 0, sizeof(*partition)); 461 mxf->partitions_count++; 462 partition->pack_length = avio_tell(pb) - klv_offset + size; 463 464 switch(uid[13]) { 465 case 2: 466 partition->type = Header; 467 break; 468 case 3: 469 partition->type = BodyPartition; 470 break; 471 case 4: 472 partition->type = Footer; 473 break; 474 default: 475 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]); 476 return AVERROR_INVALIDDATA; 477 } 478 479 /* consider both footers to be closed (there is only Footer and CompleteFooter) */ 480 partition->closed = partition->type == Footer || !(uid[14] & 1); 481 partition->complete = uid[14] > 2; 482 avio_skip(pb, 4); 483 partition->kag_size = avio_rb32(pb); 484 partition->this_partition = avio_rb64(pb); 485 partition->previous_partition = avio_rb64(pb); 486 footer_partition = avio_rb64(pb); 487 partition->header_byte_count = avio_rb64(pb); 488 partition->index_byte_count = avio_rb64(pb); 489 partition->index_sid = avio_rb32(pb); 490 avio_skip(pb, 8); 491 partition->body_sid = avio_rb32(pb); 492 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) { 493 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n"); 494 return AVERROR_INVALIDDATA; 495 } 496 nb_essence_containers = avio_rb32(pb); 497 498 if (partition->this_partition && 499 partition->previous_partition == partition->this_partition) { 500 av_log(mxf->fc, AV_LOG_ERROR, 501 "PreviousPartition equal to ThisPartition %"PRIx64"\n", 502 partition->previous_partition); 503 /* override with the actual previous partition offset */ 504 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) { 505 MXFPartition *prev = 506 mxf->partitions + mxf->last_forward_partition - 2; 507 partition->previous_partition = prev->this_partition; 508 } 509 /* if no previous body partition are found point to the header 510 * partition */ 511 if (partition->previous_partition == partition->this_partition) 512 partition->previous_partition = 0; 513 av_log(mxf->fc, AV_LOG_ERROR, 514 "Overriding PreviousPartition with %"PRIx64"\n", 515 partition->previous_partition); 516 } 517 518 /* some files don'thave FooterPartition set in every partition */ 519 if (footer_partition) { 520 if (mxf->footer_partition && mxf->footer_partition != footer_partition) { 521 av_log(mxf->fc, AV_LOG_ERROR, 522 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n", 523 mxf->footer_partition, footer_partition); 524 } else { 525 mxf->footer_partition = footer_partition; 526 } 527 } 528 529 av_dlog(mxf->fc, 530 "PartitionPack: ThisPartition = 0x%"PRIX64 531 ", PreviousPartition = 0x%"PRIX64", " 532 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n", 533 partition->this_partition, 534 partition->previous_partition, footer_partition, 535 partition->index_sid, partition->body_sid); 536 537 /* sanity check PreviousPartition if set */ 538 if (partition->previous_partition && 539 mxf->run_in + partition->previous_partition >= klv_offset) { 540 av_log(mxf->fc, AV_LOG_ERROR, 541 "PreviousPartition points to this partition or forward\n"); 542 return AVERROR_INVALIDDATA; 543 } 544 545 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a; 546 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b; 547 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c; 548 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a; 549 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b; 550 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c; 551 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a; 552 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b; 553 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c; 554 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt; 555 else if (op[12] == 0x10) { 556 /* SMPTE 390m: "There shall be exactly one essence container" 557 * The following block deals with files that violate this, namely: 558 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a 559 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */ 560 if (nb_essence_containers != 1) { 561 MXFOP op = nb_essence_containers ? OP1a : OPAtom; 562 563 /* only nag once */ 564 if (!mxf->op) 565 av_log(mxf->fc, AV_LOG_WARNING, 566 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n", 567 nb_essence_containers, 568 op == OP1a ? "OP1a" : "OPAtom"); 569 570 mxf->op = op; 571 } else 572 mxf->op = OPAtom; 573 } else { 574 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]); 575 mxf->op = OP1a; 576 } 577 578 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) { 579 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ", 580 partition->kag_size); 581 582 if (mxf->op == OPSONYOpt) 583 partition->kag_size = 512; 584 else 585 partition->kag_size = 1; 586 587 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size); 588 } 589 590 return 0; 591} 592 593static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set) 594{ 595 MXFMetadataSet **tmp; 596 597 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets)); 598 if (!tmp) 599 return AVERROR(ENOMEM); 600 mxf->metadata_sets = tmp; 601 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set; 602 mxf->metadata_sets_count++; 603 return 0; 604} 605 606static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 607{ 608 MXFCryptoContext *cryptocontext = arg; 609 if (size != 16) 610 return AVERROR_INVALIDDATA; 611 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul)) 612 avio_read(pb, cryptocontext->source_container_ul, 16); 613 return 0; 614} 615 616static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 617{ 618 MXFContext *mxf = arg; 619 switch (tag) { 620 case 0x1901: 621 mxf->packages_count = avio_rb32(pb); 622 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID)); 623 if (!mxf->packages_refs) 624 return AVERROR(ENOMEM); 625 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ 626 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID)); 627 break; 628 } 629 return 0; 630} 631 632static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 633{ 634 MXFStructuralComponent *source_clip = arg; 635 switch(tag) { 636 case 0x0202: 637 source_clip->duration = avio_rb64(pb); 638 break; 639 case 0x1201: 640 source_clip->start_position = avio_rb64(pb); 641 break; 642 case 0x1101: 643 /* UMID, only get last 16 bytes */ 644 avio_skip(pb, 16); 645 avio_read(pb, source_clip->source_package_uid, 16); 646 break; 647 case 0x1102: 648 source_clip->source_track_id = avio_rb32(pb); 649 break; 650 } 651 return 0; 652} 653 654static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 655{ 656 MXFPackage *package = arg; 657 switch(tag) { 658 case 0x4403: 659 package->tracks_count = avio_rb32(pb); 660 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID)); 661 if (!package->tracks_refs) 662 return AVERROR(ENOMEM); 663 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ 664 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); 665 break; 666 } 667 return 0; 668} 669 670static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 671{ 672 MXFTimecodeComponent *mxf_timecode = arg; 673 switch(tag) { 674 case 0x1501: 675 mxf_timecode->start_frame = avio_rb64(pb); 676 break; 677 case 0x1502: 678 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1}; 679 break; 680 case 0x1503: 681 mxf_timecode->drop_frame = avio_r8(pb); 682 break; 683 } 684 return 0; 685} 686 687static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 688{ 689 MXFTrack *track = arg; 690 switch(tag) { 691 case 0x4801: 692 track->track_id = avio_rb32(pb); 693 break; 694 case 0x4804: 695 avio_read(pb, track->track_number, 4); 696 break; 697 case 0x4b01: 698 track->edit_rate.num = avio_rb32(pb); 699 track->edit_rate.den = avio_rb32(pb); 700 break; 701 case 0x4803: 702 avio_read(pb, track->sequence_ref, 16); 703 break; 704 } 705 return 0; 706} 707 708static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 709{ 710 MXFSequence *sequence = arg; 711 switch(tag) { 712 case 0x0202: 713 sequence->duration = avio_rb64(pb); 714 break; 715 case 0x0201: 716 avio_read(pb, sequence->data_definition_ul, 16); 717 break; 718 case 0x1001: 719 sequence->structural_components_count = avio_rb32(pb); 720 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID)); 721 if (!sequence->structural_components_refs) 722 return AVERROR(ENOMEM); 723 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ 724 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID)); 725 break; 726 } 727 return 0; 728} 729 730static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 731{ 732 MXFPackage *package = arg; 733 switch(tag) { 734 case 0x4403: 735 package->tracks_count = avio_rb32(pb); 736 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID)); 737 if (!package->tracks_refs) 738 return AVERROR(ENOMEM); 739 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ 740 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); 741 break; 742 case 0x4401: 743 /* UMID, only get last 16 bytes */ 744 avio_skip(pb, 16); 745 avio_read(pb, package->package_uid, 16); 746 break; 747 case 0x4701: 748 avio_read(pb, package->descriptor_ref, 16); 749 break; 750 } 751 return 0; 752} 753 754static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment) 755{ 756 int i, length; 757 758 segment->nb_index_entries = avio_rb32(pb); 759 760 length = avio_rb32(pb); 761 762 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) || 763 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) || 764 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) 765 return AVERROR(ENOMEM); 766 767 for (i = 0; i < segment->nb_index_entries; i++) { 768 segment->temporal_offset_entries[i] = avio_r8(pb); 769 avio_r8(pb); /* KeyFrameOffset */ 770 segment->flag_entries[i] = avio_r8(pb); 771 segment->stream_offset_entries[i] = avio_rb64(pb); 772 avio_skip(pb, length - 11); 773 } 774 return 0; 775} 776 777static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 778{ 779 MXFIndexTableSegment *segment = arg; 780 switch(tag) { 781 case 0x3F05: 782 segment->edit_unit_byte_count = avio_rb32(pb); 783 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count); 784 break; 785 case 0x3F06: 786 segment->index_sid = avio_rb32(pb); 787 av_dlog(NULL, "IndexSID %d\n", segment->index_sid); 788 break; 789 case 0x3F07: 790 segment->body_sid = avio_rb32(pb); 791 av_dlog(NULL, "BodySID %d\n", segment->body_sid); 792 break; 793 case 0x3F0A: 794 av_dlog(NULL, "IndexEntryArray found\n"); 795 return mxf_read_index_entry_array(pb, segment); 796 case 0x3F0B: 797 segment->index_edit_rate.num = avio_rb32(pb); 798 segment->index_edit_rate.den = avio_rb32(pb); 799 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num, 800 segment->index_edit_rate.den); 801 break; 802 case 0x3F0C: 803 segment->index_start_position = avio_rb64(pb); 804 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position); 805 break; 806 case 0x3F0D: 807 segment->index_duration = avio_rb64(pb); 808 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration); 809 break; 810 } 811 return 0; 812} 813 814static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor) 815{ 816 int code, value, ofs = 0; 817 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */ 818 819 do { 820 code = avio_r8(pb); 821 value = avio_r8(pb); 822 av_dlog(NULL, "pixel layout: code %#x\n", code); 823 824 if (ofs <= 14) { 825 layout[ofs++] = code; 826 layout[ofs++] = value; 827 } else 828 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */ 829 } while (code != 0); /* SMPTE 377M E.2.46 */ 830 831 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt); 832} 833 834static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) 835{ 836 MXFDescriptor *descriptor = arg; 837 descriptor->pix_fmt = AV_PIX_FMT_NONE; 838 switch(tag) { 839 case 0x3F01: 840 descriptor->sub_descriptors_count = avio_rb32(pb); 841 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID)); 842 if (!descriptor->sub_descriptors_refs) 843 return AVERROR(ENOMEM); 844 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */ 845 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID)); 846 break; 847 case 0x3004: 848 avio_read(pb, descriptor->essence_container_ul, 16); 849 break; 850 case 0x3006: 851 descriptor->linked_track_id = avio_rb32(pb); 852 break; 853 case 0x3201: /* PictureEssenceCoding */ 854 avio_read(pb, descriptor->essence_codec_ul, 16); 855 break; 856 case 0x3203: 857 descriptor->width = avio_rb32(pb); 858 break; 859 case 0x3202: 860 descriptor->height = avio_rb32(pb); 861 break; 862 case 0x320C: 863 descriptor->frame_layout = avio_r8(pb); 864 break; 865 case 0x320E: 866 descriptor->aspect_ratio.num = avio_rb32(pb); 867 descriptor->aspect_ratio.den = avio_rb32(pb); 868 break; 869 case 0x3212: 870 descriptor->field_dominance = avio_r8(pb); 871 break; 872 case 0x3301: 873 descriptor->component_depth = avio_rb32(pb); 874 break; 875 case 0x3302: 876 descriptor->horiz_subsampling = avio_rb32(pb); 877 break; 878 case 0x3308: 879 descriptor->vert_subsampling = avio_rb32(pb); 880 break; 881 case 0x3D03: 882 descriptor->sample_rate.num = avio_rb32(pb); 883 descriptor->sample_rate.den = avio_rb32(pb); 884 break; 885 case 0x3D06: /* SoundEssenceCompression */ 886 avio_read(pb, descriptor->essence_codec_ul, 16); 887 break; 888 case 0x3D07: 889 descriptor->channels = avio_rb32(pb); 890 break; 891 case 0x3D01: 892 descriptor->bits_per_sample = avio_rb32(pb); 893 break; 894 case 0x3401: 895 mxf_read_pixel_layout(pb, descriptor); 896 break; 897 default: 898 /* Private uid used by SONY C0023S01.mxf */ 899 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) { 900 if (descriptor->extradata) 901 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n"); 902 av_free(descriptor->extradata); 903 descriptor->extradata_size = 0; 904 descriptor->extradata = av_malloc(size); 905 if (!descriptor->extradata) 906 return AVERROR(ENOMEM); 907 descriptor->extradata_size = size; 908 avio_read(pb, descriptor->extradata, size); 909 } 910 break; 911 } 912 return 0; 913} 914 915/* 916 * Match an uid independently of the version byte and up to len common bytes 917 * Returns: boolean 918 */ 919static int mxf_match_uid(const UID key, const UID uid, int len) 920{ 921 int i; 922 for (i = 0; i < len; i++) { 923 if (i != 7 && key[i] != uid[i]) 924 return 0; 925 } 926 return 1; 927} 928 929static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid) 930{ 931 while (uls->uid[0]) { 932 if(mxf_match_uid(uls->uid, *uid, uls->matching_len)) 933 break; 934 uls++; 935 } 936 return uls; 937} 938 939static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type) 940{ 941 int i; 942 943 if (!strong_ref) 944 return NULL; 945 for (i = 0; i < mxf->metadata_sets_count; i++) { 946 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) && 947 (type == AnyType || mxf->metadata_sets[i]->type == type)) { 948 return mxf->metadata_sets[i]; 949 } 950 } 951 return NULL; 952} 953 954static const MXFCodecUL mxf_picture_essence_container_uls[] = { 955 // video essence container uls 956 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MPEG-ES Frame wrapped */ 957 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */ 958 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */ 959 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, 960}; 961 962/* EC ULs for intra-only formats */ 963static const MXFCodecUL mxf_intra_only_essence_container_uls[] = { 964 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MXF-GC SMPTE D-10 Mappings */ 965 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, 966}; 967 968/* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */ 969static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = { 970 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra Profiles */ 971 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */ 972 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, 973}; 974 975static const MXFCodecUL mxf_sound_essence_container_uls[] = { 976 // sound essence container uls 977 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE }, /* BWF Frame wrapped */ 978 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2 }, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */ 979 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE }, /* D-10 Mapping 50Mbps PAL Extended Template */ 980 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4F }, 14, AV_CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */ 981 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, 982}; 983 984static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments) 985{ 986 int i, j, nb_segments = 0; 987 MXFIndexTableSegment **unsorted_segments; 988 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1; 989 990 /* count number of segments, allocate arrays and copy unsorted segments */ 991 for (i = 0; i < mxf->metadata_sets_count; i++) 992 if (mxf->metadata_sets[i]->type == IndexTableSegment) 993 nb_segments++; 994 995 if (!nb_segments) 996 return AVERROR_INVALIDDATA; 997 998 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) || 999 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) { 1000 av_freep(sorted_segments); 1001 av_free(unsorted_segments); 1002 return AVERROR(ENOMEM); 1003 } 1004 1005 for (i = j = 0; i < mxf->metadata_sets_count; i++) 1006 if (mxf->metadata_sets[i]->type == IndexTableSegment) 1007 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i]; 1008 1009 *nb_sorted_segments = 0; 1010 1011 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */ 1012 for (i = 0; i < nb_segments; i++) { 1013 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1; 1014 uint64_t best_index_duration = 0; 1015 1016 for (j = 0; j < nb_segments; j++) { 1017 MXFIndexTableSegment *s = unsorted_segments[j]; 1018 1019 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates. 1020 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around. 1021 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have. 1022 */ 1023 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) && 1024 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start || 1025 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) { 1026 best = j; 1027 best_body_sid = s->body_sid; 1028 best_index_sid = s->index_sid; 1029 best_index_start = s->index_start_position; 1030 best_index_duration = s->index_duration; 1031 } 1032 } 1033 1034 /* no suitable entry found -> we're done */ 1035 if (best == -1) 1036 break; 1037 1038 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best]; 1039 last_body_sid = best_body_sid; 1040 last_index_sid = best_index_sid; 1041 last_index_start = best_index_start; 1042 } 1043 1044 av_free(unsorted_segments); 1045 1046 return 0; 1047} 1048 1049/** 1050 * Computes the absolute file offset of the given essence container offset 1051 */ 1052static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out) 1053{ 1054 int x; 1055 int64_t offset_in = offset; /* for logging */ 1056 1057 for (x = 0; x < mxf->partitions_count; x++) { 1058 MXFPartition *p = &mxf->partitions[x]; 1059 1060 if (p->body_sid != body_sid) 1061 continue; 1062 1063 if (offset < p->essence_length || !p->essence_length) { 1064 *offset_out = p->essence_offset + offset; 1065 return 0; 1066 } 1067 1068 offset -= p->essence_length; 1069 } 1070 1071 av_log(mxf->fc, AV_LOG_ERROR, 1072 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n", 1073 offset_in, body_sid); 1074 1075 return AVERROR_INVALIDDATA; 1076} 1077 1078/** 1079 * Returns the end position of the essence container with given BodySID, or zero if unknown 1080 */ 1081static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid) 1082{ 1083 int x; 1084 int64_t ret = 0; 1085 1086 for (x = 0; x < mxf->partitions_count; x++) { 1087 MXFPartition *p = &mxf->partitions[x]; 1088 1089 if (p->body_sid != body_sid) 1090 continue; 1091 1092 if (!p->essence_length) 1093 return 0; 1094 1095 ret = p->essence_offset + p->essence_length; 1096 } 1097 1098 return ret; 1099} 1100 1101/* EditUnit -> absolute offset */ 1102static 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) 1103{ 1104 int i; 1105 int64_t offset_temp = 0; 1106 1107 for (i = 0; i < index_table->nb_segments; i++) { 1108 MXFIndexTableSegment *s = index_table->segments[i]; 1109 1110 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */ 1111 1112 if (edit_unit < s->index_start_position + s->index_duration) { 1113 int64_t index = edit_unit - s->index_start_position; 1114 1115 if (s->edit_unit_byte_count) 1116 offset_temp += s->edit_unit_byte_count * index; 1117 else if (s->nb_index_entries) { 1118 if (s->nb_index_entries == 2 * s->index_duration + 1) 1119 index *= 2; /* Avid index */ 1120 1121 if (index < 0 || index >= s->nb_index_entries) { 1122 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n", 1123 index_table->index_sid, s->index_start_position); 1124 return AVERROR_INVALIDDATA; 1125 } 1126 1127 offset_temp = s->stream_offset_entries[index]; 1128 } else { 1129 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n", 1130 index_table->index_sid, s->index_start_position); 1131 return AVERROR_INVALIDDATA; 1132 } 1133 1134 if (edit_unit_out) 1135 *edit_unit_out = edit_unit; 1136 1137 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out); 1138 } else { 1139 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */ 1140 offset_temp += s->edit_unit_byte_count * s->index_duration; 1141 } 1142 } 1143 1144 if (nag) 1145 av_log(mxf->fc, AV_LOG_ERROR, "failed to map EditUnit %"PRId64" in IndexSID %i to an offset\n", edit_unit, index_table->index_sid); 1146 1147 return AVERROR_INVALIDDATA; 1148} 1149 1150static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table) 1151{ 1152 int i, j, x; 1153 int8_t max_temporal_offset = -128; 1154 1155 /* first compute how many entries we have */ 1156 for (i = 0; i < index_table->nb_segments; i++) { 1157 MXFIndexTableSegment *s = index_table->segments[i]; 1158 1159 if (!s->nb_index_entries) { 1160 index_table->nb_ptses = 0; 1161 return 0; /* no TemporalOffsets */ 1162 } 1163 1164 index_table->nb_ptses += s->index_duration; 1165 } 1166 1167 /* paranoid check */ 1168 if (index_table->nb_ptses <= 0) 1169 return 0; 1170 1171 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) || 1172 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) { 1173 av_freep(&index_table->ptses); 1174 return AVERROR(ENOMEM); 1175 } 1176 1177 /* we may have a few bad TemporalOffsets 1178 * make sure the corresponding PTSes don't have the bogus value 0 */ 1179 for (x = 0; x < index_table->nb_ptses; x++) 1180 index_table->ptses[x] = AV_NOPTS_VALUE; 1181 1182 /** 1183 * We have this: 1184 * 1185 * x TemporalOffset 1186 * 0: 0 1187 * 1: 1 1188 * 2: 1 1189 * 3: -2 1190 * 4: 1 1191 * 5: 1 1192 * 6: -2 1193 * 1194 * We want to transform it into this: 1195 * 1196 * x DTS PTS 1197 * 0: -1 0 1198 * 1: 0 3 1199 * 2: 1 1 1200 * 3: 2 2 1201 * 4: 3 6 1202 * 5: 4 4 1203 * 6: 5 5 1204 * 1205 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses, 1206 * then settings mxf->first_dts = -max(TemporalOffset[x]). 1207 * The latter makes DTS <= PTS. 1208 */ 1209 for (i = x = 0; i < index_table->nb_segments; i++) { 1210 MXFIndexTableSegment *s = index_table->segments[i]; 1211 int index_delta = 1; 1212 int n = s->nb_index_entries; 1213 1214 if (s->nb_index_entries == 2 * s->index_duration + 1) { 1215 index_delta = 2; /* Avid index */ 1216 /* ignore the last entry - it's the size of the essence container */ 1217 n--; 1218 } 1219 1220 for (j = 0; j < n; j += index_delta, x++) { 1221 int offset = s->temporal_offset_entries[j] / index_delta; 1222 int index = x + offset; 1223 1224 if (x >= index_table->nb_ptses) { 1225 av_log(mxf->fc, AV_LOG_ERROR, 1226 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n", 1227 s->nb_index_entries, s->index_duration); 1228 break; 1229 } 1230 1231 index_table->fake_index[x].timestamp = x; 1232 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0; 1233 1234 if (index < 0 || index >= index_table->nb_ptses) { 1235 av_log(mxf->fc, AV_LOG_ERROR, 1236 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n", 1237 x, offset, index); 1238 continue; 1239 } 1240 1241 index_table->ptses[index] = x; 1242 max_temporal_offset = FFMAX(max_temporal_offset, offset); 1243 } 1244 } 1245 1246 index_table->first_dts = -max_temporal_offset; 1247 1248 return 0; 1249} 1250 1251/** 1252 * Sorts and collects index table segments into index tables. 1253 * Also computes PTSes if possible. 1254 */ 1255static int mxf_compute_index_tables(MXFContext *mxf) 1256{ 1257 int i, j, k, ret, nb_sorted_segments; 1258 MXFIndexTableSegment **sorted_segments = NULL; 1259 1260 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) || 1261 nb_sorted_segments <= 0) { 1262 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n"); 1263 return 0; 1264 } 1265 1266 /* sanity check and count unique BodySIDs/IndexSIDs */ 1267 for (i = 0; i < nb_sorted_segments; i++) { 1268 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) 1269 mxf->nb_index_tables++; 1270 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) { 1271 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n"); 1272 ret = AVERROR_INVALIDDATA; 1273 goto finish_decoding_index; 1274 } 1275 } 1276 1277 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables, 1278 sizeof(*mxf->index_tables)); 1279 if (!mxf->index_tables) { 1280 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n"); 1281 ret = AVERROR(ENOMEM); 1282 goto finish_decoding_index; 1283 } 1284 1285 /* distribute sorted segments to index tables */ 1286 for (i = j = 0; i < nb_sorted_segments; i++) { 1287 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) { 1288 /* next IndexSID */ 1289 j++; 1290 } 1291 1292 mxf->index_tables[j].nb_segments++; 1293 } 1294 1295 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) { 1296 MXFIndexTable *t = &mxf->index_tables[j]; 1297 1298 t->segments = av_mallocz_array(t->nb_segments, 1299 sizeof(*t->segments)); 1300 1301 if (!t->segments) { 1302 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment" 1303 " pointer array\n"); 1304 ret = AVERROR(ENOMEM); 1305 goto finish_decoding_index; 1306 } 1307 1308 if (sorted_segments[i]->index_start_position) 1309 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n", 1310 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position); 1311 1312 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*)); 1313 t->index_sid = sorted_segments[i]->index_sid; 1314 t->body_sid = sorted_segments[i]->body_sid; 1315 1316 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0) 1317 goto finish_decoding_index; 1318 1319 /* fix zero IndexDurations */ 1320 for (k = 0; k < t->nb_segments; k++) { 1321 if (t->segments[k]->index_duration) 1322 continue; 1323 1324 if (t->nb_segments > 1) 1325 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n", 1326 t->index_sid, k); 1327 1328 if (mxf->fc->nb_streams <= 0) { 1329 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n"); 1330 break; 1331 } 1332 1333 /* assume the first stream's duration is reasonable 1334 * leave index_duration = 0 on further segments in case we have any (unlikely) 1335 */ 1336 t->segments[k]->index_duration = mxf->fc->streams[0]->duration; 1337 break; 1338 } 1339 } 1340 1341 ret = 0; 1342finish_decoding_index: 1343 av_free(sorted_segments); 1344 return ret; 1345} 1346 1347static int mxf_is_intra_only(MXFDescriptor *descriptor) 1348{ 1349 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls, 1350 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE || 1351 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls, 1352 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE; 1353} 1354 1355static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc) 1356{ 1357 char buf[AV_TIMECODE_STR_SIZE]; 1358 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0); 1359 1360 return 0; 1361} 1362 1363static int mxf_parse_structural_metadata(MXFContext *mxf) 1364{ 1365 MXFPackage *material_package = NULL; 1366 MXFPackage *temp_package = NULL; 1367 int i, j, k, ret; 1368 1369 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count); 1370 /* TODO: handle multiple material packages (OP3x) */ 1371 for (i = 0; i < mxf->packages_count; i++) { 1372 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage); 1373 if (material_package) break; 1374 } 1375 if (!material_package) { 1376 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n"); 1377 return AVERROR_INVALIDDATA; 1378 } 1379 1380 for (i = 0; i < material_package->tracks_count; i++) { 1381 MXFPackage *source_package = NULL; 1382 MXFTrack *material_track = NULL; 1383 MXFTrack *source_track = NULL; 1384 MXFTrack *temp_track = NULL; 1385 MXFDescriptor *descriptor = NULL; 1386 MXFStructuralComponent *component = NULL; 1387 MXFTimecodeComponent *mxf_tc = NULL; 1388 UID *essence_container_ul = NULL; 1389 const MXFCodecUL *codec_ul = NULL; 1390 const MXFCodecUL *container_ul = NULL; 1391 const MXFCodecUL *pix_fmt_ul = NULL; 1392 AVStream *st; 1393 AVTimecode tc; 1394 int flags; 1395 1396 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) { 1397 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n"); 1398 continue; 1399 } 1400 1401 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) { 1402 mxf_tc = (MXFTimecodeComponent*)component; 1403 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0; 1404 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) { 1405 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc); 1406 } 1407 } 1408 1409 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) { 1410 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n"); 1411 continue; 1412 } 1413 1414 for (j = 0; j < material_track->sequence->structural_components_count; j++) { 1415 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent); 1416 if (!component) 1417 continue; 1418 1419 mxf_tc = (MXFTimecodeComponent*)component; 1420 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0; 1421 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) { 1422 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc); 1423 break; 1424 } 1425 } 1426 1427 /* TODO: handle multiple source clips */ 1428 for (j = 0; j < material_track->sequence->structural_components_count; j++) { 1429 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip); 1430 if (!component) 1431 continue; 1432 1433 for (k = 0; k < mxf->packages_count; k++) { 1434 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage); 1435 if (!temp_package) 1436 continue; 1437 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) { 1438 source_package = temp_package; 1439 break; 1440 } 1441 } 1442 if (!source_package) { 1443 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id); 1444 break; 1445 } 1446 for (k = 0; k < source_package->tracks_count; k++) { 1447 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) { 1448 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n"); 1449 ret = AVERROR_INVALIDDATA; 1450 goto fail_and_free; 1451 } 1452 if (temp_track->track_id == component->source_track_id) { 1453 source_track = temp_track; 1454 break; 1455 } 1456 } 1457 if (!source_track) { 1458 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id); 1459 break; 1460 } 1461 } 1462 if (!source_track || !component) 1463 continue; 1464 1465 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) { 1466 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n"); 1467 ret = AVERROR_INVALIDDATA; 1468 goto fail_and_free; 1469 } 1470 1471 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf 1472 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */ 1473 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) { 1474 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id); 1475 continue; 1476 } 1477 1478 st = avformat_new_stream(mxf->fc, NULL); 1479 if (!st) { 1480 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n"); 1481 ret = AVERROR(ENOMEM); 1482 goto fail_and_free; 1483 } 1484 st->id = source_track->track_id; 1485 st->priv_data = source_track; 1486 source_track->original_duration = st->duration = component->duration; 1487 if (st->duration == -1) 1488 st->duration = AV_NOPTS_VALUE; 1489 st->start_time = component->start_position; 1490 if (material_track->edit_rate.num <= 0 || 1491 material_track->edit_rate.den <= 0) { 1492 av_log(mxf->fc, AV_LOG_WARNING, 1493 "Invalid edit rate (%d/%d) found on stream #%d, " 1494 "defaulting to 25/1\n", 1495 material_track->edit_rate.num, 1496 material_track->edit_rate.den, st->index); 1497 material_track->edit_rate = (AVRational){25, 1}; 1498 } 1499 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num); 1500 1501 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only 1502 * the former is accessible via st->priv_data */ 1503 source_track->edit_rate = material_track->edit_rate; 1504 1505 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul); 1506 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul); 1507 st->codec->codec_type = codec_ul->id; 1508 1509 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType); 1510 if (source_package->descriptor) { 1511 if (source_package->descriptor->type == MultipleDescriptor) { 1512 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) { 1513 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor); 1514 1515 if (!sub_descriptor) { 1516 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n"); 1517 continue; 1518 } 1519 if (sub_descriptor->linked_track_id == source_track->track_id) { 1520 descriptor = sub_descriptor; 1521 break; 1522 } 1523 } 1524 } else if (source_package->descriptor->type == Descriptor) 1525 descriptor = source_package->descriptor; 1526 } 1527 if (!descriptor) { 1528 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index); 1529 continue; 1530 } 1531 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul); 1532 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul); 1533 essence_container_ul = &descriptor->essence_container_ul; 1534 /* HACK: replacing the original key with mxf_encrypted_essence_container 1535 * is not allowed according to s429-6, try to find correct information anyway */ 1536 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) { 1537 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n"); 1538 for (k = 0; k < mxf->metadata_sets_count; k++) { 1539 MXFMetadataSet *metadata = mxf->metadata_sets[k]; 1540 if (metadata->type == CryptoContext) { 1541 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul; 1542 break; 1543 } 1544 } 1545 } 1546 1547 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */ 1548 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul); 1549 st->codec->codec_id = (enum AVCodecID)codec_ul->id; 1550 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ", 1551 avcodec_get_name(st->codec->codec_id)); 1552 for (k = 0; k < 16; k++) { 1553 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x", 1554 descriptor->essence_codec_ul[k]); 1555 if (!(k+1 & 19) || k == 5) 1556 av_log(mxf->fc, AV_LOG_VERBOSE, "."); 1557 } 1558 av_log(mxf->fc, AV_LOG_VERBOSE, "\n"); 1559 1560 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 1561 source_track->intra_only = mxf_is_intra_only(descriptor); 1562 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul); 1563 if (st->codec->codec_id == AV_CODEC_ID_NONE) 1564 st->codec->codec_id = container_ul->id; 1565 st->codec->width = descriptor->width; 1566 st->codec->height = descriptor->height; /* Field height, not frame height */ 1567 switch (descriptor->frame_layout) { 1568 case SegmentedFrame: 1569 /* This one is a weird layout I don't fully understand. */ 1570 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n"); 1571 break; 1572 case FullFrame: 1573 st->codec->field_order = AV_FIELD_PROGRESSIVE; 1574 break; 1575 case OneField: 1576 /* Every other line is stored and needs to be duplicated. */ 1577 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n"); 1578 break; /* The correct thing to do here is fall through, but by breaking we might be 1579 able to decode some streams at half the vertical resolution, rather than not al all. 1580 It's also for compatibility with the old behavior. */ 1581 case MixedFields: 1582 break; 1583 case SeparateFields: 1584 switch (descriptor->field_dominance) { 1585 case MXF_TFF: 1586 st->codec->field_order = AV_FIELD_TT; 1587 break; 1588 case MXF_BFF: 1589 st->codec->field_order = AV_FIELD_BB; 1590 break; 1591 default: 1592 avpriv_request_sample(mxf->fc, 1593 "Field dominance %d support", 1594 descriptor->field_dominance); 1595 break; 1596 } 1597 /* Turn field height into frame height. */ 1598 st->codec->height *= 2; 1599 break; 1600 default: 1601 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout); 1602 } 1603 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) { 1604 st->codec->pix_fmt = descriptor->pix_fmt; 1605 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) { 1606 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls, 1607 &descriptor->essence_codec_ul); 1608 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id; 1609 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) { 1610 /* support files created before RP224v10 by defaulting to UYVY422 1611 if subsampling is 4:2:2 and component depth is 8-bit */ 1612 if (descriptor->horiz_subsampling == 2 && 1613 descriptor->vert_subsampling == 1 && 1614 descriptor->component_depth == 8) { 1615 st->codec->pix_fmt = AV_PIX_FMT_UYVY422; 1616 } 1617 } 1618 } 1619 } 1620 st->need_parsing = AVSTREAM_PARSE_HEADERS; 1621 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 1622 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul); 1623 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */ 1624 if (st->codec->codec_id == AV_CODEC_ID_NONE || (st->codec->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE)) 1625 st->codec->codec_id = (enum AVCodecID)container_ul->id; 1626 st->codec->channels = descriptor->channels; 1627 st->codec->bits_per_coded_sample = descriptor->bits_per_sample; 1628 1629 if (descriptor->sample_rate.den > 0) { 1630 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den; 1631 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num); 1632 } else { 1633 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) " 1634 "found for stream #%d, time base forced to 1/48000\n", 1635 descriptor->sample_rate.num, descriptor->sample_rate.den, 1636 st->index); 1637 avpriv_set_pts_info(st, 64, 1, 48000); 1638 } 1639 1640 /* if duration is set, rescale it from EditRate to SampleRate */ 1641 if (st->duration != AV_NOPTS_VALUE) 1642 st->duration = av_rescale_q(st->duration, 1643 av_inv_q(material_track->edit_rate), 1644 st->time_base); 1645 1646 /* TODO: implement AV_CODEC_ID_RAWAUDIO */ 1647 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) { 1648 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24) 1649 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE; 1650 else if (descriptor->bits_per_sample == 32) 1651 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE; 1652 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) { 1653 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24) 1654 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE; 1655 else if (descriptor->bits_per_sample == 32) 1656 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE; 1657 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) { 1658 st->need_parsing = AVSTREAM_PARSE_FULL; 1659 } 1660 } 1661 if (descriptor->extradata) { 1662 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) { 1663 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size); 1664 } 1665 } else if (st->codec->codec_id == AV_CODEC_ID_H264) { 1666 ret = ff_generate_avci_extradata(st); 1667 if (ret < 0) 1668 return ret; 1669 } 1670 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) { 1671 /* TODO: decode timestamps */ 1672 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS; 1673 } 1674 } 1675 1676 ret = 0; 1677fail_and_free: 1678 return ret; 1679} 1680 1681static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str) 1682{ 1683 int ret; 1684 size_t buf_size; 1685 1686 if (size < 0) 1687 return AVERROR(EINVAL); 1688 1689 buf_size = size + size / 2 + 1; 1690 *str = av_malloc(buf_size); 1691 if (!*str) 1692 return AVERROR(ENOMEM); 1693 1694 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) { 1695 av_freep(str); 1696 return ret; 1697 } 1698 1699 return ret; 1700} 1701 1702static int mxf_uid_to_str(UID uid, char **str) 1703{ 1704 int i; 1705 char *p; 1706 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1); 1707 if (!p) 1708 return AVERROR(ENOMEM); 1709 for (i = 0; i < sizeof(UID); i++) { 1710 snprintf(p, 2 + 1, "%.2x", uid[i]); 1711 p += 2; 1712 if (i == 3 || i == 5 || i == 7 || i == 9) { 1713 snprintf(p, 1 + 1, "-"); 1714 p++; 1715 } 1716 } 1717 return 0; 1718} 1719 1720static int mxf_timestamp_to_str(uint64_t timestamp, char **str) 1721{ 1722 struct tm time = { 0 }; 1723 time.tm_year = (timestamp >> 48) - 1900; 1724 time.tm_mon = (timestamp >> 40 & 0xFF) - 1; 1725 time.tm_mday = (timestamp >> 32 & 0xFF); 1726 time.tm_hour = (timestamp >> 24 & 0xFF); 1727 time.tm_min = (timestamp >> 16 & 0xFF); 1728 time.tm_sec = (timestamp >> 8 & 0xFF); 1729 1730 /* msvcrt versions of strftime calls the invalid parameter handler 1731 * (aborting the process if one isn't set) if the parameters are out 1732 * of range. */ 1733 time.tm_mon = av_clip(time.tm_mon, 0, 11); 1734 time.tm_mday = av_clip(time.tm_mday, 1, 31); 1735 time.tm_hour = av_clip(time.tm_hour, 0, 23); 1736 time.tm_min = av_clip(time.tm_min, 0, 59); 1737 time.tm_sec = av_clip(time.tm_sec, 0, 59); 1738 1739 *str = av_mallocz(32); 1740 if (!*str) 1741 return AVERROR(ENOMEM); 1742 strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time); 1743 1744 return 0; 1745} 1746 1747#define SET_STR_METADATA(pb, name, str) do { \ 1748 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \ 1749 return ret; \ 1750 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \ 1751} while (0) 1752 1753#define SET_UID_METADATA(pb, name, var, str) do { \ 1754 avio_read(pb, var, 16); \ 1755 if ((ret = mxf_uid_to_str(var, &str)) < 0) \ 1756 return ret; \ 1757 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \ 1758} while (0) 1759 1760#define SET_TS_METADATA(pb, name, var, str) do { \ 1761 var = avio_rb64(pb); \ 1762 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \ 1763 return ret; \ 1764 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \ 1765} while (0) 1766 1767static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset) 1768{ 1769 MXFContext *mxf = arg; 1770 AVFormatContext *s = mxf->fc; 1771 int ret; 1772 UID uid = { 0 }; 1773 char *str = NULL; 1774 uint64_t ts; 1775 switch (tag) { 1776 case 0x3C01: 1777 SET_STR_METADATA(pb, "company_name", str); 1778 break; 1779 case 0x3C02: 1780 SET_STR_METADATA(pb, "product_name", str); 1781 break; 1782 case 0x3C04: 1783 SET_STR_METADATA(pb, "product_version", str); 1784 break; 1785 case 0x3C05: 1786 SET_UID_METADATA(pb, "product_uid", uid, str); 1787 break; 1788 case 0x3C06: 1789 SET_TS_METADATA(pb, "modification_date", ts, str); 1790 break; 1791 case 0x3C08: 1792 SET_STR_METADATA(pb, "application_platform", str); 1793 break; 1794 case 0x3C09: 1795 SET_UID_METADATA(pb, "generation_uid", uid, str); 1796 break; 1797 case 0x3C0A: 1798 SET_UID_METADATA(pb, "uid", uid, str); 1799 break; 1800 } 1801 return 0; 1802} 1803 1804static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = { 1805 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack }, 1806 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack }, 1807 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack }, 1808 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack }, 1809 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack }, 1810 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack }, 1811 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack }, 1812 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack }, 1813 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack }, 1814 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack }, 1815 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack }, 1816 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata }, 1817 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType }, 1818 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage }, 1819 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage }, 1820 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence }, 1821 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip }, 1822 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor }, 1823 { { 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 */ 1824 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */ 1825 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */ 1826 { { 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 */ 1827 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */ 1828 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */ 1829 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */ 1830 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */ 1831 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent }, 1832 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext }, 1833 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment }, 1834 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType }, 1835}; 1836 1837static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type) 1838{ 1839 AVIOContext *pb = mxf->fc->pb; 1840 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf; 1841 uint64_t klv_end = avio_tell(pb) + klv->length; 1842 1843 if (!ctx) 1844 return AVERROR(ENOMEM); 1845 while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) { 1846 int ret; 1847 int tag = avio_rb16(pb); 1848 int size = avio_rb16(pb); /* KLV specified by 0x53 */ 1849 uint64_t next = avio_tell(pb) + size; 1850 UID uid = {0}; 1851 1852 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size); 1853 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */ 1854 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag); 1855 continue; 1856 } 1857 if (tag > 0x7FFF) { /* dynamic tag */ 1858 int i; 1859 for (i = 0; i < mxf->local_tags_count; i++) { 1860 int local_tag = AV_RB16(mxf->local_tags+i*18); 1861 if (local_tag == tag) { 1862 memcpy(uid, mxf->local_tags+i*18+2, 16); 1863 av_dlog(mxf->fc, "local tag %#04x\n", local_tag); 1864 PRINT_KEY(mxf->fc, "uid", uid); 1865 } 1866 } 1867 } 1868 if (ctx_size && tag == 0x3C0A) 1869 avio_read(pb, ctx->uid, 16); 1870 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) 1871 return ret; 1872 1873 /* Accept the 64k local set limit being exceeded (Avid). Don't accept 1874 * it extending past the end of the KLV though (zzuf5.mxf). */ 1875 if (avio_tell(pb) > klv_end) { 1876 if (ctx_size) 1877 av_free(ctx); 1878 1879 av_log(mxf->fc, AV_LOG_ERROR, 1880 "local tag %#04x extends past end of local set @ %#"PRIx64"\n", 1881 tag, klv->offset); 1882 return AVERROR_INVALIDDATA; 1883 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */ 1884 avio_seek(pb, next, SEEK_SET); 1885 } 1886 if (ctx_size) ctx->type = type; 1887 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0; 1888} 1889 1890/** 1891 * Seeks to the previous partition, if possible 1892 * @return <= 0 if we should stop parsing, > 0 if we should keep going 1893 */ 1894static int mxf_seek_to_previous_partition(MXFContext *mxf) 1895{ 1896 AVIOContext *pb = mxf->fc->pb; 1897 1898 if (!mxf->current_partition || 1899 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell) 1900 return 0; /* we've parsed all partitions */ 1901 1902 /* seek to previous partition */ 1903 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET); 1904 mxf->current_partition = NULL; 1905 1906 av_dlog(mxf->fc, "seeking to previous partition\n"); 1907 1908 return 1; 1909} 1910 1911/** 1912 * Called when essence is encountered 1913 * @return <= 0 if we should stop parsing, > 0 if we should keep going 1914 */ 1915static int mxf_parse_handle_essence(MXFContext *mxf) 1916{ 1917 AVIOContext *pb = mxf->fc->pb; 1918 int64_t ret; 1919 1920 if (mxf->parsing_backward) { 1921 return mxf_seek_to_previous_partition(mxf); 1922 } else { 1923 uint64_t offset = mxf->footer_partition ? mxf->footer_partition 1924 : mxf->last_partition; 1925 1926 if (!offset) { 1927 av_dlog(mxf->fc, "no last partition\n"); 1928 return 0; 1929 } 1930 1931 av_dlog(mxf->fc, "seeking to last partition\n"); 1932 1933 /* remember where we were so we don't end up seeking further back than this */ 1934 mxf->last_forward_tell = avio_tell(pb); 1935 1936 if (!pb->seekable) { 1937 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n"); 1938 return -1; 1939 } 1940 1941 /* seek to last partition and parse backward */ 1942 if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) { 1943 av_log(mxf->fc, AV_LOG_ERROR, 1944 "failed to seek to last partition @ 0x%" PRIx64 1945 " (%"PRId64") - partial file?\n", 1946 mxf->run_in + offset, ret); 1947 return ret; 1948 } 1949 1950 mxf->current_partition = NULL; 1951 mxf->parsing_backward = 1; 1952 } 1953 1954 return 1; 1955} 1956 1957/** 1958 * Called when the next partition or EOF is encountered 1959 * @return <= 0 if we should stop parsing, > 0 if we should keep going 1960 */ 1961static int mxf_parse_handle_partition_or_eof(MXFContext *mxf) 1962{ 1963 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1; 1964} 1965 1966/** 1967 * Figures out the proper offset and length of the essence container in each partition 1968 */ 1969static void mxf_compute_essence_containers(MXFContext *mxf) 1970{ 1971 int x; 1972 1973 /* everything is already correct */ 1974 if (mxf->op == OPAtom) 1975 return; 1976 1977 for (x = 0; x < mxf->partitions_count; x++) { 1978 MXFPartition *p = &mxf->partitions[x]; 1979 1980 if (!p->body_sid) 1981 continue; /* BodySID == 0 -> no essence */ 1982 1983 if (x >= mxf->partitions_count - 1) 1984 break; /* last partition - can't compute length (and we don't need to) */ 1985 1986 /* essence container spans to the next partition */ 1987 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset; 1988 1989 if (p->essence_length < 0) { 1990 /* next ThisPartition < essence_offset */ 1991 p->essence_length = 0; 1992 av_log(mxf->fc, AV_LOG_ERROR, 1993 "partition %i: bad ThisPartition = %"PRIX64"\n", 1994 x+1, mxf->partitions[x+1].this_partition); 1995 } 1996 } 1997} 1998 1999static int64_t round_to_kag(int64_t position, int kag_size) 2000{ 2001 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */ 2002 /* NOTE: kag_size may be any integer between 1 - 2^10 */ 2003 int64_t ret = (position / kag_size) * kag_size; 2004 return ret == position ? ret : ret + kag_size; 2005} 2006 2007static int is_pcm(enum AVCodecID codec_id) 2008{ 2009 /* we only care about "normal" PCM codecs until we get samples */ 2010 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD; 2011} 2012 2013/** 2014 * Deal with the case where for some audio atoms EditUnitByteCount is 2015 * very small (2, 4..). In those cases we should read more than one 2016 * sample per call to mxf_read_packet(). 2017 */ 2018static void mxf_handle_small_eubc(AVFormatContext *s) 2019{ 2020 MXFContext *mxf = s->priv_data; 2021 2022 /* assuming non-OPAtom == frame wrapped 2023 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */ 2024 if (mxf->op != OPAtom) 2025 return; 2026 2027 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */ 2028 if (s->nb_streams != 1 || 2029 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO || 2030 !is_pcm(s->streams[0]->codec->codec_id) || 2031 mxf->nb_index_tables != 1 || 2032 mxf->index_tables[0].nb_segments != 1 || 2033 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32) 2034 return; 2035 2036 /* arbitrarily default to 48 kHz PAL audio frame size */ 2037 /* TODO: We could compute this from the ratio between the audio 2038 * and video edit rates for 48 kHz NTSC we could use the 2039 * 1802-1802-1802-1802-1801 pattern. */ 2040 mxf->edit_units_per_packet = 1920; 2041} 2042 2043static void mxf_read_random_index_pack(AVFormatContext *s) 2044{ 2045 MXFContext *mxf = s->priv_data; 2046 uint32_t length; 2047 int64_t file_size; 2048 KLVPacket klv; 2049 2050 if (!s->pb->seekable) 2051 return; 2052 2053 file_size = avio_size(s->pb); 2054 avio_seek(s->pb, file_size - 4, SEEK_SET); 2055 length = avio_rb32(s->pb); 2056 if (length <= 32 || length >= FFMIN(file_size, INT_MAX)) 2057 goto end; 2058 avio_seek(s->pb, file_size - length, SEEK_SET); 2059 if (klv_read_packet(&klv, s->pb) < 0 || 2060 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) || 2061 klv.length != length - 20) 2062 goto end; 2063 2064 avio_skip(s->pb, klv.length - 12); 2065 mxf->last_partition = avio_rb64(s->pb); 2066 2067end: 2068 avio_seek(s->pb, mxf->run_in, SEEK_SET); 2069} 2070 2071static int mxf_read_header(AVFormatContext *s) 2072{ 2073 MXFContext *mxf = s->priv_data; 2074 KLVPacket klv; 2075 int64_t essence_offset = 0; 2076 int64_t last_pos = -1; 2077 uint64_t last_pos_index = 1; 2078 int ret; 2079 2080 mxf->last_forward_tell = INT64_MAX; 2081 mxf->edit_units_per_packet = 1; 2082 2083 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) { 2084 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n"); 2085 return AVERROR_INVALIDDATA; 2086 } 2087 avio_seek(s->pb, -14, SEEK_CUR); 2088 mxf->fc = s; 2089 mxf->run_in = avio_tell(s->pb); 2090 2091 mxf_read_random_index_pack(s); 2092 2093 while (!url_feof(s->pb)) { 2094 const MXFMetadataReadTableEntry *metadata; 2095 if (avio_tell(s->pb) == last_pos) { 2096 av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n"); 2097 return AVERROR_INVALIDDATA; 2098 } 2099 if ((1ULL<<61) % last_pos_index++ == 0) 2100 last_pos = avio_tell(s->pb); 2101 if (klv_read_packet(&klv, s->pb) < 0) { 2102 /* EOF - seek to previous partition or stop */ 2103 if(mxf_parse_handle_partition_or_eof(mxf) <= 0) 2104 break; 2105 else 2106 continue; 2107 } 2108 2109 PRINT_KEY(s, "read header", klv.key); 2110 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); 2111 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) || 2112 IS_KLV_KEY(klv.key, mxf_essence_element_key) || 2113 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) || 2114 IS_KLV_KEY(klv.key, mxf_system_item_key)) { 2115 2116 if (!mxf->current_partition) { 2117 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n"); 2118 return AVERROR_INVALIDDATA; 2119 } 2120 2121 if (!mxf->current_partition->essence_offset) { 2122 /* for OP1a we compute essence_offset 2123 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25) 2124 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset 2125 * for OPAtom we still need the actual essence_offset though (the KL's length can vary) 2126 */ 2127 int64_t op1a_essence_offset = 2128 round_to_kag(mxf->current_partition->this_partition + 2129 mxf->current_partition->pack_length, mxf->current_partition->kag_size) + 2130 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) + 2131 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size); 2132 2133 if (mxf->op == OPAtom) { 2134 /* point essence_offset to the actual data 2135 * OPAtom has all the essence in one big KLV 2136 */ 2137 mxf->current_partition->essence_offset = avio_tell(s->pb); 2138 mxf->current_partition->essence_length = klv.length; 2139 } else { 2140 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */ 2141 mxf->current_partition->essence_offset = op1a_essence_offset; 2142 } 2143 } 2144 2145 if (!essence_offset) 2146 essence_offset = klv.offset; 2147 2148 /* seek to footer, previous partition or stop */ 2149 if (mxf_parse_handle_essence(mxf) <= 0) 2150 break; 2151 continue; 2152 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) && 2153 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) { 2154 /* next partition pack - keep going, seek to previous partition or stop */ 2155 if(mxf_parse_handle_partition_or_eof(mxf) <= 0) 2156 break; 2157 else if (mxf->parsing_backward) 2158 continue; 2159 /* we're still parsing forward. proceed to parsing this partition pack */ 2160 } 2161 2162 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) { 2163 if (IS_KLV_KEY(klv.key, metadata->key)) { 2164 int res; 2165 if (klv.key[5] == 0x53) { 2166 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type); 2167 } else { 2168 uint64_t next = avio_tell(s->pb) + klv.length; 2169 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset); 2170 2171 /* only seek forward, else this can loop for a long time */ 2172 if (avio_tell(s->pb) > next) { 2173 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n", 2174 klv.offset); 2175 return AVERROR_INVALIDDATA; 2176 } 2177 2178 avio_seek(s->pb, next, SEEK_SET); 2179 } 2180 if (res < 0) { 2181 av_log(s, AV_LOG_ERROR, "error reading header metadata\n"); 2182 return res; 2183 } 2184 break; 2185 } 2186 } 2187 if (!metadata->read) 2188 avio_skip(s->pb, klv.length); 2189 } 2190 /* FIXME avoid seek */ 2191 if (!essence_offset) { 2192 av_log(s, AV_LOG_ERROR, "no essence\n"); 2193 return AVERROR_INVALIDDATA; 2194 } 2195 avio_seek(s->pb, essence_offset, SEEK_SET); 2196 2197 mxf_compute_essence_containers(mxf); 2198 2199 /* we need to do this before computing the index tables 2200 * to be able to fill in zero IndexDurations with st->duration */ 2201 if ((ret = mxf_parse_structural_metadata(mxf)) < 0) 2202 goto fail; 2203 2204 if ((ret = mxf_compute_index_tables(mxf)) < 0) 2205 goto fail; 2206 2207 if (mxf->nb_index_tables > 1) { 2208 /* TODO: look up which IndexSID to use via EssenceContainerData */ 2209 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n", 2210 mxf->nb_index_tables, mxf->index_tables[0].index_sid); 2211 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) { 2212 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n"); 2213 ret = AVERROR_INVALIDDATA; 2214 goto fail; 2215 } 2216 2217 mxf_handle_small_eubc(s); 2218 2219 return 0; 2220fail: 2221 mxf_read_close(s); 2222 2223 return ret; 2224} 2225 2226/** 2227 * Sets mxf->current_edit_unit based on what offset we're currently at. 2228 * @return next_ofs if OK, <0 on error 2229 */ 2230static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset) 2231{ 2232 int64_t last_ofs = -1, next_ofs = -1; 2233 MXFIndexTable *t = &mxf->index_tables[0]; 2234 2235 /* this is called from the OP1a demuxing logic, which means there 2236 * may be no index tables */ 2237 if (mxf->nb_index_tables <= 0) 2238 return -1; 2239 2240 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */ 2241 while (mxf->current_edit_unit >= 0) { 2242 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0) 2243 return -1; 2244 2245 if (next_ofs <= last_ofs) { 2246 /* large next_ofs didn't change or current_edit_unit wrapped 2247 * around this fixes the infinite loop on zzuf3.mxf */ 2248 av_log(mxf->fc, AV_LOG_ERROR, 2249 "next_ofs didn't change. not deriving packet timestamps\n"); 2250 return -1; 2251 } 2252 2253 if (next_ofs > current_offset) 2254 break; 2255 2256 last_ofs = next_ofs; 2257 mxf->current_edit_unit++; 2258 } 2259 2260 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */ 2261 if (mxf->current_edit_unit < 0) 2262 return -1; 2263 2264 return next_ofs; 2265} 2266 2267static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, 2268 uint64_t *sample_count) 2269{ 2270 int i, total = 0, size = 0; 2271 AVStream *st = mxf->fc->streams[stream_index]; 2272 MXFTrack *track = st->priv_data; 2273 AVRational time_base = av_inv_q(track->edit_rate); 2274 AVRational sample_rate = av_inv_q(st->time_base); 2275 const MXFSamplesPerFrame *spf = NULL; 2276 2277 if ((sample_rate.num / sample_rate.den) == 48000) 2278 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base); 2279 if (!spf) { 2280 int remainder = (sample_rate.num * time_base.num) % 2281 (time_base.den * sample_rate.den); 2282 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1}, 2283 av_mul_q(sample_rate, time_base))); 2284 if (remainder) 2285 av_log(mxf->fc, AV_LOG_WARNING, 2286 "seeking detected on stream #%d with time base (%d/%d) and " 2287 "sample rate (%d/%d), audio pts won't be accurate.\n", 2288 stream_index, time_base.num, time_base.den, 2289 sample_rate.num, sample_rate.den); 2290 return 0; 2291 } 2292 2293 while (spf->samples_per_frame[size]) { 2294 total += spf->samples_per_frame[size]; 2295 size++; 2296 } 2297 2298 av_assert2(size); 2299 2300 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total; 2301 for (i = 0; i < mxf->current_edit_unit % size; i++) { 2302 *sample_count += spf->samples_per_frame[i]; 2303 } 2304 2305 return 0; 2306} 2307 2308static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, 2309 AVPacket *pkt) 2310{ 2311 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data; 2312 int64_t bits_per_sample = av_get_bits_per_sample(codec->codec_id); 2313 2314 pkt->pts = track->sample_count; 2315 2316 if ( codec->channels <= 0 2317 || bits_per_sample <= 0 2318 || codec->channels * (int64_t)bits_per_sample < 8) 2319 return AVERROR(EINVAL); 2320 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8); 2321 return 0; 2322} 2323 2324static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt) 2325{ 2326 KLVPacket klv; 2327 MXFContext *mxf = s->priv_data; 2328 int ret; 2329 2330 while ((ret = klv_read_packet(&klv, s->pb)) == 0) { 2331 PRINT_KEY(s, "read packet", klv.key); 2332 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); 2333 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) { 2334 ret = mxf_decrypt_triplet(s, pkt, &klv); 2335 if (ret < 0) { 2336 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n"); 2337 return ret; 2338 } 2339 return 0; 2340 } 2341 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) || 2342 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) { 2343 int index = mxf_get_stream_index(s, &klv); 2344 int64_t next_ofs, next_klv; 2345 AVStream *st; 2346 MXFTrack *track; 2347 AVCodecContext *codec; 2348 2349 if (index < 0) { 2350 av_log(s, AV_LOG_ERROR, 2351 "error getting stream index %"PRIu32"\n", 2352 AV_RB32(klv.key + 12)); 2353 goto skip; 2354 } 2355 2356 st = s->streams[index]; 2357 track = st->priv_data; 2358 2359 if (s->streams[index]->discard == AVDISCARD_ALL) 2360 goto skip; 2361 2362 next_klv = avio_tell(s->pb) + klv.length; 2363 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset); 2364 2365 if (next_ofs >= 0 && next_klv > next_ofs) { 2366 /* if this check is hit then it's possible OPAtom was treated as OP1a 2367 * truncate the packet since it's probably very large (>2 GiB is common) */ 2368 avpriv_request_sample(s, 2369 "OPAtom misinterpreted as OP1a?" 2370 "KLV for edit unit %i extending into " 2371 "next edit unit", 2372 mxf->current_edit_unit); 2373 klv.length = next_ofs - avio_tell(s->pb); 2374 } 2375 2376 /* check for 8 channels AES3 element */ 2377 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) { 2378 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index], 2379 pkt, klv.length); 2380 if (ret < 0) { 2381 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n"); 2382 return ret; 2383 } 2384 } else { 2385 ret = av_get_packet(s->pb, pkt, klv.length); 2386 if (ret < 0) 2387 return ret; 2388 } 2389 pkt->stream_index = index; 2390 pkt->pos = klv.offset; 2391 2392 codec = s->streams[index]->codec; 2393 2394 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) { 2395 /* mxf->current_edit_unit good - see if we have an 2396 * index table to derive timestamps from */ 2397 MXFIndexTable *t = &mxf->index_tables[0]; 2398 2399 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) { 2400 pkt->dts = mxf->current_edit_unit + t->first_dts; 2401 pkt->pts = t->ptses[mxf->current_edit_unit]; 2402 } else if (track->intra_only) { 2403 /* intra-only -> PTS = EditUnit. 2404 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */ 2405 pkt->pts = mxf->current_edit_unit; 2406 } 2407 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) { 2408 ret = mxf_set_audio_pts(mxf, codec, pkt); 2409 if (ret < 0) 2410 return ret; 2411 } 2412 2413 /* seek for truncated packets */ 2414 avio_seek(s->pb, next_klv, SEEK_SET); 2415 2416 return 0; 2417 } else 2418 skip: 2419 avio_skip(s->pb, klv.length); 2420 } 2421 return url_feof(s->pb) ? AVERROR_EOF : ret; 2422} 2423 2424static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt) 2425{ 2426 MXFContext *mxf = s->priv_data; 2427 int ret, size; 2428 int64_t ret64, pos, next_pos; 2429 AVStream *st; 2430 MXFIndexTable *t; 2431 int edit_units; 2432 2433 if (mxf->op != OPAtom) 2434 return mxf_read_packet_old(s, pkt); 2435 2436 /* OPAtom - clip wrapped demuxing */ 2437 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */ 2438 st = s->streams[0]; 2439 t = &mxf->index_tables[0]; 2440 2441 if (mxf->current_edit_unit >= st->duration) 2442 return AVERROR_EOF; 2443 2444 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit); 2445 2446 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0) 2447 return ret; 2448 2449 /* compute size by finding the next edit unit or the end of the essence container 2450 * not pretty, but it works */ 2451 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 && 2452 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) { 2453 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n"); 2454 return AVERROR_INVALIDDATA; 2455 } 2456 2457 if ((size = next_pos - pos) <= 0) { 2458 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size); 2459 return AVERROR_INVALIDDATA; 2460 } 2461 2462 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0) 2463 return ret64; 2464 2465 if ((size = av_get_packet(s->pb, pkt, size)) < 0) 2466 return size; 2467 2468 pkt->stream_index = 0; 2469 2470 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses && 2471 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) { 2472 pkt->dts = mxf->current_edit_unit + t->first_dts; 2473 pkt->pts = t->ptses[mxf->current_edit_unit]; 2474 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 2475 int ret = mxf_set_audio_pts(mxf, st->codec, pkt); 2476 if (ret < 0) 2477 return ret; 2478 } 2479 2480 mxf->current_edit_unit += edit_units; 2481 2482 return 0; 2483} 2484 2485static int mxf_read_close(AVFormatContext *s) 2486{ 2487 MXFContext *mxf = s->priv_data; 2488 MXFIndexTableSegment *seg; 2489 int i; 2490 2491 av_freep(&mxf->packages_refs); 2492 2493 for (i = 0; i < s->nb_streams; i++) 2494 s->streams[i]->priv_data = NULL; 2495 2496 for (i = 0; i < mxf->metadata_sets_count; i++) { 2497 switch (mxf->metadata_sets[i]->type) { 2498 case Descriptor: 2499 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata); 2500 break; 2501 case MultipleDescriptor: 2502 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs); 2503 break; 2504 case Sequence: 2505 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs); 2506 break; 2507 case SourcePackage: 2508 case MaterialPackage: 2509 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs); 2510 break; 2511 case IndexTableSegment: 2512 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i]; 2513 av_freep(&seg->temporal_offset_entries); 2514 av_freep(&seg->flag_entries); 2515 av_freep(&seg->stream_offset_entries); 2516 break; 2517 default: 2518 break; 2519 } 2520 av_freep(&mxf->metadata_sets[i]); 2521 } 2522 av_freep(&mxf->partitions); 2523 av_freep(&mxf->metadata_sets); 2524 av_freep(&mxf->aesc); 2525 av_freep(&mxf->local_tags); 2526 2527 if (mxf->index_tables) { 2528 for (i = 0; i < mxf->nb_index_tables; i++) { 2529 av_freep(&mxf->index_tables[i].segments); 2530 av_freep(&mxf->index_tables[i].ptses); 2531 av_freep(&mxf->index_tables[i].fake_index); 2532 } 2533 } 2534 av_freep(&mxf->index_tables); 2535 2536 return 0; 2537} 2538 2539static int mxf_probe(AVProbeData *p) { 2540 const uint8_t *bufp = p->buf; 2541 const uint8_t *end = p->buf + p->buf_size; 2542 2543 if (p->buf_size < sizeof(mxf_header_partition_pack_key)) 2544 return 0; 2545 2546 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */ 2547 end -= sizeof(mxf_header_partition_pack_key); 2548 2549 for (; bufp < end;) { 2550 if (!((bufp[13] - 1) & 0xF2)){ 2551 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) && 2552 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) && 2553 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) && 2554 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12)) 2555 return AVPROBE_SCORE_MAX; 2556 bufp ++; 2557 } else 2558 bufp += 10; 2559 } 2560 2561 return 0; 2562} 2563 2564/* rudimentary byte seek */ 2565/* XXX: use MXF Index */ 2566static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags) 2567{ 2568 AVStream *st = s->streams[stream_index]; 2569 int64_t seconds; 2570 MXFContext* mxf = s->priv_data; 2571 int64_t seekpos; 2572 int i, ret; 2573 MXFIndexTable *t; 2574 MXFTrack *source_track = st->priv_data; 2575 2576 /* if audio then truncate sample_time to EditRate */ 2577 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) 2578 sample_time = av_rescale_q(sample_time, st->time_base, 2579 av_inv_q(source_track->edit_rate)); 2580 2581 if (mxf->nb_index_tables <= 0) { 2582 if (!s->bit_rate) 2583 return AVERROR_INVALIDDATA; 2584 if (sample_time < 0) 2585 sample_time = 0; 2586 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den); 2587 2588 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET); 2589 if (seekpos < 0) 2590 return seekpos; 2591 2592 ff_update_cur_dts(s, st, sample_time); 2593 mxf->current_edit_unit = sample_time; 2594 } else { 2595 t = &mxf->index_tables[0]; 2596 2597 /* clamp above zero, else ff_index_search_timestamp() returns negative 2598 * this also means we allow seeking before the start */ 2599 sample_time = FFMAX(sample_time, 0); 2600 2601 if (t->fake_index) { 2602 /* behave as if we have a proper index */ 2603 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0) 2604 return sample_time; 2605 } else { 2606 /* no IndexEntryArray (one or more CBR segments) 2607 * make sure we don't seek past the end */ 2608 sample_time = FFMIN(sample_time, source_track->original_duration - 1); 2609 } 2610 2611 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0) 2612 return ret; 2613 2614 ff_update_cur_dts(s, st, sample_time); 2615 mxf->current_edit_unit = sample_time; 2616 avio_seek(s->pb, seekpos, SEEK_SET); 2617 } 2618 2619 // Update all tracks sample count 2620 for (i = 0; i < s->nb_streams; i++) { 2621 AVStream *cur_st = s->streams[i]; 2622 MXFTrack *cur_track = cur_st->priv_data; 2623 uint64_t current_sample_count = 0; 2624 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 2625 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count); 2626 if (ret < 0) 2627 return ret; 2628 2629 cur_track->sample_count = current_sample_count; 2630 } 2631 } 2632 return 0; 2633} 2634 2635AVInputFormat ff_mxf_demuxer = { 2636 .name = "mxf", 2637 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"), 2638 .priv_data_size = sizeof(MXFContext), 2639 .read_probe = mxf_probe, 2640 .read_header = mxf_read_header, 2641 .read_packet = mxf_read_packet, 2642 .read_close = mxf_read_close, 2643 .read_seek = mxf_read_seek, 2644}; 2645