mxfdec.c 94.5 KB
Newer Older
1 2
/*
 * MXF demuxer.
3
 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
 * References
 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
 * SMPTE 377M MXF File Format Specifications
 * SMPTE 378M Operational Pattern 1a
 * SMPTE 379M MXF Generic Container
 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
 *
 * Principle
 * Search for Track numbers which will identify essence element KLV packets.
 * Search for SourcePackage which define tracks which contains Track numbers.
 * Material Package contains tracks with reference to SourcePackage tracks.
 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
 * Assign Descriptors to correct Tracks.
 *
 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
 * Metadata parsing resolves Strong References to objects.
 *
 * Simple demuxer, only OP1A supported and some files might not work at all.
 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
 */

#include "libavutil/aes.h"
47
#include "libavutil/avassert.h"
48
#include "libavutil/mathematics.h"
49
#include "libavcodec/bytestream.h"
50
#include "libavutil/timecode.h"
51
#include "avformat.h"
52
#include "internal.h"
53
#include "mxf.h"
54

Tomas Härdin's avatar
Tomas Härdin committed
55 56 57 58 59 60 61
typedef enum {
    Header,
    BodyPartition,
    Footer
} MXFPartitionType;

typedef enum {
62
    OP1a = 1,
Tomas Härdin's avatar
Tomas Härdin committed
63 64 65 66 67 68 69 70 71
    OP1b,
    OP1c,
    OP2a,
    OP2b,
    OP2c,
    OP3a,
    OP3b,
    OP3c,
    OPAtom,
72
    OPSONYOpt,  /* FATE sample, violates the spec in places */
Tomas Härdin's avatar
Tomas Härdin committed
73 74 75 76 77 78 79 80 81
} MXFOP;

typedef struct {
    int closed;
    int complete;
    MXFPartitionType type;
    uint64_t previous_partition;
    int index_sid;
    int body_sid;
82
    int64_t this_partition;
83
    int64_t essence_offset;         ///< absolute offset of essence
84
    int64_t essence_length;
85 86 87 88
    int32_t kag_size;
    int64_t header_byte_count;
    int64_t index_byte_count;
    int pack_length;
Tomas Härdin's avatar
Tomas Härdin committed
89 90
} MXFPartition;

91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
    UID source_container_ul;
} MXFCryptoContext;

typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
    UID source_package_uid;
    UID data_definition_ul;
    int64_t duration;
    int64_t start_position;
    int source_track_id;
} MXFStructuralComponent;

typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
    UID data_definition_ul;
    UID *structural_components_refs;
    int structural_components_count;
    int64_t duration;
} MXFSequence;

116 117 118 119 120 121 122 123 124
typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
    int drop_frame;
    int start_frame;
    struct AVRational rate;
    AVTimecode tc;
} MXFTimecodeComponent;

125 126 127 128 129 130 131 132
typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
    MXFSequence *sequence; /* mandatory, and only one */
    UID sequence_ref;
    int track_id;
    uint8_t track_number[4];
    AVRational edit_rate;
133
    int intra_only;
134
    uint64_t sample_count;
135
    int64_t original_duration;  ///< duration before multiplying st->duration by SampleRate/EditRate
136 137 138 139 140 141 142 143 144 145
} MXFTrack;

typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
    UID essence_container_ul;
    UID essence_codec_ul;
    AVRational sample_rate;
    AVRational aspect_ratio;
    int width;
146 147
    int height; /* Field height, not frame height */
    int frame_layout; /* See MXFFrameLayout enum */
148 149
    int channels;
    int bits_per_sample;
150
    int field_dominance;
151 152 153
    unsigned int component_depth;
    unsigned int horiz_subsampling;
    unsigned int vert_subsampling;
154 155 156 157 158
    UID *sub_descriptors_refs;
    int sub_descriptors_count;
    int linked_track_id;
    uint8_t *extradata;
    int extradata_size;
159
    enum AVPixelFormat pix_fmt;
160 161
} MXFDescriptor;

162 163 164
typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
165 166 167 168 169 170
    int edit_unit_byte_count;
    int index_sid;
    int body_sid;
    AVRational index_edit_rate;
    uint64_t index_start_position;
    uint64_t index_duration;
171
    int8_t *temporal_offset_entries;
172 173 174
    int *flag_entries;
    uint64_t *stream_offset_entries;
    int nb_index_entries;
175 176
} MXFIndexTableSegment;

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
    UID package_uid;
    UID *tracks_refs;
    int tracks_count;
    MXFDescriptor *descriptor; /* only one */
    UID descriptor_ref;
} MXFPackage;

typedef struct {
    UID uid;
    enum MXFMetadataSetType type;
} MXFMetadataSet;

192 193 194 195 196 197 198 199 200
/* decoded index table */
typedef struct {
    int index_sid;
    int body_sid;
    int nb_ptses;               /* number of PTSes or total duration of index */
    int64_t first_dts;          /* DTS = EditUnit + first_dts */
    int64_t *ptses;             /* maps EditUnit -> PTS */
    int nb_segments;
    MXFIndexTableSegment **segments;    /* sorted by IndexStartPosition */
201
    AVIndexEntry *fake_index;   /* used for calling ff_index_search_timestamp() */
202 203
} MXFIndexTable;

204
typedef struct {
Tomas Härdin's avatar
Tomas Härdin committed
205 206 207
    MXFPartition *partitions;
    unsigned partitions_count;
    MXFOP op;
208 209 210 211 212 213 214 215
    UID *packages_refs;
    int packages_count;
    MXFMetadataSet **metadata_sets;
    int metadata_sets_count;
    AVFormatContext *fc;
    struct AVAES *aesc;
    uint8_t *local_tags;
    int local_tags_count;
216
    uint64_t footer_partition;
217 218
    KLVPacket current_klv_data;
    int current_klv_index;
219 220 221 222
    int run_in;
    MXFPartition *current_partition;
    int parsing_backward;
    int64_t last_forward_tell;
223
    int last_forward_partition;
224
    int current_edit_unit;
225 226
    int nb_index_tables;
    MXFIndexTable *index_tables;
227
    int edit_units_per_packet;      ///< how many edit units to read at a time (PCM, OPAtom)
228 229 230 231 232 233 234
} MXFContext;

enum MXFWrappingScheme {
    Frame,
    Clip,
};

235 236
/* NOTE: klv_offset is not set (-1) for local keys */
typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
237

238 239
typedef struct {
    const UID key;
240
    MXFMetadataReadFunc *read;
241 242 243 244
    int ctx_size;
    enum MXFMetadataSetType type;
} MXFMetadataReadTableEntry;

245 246
static int mxf_read_close(AVFormatContext *s);

247 248 249
/* partial keys to match */
static const uint8_t mxf_header_partition_pack_key[]       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
static const uint8_t mxf_essence_element_key[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
250
static const uint8_t mxf_avid_essence_element_key[]        = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
251
static const uint8_t mxf_system_item_key[]                 = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
252 253 254 255 256 257 258 259 260
static const uint8_t mxf_klv_key[]                         = { 0x06,0x0e,0x2b,0x34 };
/* complete keys to match */
static const uint8_t mxf_crypto_source_container_ul[]      = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
static const uint8_t mxf_encrypted_triplet_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
static const uint8_t mxf_encrypted_essence_container[]     = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
static const uint8_t mxf_sony_mpeg4_extradata[]            = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };

#define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))

261
static int64_t klv_decode_ber_length(AVIOContext *pb)
262
{
263
    uint64_t size = avio_r8(pb);
264 265 266 267
    if (size & 0x80) { /* long form */
        int bytes_num = size & 0x7f;
        /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
        if (bytes_num > 8)
268
            return AVERROR_INVALIDDATA;
269 270
        size = 0;
        while (bytes_num--)
271
            size = size << 8 | avio_r8(pb);
272 273 274 275
    }
    return size;
}

276
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
277 278 279
{
    int i, b;
    for (i = 0; i < size && !url_feof(pb); i++) {
280
        b = avio_r8(pb);
281 282 283 284 285 286 287 288
        if (b == key[0])
            i = 0;
        else if (b != key[i])
            i = -1;
    }
    return i == size;
}

289
static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
290 291
{
    if (!mxf_read_sync(pb, mxf_klv_key, 4))
292
        return AVERROR_INVALIDDATA;
293
    klv->offset = avio_tell(pb) - 4;
294
    memcpy(klv->key, mxf_klv_key, 4);
295
    avio_read(pb, klv->key + 4, 12);
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
    klv->length = klv_decode_ber_length(pb);
    return klv->length == -1 ? -1 : 0;
}

static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
{
    int i;

    for (i = 0; i < s->nb_streams; i++) {
        MXFTrack *track = s->streams[i]->priv_data;
        /* SMPTE 379M 7.3 */
        if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
            return i;
    }
    /* return 0 if only one stream, for OP Atom files with 0 as track number */
    return s->nb_streams == 1 ? 0 : -1;
}

/* XXX: use AVBitStreamFilter */
315
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
316 317 318 319 320 321
{
    const uint8_t *buf_ptr, *end_ptr;
    uint8_t *data_ptr;
    int i;

    if (length > 61444) /* worst case PAL 1920 samples 8 channels */
322
        return AVERROR_INVALIDDATA;
323 324 325
    length = av_get_packet(pb, pkt, length);
    if (length < 0)
        return length;
326
    data_ptr = pkt->data;
327 328
    end_ptr = pkt->data + length;
    buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
329
    for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
330 331
        for (i = 0; i < st->codec->channels; i++) {
            uint32_t sample = bytestream_get_le32(&buf_ptr);
332
            if (st->codec->bits_per_coded_sample == 24)
333 334 335 336 337 338
                bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
            else
                bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
        }
        buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
    }
339
    av_shrink_packet(pkt, data_ptr - pkt->data);
340 341 342 343 344 345 346
    return 0;
}

static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
{
    static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
    MXFContext *mxf = s->priv_data;
347
    AVIOContext *pb = s->pb;
348
    int64_t end = avio_tell(pb) + klv->length;
349
    int64_t size;
350 351 352 353 354 355 356
    uint64_t orig_size;
    uint64_t plaintext_size;
    uint8_t ivec[16];
    uint8_t tmpbuf[16];
    int index;

    if (!mxf->aesc && s->key && s->keylen == 16) {
357
        mxf->aesc = av_aes_alloc();
358
        if (!mxf->aesc)
359
            return AVERROR(ENOMEM);
360 361 362
        av_aes_init(mxf->aesc, s->key, 128, 1);
    }
    // crypto context
363
    avio_skip(pb, klv_decode_ber_length(pb));
364 365
    // plaintext offset
    klv_decode_ber_length(pb);
366
    plaintext_size = avio_rb64(pb);
367 368
    // source klv key
    klv_decode_ber_length(pb);
369
    avio_read(pb, klv->key, 16);
370
    if (!IS_KLV_KEY(klv, mxf_essence_element_key))
371
        return AVERROR_INVALIDDATA;
372 373
    index = mxf_get_stream_index(s, klv);
    if (index < 0)
374
        return AVERROR_INVALIDDATA;
375 376
    // source size
    klv_decode_ber_length(pb);
377
    orig_size = avio_rb64(pb);
378
    if (orig_size < plaintext_size)
379
        return AVERROR_INVALIDDATA;
380 381 382
    // enc. code
    size = klv_decode_ber_length(pb);
    if (size < 32 || size - 32 < orig_size)
383
        return AVERROR_INVALIDDATA;
384 385
    avio_read(pb, ivec, 16);
    avio_read(pb, tmpbuf, 16);
386 387 388 389 390
    if (mxf->aesc)
        av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
    if (memcmp(tmpbuf, checkv, 16))
        av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
    size -= 32;
391 392 393 394 395
    size = av_get_packet(pb, pkt, size);
    if (size < 0)
        return size;
    else if (size < plaintext_size)
        return AVERROR_INVALIDDATA;
396 397 398 399
    size -= plaintext_size;
    if (mxf->aesc)
        av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
                     &pkt->data[plaintext_size], size >> 4, ivec, 1);
400
    av_shrink_packet(pkt, orig_size);
401
    pkt->stream_index = index;
402
    avio_skip(pb, end - avio_tell(pb));
403 404 405
    return 0;
}

406
static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
407
{
408
    MXFContext *mxf = arg;
409 410
    int item_num = avio_rb32(pb);
    int item_len = avio_rb32(pb);
411 412

    if (item_len != 18) {
413
        avpriv_request_sample(pb, "Primer pack item length %d", item_len);
414
        return AVERROR_PATCHWELCOME;
415
    }
416 417
    if (item_num > 65536) {
        av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
418
        return AVERROR_INVALIDDATA;
419 420
    }
    mxf->local_tags = av_calloc(item_num, item_len);
421
    if (!mxf->local_tags)
422
        return AVERROR(ENOMEM);
423
    mxf->local_tags_count = item_num;
424
    avio_read(pb, mxf->local_tags, item_num*item_len);
425 426 427
    return 0;
}

428
static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Tomas Härdin's avatar
Tomas Härdin committed
429 430
{
    MXFContext *mxf = arg;
431
    MXFPartition *partition, *tmp_part;
Tomas Härdin's avatar
Tomas Härdin committed
432
    UID op;
433
    uint64_t footer_partition;
434
    uint32_t nb_essence_containers;
Tomas Härdin's avatar
Tomas Härdin committed
435 436 437 438

    if (mxf->partitions_count+1 >= UINT_MAX / sizeof(*mxf->partitions))
        return AVERROR(ENOMEM);

439 440
    tmp_part = av_realloc(mxf->partitions, (mxf->partitions_count + 1) * sizeof(*mxf->partitions));
    if (!tmp_part)
Tomas Härdin's avatar
Tomas Härdin committed
441
        return AVERROR(ENOMEM);
442
    mxf->partitions = tmp_part;
Tomas Härdin's avatar
Tomas Härdin committed
443

444 445 446 447 448 449 450 451 452 453 454 455 456 457
    if (mxf->parsing_backward) {
        /* insert the new partition pack in the middle
         * this makes the entries in mxf->partitions sorted by offset */
        memmove(&mxf->partitions[mxf->last_forward_partition+1],
                &mxf->partitions[mxf->last_forward_partition],
                (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
        partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
    } else {
        mxf->last_forward_partition++;
        partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
    }

    memset(partition, 0, sizeof(*partition));
    mxf->partitions_count++;
458
    partition->pack_length = avio_tell(pb) - klv_offset + size;
Tomas Härdin's avatar
Tomas Härdin committed
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477

    switch(uid[13]) {
    case 2:
        partition->type = Header;
        break;
    case 3:
        partition->type = BodyPartition;
        break;
    case 4:
        partition->type = Footer;
        break;
    default:
        av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
        return AVERROR_INVALIDDATA;
    }

    /* consider both footers to be closed (there is only Footer and CompleteFooter) */
    partition->closed = partition->type == Footer || !(uid[14] & 1);
    partition->complete = uid[14] > 2;
478 479
    avio_skip(pb, 4);
    partition->kag_size = avio_rb32(pb);
480
    partition->this_partition = avio_rb64(pb);
Tomas Härdin's avatar
Tomas Härdin committed
481
    partition->previous_partition = avio_rb64(pb);
482
    footer_partition = avio_rb64(pb);
483 484
    partition->header_byte_count = avio_rb64(pb);
    partition->index_byte_count = avio_rb64(pb);
Tomas Härdin's avatar
Tomas Härdin committed
485 486 487 488
    partition->index_sid = avio_rb32(pb);
    avio_skip(pb, 8);
    partition->body_sid = avio_rb32(pb);
    avio_read(pb, op, sizeof(UID));
489
    nb_essence_containers = avio_rb32(pb);
Tomas Härdin's avatar
Tomas Härdin committed
490

491 492 493
    /* some files don'thave FooterPartition set in every partition */
    if (footer_partition) {
        if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
494 495
            av_log(mxf->fc, AV_LOG_ERROR,
                   "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
496 497 498 499 500 501
                   mxf->footer_partition, footer_partition);
        } else {
            mxf->footer_partition = footer_partition;
        }
    }

502 503 504 505
    av_dlog(mxf->fc,
            "PartitionPack: ThisPartition = 0x%"PRIX64
            ", PreviousPartition = 0x%"PRIX64", "
            "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
506
            partition->this_partition,
507
            partition->previous_partition, footer_partition,
Tomas Härdin's avatar
Tomas Härdin committed
508 509
            partition->index_sid, partition->body_sid);

510 511 512
    /* sanity check PreviousPartition if set */
    if (partition->previous_partition &&
        mxf->run_in + partition->previous_partition >= klv_offset) {
513 514
        av_log(mxf->fc, AV_LOG_ERROR,
               "PreviousPartition points to this partition or forward\n");
515 516 517
        return AVERROR_INVALIDDATA;
    }

Tomas Härdin's avatar
Tomas Härdin committed
518 519 520 521 522 523 524 525 526
    if      (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
    else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
    else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
    else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
    else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
    else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
    else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
    else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
    else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
527
    else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
528 529
    else if (op[12] == 0x10) {
        /* SMPTE 390m: "There shall be exactly one essence container"
530 531 532
         * The following block deals with files that violate this, namely:
         * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
         * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
533
        if (nb_essence_containers != 1) {
534 535
            MXFOP op = nb_essence_containers ? OP1a : OPAtom;

536 537
            /* only nag once */
            if (!mxf->op)
538 539
                av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
                       nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
540

541
            mxf->op = op;
542 543 544
        } else
            mxf->op = OPAtom;
    } else {
545 546 547 548 549 550 551 552 553 554 555 556 557 558
        av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
        mxf->op = OP1a;
    }

    if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
        av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);

        if (mxf->op == OPSONYOpt)
            partition->kag_size = 512;
        else
            partition->kag_size = 1;

        av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
    }
Tomas Härdin's avatar
Tomas Härdin committed
559 560 561 562

    return 0;
}

563 564
static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
{
565
    MXFMetadataSet **tmp;
566 567
    if (mxf->metadata_sets_count+1 >= UINT_MAX / sizeof(*mxf->metadata_sets))
        return AVERROR(ENOMEM);
568 569
    tmp = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets));
    if (!tmp)
570
        return AVERROR(ENOMEM);
571
    mxf->metadata_sets = tmp;
572 573 574 575 576
    mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
    mxf->metadata_sets_count++;
    return 0;
}

577
static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
578
{
579
    MXFCryptoContext *cryptocontext = arg;
580
    if (size != 16)
581
        return AVERROR_INVALIDDATA;
582
    if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
583
        avio_read(pb, cryptocontext->source_container_ul, 16);
584 585 586
    return 0;
}

587
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
588
{
589
    MXFContext *mxf = arg;
590 591
    switch (tag) {
    case 0x1901:
592
        mxf->packages_count = avio_rb32(pb);
593
        mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
594
        if (!mxf->packages_refs)
595
            return AVERROR(ENOMEM);
596
        avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
597
        avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
598 599 600 601 602
        break;
    }
    return 0;
}

603
static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
604
{
605
    MXFStructuralComponent *source_clip = arg;
606 607
    switch(tag) {
    case 0x0202:
608
        source_clip->duration = avio_rb64(pb);
609 610
        break;
    case 0x1201:
611
        source_clip->start_position = avio_rb64(pb);
612 613 614
        break;
    case 0x1101:
        /* UMID, only get last 16 bytes */
615
        avio_skip(pb, 16);
616
        avio_read(pb, source_clip->source_package_uid, 16);
617 618
        break;
    case 0x1102:
619
        source_clip->source_track_id = avio_rb32(pb);
620 621 622 623 624
        break;
    }
    return 0;
}

625
static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
626
{
627
    MXFPackage *package = arg;
628 629
    switch(tag) {
    case 0x4403:
630
        package->tracks_count = avio_rb32(pb);
631
        package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
632
        if (!package->tracks_refs)
633
            return AVERROR(ENOMEM);
634
        avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
635
        avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
636 637 638 639 640
        break;
    }
    return 0;
}

641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
{
    MXFTimecodeComponent *mxf_timecode = arg;
    switch(tag) {
    case 0x1501:
        mxf_timecode->start_frame = avio_rb64(pb);
        break;
    case 0x1502:
        mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
        break;
    case 0x1503:
        mxf_timecode->drop_frame = avio_r8(pb);
        break;
    }
    return 0;
}

658
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
659
{
660
    MXFTrack *track = arg;
661 662
    switch(tag) {
    case 0x4801:
663
        track->track_id = avio_rb32(pb);
664 665
        break;
    case 0x4804:
666
        avio_read(pb, track->track_number, 4);
667 668
        break;
    case 0x4B01:
669
        track->edit_rate.num = avio_rb32(pb);
670
        track->edit_rate.den = avio_rb32(pb);
671 672
        break;
    case 0x4803:
673
        avio_read(pb, track->sequence_ref, 16);
674 675 676 677 678
        break;
    }
    return 0;
}

679
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
680
{
681
    MXFSequence *sequence = arg;
682 683
    switch(tag) {
    case 0x0202:
684
        sequence->duration = avio_rb64(pb);
685 686
        break;
    case 0x0201:
687
        avio_read(pb, sequence->data_definition_ul, 16);
688 689
        break;
    case 0x1001:
690
        sequence->structural_components_count = avio_rb32(pb);
691
        sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
692
        if (!sequence->structural_components_refs)
693
            return AVERROR(ENOMEM);
694
        avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
695
        avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
696 697 698 699 700
        break;
    }
    return 0;
}

701
static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
702
{
703
    MXFPackage *package = arg;
704 705
    switch(tag) {
    case 0x4403:
706
        package->tracks_count = avio_rb32(pb);
707
        package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
708
        if (!package->tracks_refs)
709
            return AVERROR(ENOMEM);
710
        avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
711
        avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
712 713 714
        break;
    case 0x4401:
        /* UMID, only get last 16 bytes */
715
        avio_skip(pb, 16);
716
        avio_read(pb, package->package_uid, 16);
717 718
        break;
    case 0x4701:
719
        avio_read(pb, package->descriptor_ref, 16);
720 721 722 723 724
        break;
    }
    return 0;
}

725 726
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
{
727
    int i, length;
728 729

    segment->nb_index_entries = avio_rb32(pb);
730

731 732
    length = avio_rb32(pb);

733 734
    if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
        !(segment->flag_entries          = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
735 736 737 738
        !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
        return AVERROR(ENOMEM);

    for (i = 0; i < segment->nb_index_entries; i++) {
739 740
        segment->temporal_offset_entries[i] = avio_r8(pb);
        avio_r8(pb);                                        /* KeyFrameOffset */
741 742
        segment->flag_entries[i] = avio_r8(pb);
        segment->stream_offset_entries[i] = avio_rb64(pb);
743
        avio_skip(pb, length - 11);
744 745 746 747
    }
    return 0;
}

748
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
749
{
750
    MXFIndexTableSegment *segment = arg;
751
    switch(tag) {
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
    case 0x3F05:
        segment->edit_unit_byte_count = avio_rb32(pb);
        av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
        break;
    case 0x3F06:
        segment->index_sid = avio_rb32(pb);
        av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
        break;
    case 0x3F07:
        segment->body_sid = avio_rb32(pb);
        av_dlog(NULL, "BodySID %d\n", segment->body_sid);
        break;
    case 0x3F0A:
        av_dlog(NULL, "IndexEntryArray found\n");
        return mxf_read_index_entry_array(pb, segment);
    case 0x3F0B:
        segment->index_edit_rate.num = avio_rb32(pb);
        segment->index_edit_rate.den = avio_rb32(pb);
        av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
                segment->index_edit_rate.den);
        break;
    case 0x3F0C:
        segment->index_start_position = avio_rb64(pb);
        av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
        break;
    case 0x3F0D:
        segment->index_duration = avio_rb64(pb);
        av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
        break;
781 782 783 784
    }
    return 0;
}

785
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
786
{
787
    int code, value, ofs = 0;
Tomas Härdin's avatar
Tomas Härdin committed
788
    char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
789 790

    do {
791 792
        code = avio_r8(pb);
        value = avio_r8(pb);
793
        av_dlog(NULL, "pixel layout: code %#x\n", code);
794

Tomas Härdin's avatar
Tomas Härdin committed
795
        if (ofs <= 14) {
796 797
            layout[ofs++] = code;
            layout[ofs++] = value;
798 799
        } else
            break;  /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
800
    } while (code != 0); /* SMPTE 377M E.2.46 */
801 802

    ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
803 804
}

805
static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
806
{
807
    MXFDescriptor *descriptor = arg;
808
    descriptor->pix_fmt = AV_PIX_FMT_NONE;
809 810
    switch(tag) {
    case 0x3F01:
811
        descriptor->sub_descriptors_count = avio_rb32(pb);
812
        descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
813
        if (!descriptor->sub_descriptors_refs)
814
            return AVERROR(ENOMEM);
815
        avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
816
        avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
817 818
        break;
    case 0x3004:
819
        avio_read(pb, descriptor->essence_container_ul, 16);
820 821
        break;
    case 0x3006:
822
        descriptor->linked_track_id = avio_rb32(pb);
823 824
        break;
    case 0x3201: /* PictureEssenceCoding */
825
        avio_read(pb, descriptor->essence_codec_ul, 16);
826 827
        break;
    case 0x3203:
828
        descriptor->width = avio_rb32(pb);
829 830
        break;
    case 0x3202:
831
        descriptor->height = avio_rb32(pb);
832
        break;
833 834 835
    case 0x320C:
        descriptor->frame_layout = avio_r8(pb);
        break;
836
    case 0x320E:
837 838
        descriptor->aspect_ratio.num = avio_rb32(pb);
        descriptor->aspect_ratio.den = avio_rb32(pb);
839
        break;
840 841 842
    case 0x3212:
        descriptor->field_dominance = avio_r8(pb);
        break;
843 844 845 846 847 848 849 850 851
    case 0x3301:
        descriptor->component_depth = avio_rb32(pb);
        break;
    case 0x3302:
        descriptor->horiz_subsampling = avio_rb32(pb);
        break;
    case 0x3308:
        descriptor->vert_subsampling = avio_rb32(pb);
        break;
852
    case 0x3D03:
853 854
        descriptor->sample_rate.num = avio_rb32(pb);
        descriptor->sample_rate.den = avio_rb32(pb);
855 856
        break;
    case 0x3D06: /* SoundEssenceCompression */
857
        avio_read(pb, descriptor->essence_codec_ul, 16);
858 859
        break;
    case 0x3D07:
860
        descriptor->channels = avio_rb32(pb);
861 862
        break;
    case 0x3D01:
863
        descriptor->bits_per_sample = avio_rb32(pb);
864 865 866 867 868 869 870
        break;
    case 0x3401:
        mxf_read_pixel_layout(pb, descriptor);
        break;
    default:
        /* Private uid used by SONY C0023S01.mxf */
        if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
871 872 873 874
            if (descriptor->extradata)
                av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
            av_free(descriptor->extradata);
            descriptor->extradata_size = 0;
875
            descriptor->extradata = av_malloc(size);
876
            if (!descriptor->extradata)
877
                return AVERROR(ENOMEM);
878
            descriptor->extradata_size = size;
879
            avio_read(pb, descriptor->extradata, size);
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
        }
        break;
    }
    return 0;
}

/*
 * Match an uid independently of the version byte and up to len common bytes
 * Returns: boolean
 */
static int mxf_match_uid(const UID key, const UID uid, int len)
{
    int i;
    for (i = 0; i < len; i++) {
        if (i != 7 && key[i] != uid[i])
            return 0;
    }
    return 1;
}

static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
{
902
    while (uls->uid[0]) {
903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
        if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
            break;
        uls++;
    }
    return uls;
}

static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
{
    int i;

    if (!strong_ref)
        return NULL;
    for (i = 0; i < mxf->metadata_sets_count; i++) {
        if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
            (type == AnyType || mxf->metadata_sets[i]->type == type)) {
            return mxf->metadata_sets[i];
        }
    }
    return NULL;
}

925
static const MXFCodecUL mxf_picture_essence_container_uls[] = {
926
    // video essence container uls
927 928 929 930
    { { 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 */
    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,    AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,   AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
931
};
932 933 934

/* EC ULs for intra-only formats */
static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
935 936
    { { 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 */
    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
937 938 939 940
};

/* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
941 942
    { { 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 */
    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
943 944
};

945
static const MXFCodecUL mxf_sound_essence_container_uls[] = {
946
    // sound essence container uls
947 948 949 950 951
    { { 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 */
    { { 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 */
    { { 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 */
    { { 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 */
    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
952 953
};

954 955 956 957 958 959 960 961 962 963 964
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
{
    int i, j, nb_segments = 0;
    MXFIndexTableSegment **unsorted_segments;
    int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;

    /* count number of segments, allocate arrays and copy unsorted segments */
    for (i = 0; i < mxf->metadata_sets_count; i++)
        if (mxf->metadata_sets[i]->type == IndexTableSegment)
            nb_segments++;

965 966 967
    if (!nb_segments)
        return AVERROR_INVALIDDATA;

968 969
    if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
        !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
970
        av_freep(sorted_segments);
971 972 973 974 975 976 977 978 979 980 981 982 983
        av_free(unsorted_segments);
        return AVERROR(ENOMEM);
    }

    for (i = j = 0; i < mxf->metadata_sets_count; i++)
        if (mxf->metadata_sets[i]->type == IndexTableSegment)
            unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];

    *nb_sorted_segments = 0;

    /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
    for (i = 0; i < nb_segments; i++) {
        int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
984
        uint64_t best_index_duration = 0;
985 986 987 988 989 990

        for (j = 0; j < nb_segments; j++) {
            MXFIndexTableSegment *s = unsorted_segments[j];

            /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
             * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
991
             * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
992 993
             */
            if ((i == 0     || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
994 995
                (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
                (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
996 997 998 999
                best             = j;
                best_body_sid    = s->body_sid;
                best_index_sid   = s->index_sid;
                best_index_start = s->index_start_position;
1000
                best_index_duration = s->index_duration;
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
            }
        }

        /* no suitable entry found -> we're done */
        if (best == -1)
            break;

        (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
        last_body_sid    = best_body_sid;
        last_index_sid   = best_index_sid;
        last_index_start = best_index_start;
    }

    av_free(unsorted_segments);

    return 0;
}

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
/**
 * Computes the absolute file offset of the given essence container offset
 */
static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
{
    int x;
    int64_t offset_in = offset;     /* for logging */

    for (x = 0; x < mxf->partitions_count; x++) {
        MXFPartition *p = &mxf->partitions[x];

        if (p->body_sid != body_sid)
            continue;

        if (offset < p->essence_length || !p->essence_length) {
            *offset_out = p->essence_offset + offset;
            return 0;
        }

        offset -= p->essence_length;
    }

1041 1042
    av_log(mxf->fc, AV_LOG_ERROR,
           "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1043 1044 1045 1046 1047
           offset_in, body_sid);

    return AVERROR_INVALIDDATA;
}

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
/**
 * Returns the end position of the essence container with given BodySID, or zero if unknown
 */
static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
{
    int x;
    int64_t ret = 0;

    for (x = 0; x < mxf->partitions_count; x++) {
        MXFPartition *p = &mxf->partitions[x];

        if (p->body_sid != body_sid)
            continue;

        if (!p->essence_length)
            return 0;

        ret = p->essence_offset + p->essence_length;
    }

    return ret;
}

1071 1072 1073 1074
/* EditUnit -> absolute offset */
static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, int64_t *edit_unit_out, int64_t *offset_out, int nag)
{
    int i;
1075
    int64_t offset_temp = 0;
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090

    for (i = 0; i < index_table->nb_segments; i++) {
        MXFIndexTableSegment *s = index_table->segments[i];

        edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */

        if (edit_unit < s->index_start_position + s->index_duration) {
            int64_t index = edit_unit - s->index_start_position;

            if (s->edit_unit_byte_count)
                offset_temp += s->edit_unit_byte_count * index;
            else if (s->nb_index_entries) {
                if (s->nb_index_entries == 2 * s->index_duration + 1)
                    index *= 2;     /* Avid index */

1091
                if (index < 0 || index >= s->nb_index_entries) {
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
                    av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
                           index_table->index_sid, s->index_start_position);
                    return AVERROR_INVALIDDATA;
                }

                offset_temp = s->stream_offset_entries[index];
            } else {
                av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
                       index_table->index_sid, s->index_start_position);
                return AVERROR_INVALIDDATA;
            }

            if (edit_unit_out)
                *edit_unit_out = edit_unit;

            return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
        } else {
            /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
            offset_temp += s->edit_unit_byte_count * s->index_duration;
        }
    }

    if (nag)
        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);

    return AVERROR_INVALIDDATA;
}

1120
static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1121
{
1122
    int i, j, x;
1123 1124 1125
    int8_t max_temporal_offset = -128;

    /* first compute how many entries we have */
1126 1127
    for (i = 0; i < index_table->nb_segments; i++) {
        MXFIndexTableSegment *s = index_table->segments[i];
1128

1129 1130
        if (!s->nb_index_entries) {
            index_table->nb_ptses = 0;
1131
            return 0;                               /* no TemporalOffsets */
1132
        }
1133

1134
        index_table->nb_ptses += s->index_duration;
1135 1136 1137
    }

    /* paranoid check */
1138
    if (index_table->nb_ptses <= 0)
1139 1140
        return 0;

1141 1142 1143
    if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
        !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
        av_freep(&index_table->ptses);
1144
        return AVERROR(ENOMEM);
1145
    }
1146 1147 1148

    /* we may have a few bad TemporalOffsets
     * make sure the corresponding PTSes don't have the bogus value 0 */
1149 1150
    for (x = 0; x < index_table->nb_ptses; x++)
        index_table->ptses[x] = AV_NOPTS_VALUE;
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178

    /**
     * We have this:
     *
     * x  TemporalOffset
     * 0:  0
     * 1:  1
     * 2:  1
     * 3: -2
     * 4:  1
     * 5:  1
     * 6: -2
     *
     * We want to transform it into this:
     *
     * x  DTS PTS
     * 0: -1   0
     * 1:  0   3
     * 2:  1   1
     * 3:  2   2
     * 4:  3   6
     * 5:  4   4
     * 6:  5   5
     *
     * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
     * then settings mxf->first_dts = -max(TemporalOffset[x]).
     * The latter makes DTS <= PTS.
     */
1179 1180
    for (i = x = 0; i < index_table->nb_segments; i++) {
        MXFIndexTableSegment *s = index_table->segments[i];
1181
        int index_delta = 1;
1182
        int n = s->nb_index_entries;
1183

1184
        if (s->nb_index_entries == 2 * s->index_duration + 1) {
1185
            index_delta = 2;    /* Avid index */
1186 1187 1188 1189 1190
            /* ignore the last entry - it's the size of the essence container */
            n--;
        }

        for (j = 0; j < n; j += index_delta, x++) {
1191 1192 1193
            int offset = s->temporal_offset_entries[j] / index_delta;
            int index  = x + offset;

1194
            if (x >= index_table->nb_ptses) {
1195 1196
                av_log(mxf->fc, AV_LOG_ERROR,
                       "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1197 1198 1199 1200
                       s->nb_index_entries, s->index_duration);
                break;
            }

1201 1202 1203 1204
            index_table->fake_index[x].timestamp = x;
            index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;

            if (index < 0 || index >= index_table->nb_ptses) {
1205 1206 1207 1208 1209 1210
                av_log(mxf->fc, AV_LOG_ERROR,
                       "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
                       x, offset, index);
                continue;
            }

1211
            index_table->ptses[index] = x;
1212 1213 1214 1215
            max_temporal_offset = FFMAX(max_temporal_offset, offset);
        }
    }

1216
    index_table->first_dts = -max_temporal_offset;
1217 1218 1219 1220

    return 0;
}

1221 1222 1223 1224 1225 1226
/**
 * Sorts and collects index table segments into index tables.
 * Also computes PTSes if possible.
 */
static int mxf_compute_index_tables(MXFContext *mxf)
{
1227
    int i, j, k, ret, nb_sorted_segments;
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
    MXFIndexTableSegment **sorted_segments = NULL;

    if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
        nb_sorted_segments <= 0) {
        av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
        return 0;
    }

    /* sanity check and count unique BodySIDs/IndexSIDs */
    for (i = 0; i < nb_sorted_segments; i++) {
        if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
            mxf->nb_index_tables++;
        else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
            av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
            ret = AVERROR_INVALIDDATA;
            goto finish_decoding_index;
        }
    }

    if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
        av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
        ret = AVERROR(ENOMEM);
        goto finish_decoding_index;
    }

    /* distribute sorted segments to index tables */
    for (i = j = 0; i < nb_sorted_segments; i++) {
        if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
            /* next IndexSID */
            j++;
        }

        mxf->index_tables[j].nb_segments++;
    }

    for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
        MXFIndexTable *t = &mxf->index_tables[j];

        if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
            av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
            ret = AVERROR(ENOMEM);
            goto finish_decoding_index;
        }

        if (sorted_segments[i]->index_start_position)
            av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
                   sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);

        memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
        t->index_sid = sorted_segments[i]->index_sid;
        t->body_sid = sorted_segments[i]->body_sid;
1279 1280 1281

        if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
            goto finish_decoding_index;
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302

        /* fix zero IndexDurations */
        for (k = 0; k < t->nb_segments; k++) {
            if (t->segments[k]->index_duration)
                continue;

            if (t->nb_segments > 1)
                av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
                       t->index_sid, k);

            if (mxf->fc->nb_streams <= 0) {
                av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
                break;
            }

            /* assume the first stream's duration is reasonable
             * leave index_duration = 0 on further segments in case we have any (unlikely)
             */
            t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
            break;
        }
1303 1304 1305 1306 1307 1308 1309 1310
    }

    ret = 0;
finish_decoding_index:
    av_free(sorted_segments);
    return ret;
}

1311 1312 1313
static int mxf_is_intra_only(MXFDescriptor *descriptor)
{
    return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1314
                            &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1315
           mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1316
                            &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1317 1318
}

1319 1320 1321 1322 1323 1324 1325 1326
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
{
    char buf[AV_TIMECODE_STR_SIZE];
    av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);

    return 0;
}

1327 1328 1329 1330
static int mxf_parse_structural_metadata(MXFContext *mxf)
{
    MXFPackage *material_package = NULL;
    MXFPackage *temp_package = NULL;
1331
    int i, j, k, ret;
1332

1333
    av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1334 1335 1336 1337 1338 1339 1340
    /* TODO: handle multiple material packages (OP3x) */
    for (i = 0; i < mxf->packages_count; i++) {
        material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
        if (material_package) break;
    }
    if (!material_package) {
        av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1341
        return AVERROR_INVALIDDATA;
1342 1343 1344 1345 1346 1347 1348 1349 1350
    }

    for (i = 0; i < material_package->tracks_count; i++) {
        MXFPackage *source_package = NULL;
        MXFTrack *material_track = NULL;
        MXFTrack *source_track = NULL;
        MXFTrack *temp_track = NULL;
        MXFDescriptor *descriptor = NULL;
        MXFStructuralComponent *component = NULL;
1351
        MXFTimecodeComponent *mxf_tc = NULL;
1352 1353 1354
        UID *essence_container_ul = NULL;
        const MXFCodecUL *codec_ul = NULL;
        const MXFCodecUL *container_ul = NULL;
1355
        const MXFCodecUL *pix_fmt_ul = NULL;
1356
        AVStream *st;
1357 1358
        AVTimecode tc;
        int flags;
1359 1360 1361 1362 1363 1364

        if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
            av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
            continue;
        }

1365 1366 1367
        if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
            mxf_tc = (MXFTimecodeComponent*)component;
            flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1368
            if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1369 1370 1371 1372
                mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
            }
        }

1373 1374
        if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
            av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1375
            continue;
1376 1377
        }

1378 1379 1380 1381 1382 1383 1384
        for (j = 0; j < material_track->sequence->structural_components_count; j++) {
            component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
            if (!component)
                continue;

            mxf_tc = (MXFTimecodeComponent*)component;
            flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1385
            if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1386 1387 1388 1389 1390
                mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
                break;
            }
        }

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
        /* TODO: handle multiple source clips */
        for (j = 0; j < material_track->sequence->structural_components_count; j++) {
            component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
            if (!component)
                continue;

            for (k = 0; k < mxf->packages_count; k++) {
                temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
                if (!temp_package)
                    continue;
                if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
                    source_package = temp_package;
                    break;
                }
            }
            if (!source_package) {
1407
                av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1408 1409 1410 1411 1412
                break;
            }
            for (k = 0; k < source_package->tracks_count; k++) {
                if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
                    av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1413
                    ret = AVERROR_INVALIDDATA;
1414
                    goto fail_and_free;
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
                }
                if (temp_track->track_id == component->source_track_id) {
                    source_track = temp_track;
                    break;
                }
            }
            if (!source_track) {
                av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
                break;
            }
        }
1426
        if (!source_track || !component)
1427 1428
            continue;

1429 1430
        if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
            av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1431
            ret = AVERROR_INVALIDDATA;
1432
            goto fail_and_free;
1433 1434 1435 1436 1437 1438 1439 1440 1441
        }

        /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
         * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
        if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
            av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
            continue;
        }

1442
        st = avformat_new_stream(mxf->fc, NULL);
1443 1444
        if (!st) {
            av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1445 1446
            ret = AVERROR(ENOMEM);
            goto fail_and_free;
1447
        }
1448
        st->id = source_track->track_id;
1449
        st->priv_data = source_track;
1450
        source_track->original_duration = st->duration = component->duration;
1451 1452 1453
        if (st->duration == -1)
            st->duration = AV_NOPTS_VALUE;
        st->start_time = component->start_position;
1454 1455 1456 1457 1458 1459
        if (material_track->edit_rate.num <= 0 || material_track->edit_rate.den <= 0) {
            av_log(mxf->fc, AV_LOG_WARNING,
                   "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
                   material_track->edit_rate.num, material_track->edit_rate.den, st->index);
            material_track->edit_rate = (AVRational){25, 1};
        }
1460
        avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1461

1462 1463 1464
        /* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
        source_track->edit_rate = material_track->edit_rate;

1465
        PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
1466 1467
        codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
        st->codec->codec_type = codec_ul->id;
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505

        source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
        if (source_package->descriptor) {
            if (source_package->descriptor->type == MultipleDescriptor) {
                for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
                    MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);

                    if (!sub_descriptor) {
                        av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
                        continue;
                    }
                    if (sub_descriptor->linked_track_id == source_track->track_id) {
                        descriptor = sub_descriptor;
                        break;
                    }
                }
            } else if (source_package->descriptor->type == Descriptor)
                descriptor = source_package->descriptor;
        }
        if (!descriptor) {
            av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
            continue;
        }
        PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
        PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
        essence_container_ul = &descriptor->essence_container_ul;
        /* HACK: replacing the original key with mxf_encrypted_essence_container
         * is not allowed according to s429-6, try to find correct information anyway */
        if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
            av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
            for (k = 0; k < mxf->metadata_sets_count; k++) {
                MXFMetadataSet *metadata = mxf->metadata_sets[k];
                if (metadata->type == CryptoContext) {
                    essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
                    break;
                }
            }
        }
1506

1507
        /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1508
        codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1509
        st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1510 1511
        av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
               avcodec_get_name(st->codec->codec_id));
1512
        for (k = 0; k < 16; k++) {
1513 1514
            av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
                   descriptor->essence_codec_ul[k]);
1515 1516 1517
            if (!(k+1 & 19) || k == 5)
                av_log(mxf->fc, AV_LOG_VERBOSE, ".");
        }
1518
        av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1519
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1520
            source_track->intra_only = mxf_is_intra_only(descriptor);
1521
            container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1522
            if (st->codec->codec_id == AV_CODEC_ID_NONE)
1523 1524
                st->codec->codec_id = container_ul->id;
            st->codec->width = descriptor->width;
1525 1526 1527 1528 1529 1530 1531
            st->codec->height = descriptor->height; /* Field height, not frame height */
            switch (descriptor->frame_layout) {
                case SegmentedFrame:
                    /* This one is a weird layout I don't fully understand. */
                    av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
                    break;
                case FullFrame:
1532
                    st->codec->field_order = AV_FIELD_PROGRESSIVE;
1533 1534 1535 1536 1537 1538 1539 1540
                    break;
                case OneField:
                    /* Every other line is stored and needs to be duplicated. */
                    av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
                    break; /* The correct thing to do here is fall through, but by breaking we might be
                              able to decode some streams at half the vertical resolution, rather than not al all.
                              It's also for compatibility with the old behavior. */
                case MixedFields:
1541 1542
                    break;
                case SeparateFields:
1543
                    st->codec->height *= 2; /* Turn field height into frame height. */
1544
                    break;
1545 1546 1547
                default:
                    av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
            }
1548
            if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1549
                st->codec->pix_fmt = descriptor->pix_fmt;
1550
                if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1551 1552
                    pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
                                                  &descriptor->essence_codec_ul);
1553
                    st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1554
                    if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1555 1556 1557 1558 1559
                        /* support files created before RP224v10 by defaulting to UYVY422
                           if subsampling is 4:2:2 and component depth is 8-bit */
                        if (descriptor->horiz_subsampling == 2 &&
                            descriptor->vert_subsampling == 1 &&
                            descriptor->component_depth == 8) {
1560
                            st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1561 1562 1563 1564
                        }
                    }
                }
            }
1565
            st->need_parsing = AVSTREAM_PARSE_HEADERS;
1566
        } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1567
            container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1568
            /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1569 1570
            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))
                st->codec->codec_id = (enum AVCodecID)container_ul->id;
1571
            st->codec->channels = descriptor->channels;
1572
            st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1573

1574 1575
            if (descriptor->sample_rate.den > 0) {
                avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1576
                st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1577 1578 1579 1580 1581
            } else {
                av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) found for stream #%d, time base forced to 1/48000\n",
                       descriptor->sample_rate.num, descriptor->sample_rate.den, st->index);
                avpriv_set_pts_info(st, 64, 1, 48000);
            }
1582

1583 1584 1585 1586
            /* if duration is set, rescale it from EditRate to SampleRate */
            if (st->duration != AV_NOPTS_VALUE)
                st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);

1587 1588
            /* TODO: implement AV_CODEC_ID_RAWAUDIO */
            if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1589
                if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1590
                    st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1591
                else if (descriptor->bits_per_sample == 32)
1592 1593
                    st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
            } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1594
                if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1595
                    st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1596
                else if (descriptor->bits_per_sample == 32)
1597 1598
                    st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
            } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1599 1600 1601
                st->need_parsing = AVSTREAM_PARSE_FULL;
            }
        }
1602 1603 1604 1605
        if (descriptor->extradata) {
            st->codec->extradata = av_mallocz(descriptor->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
            if (st->codec->extradata)
                memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1606
        } else if(st->codec->codec_id == AV_CODEC_ID_H264) {
1607 1608
            ff_generate_avci_extradata(st);
        }
1609
        if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1610 1611
            /* TODO: decode timestamps */
            st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1612 1613
        }
    }
1614

1615
    ret = 0;
1616 1617
fail_and_free:
    return ret;
1618 1619
}

1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
{
    int ret;
    size_t buf_size;

    if (size < 0)
        return AVERROR(EINVAL);

    buf_size = size + size/2 + 1;
    *str = av_malloc(buf_size);
    if (!*str)
        return AVERROR(ENOMEM);

    if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
        av_freep(str);
        return ret;
    }

    return ret;
}

static int mxf_uid_to_str(UID uid, char **str)
{
    int i;
    char *p;
    p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
    if (!p)
        return AVERROR(ENOMEM);
    for (i = 0; i < sizeof(UID); i++) {
        snprintf(p, 2 + 1, "%.2x", uid[i]);
        p += 2;
        if (i == 3 || i == 5 || i == 7 || i == 9) {
            snprintf(p, 1 + 1, "-");
            p++;
        }
    }
    return 0;
}

static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
{
1661
    struct tm time = {0};
1662
    time.tm_year = (timestamp >> 48) - 1900;
1663 1664 1665 1666 1667
    time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
    time.tm_mday = (timestamp >> 32 & 0xFF);
    time.tm_hour = (timestamp >> 24 & 0xFF);
    time.tm_min  = (timestamp >> 16 & 0xFF);
    time.tm_sec  = (timestamp >> 8  & 0xFF);
1668

1669 1670 1671 1672
    /* ensure month/day are valid */
    time.tm_mon  = FFMAX(time.tm_mon, 0);
    time.tm_mday = FFMAX(time.tm_mday, 1);

1673 1674 1675
    *str = av_mallocz(32);
    if (!*str)
        return AVERROR(ENOMEM);
1676
    strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737

    return 0;
}

#define SET_STR_METADATA(pb, name, str) do { \
    if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
        return ret; \
    av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
} while (0)

#define SET_UID_METADATA(pb, name, var, str) do { \
    avio_read(pb, var, 16); \
    if ((ret = mxf_uid_to_str(var, &str)) < 0) \
        return ret; \
    av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
} while (0)

#define SET_TS_METADATA(pb, name, var, str) do { \
    var = avio_rb64(pb); \
    if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
        return ret; \
    av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
} while (0)

static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
{
    MXFContext *mxf = arg;
    AVFormatContext *s = mxf->fc;
    int ret;
    UID uid = { 0 };
    char *str = NULL;
    uint64_t ts;
    switch (tag) {
    case 0x3C01:
        SET_STR_METADATA(pb, "company_name", str);
        break;
    case 0x3C02:
        SET_STR_METADATA(pb, "product_name", str);
        break;
    case 0x3C04:
        SET_STR_METADATA(pb, "product_version", str);
        break;
    case 0x3C05:
        SET_UID_METADATA(pb, "product_uid", uid, str);
        break;
    case 0x3C06:
        SET_TS_METADATA(pb, "modification_date", ts, str);
        break;
    case 0x3C08:
        SET_STR_METADATA(pb, "application_platform", str);
        break;
    case 0x3C09:
        SET_UID_METADATA(pb, "generation_uid", uid, str);
        break;
    case 0x3C0A:
        SET_UID_METADATA(pb, "uid", uid, str);
        break;
    }
    return 0;
}

1738 1739
static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
Tomas Härdin's avatar
Tomas Härdin committed
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1750
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
    { { 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 */
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
    { { 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 */
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1765
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1766
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1767
    { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1768 1769 1770
    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
};

1771
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1772
{
1773
    AVIOContext *pb = mxf->fc->pb;
1774
    MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1775
    uint64_t klv_end = avio_tell(pb) + klv->length;
1776 1777

    if (!ctx)
1778
        return AVERROR(ENOMEM);
1779
    while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1780
        int ret;
1781 1782
        int tag = avio_rb16(pb);
        int size = avio_rb16(pb); /* KLV specified by 0x53 */
1783
        uint64_t next = avio_tell(pb) + size;
1784 1785
        UID uid = {0};

1786
        av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1787
        if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1788
            av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1789 1790 1791 1792 1793 1794 1795 1796
            continue;
        }
        if (tag > 0x7FFF) { /* dynamic tag */
            int i;
            for (i = 0; i < mxf->local_tags_count; i++) {
                int local_tag = AV_RB16(mxf->local_tags+i*18);
                if (local_tag == tag) {
                    memcpy(uid, mxf->local_tags+i*18+2, 16);
1797
                    av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1798 1799 1800 1801 1802
                    PRINT_KEY(mxf->fc, "uid", uid);
                }
            }
        }
        if (ctx_size && tag == 0x3C0A)
1803
            avio_read(pb, ctx->uid, 16);
1804
        else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1805
            return ret;
1806

1807 1808
        /* Accept the 64k local set limit being exceeded (Avid). Don't accept
         * it extending past the end of the KLV though (zzuf5.mxf). */
1809
        if (avio_tell(pb) > klv_end) {
1810 1811 1812
            if (ctx_size)
                av_free(ctx);

1813 1814
            av_log(mxf->fc, AV_LOG_ERROR,
                   "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1815 1816 1817
                   tag, klv->offset);
            return AVERROR_INVALIDDATA;
        } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
1818
            avio_seek(pb, next, SEEK_SET);
1819 1820 1821 1822 1823
    }
    if (ctx_size) ctx->type = type;
    return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
}

1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
/**
 * Seeks to the previous partition, if possible
 * @return <= 0 if we should stop parsing, > 0 if we should keep going
 */
static int mxf_seek_to_previous_partition(MXFContext *mxf)
{
    AVIOContext *pb = mxf->fc->pb;

    if (!mxf->current_partition ||
        mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
        return 0;   /* we've parsed all partitions */

    /* seek to previous partition */
    avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
    mxf->current_partition = NULL;

    av_dlog(mxf->fc, "seeking to previous partition\n");

    return 1;
}

/**
 * Called when essence is encountered
 * @return <= 0 if we should stop parsing, > 0 if we should keep going
 */
static int mxf_parse_handle_essence(MXFContext *mxf)
{
    AVIOContext *pb = mxf->fc->pb;
    int64_t ret;

    if (mxf->parsing_backward) {
        return mxf_seek_to_previous_partition(mxf);
    } else {
        if (!mxf->footer_partition) {
            av_dlog(mxf->fc, "no footer\n");
            return 0;
        }

        av_dlog(mxf->fc, "seeking to footer\n");

        /* remember where we were so we don't end up seeking further back than this */
        mxf->last_forward_tell = avio_tell(pb);

        if (!pb->seekable) {
            av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
            return -1;
        }

        /* seek to footer partition and parse backward */
        if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
            av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
                   mxf->run_in + mxf->footer_partition, ret);
            return ret;
        }

        mxf->current_partition = NULL;
        mxf->parsing_backward = 1;
    }

    return 1;
}

/**
 * Called when the next partition or EOF is encountered
 * @return <= 0 if we should stop parsing, > 0 if we should keep going
 */
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
{
    return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
}

1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
/**
 * Figures out the proper offset and length of the essence container in each partition
 */
static void mxf_compute_essence_containers(MXFContext *mxf)
{
    int x;

    /* everything is already correct */
    if (mxf->op == OPAtom)
        return;

    for (x = 0; x < mxf->partitions_count; x++) {
        MXFPartition *p = &mxf->partitions[x];

        if (!p->body_sid)
            continue;       /* BodySID == 0 -> no essence */

        if (x >= mxf->partitions_count - 1)
            break;          /* last partition - can't compute length (and we don't need to) */

        /* essence container spans to the next partition */
        p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;

        if (p->essence_length < 0) {
            /* next ThisPartition < essence_offset */
            p->essence_length = 0;
1921 1922
            av_log(mxf->fc, AV_LOG_ERROR,
                   "partition %i: bad ThisPartition = %"PRIX64"\n",
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935
                   x+1, mxf->partitions[x+1].this_partition);
        }
    }
}

static int64_t round_to_kag(int64_t position, int kag_size)
{
    /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
    /* NOTE: kag_size may be any integer between 1 - 2^10 */
    int64_t ret = (position / kag_size) * kag_size;
    return ret == position ? ret : ret + kag_size;
}

1936
static int is_pcm(enum AVCodecID codec_id)
1937 1938
{
    /* we only care about "normal" PCM codecs until we get samples */
1939
    return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1940 1941 1942
}

/**
1943 1944 1945
 * Deal with the case where for some audio atoms EditUnitByteCount is
 * very small (2, 4..). In those cases we should read more than one
 * sample per call to mxf_read_packet().
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
 */
static void mxf_handle_small_eubc(AVFormatContext *s)
{
    MXFContext *mxf = s->priv_data;

    /* assuming non-OPAtom == frame wrapped
     * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
    if (mxf->op != OPAtom)
        return;

    /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1957 1958 1959 1960 1961
    if (s->nb_streams != 1                                     ||
        s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
        !is_pcm(s->streams[0]->codec->codec_id)                ||
        mxf->nb_index_tables != 1                              ||
        mxf->index_tables[0].nb_segments != 1                  ||
1962 1963 1964 1965
        mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
        return;

    /* arbitrarily default to 48 kHz PAL audio frame size */
1966 1967 1968
    /* TODO: We could compute this from the ratio between the audio
     *       and video edit rates for 48 kHz NTSC we could use the
     *       1802-1802-1802-1802-1801 pattern. */
1969 1970 1971
    mxf->edit_units_per_packet = 1920;
}

1972
static int mxf_read_header(AVFormatContext *s)
1973 1974 1975
{
    MXFContext *mxf = s->priv_data;
    KLVPacket klv;
1976
    int64_t essence_offset = 0;
1977
    int ret;
1978

1979
    mxf->last_forward_tell = INT64_MAX;
1980
    mxf->edit_units_per_packet = 1;
1981

1982 1983
    if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
        av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1984
        return AVERROR_INVALIDDATA;
1985
    }
1986
    avio_seek(s->pb, -14, SEEK_CUR);
1987
    mxf->fc = s;
1988 1989
    mxf->run_in = avio_tell(s->pb);

1990 1991 1992
    while (!url_feof(s->pb)) {
        const MXFMetadataReadTableEntry *metadata;

1993 1994 1995 1996 1997 1998 1999 2000
        if (klv_read_packet(&klv, s->pb) < 0) {
            /* EOF - seek to previous partition or stop */
            if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
                break;
            else
                continue;
        }

2001
        PRINT_KEY(s, "read header", klv.key);
2002
        av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2003
        if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2004
            IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2005
            IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2006
            IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2007 2008 2009 2010 2011 2012

            if (!mxf->current_partition) {
                av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
                return AVERROR_INVALIDDATA;
            }

2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036
            if (!mxf->current_partition->essence_offset) {
                /* for OP1a we compute essence_offset
                 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
                 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
                 *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
                 */
                int64_t op1a_essence_offset =
                    round_to_kag(mxf->current_partition->this_partition +
                                 mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
                    round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
                    round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);

                if (mxf->op == OPAtom) {
                    /* point essence_offset to the actual data
                    * OPAtom has all the essence in one big KLV
                    */
                    mxf->current_partition->essence_offset = avio_tell(s->pb);
                    mxf->current_partition->essence_length = klv.length;
                } else {
                    /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
                    mxf->current_partition->essence_offset = op1a_essence_offset;
                }
            }

2037 2038
            if (!essence_offset)
                essence_offset = klv.offset;
2039 2040 2041 2042

            /* seek to footer, previous partition or stop */
            if (mxf_parse_handle_essence(mxf) <= 0)
                break;
2043
            continue;
2044 2045 2046 2047 2048
        } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
                   klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
            /* next partition pack - keep going, seek to previous partition or stop */
            if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
                break;
2049 2050 2051
            else if (mxf->parsing_backward)
                continue;
            /* we're still parsing forward. proceed to parsing this partition pack */
2052
        }
2053 2054 2055

        for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
            if (IS_KLV_KEY(klv.key, metadata->key)) {
2056 2057 2058
                int res;
                if (klv.key[5] == 0x53) {
                    res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2059 2060
                } else {
                    uint64_t next = avio_tell(s->pb) + klv.length;
2061
                    res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2062 2063 2064 2065 2066 2067 2068 2069

                    /* only seek forward, else this can loop for a long time */
                    if (avio_tell(s->pb) > next) {
                        av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
                               klv.offset);
                        return AVERROR_INVALIDDATA;
                    }

2070 2071
                    avio_seek(s->pb, next, SEEK_SET);
                }
2072
                if (res < 0) {
2073
                    av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2074
                    return res;
2075 2076 2077 2078 2079
                }
                break;
            }
        }
        if (!metadata->read)
2080
            avio_skip(s->pb, klv.length);
2081
    }
2082
    /* FIXME avoid seek */
2083
    if (!essence_offset)  {
2084 2085 2086
        av_log(s, AV_LOG_ERROR, "no essence\n");
        return AVERROR_INVALIDDATA;
    }
2087
    avio_seek(s->pb, essence_offset, SEEK_SET);
2088 2089 2090

    mxf_compute_essence_containers(mxf);

2091 2092 2093
    /* we need to do this before computing the index tables
     * to be able to fill in zero IndexDurations with st->duration */
    if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2094
        goto fail;
2095

2096
    if ((ret = mxf_compute_index_tables(mxf)) < 0)
2097
        goto fail;
2098 2099 2100 2101 2102 2103 2104

    if (mxf->nb_index_tables > 1) {
        /* TODO: look up which IndexSID to use via EssenceContainerData */
        av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
               mxf->nb_index_tables, mxf->index_tables[0].index_sid);
    } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
        av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2105 2106
        ret = AVERROR_INVALIDDATA;
        goto fail;
2107 2108
    }

2109 2110
    mxf_handle_small_eubc(s);

2111
    return 0;
2112 2113 2114 2115
fail:
    mxf_read_close(s);

    return ret;
2116 2117
}

2118
/**
2119 2120
 * Sets mxf->current_edit_unit based on what offset we're currently at.
 * @return next_ofs if OK, <0 on error
2121
 */
2122
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2123
{
2124
    int64_t last_ofs = -1, next_ofs = -1;
2125 2126
    MXFIndexTable *t = &mxf->index_tables[0];

2127 2128
    /* this is called from the OP1a demuxing logic, which means there
     * may be no index tables */
2129
    if (mxf->nb_index_tables <= 0)
2130
        return -1;
2131

2132
    /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2133
    while (mxf->current_edit_unit >= 0) {
2134
        if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2135
            return -1;
2136

2137
        if (next_ofs <= last_ofs) {
2138 2139 2140 2141
            /* large next_ofs didn't change or current_edit_unit wrapped
             * around this fixes the infinite loop on zzuf3.mxf */
            av_log(mxf->fc, AV_LOG_ERROR,
                   "next_ofs didn't change. not deriving packet timestamps\n");
2142
            return -1;
2143 2144
        }

2145
        if (next_ofs > current_offset)
2146 2147
            break;

2148
        last_ofs = next_ofs;
2149 2150 2151
        mxf->current_edit_unit++;
    }

2152 2153 2154
    /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
    if (mxf->current_edit_unit < 0)
        return -1;
2155

2156
    return next_ofs;
2157 2158
}

2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
{
    int i, total = 0, size = 0;
    AVStream *st = mxf->fc->streams[stream_index];
    MXFTrack *track = st->priv_data;
    AVRational time_base = av_inv_q(track->edit_rate);
    AVRational sample_rate = av_inv_q(st->time_base);
    const MXFSamplesPerFrame *spf = NULL;

    if ((sample_rate.num / sample_rate.den) == 48000)
        spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
    if (!spf) {
        int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
        *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
                                        av_mul_q(sample_rate, time_base)));
        if (remainder)
            av_log(mxf->fc, AV_LOG_WARNING,
                   "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
                   stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
        return 0;
    }

    while (spf->samples_per_frame[size]) {
        total += spf->samples_per_frame[size];
        size++;
    }

    av_assert2(size);

2188
    *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
    for (i = 0; i < mxf->current_edit_unit % size; i++) {
        *sample_count += spf->samples_per_frame[i];
    }

    return 0;
}

static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
{
    MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
    pkt->pts = track->sample_count;
2200 2201
    if (codec->channels <= 0 || av_get_bits_per_sample(codec->codec_id) <= 0)
        return AVERROR(EINVAL);
2202
    track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2203 2204 2205
    return 0;
}

2206 2207 2208
static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
{
    KLVPacket klv;
2209
    MXFContext *mxf = s->priv_data;
2210

2211
    while (klv_read_packet(&klv, s->pb) == 0) {
2212
        int ret;
2213 2214 2215
        PRINT_KEY(s, "read packet", klv.key);
        av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
        if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2216 2217
            ret = mxf_decrypt_triplet(s, pkt, &klv);
            if (ret < 0) {
2218
                av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2219
                return AVERROR_INVALIDDATA;
2220 2221 2222 2223 2224 2225
            }
            return 0;
        }
        if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
            IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
            int index = mxf_get_stream_index(s, &klv);
2226
            int64_t next_ofs, next_klv;
2227 2228
            AVStream *st;
            MXFTrack *track;
2229
            AVCodecContext *codec;
2230

2231 2232 2233 2234
            if (index < 0) {
                av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
                goto skip;
            }
2235 2236 2237 2238

            st = s->streams[index];
            track = st->priv_data;

2239 2240
            if (s->streams[index]->discard == AVDISCARD_ALL)
                goto skip;
2241 2242 2243 2244 2245 2246 2247

            next_klv = avio_tell(s->pb) + klv.length;
            next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);

            if (next_ofs >= 0 && next_klv > next_ofs) {
                /* if this check is hit then it's possible OPAtom was treated as OP1a
                 * truncate the packet since it's probably very large (>2 GiB is common) */
2248 2249 2250 2251
                avpriv_request_sample(s,
                                      "OPAtom misinterpreted as OP1a?"
                                      "KLV for edit unit %i extending into "
                                      "next edit unit",
2252
                                      mxf->current_edit_unit);
2253 2254 2255
                klv.length = next_ofs - avio_tell(s->pb);
            }

2256 2257 2258 2259
            /* check for 8 channels AES3 element */
            if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
                if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
                    av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2260
                    return AVERROR_INVALIDDATA;
2261 2262
                }
            } else {
2263
                ret = av_get_packet(s->pb, pkt, klv.length);
2264 2265 2266 2267 2268
                if (ret < 0)
                    return ret;
            }
            pkt->stream_index = index;
            pkt->pos = klv.offset;
2269

2270 2271
            codec = s->streams[index]->codec;
            if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2272 2273 2274 2275 2276 2277
                /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
                MXFIndexTable *t = &mxf->index_tables[0];

                if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
                    pkt->dts = mxf->current_edit_unit + t->first_dts;
                    pkt->pts = t->ptses[mxf->current_edit_unit];
2278 2279 2280 2281
                } else if (track->intra_only) {
                    /* intra-only -> PTS = EditUnit.
                     * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
                    pkt->pts = mxf->current_edit_unit;
2282
                }
2283 2284 2285 2286
            } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
                int ret = mxf_set_audio_pts(mxf, codec, pkt);
                if (ret < 0)
                    return ret;
2287 2288 2289 2290
            }

            /* seek for truncated packets */
            avio_seek(s->pb, next_klv, SEEK_SET);
2291

2292 2293 2294 2295 2296
            return 0;
        } else
        skip:
            avio_skip(s->pb, klv.length);
    }
2297
    return url_feof(s->pb) ? AVERROR_EOF : -1;
2298 2299 2300 2301 2302
}

static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    MXFContext *mxf = s->priv_data;
2303 2304
    int ret, size;
    int64_t ret64, pos, next_pos;
2305
    AVStream *st;
2306
    MXFIndexTable *t;
2307
    int edit_units;
2308

2309
    if (mxf->op != OPAtom)
2310 2311
        return mxf_read_packet_old(s, pkt);

2312
    /* OPAtom - clip wrapped demuxing */
2313
    /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2314 2315
    st = s->streams[0];
    t = &mxf->index_tables[0];
2316

2317
    if (mxf->current_edit_unit >= st->duration)
2318 2319
        return AVERROR_EOF;

2320 2321
    edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);

2322 2323
    if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
        return ret;
2324

2325 2326
    /* compute size by finding the next edit unit or the end of the essence container
     * not pretty, but it works */
2327
    if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2328 2329 2330 2331
        (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
        av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
        return AVERROR_INVALIDDATA;
    }
2332

2333 2334 2335 2336
    if ((size = next_pos - pos) <= 0) {
        av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
        return AVERROR_INVALIDDATA;
    }
2337

2338 2339
    if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
        return ret64;
2340

2341 2342
    if ((size = av_get_packet(s->pb, pkt, size)) < 0)
        return size;
2343

2344 2345
    pkt->stream_index = 0;

2346 2347 2348 2349
    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
        mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
        pkt->dts = mxf->current_edit_unit + t->first_dts;
        pkt->pts = t->ptses[mxf->current_edit_unit];
2350 2351 2352 2353
    } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
        int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
        if (ret < 0)
            return ret;
2354 2355
    }

2356
    mxf->current_edit_unit += edit_units;
2357 2358 2359 2360

    return 0;
}

2361 2362 2363
static int mxf_read_close(AVFormatContext *s)
{
    MXFContext *mxf = s->priv_data;
2364
    MXFIndexTableSegment *seg;
2365
    int i;
2366 2367

    av_freep(&mxf->packages_refs);
2368 2369 2370 2371

    for (i = 0; i < s->nb_streams; i++)
        s->streams[i]->priv_data = NULL;

2372 2373
    for (i = 0; i < mxf->metadata_sets_count; i++) {
        switch (mxf->metadata_sets[i]->type) {
2374 2375 2376
        case Descriptor:
            av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
            break;
2377 2378 2379 2380 2381 2382 2383 2384 2385 2386
        case MultipleDescriptor:
            av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
            break;
        case Sequence:
            av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
            break;
        case SourcePackage:
        case MaterialPackage:
            av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
            break;
2387 2388
        case IndexTableSegment:
            seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2389
            av_freep(&seg->temporal_offset_entries);
2390 2391 2392
            av_freep(&seg->flag_entries);
            av_freep(&seg->stream_offset_entries);
            break;
2393 2394 2395 2396 2397
        default:
            break;
        }
        av_freep(&mxf->metadata_sets[i]);
    }
Tomas Härdin's avatar
Tomas Härdin committed
2398
    av_freep(&mxf->partitions);
2399 2400 2401
    av_freep(&mxf->metadata_sets);
    av_freep(&mxf->aesc);
    av_freep(&mxf->local_tags);
2402

2403 2404 2405 2406 2407 2408
    if (mxf->index_tables) {
        for (i = 0; i < mxf->nb_index_tables; i++) {
            av_freep(&mxf->index_tables[i].segments);
            av_freep(&mxf->index_tables[i].ptses);
            av_freep(&mxf->index_tables[i].fake_index);
        }
2409
    }
2410 2411
    av_freep(&mxf->index_tables);

2412 2413 2414 2415
    return 0;
}

static int mxf_probe(AVProbeData *p) {
2416 2417
    const uint8_t *bufp = p->buf;
    const uint8_t *end = p->buf + p->buf_size;
2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436

    if (p->buf_size < sizeof(mxf_header_partition_pack_key))
        return 0;

    /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
    end -= sizeof(mxf_header_partition_pack_key);
    for (; bufp < end; bufp++) {
        if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
            return AVPROBE_SCORE_MAX;
    }
    return 0;
}

/* rudimentary byte seek */
/* XXX: use MXF Index */
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
{
    AVStream *st = s->streams[stream_index];
    int64_t seconds;
2437 2438
    MXFContext* mxf = s->priv_data;
    int64_t seekpos;
2439
    int i, ret;
2440
    int64_t ret64;
2441
    MXFIndexTable *t;
2442 2443 2444 2445 2446
    MXFTrack *source_track = st->priv_data;

    /* if audio then truncate sample_time to EditRate */
    if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
        sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2447

2448
    if (mxf->nb_index_tables <= 0) {
2449
    if (!s->bit_rate)
2450
        return AVERROR_INVALIDDATA;
2451 2452 2453
    if (sample_time < 0)
        sample_time = 0;
    seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2454

2455 2456
    if ((ret64 = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
        return ret64;
2457
    ff_update_cur_dts(s, st, sample_time);
2458
    mxf->current_edit_unit = sample_time;
2459
    } else {
2460
        t = &mxf->index_tables[0];
2461

2462 2463 2464
        /* clamp above zero, else ff_index_search_timestamp() returns negative
         * this also means we allow seeking before the start */
        sample_time = FFMAX(sample_time, 0);
2465

2466 2467 2468 2469 2470 2471 2472
        if (t->fake_index) {
            /* behave as if we have a proper index */
            if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
                return sample_time;
        } else {
            /* no IndexEntryArray (one or more CBR segments)
             * make sure we don't seek past the end */
2473
            sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2474 2475
        }

2476 2477 2478
        if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
            return ret;

2479
        ff_update_cur_dts(s, st, sample_time);
2480
        mxf->current_edit_unit = sample_time;
2481 2482
        avio_seek(s->pb, seekpos, SEEK_SET);
    }
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496

    // Update all tracks sample count
    for (i = 0; i < s->nb_streams; i++) {
        AVStream *cur_st = s->streams[i];
        MXFTrack *cur_track = cur_st->priv_data;
        uint64_t current_sample_count = 0;
        if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
            ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
            if (ret < 0)
                return ret;

            cur_track->sample_count = current_sample_count;
        }
    }
2497 2498 2499
    return 0;
}

2500
AVInputFormat ff_mxf_demuxer = {
2501
    .name           = "mxf",
2502
    .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2503 2504 2505 2506 2507 2508
    .priv_data_size = sizeof(MXFContext),
    .read_probe     = mxf_probe,
    .read_header    = mxf_read_header,
    .read_packet    = mxf_read_packet,
    .read_close     = mxf_read_close,
    .read_seek      = mxf_read_seek,
2509
};