git.sesse.net Git - ffmpeg/blob - libavformat/mxf.c

   1 /*
   2  * MXF demuxer.
   3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 /*
  21  * References
  22  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
  23  * SMPTE 377M MXF File Format Specifications
  24  * SMPTE 378M Operational Pattern 1a
  25  * SMPTE 379M MXF Generic Container
  26  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
  27  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
  28  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
  29  *
  30  * Principle
  31  * Search for Track numbers which will identify essence element KLV packets.
  32  * Search for SourcePackage which define tracks which contains Track numbers.
  33  * Material Package contains tracks with reference to SourcePackage tracks.
  34  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
  35  * Assign Descriptors to correct Tracks.
  36  *
  37  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
  38  * Metadata parsing resolves Strong References to objects.
  39  *
  40  * Simple demuxer, only OP1A supported and some files might not work at all.
  41  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
  42  * Only descriptors with EssenceSoundCompression or PictureEssenceCoding will be taken into account. "D/req" SMPTE 377M
  43  */
  44
  45 //#define DEBUG
  46
  47 #include "avformat.h"
  48
  49 typedef uint8_t UID[16];
  50
  51 enum MXFMetadataSetType {
  52     MaterialPackage,
  53     SourcePackage,
  54     SourceClip,
  55     TimecodeComponent,
  56     Sequence,
  57     MultipleDescriptor,
  58     Descriptor,
  59     Track,
  60     EssenceContainerData,
  61 };
  62
  63 typedef struct MXFStructuralComponent {
  64     UID uid;
  65     enum MXFMetadataSetType type;
  66     UID source_package_uid;
  67     UID data_definition_ul;
  68     int64_t duration;
  69     int64_t start_position;
  70     int source_track_id;
  71 } MXFStructuralComponent;
  72
  73 typedef struct MXFSequence {
  74     UID uid;
  75     enum MXFMetadataSetType type;
  76     UID data_definition_ul;
  77     UID *structural_components_refs;
  78     int structural_components_count;
  79     int64_t duration;
  80 } MXFSequence;
  81
  82 typedef struct MXFTrack {
  83     UID uid;
  84     enum MXFMetadataSetType type;
  85     MXFSequence *sequence; /* mandatory, and only one */
  86     UID sequence_ref;
  87     int track_id;
  88     uint8_t track_number[4];
  89     AVRational edit_rate;
  90 } MXFTrack;
  91
  92 typedef struct MXFDescriptor {
  93     UID uid;
  94     enum MXFMetadataSetType type;
  95     UID essence_container_ul;
  96     UID essence_codec_ul;
  97     AVRational sample_rate;
  98     AVRational aspect_ratio;
  99     int width;
 100     int height;
 101     int channels;
 102     int bits_per_sample;
 103     UID *sub_descriptors_refs;
 104     int sub_descriptors_count;
 105     int linked_track_id;
 106 } MXFDescriptor;
 107
 108 typedef struct MXFPackage {
 109     UID uid;
 110     enum MXFMetadataSetType type;
 111     UID package_uid;
 112     UID *tracks_refs;
 113     int tracks_count;
 114     MXFDescriptor *descriptor; /* only one */
 115     UID descriptor_ref;
 116 } MXFPackage;
 117
 118 typedef struct MXFEssenceContainerData {
 119     UID uid;
 120     enum MXFMetadataSetType type;
 121     UID linked_package_uid;
 122 } MXFEssenceContainerData;
 123
 124 typedef struct {
 125     UID uid;
 126     enum MXFMetadataSetType type;
 127 } MXFMetadataSet;
 128
 129 typedef struct MXFContext {
 130     UID *packages_refs;
 131     int packages_count;
 132     UID *essence_container_data_sets_refs;
 133     int essence_container_data_sets_count;
 134     UID *essence_containers_uls; /* Universal Labels SMPTE RP224 */
 135     int essence_containers_uls_count;
 136     UID operational_pattern_ul;
 137     UID content_storage_uid;
 138     MXFMetadataSet **metadata_sets;
 139     int metadata_sets_count;
 140     AVFormatContext *fc;
 141 } MXFContext;
 142
 143 typedef struct KLVPacket {
 144     UID key;
 145     offset_t offset;
 146     uint64_t length;
 147 } KLVPacket;
 148
 149 typedef struct MXFCodecUL {
 150     UID uid;
 151     enum CodecID id;
 152 } MXFCodecUL;
 153
 154 typedef struct MXFMetadataReadTableEntry {
 155     const UID key;
 156     int (*read)(MXFContext *mxf, KLVPacket *klv);
 157 } MXFMetadataReadTableEntry;
 158
 159 /* partial keys to match */
 160 static const uint8_t mxf_header_partition_pack_key[]       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
 161 static const uint8_t mxf_essence_element_key[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
 162
 163 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
 164
 165 #define PRINT_KEY(x) dprintf("%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", \
 166                              (x)[0], (x)[1], (x)[2], (x)[3], (x)[4], (x)[5], (x)[6], (x)[7], (x)[8], (x)[9], (x)[10], (x)[11], (x)[12], (x)[13], (x)[14], (x)[15])
 167
 168 static int64_t klv_decode_ber_length(ByteIOContext *pb)
 169 {
 170     int64_t size = 0;
 171     uint8_t length = get_byte(pb);
 172     int type = length >> 7;
 173
 174     if (type) { /* long form */
 175         int bytes_num = length & 0x7f;
 176         /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
 177         if (bytes_num > 8)
 178             return -1;
 179         while (bytes_num--)
 180             size = size << 8 | get_byte(pb);
 181     } else {
 182         size = length & 0x7f;
 183     }
 184     return size;
 185 }
 186
 187 static int klv_read_packet(KLVPacket *klv, ByteIOContext *pb)
 188 {
 189     klv->offset = url_ftell(pb);
 190     get_buffer(pb, klv->key, 16);
 191     klv->length = klv_decode_ber_length(pb);
 192     return klv->length == -1 ? -1 : 0;
 193 }
 194
 195 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
 196 {
 197     int i;
 198
 199     for (i = 0; i < s->nb_streams; i++) {
 200         MXFTrack *track = s->streams[i]->priv_data;
 201          /* SMPTE 379M 7.3 */
 202         if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
 203             return i;
 204     }
 205     return -1;
 206 }
 207
 208 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
 209 {
 210     KLVPacket klv;
 211
 212     while (!url_feof(&s->pb)) {
 213         if (klv_read_packet(&klv, &s->pb) < 0) {
 214             av_log(s, AV_LOG_ERROR, "error reading KLV packet\n");
 215             return -1;
 216         }
 217 #ifdef DEBUG
 218         PRINT_KEY(klv.key);
 219 #endif
 220         if (IS_KLV_KEY(klv.key, mxf_essence_element_key)) {
 221             av_get_packet(&s->pb, pkt, klv.length);
 222             pkt->stream_index = mxf_get_stream_index(s, &klv);
 223             return pkt->stream_index == -1 ? -1 : 0;
 224         } else
 225             url_fskip(&s->pb, klv.length);
 226     }
 227     return AVERROR_IO;
 228 }
 229
 230 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
 231 {
 232     mxf->metadata_sets = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets));
 233     mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
 234     mxf->metadata_sets_count++;
 235     return 0;
 236 }
 237
 238 static int mxf_read_metadata_preface(MXFContext *mxf, KLVPacket *klv)
 239 {
 240     ByteIOContext *pb = &mxf->fc->pb;
 241     int bytes_read = 0;
 242
 243     while (bytes_read < klv->length) {
 244         int tag = get_be16(pb);
 245         int size = get_be16(pb); /* SMPTE 336M Table 8 KLV specified length, 0x53 */
 246
 247         switch (tag) {
 248         case 0x3B03:
 249             get_buffer(pb, mxf->content_storage_uid, 16);
 250             break;
 251         case 0x3B09:
 252             get_buffer(pb, mxf->operational_pattern_ul, 16);
 253             break;
 254         case 0x3B0A:
 255             mxf->essence_containers_uls_count = get_be32(pb);
 256             if (mxf->essence_containers_uls_count >= UINT_MAX / sizeof(UID))
 257                 return -1;
 258             mxf->essence_containers_uls = av_malloc(mxf->essence_containers_uls_count * sizeof(UID));
 259             url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
 260             get_buffer(pb, mxf->essence_containers_uls, mxf->essence_containers_uls_count * sizeof(UID));
 261             break;
 262         default:
 263             url_fskip(pb, size);
 264         }
 265         bytes_read += size + 4;
 266     }
 267     return 0;
 268 }
 269
 270 static int mxf_read_metadata_content_storage(MXFContext *mxf, KLVPacket *klv)
 271 {
 272     ByteIOContext *pb = &mxf->fc->pb;
 273     int bytes_read = 0;
 274
 275     while (bytes_read < klv->length) {
 276         int tag = get_be16(pb);
 277         int size = get_be16(pb); /* SMPTE 336M Table 8 KLV specified length, 0x53 */
 278
 279         dprintf("tag 0x%04X, size %d\n", tag, size);
 280         switch (tag) {
 281         case 0x1901:
 282             mxf->packages_count = get_be32(pb);
 283             if (mxf->packages_count >= UINT_MAX / sizeof(UID))
 284                 return -1;
 285             mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID));
 286             url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
 287             get_buffer(pb, mxf->packages_refs, mxf->packages_count * sizeof(UID));
 288             break;
 289         case 0x1902:
 290             mxf->essence_container_data_sets_count = get_be32(pb);
 291             if (mxf->essence_container_data_sets_count >= UINT_MAX / sizeof(UID))
 292                 return -1;
 293             mxf->essence_container_data_sets_refs = av_malloc(mxf->essence_container_data_sets_count * sizeof(UID));
 294             url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
 295             get_buffer(pb, mxf->essence_container_data_sets_refs, mxf->essence_container_data_sets_count * sizeof(UID));
 296             break;
 297         default:
 298             url_fskip(pb, size);
 299         }
 300         bytes_read += size + 4;
 301     }
 302     return 0;
 303 }
 304
 305 static int mxf_read_metadata_source_clip(MXFContext *mxf, KLVPacket *klv)
 306 {
 307     ByteIOContext *pb = &mxf->fc->pb;
 308     MXFStructuralComponent *source_clip = av_mallocz(sizeof(*source_clip));
 309     int bytes_read = 0;
 310
 311     while (bytes_read < klv->length) {
 312         int tag = get_be16(pb);
 313         int size = get_be16(pb); /* SMPTE 336M Table 8 KLV specified length, 0x53 */
 314
 315         dprintf("tag 0x%04X, size %d\n", tag, size);
 316         switch (tag) {
 317         case 0x3C0A:
 318             get_buffer(pb, source_clip->uid, 16);
 319             break;
 320         case 0x0202:
 321             source_clip->duration = get_be64(pb);
 322             break;
 323         case 0x1201:
 324             source_clip->start_position = get_be64(pb);
 325             break;
 326         case 0x1101:
 327             /* UMID, only get last 16 bytes */
 328             url_fskip(pb, 16);
 329             get_buffer(pb, source_clip->source_package_uid, 16);
 330             break;
 331         case 0x1102:
 332             source_clip->source_track_id = get_be32(pb);
 333             break;
 334         default:
 335             url_fskip(pb, size);
 336         }
 337         bytes_read += size + 4;
 338     }
 339     source_clip->type = SourceClip;
 340     return mxf_add_metadata_set(mxf, source_clip);
 341 }
 342
 343 static int mxf_read_metadata_material_package(MXFContext *mxf, KLVPacket *klv)
 344 {
 345     ByteIOContext *pb = &mxf->fc->pb;
 346     MXFPackage *package = av_mallocz(sizeof(*package));
 347     int bytes_read = 0;
 348
 349     while (bytes_read < klv->length) {
 350         int tag = get_be16(pb);
 351         int size = get_be16(pb); /* KLV specified by 0x53 */
 352
 353         switch (tag) {
 354         case 0x3C0A:
 355             get_buffer(pb, package->uid, 16);
 356             break;
 357         case 0x4403:
 358             package->tracks_count = get_be32(pb);
 359             if (package->tracks_count >= UINT_MAX / sizeof(UID))
 360                 return -1;
 361             package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
 362             url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
 363             get_buffer(pb, package->tracks_refs, package->tracks_count * sizeof(UID));
 364             break;
 365         default:
 366             url_fskip(pb, size);
 367         }
 368         bytes_read += size + 4;
 369     }
 370     package->type = MaterialPackage;
 371     return mxf_add_metadata_set(mxf, package);
 372 }
 373
 374 static int mxf_read_metadata_track(MXFContext *mxf, KLVPacket *klv)
 375 {
 376     ByteIOContext *pb = &mxf->fc->pb;
 377     MXFTrack *track = av_mallocz(sizeof(*track));
 378     int bytes_read = 0;
 379
 380     while (bytes_read < klv->length) {
 381         int tag = get_be16(pb);
 382         int size = get_be16(pb); /* KLV specified by 0x53 */
 383
 384         dprintf("tag 0x%04X, size %d\n", tag, size);
 385         switch (tag) {
 386         case 0x3C0A:
 387             get_buffer(pb, track->uid, 16);
 388             break;
 389         case 0x4801:
 390             track->track_id = get_be32(pb);
 391             break;
 392         case 0x4804:
 393             get_buffer(pb, track->track_number, 4);
 394             break;
 395         case 0x4B01:
 396             track->edit_rate.den = get_be32(pb);
 397             track->edit_rate.num = get_be32(pb);
 398             break;
 399         case 0x4803:
 400             get_buffer(pb, track->sequence_ref, 16);
 401             break;
 402         default:
 403             url_fskip(pb, size);
 404         }
 405         bytes_read += size + 4;
 406     }
 407     track->type = Track;
 408     return mxf_add_metadata_set(mxf, track);
 409 }
 410
 411 static int mxf_read_metadata_sequence(MXFContext *mxf, KLVPacket *klv)
 412 {
 413     ByteIOContext *pb = &mxf->fc->pb;
 414     MXFSequence *sequence = av_mallocz(sizeof(*sequence));
 415     int bytes_read = 0;
 416
 417     while (bytes_read < klv->length) {
 418         int tag = get_be16(pb);
 419         int size = get_be16(pb); /* KLV specified by 0x53 */
 420
 421         dprintf("tag 0x%04X, size %d\n", tag, size);
 422         switch (tag) {
 423         case 0x3C0A:
 424             get_buffer(pb, sequence->uid, 16);
 425             break;
 426         case 0x0202:
 427             sequence->duration = get_be64(pb);
 428             break;
 429         case 0x0201:
 430             get_buffer(pb, sequence->data_definition_ul, 16);
 431             break;
 432         case 0x1001:
 433             sequence->structural_components_count = get_be32(pb);
 434             if (sequence->structural_components_count >= UINT_MAX / sizeof(UID))
 435                 return -1;
 436             sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID));
 437             url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
 438             get_buffer(pb, sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
 439             break;
 440         default:
 441             url_fskip(pb, size);
 442         }
 443         bytes_read += size + 4;
 444     }
 445     sequence->type = Sequence;
 446     return mxf_add_metadata_set(mxf, sequence);
 447 }
 448
 449 static int mxf_read_metadata_source_package(MXFContext *mxf, KLVPacket *klv)
 450 {
 451     ByteIOContext *pb = &mxf->fc->pb;
 452     MXFPackage *package = av_mallocz(sizeof(*package));
 453     int bytes_read = 0;
 454
 455     while (bytes_read < klv->length) {
 456         int tag = get_be16(pb);
 457         int size = get_be16(pb); /* KLV specified by 0x53 */
 458
 459         dprintf("tag 0x%04X, size %d\n", tag, size);
 460         switch (tag) {
 461         case 0x3C0A:
 462             get_buffer(pb, package->uid, 16);
 463             break;
 464         case 0x4403:
 465             package->tracks_count = get_be32(pb);
 466             if (package->tracks_count >= UINT_MAX / sizeof(UID))
 467                 return -1;
 468             package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
 469             url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
 470             get_buffer(pb, package->tracks_refs, package->tracks_count * sizeof(UID));
 471             break;
 472         case 0x4401:
 473             /* UMID, only get last 16 bytes */
 474             url_fskip(pb, 16);
 475             get_buffer(pb, package->package_uid, 16);
 476             break;
 477         case 0x4701:
 478             get_buffer(pb, package->descriptor_ref, 16);
 479             break;
 480         default:
 481             url_fskip(pb, size);
 482         }
 483         bytes_read += size + 4;
 484     }
 485     package->type = SourcePackage;
 486     return mxf_add_metadata_set(mxf, package);
 487 }
 488
 489 static int mxf_read_metadata_multiple_descriptor(MXFContext *mxf, KLVPacket *klv)
 490 {
 491     ByteIOContext *pb = &mxf->fc->pb;
 492     MXFDescriptor *descriptor = av_mallocz(sizeof(*descriptor));
 493     int bytes_read = 0;
 494
 495     while (bytes_read < klv->length) {
 496         int tag = get_be16(pb);
 497         int size = get_be16(pb); /* KLV specified by 0x53 */
 498
 499         dprintf("tag 0x%04X, size %d\n", tag, size);
 500         switch (tag) {
 501         case 0x3C0A:
 502             get_buffer(pb, descriptor->uid, 16);
 503             break;
 504         case 0x3F01:
 505             descriptor->sub_descriptors_count = get_be32(pb);
 506             if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))
 507                 return -1;
 508             descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));
 509             url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
 510             get_buffer(pb, descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
 511             break;
 512         default:
 513             url_fskip(pb, size);
 514         }
 515         bytes_read += size + 4;
 516     }
 517     descriptor->type = MultipleDescriptor;
 518     return mxf_add_metadata_set(mxf, descriptor);
 519 }
 520
 521 static void mxf_read_metadata_pixel_layout(ByteIOContext *pb, MXFDescriptor *descriptor)
 522 {
 523     int code;
 524
 525     do {
 526         code = get_byte(pb);
 527         dprintf("pixel layout: code 0x%x\n", code);
 528         switch (code) {
 529         case 0x52: /* R */
 530             descriptor->bits_per_sample += get_byte(pb);
 531             break;
 532         case 0x47: /* G */
 533             descriptor->bits_per_sample += get_byte(pb);
 534             break;
 535         case 0x42: /* B */
 536             descriptor->bits_per_sample += get_byte(pb);
 537             break;
 538         default:
 539             get_byte(pb);
 540         }
 541     } while (code != 0); /* SMPTE 377M E.2.46 */
 542 }
 543
 544 static int mxf_read_metadata_generic_descriptor(MXFContext *mxf, KLVPacket *klv)
 545 {
 546     ByteIOContext *pb = &mxf->fc->pb;
 547     MXFDescriptor *descriptor = av_mallocz(sizeof(*descriptor));
 548     int bytes_read = 0;
 549
 550     while (bytes_read < klv->length) {
 551         int tag = get_be16(pb);
 552         int size = get_be16(pb); /* KLV specified by 0x53 */
 553
 554         dprintf("tag 0x%04X, size %d\n", tag, size);
 555         switch (tag) {
 556         case 0x3C0A:
 557             get_buffer(pb, descriptor->uid, 16);
 558             break;
 559         case 0x3004:
 560             get_buffer(pb, descriptor->essence_container_ul, 16);
 561             break;
 562         case 0x3006:
 563             descriptor->linked_track_id = get_be32(pb);
 564             break;
 565         case 0x3201: /* PictureEssenceCoding */
 566             get_buffer(pb, descriptor->essence_codec_ul, 16);
 567             break;
 568         case 0x3203:
 569             descriptor->width = get_be32(pb);
 570             break;
 571         case 0x3202:
 572             descriptor->height = get_be32(pb);
 573             break;
 574         case 0x320E:
 575             descriptor->aspect_ratio.num = get_be32(pb);
 576             descriptor->aspect_ratio.den = get_be32(pb);
 577             break;
 578         case 0x3D03:
 579             descriptor->sample_rate.num = get_be32(pb);
 580             descriptor->sample_rate.den = get_be32(pb);
 581             break;
 582         case 0x3D06: /* SoundEssenceCompression */
 583             get_buffer(pb, descriptor->essence_codec_ul, 16);
 584             break;
 585         case 0x3D07:
 586             descriptor->channels = get_be32(pb);
 587             break;
 588         case 0x3D01:
 589             descriptor->bits_per_sample = get_be32(pb);
 590             break;
 591         case 0x3401:
 592             mxf_read_metadata_pixel_layout(pb, descriptor);
 593             break;
 594         default:
 595             url_fskip(pb, size);
 596         }
 597         bytes_read += size + 4;
 598     }
 599     descriptor->type = Descriptor;
 600     return mxf_add_metadata_set(mxf, descriptor);
 601 }
 602
 603 /* SMPTE RP224 http://www.smpte-ra.org/mdd/index.html */
 604 static const UID picture_essence_track_ul = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x02,0x01,0x00,0x00,0x00 };
 605 static const UID sound_essence_track_ul   = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x02,0x02,0x00,0x00,0x00 };
 606
 607 static const MXFCodecUL mxf_codec_uls[] = {
 608     /* PictureEssenceCoding */
 609     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, CODEC_ID_MPEG2VIDEO }, /* 422P@ML I-Frame */
 610     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, CODEC_ID_MPEG2VIDEO }, /* 422P@HL Long GoP */
 611     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, CODEC_ID_MPEG2VIDEO }, /* MP@ML Long GoP */
 612     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, CODEC_ID_MPEG2VIDEO }, /* 422P@ML Long GoP */
 613     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, CODEC_ID_MPEG2VIDEO }, /* MP@HL Long GoP */
 614     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x20,0x02,0x03 },      CODEC_ID_MPEG4 }, /* XDCAM proxy_pal030926.mxf */
 615     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x20,0x02,0x04 },      CODEC_ID_MPEG4 }, /* XDCAM Proxy C0023S01.mxf */
 616     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x05 }, CODEC_ID_MPEG2VIDEO }, /* D-10 30Mbps PAL */
 617     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 }, CODEC_ID_MPEG2VIDEO }, /* D-10 50Mbps PAL */
 618     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x04,0x00 },    CODEC_ID_DVVIDEO }, /* DVCPRO50 PAL */
 619     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x02,0x00 },    CODEC_ID_DVVIDEO }, /* DVCPRO25 PAL */
 620     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x02,0x00 },    CODEC_ID_DVVIDEO }, /* DV25 IEC PAL */
 621   //{ { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 },     CODEC_ID_JPEG2K }, /* JPEG2000 Codestream */
 622     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x01,0x7F,0x00,0x00,0x00 },   CODEC_ID_RAWVIDEO }, /* Uncompressed */
 623     /* SoundEssenceCompression */
 624     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },  CODEC_ID_PCM_S16LE }, /* Uncompressed */
 625     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x7F,0x00,0x00,0x00 },  CODEC_ID_PCM_S16LE },
 626     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x02,0x02,0x01,0x7E,0x00,0x00,0x00 },  CODEC_ID_PCM_S16BE }, /* From Omneon MXF file */
 627     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x01,0x01,0x00 },   CODEC_ID_PCM_ALAW },
 628     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x04,0x04,0x02,0x02,0x02,0x03,0x01,0x01,0x00 },   CODEC_ID_PCM_ALAW }, /* XDCAM Proxy C0023S01.mxf */
 629     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x01,0x00 },        CODEC_ID_AC3 },
 630     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x05,0x00 },        CODEC_ID_MP2 }, /* MP2 or MP3 */
 631   //{ { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x1C,0x00 },    CODEC_ID_DOLBY_E }, /* Dolby-E */
 632     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },       CODEC_ID_NONE },
 633 };
 634
 635 static enum CodecID mxf_get_codec_id(const MXFCodecUL *uls, UID *uid)
 636 {
 637     while (uls->id != CODEC_ID_NONE) {
 638         if(!memcmp(uls->uid, *uid, 16))
 639             return uls->id;
 640         uls++;
 641     }
 642     return CODEC_ID_NONE;
 643 }
 644
 645 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref)
 646 {
 647     int i;
 648
 649     if (!strong_ref)
 650         return NULL;
 651     for (i = 0; i < mxf->metadata_sets_count; i++) {
 652         if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16)) {
 653             return mxf->metadata_sets[i];
 654         }
 655     }
 656     return NULL;
 657 }
 658
 659 static int mxf_parse_structural_metadata(MXFContext *mxf)
 660 {
 661     MXFPackage *material_package = NULL;
 662     MXFPackage *source_package = NULL;
 663     MXFPackage *temp_package = NULL;
 664     int i, j, k;
 665
 666     dprintf("metadata sets count %d\n", mxf->metadata_sets_count);
 667     /* TODO: handle multiple material packages (OP3x) */
 668     for (i = 0; i < mxf->packages_count; i++) {
 669         if (!(temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i]))) {
 670             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve package strong ref\n");
 671             return -1;
 672         }
 673         if (temp_package->type == MaterialPackage) {
 674             material_package = temp_package;
 675             break;
 676         }
 677     }
 678     if (!material_package) {
 679         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
 680         return -1;
 681     }
 682
 683     for (i = 0; i < material_package->tracks_count; i++) {
 684         MXFTrack *material_track = NULL;
 685         MXFTrack *source_track = NULL;
 686         MXFTrack *temp_track = NULL;
 687         MXFDescriptor *descriptor = NULL;
 688         MXFStructuralComponent *component = NULL;
 689         AVStream *st;
 690
 691         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i]))) {
 692             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
 693             continue;
 694         }
 695
 696         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref))) {
 697             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
 698             return -1;
 699         }
 700
 701         /* TODO: handle multiple source clips */
 702         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
 703             /* TODO: handle timecode component */
 704             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j]);
 705             if (!component || component->type != SourceClip)
 706                 continue;
 707
 708             for (k = 0; k < mxf->packages_count; k++) {
 709                 if (!(temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k]))) {
 710                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
 711                     return -1;
 712                 }
 713                 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
 714                     source_package = temp_package;
 715                     break;
 716                 }
 717             }
 718             if (!source_package) {
 719                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source package found\n", material_track->track_id);
 720                 break;
 721             }
 722             for (k = 0; k < source_package->tracks_count; k++) {
 723                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k]))) {
 724                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
 725                     return -1;
 726                 }
 727                 if (temp_track->track_id == component->source_track_id) {
 728                     source_track = temp_track;
 729                     break;
 730                 }
 731             }
 732             if (!source_track) {
 733                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
 734                 break;
 735             }
 736         }
 737         if (!source_track)
 738             continue;
 739
 740         st = av_new_stream(mxf->fc, source_track->track_id);
 741         st->priv_data = source_track;
 742         st->duration = component->duration;
 743         if (st->duration == -1)
 744             st->duration = AV_NOPTS_VALUE;
 745         st->start_time = component->start_position;
 746         av_set_pts_info(st, 64, material_track->edit_rate.num, material_track->edit_rate.den);
 747
 748         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref))) {
 749             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
 750             return -1;
 751         }
 752
 753 #ifdef DEBUG
 754         PRINT_KEY(source_track->sequence->data_definition_ul);
 755 #endif
 756         if (!memcmp(source_track->sequence->data_definition_ul, picture_essence_track_ul, 16))
 757             st->codec->codec_type = CODEC_TYPE_VIDEO;
 758         else if (!memcmp(source_track->sequence->data_definition_ul, sound_essence_track_ul, 16))
 759             st->codec->codec_type = CODEC_TYPE_AUDIO;
 760         else
 761             st->codec->codec_type = CODEC_TYPE_DATA;
 762
 763         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref);
 764         if (source_package->descriptor) {
 765             if (source_package->descriptor->type == MultipleDescriptor) {
 766                 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
 767                     MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j]);
 768
 769                     if (!sub_descriptor) {
 770                         av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
 771                         continue;
 772                     }
 773                     if (sub_descriptor->linked_track_id == source_track->track_id) {
 774                         descriptor = sub_descriptor;
 775                         break;
 776                     }
 777                 }
 778             } else
 779                 descriptor = source_package->descriptor;
 780         }
 781         if (!descriptor) {
 782             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
 783             continue;
 784         }
 785 #ifdef DEBUG
 786         PRINT_KEY(descriptor->essence_codec_ul);
 787 #endif
 788         st->codec->codec_id = mxf_get_codec_id(mxf_codec_uls, &descriptor->essence_codec_ul);
 789         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
 790             st->codec->width = descriptor->width;
 791             st->codec->height = descriptor->height;
 792             st->codec->bits_per_sample = descriptor->bits_per_sample; /* Uncompressed */
 793         } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
 794             st->codec->channels = descriptor->channels;
 795             st->codec->bits_per_sample = descriptor->bits_per_sample;
 796             st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
 797             /* TODO: implement CODEC_ID_RAWAUDIO */
 798             if (st->codec->codec_id == CODEC_ID_PCM_S16LE) {
 799                 if (descriptor->bits_per_sample == 24)
 800                     st->codec->codec_id = CODEC_ID_PCM_S24LE;
 801                 else if (descriptor->bits_per_sample == 32)
 802                     st->codec->codec_id = CODEC_ID_PCM_S32LE;
 803             } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
 804                 if (descriptor->bits_per_sample == 24)
 805                     st->codec->codec_id = CODEC_ID_PCM_S24BE;
 806                 else if (descriptor->bits_per_sample == 32)
 807                     st->codec->codec_id = CODEC_ID_PCM_S32BE;
 808             }
 809         }
 810     }
 811     return 0;
 812 }
 813
 814 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
 815     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2F,0x00 }, mxf_read_metadata_preface },
 816     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_metadata_content_storage },
 817     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_metadata_source_package },
 818     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_metadata_material_package },
 819     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_metadata_sequence },
 820     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_metadata_source_clip },
 821     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_metadata_multiple_descriptor },
 822     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 }, mxf_read_metadata_generic_descriptor }, /* Generic Sound */
 823     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_metadata_generic_descriptor }, /* CDCI */
 824     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_metadata_generic_descriptor }, /* RGBA */
 825     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_metadata_generic_descriptor }, /* MPEG 2 Video */
 826     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_metadata_generic_descriptor }, /* Wave */
 827     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_metadata_generic_descriptor }, /* AES3 */
 828     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_metadata_track }, /* Static Track */
 829     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_metadata_track }, /* Generic Track */
 830     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL },
 831 };
 832
 833 static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap)
 834 {
 835     MXFContext *mxf = s->priv_data;
 836     KLVPacket klv;
 837
 838     mxf->fc = s;
 839     while (!url_feof(&s->pb)) {
 840         const MXFMetadataReadTableEntry *function;
 841
 842         if (klv_read_packet(&klv, &s->pb) < 0) {
 843             av_log(s, AV_LOG_ERROR, "error reading KLV packet\n");
 844             return -1;
 845         }
 846 #ifdef DEBUG
 847         PRINT_KEY(klv.key);
 848 #endif
 849         if (IS_KLV_KEY(klv.key, mxf_essence_element_key)) {
 850             /* FIXME avoid seek */
 851             url_fseek(&s->pb, klv.offset, SEEK_SET);
 852             break;
 853         }
 854
 855         for (function = mxf_metadata_read_table; function->read; function++) {
 856             if (IS_KLV_KEY(klv.key, function->key)) {
 857                 if (function->read(mxf, &klv) < 0) {
 858                     av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
 859                     return -1;
 860                 }
 861                 break;
 862             }
 863         }
 864         if (!function->read)
 865             url_fskip(&s->pb, klv.length);
 866     }
 867     return mxf_parse_structural_metadata(mxf);
 868 }
 869
 870 static int mxf_read_close(AVFormatContext *s)
 871 {
 872     MXFContext *mxf = s->priv_data;
 873     int i;
 874
 875     av_freep(&mxf->packages_refs);
 876     av_freep(&mxf->essence_container_data_sets_refs);
 877     av_freep(&mxf->essence_containers_uls);
 878     for (i = 0; i < mxf->metadata_sets_count; i++) {
 879         switch (mxf->metadata_sets[i]->type) {
 880         case MultipleDescriptor:
 881             av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
 882             break;
 883         case Sequence:
 884             av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
 885             break;
 886         case SourcePackage:
 887         case MaterialPackage:
 888             av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
 889             break;
 890         default:
 891             break;
 892         }
 893         av_freep(&mxf->metadata_sets[i]);
 894     }
 895     av_freep(&mxf->metadata_sets);
 896     return 0;
 897 }
 898
 899 static int mxf_probe(AVProbeData *p) {
 900     uint8_t *bufp = p->buf;
 901     uint8_t *end = p->buf + p->buf_size;
 902
 903     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
 904         return 0;
 905
 906     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
 907     end -= sizeof(mxf_header_partition_pack_key);
 908     for (; bufp < end; bufp++) {
 909         if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
 910             return AVPROBE_SCORE_MAX;
 911     }
 912     return 0;
 913 }
 914
 915
 916 AVInputFormat mxf_demuxer = {
 917     "mxf",
 918     "MXF format",
 919     sizeof(MXFContext),
 920     mxf_probe,
 921     mxf_read_header,
 922     mxf_read_packet,
 923     mxf_read_close,
 924     NULL,
 925 };