avformat/mxfdec: add support for recognizing timed text streams
[ffmpeg.git] / libavformat / mxfdec.c
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  *
32  * Principle
33  * Search for Track numbers which will identify essence element KLV packets.
34  * Search for SourcePackage which define tracks which contains Track numbers.
35  * Material Package contains tracks with reference to SourcePackage tracks.
36  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37  * Assign Descriptors to correct Tracks.
38  *
39  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40  * Metadata parsing resolves Strong References to objects.
41  *
42  * Simple demuxer, only OP1A supported and some files might not work at all.
43  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
44  */
45
46 #include <inttypes.h>
47
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/parseutils.h"
54 #include "libavutil/timecode.h"
55 #include "avformat.h"
56 #include "internal.h"
57 #include "mxf.h"
58
59 typedef enum {
60     Header,
61     BodyPartition,
62     Footer
63 } MXFPartitionType;
64
65 typedef enum {
66     OP1a = 1,
67     OP1b,
68     OP1c,
69     OP2a,
70     OP2b,
71     OP2c,
72     OP3a,
73     OP3b,
74     OP3c,
75     OPAtom,
76     OPSONYOpt,  /* FATE sample, violates the spec in places */
77 } MXFOP;
78
79 typedef struct MXFPartition {
80     int closed;
81     int complete;
82     MXFPartitionType type;
83     uint64_t previous_partition;
84     int index_sid;
85     int body_sid;
86     int64_t this_partition;
87     int64_t essence_offset;         ///< absolute offset of essence
88     int64_t essence_length;
89     int32_t kag_size;
90     int64_t header_byte_count;
91     int64_t index_byte_count;
92     int pack_length;
93     int64_t pack_ofs;               ///< absolute offset of pack in file, including run-in
94     int64_t body_offset;
95 } MXFPartition;
96
97 typedef struct MXFCryptoContext {
98     UID uid;
99     enum MXFMetadataSetType type;
100     UID source_container_ul;
101 } MXFCryptoContext;
102
103 typedef struct MXFStructuralComponent {
104     UID uid;
105     enum MXFMetadataSetType type;
106     UID source_package_ul;
107     UID source_package_uid;
108     UID data_definition_ul;
109     int64_t duration;
110     int64_t start_position;
111     int source_track_id;
112 } MXFStructuralComponent;
113
114 typedef struct MXFSequence {
115     UID uid;
116     enum MXFMetadataSetType type;
117     UID data_definition_ul;
118     UID *structural_components_refs;
119     int structural_components_count;
120     int64_t duration;
121     uint8_t origin;
122 } MXFSequence;
123
124 typedef struct MXFTrack {
125     UID uid;
126     enum MXFMetadataSetType type;
127     int drop_frame;
128     int start_frame;
129     struct AVRational rate;
130     AVTimecode tc;
131 } MXFTimecodeComponent;
132
133 typedef struct {
134     UID uid;
135     enum MXFMetadataSetType type;
136     UID input_segment_ref;
137 } MXFPulldownComponent;
138
139 typedef struct {
140     UID uid;
141     enum MXFMetadataSetType type;
142     UID *structural_components_refs;
143     int structural_components_count;
144     int64_t duration;
145 } MXFEssenceGroup;
146
147 typedef struct {
148     UID uid;
149     enum MXFMetadataSetType type;
150     char *name;
151     char *value;
152 } MXFTaggedValue;
153
154 typedef struct {
155     UID uid;
156     enum MXFMetadataSetType type;
157     MXFSequence *sequence; /* mandatory, and only one */
158     UID sequence_ref;
159     int track_id;
160     char *name;
161     uint8_t track_number[4];
162     AVRational edit_rate;
163     int intra_only;
164     uint64_t sample_count;
165     int64_t original_duration; /* st->duration in SampleRate/EditRate units */
166     int index_sid;
167     int body_sid;
168 } MXFTrack;
169
170 typedef struct MXFDescriptor {
171     UID uid;
172     enum MXFMetadataSetType type;
173     UID essence_container_ul;
174     UID essence_codec_ul;
175     UID codec_ul;
176     AVRational sample_rate;
177     AVRational aspect_ratio;
178     int width;
179     int height; /* Field height, not frame height */
180     int frame_layout; /* See MXFFrameLayout enum */
181     int video_line_map[2];
182 #define MXF_FIELD_DOMINANCE_DEFAULT 0
183 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
184 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
185     int field_dominance;
186     int channels;
187     int bits_per_sample;
188     int64_t duration; /* ContainerDuration optional property */
189     unsigned int component_depth;
190     unsigned int horiz_subsampling;
191     unsigned int vert_subsampling;
192     UID *sub_descriptors_refs;
193     int sub_descriptors_count;
194     int linked_track_id;
195     uint8_t *extradata;
196     int extradata_size;
197     enum AVPixelFormat pix_fmt;
198 } MXFDescriptor;
199
200 typedef struct MXFIndexTableSegment {
201     UID uid;
202     enum MXFMetadataSetType type;
203     int edit_unit_byte_count;
204     int index_sid;
205     int body_sid;
206     AVRational index_edit_rate;
207     uint64_t index_start_position;
208     uint64_t index_duration;
209     int8_t *temporal_offset_entries;
210     int *flag_entries;
211     uint64_t *stream_offset_entries;
212     int nb_index_entries;
213 } MXFIndexTableSegment;
214
215 typedef struct MXFPackage {
216     UID uid;
217     enum MXFMetadataSetType type;
218     UID package_uid;
219     UID package_ul;
220     UID *tracks_refs;
221     int tracks_count;
222     MXFDescriptor *descriptor; /* only one */
223     UID descriptor_ref;
224     char *name;
225     UID *comment_refs;
226     int comment_count;
227 } MXFPackage;
228
229 typedef struct MXFEssenceContainerData {
230     UID uid;
231     enum MXFMetadataSetType type;
232     UID package_uid;
233     UID package_ul;
234     int index_sid;
235     int body_sid;
236 } MXFEssenceContainerData;
237
238 typedef struct MXFMetadataSet {
239     UID uid;
240     enum MXFMetadataSetType type;
241 } MXFMetadataSet;
242
243 /* decoded index table */
244 typedef struct MXFIndexTable {
245     int index_sid;
246     int body_sid;
247     int nb_ptses;               /* number of PTSes or total duration of index */
248     int64_t first_dts;          /* DTS = EditUnit + first_dts */
249     int64_t *ptses;             /* maps EditUnit -> PTS */
250     int nb_segments;
251     MXFIndexTableSegment **segments;    /* sorted by IndexStartPosition */
252     AVIndexEntry *fake_index;   /* used for calling ff_index_search_timestamp() */
253     int8_t *offsets;            /* temporal offsets for display order to stored order conversion */
254 } MXFIndexTable;
255
256 typedef struct MXFContext {
257     MXFPartition *partitions;
258     unsigned partitions_count;
259     MXFOP op;
260     UID *packages_refs;
261     int packages_count;
262     UID *essence_container_data_refs;
263     int essence_container_data_count;
264     MXFMetadataSet **metadata_sets;
265     int metadata_sets_count;
266     AVFormatContext *fc;
267     struct AVAES *aesc;
268     uint8_t *local_tags;
269     int local_tags_count;
270     uint64_t footer_partition;
271     KLVPacket current_klv_data;
272     int current_klv_index;
273     int run_in;
274     MXFPartition *current_partition;
275     int parsing_backward;
276     int64_t last_forward_tell;
277     int last_forward_partition;
278     int64_t current_edit_unit;
279     int nb_index_tables;
280     MXFIndexTable *index_tables;
281     int edit_units_per_packet;      ///< how many edit units to read at a time (PCM, OPAtom)
282 } MXFContext;
283
284 enum MXFWrappingScheme {
285     Frame,
286     Clip,
287 };
288
289 /* NOTE: klv_offset is not set (-1) for local keys */
290 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
291
292 typedef struct MXFMetadataReadTableEntry {
293     const UID key;
294     MXFMetadataReadFunc *read;
295     int ctx_size;
296     enum MXFMetadataSetType type;
297 } MXFMetadataReadTableEntry;
298
299 static int mxf_read_close(AVFormatContext *s);
300
301 /* partial keys to match */
302 static const uint8_t mxf_header_partition_pack_key[]       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
303 static const uint8_t mxf_essence_element_key[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
304 static const uint8_t mxf_avid_essence_element_key[]        = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
305 static const uint8_t mxf_canopus_essence_element_key[]     = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
306 static const uint8_t mxf_system_item_key_cp[]              = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
307 static const uint8_t mxf_system_item_key_gc[]              = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
308 static const uint8_t mxf_klv_key[]                         = { 0x06,0x0e,0x2b,0x34 };
309 /* complete keys to match */
310 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 };
311 static const uint8_t mxf_encrypted_triplet_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
312 static const uint8_t mxf_encrypted_essence_container[]     = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
313 static const uint8_t mxf_random_index_pack_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
314 static const uint8_t mxf_sony_mpeg4_extradata[]            = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
315 static const uint8_t mxf_avid_project_name[]               = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
316 static const uint8_t mxf_jp2k_rsiz[]                       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
317 static const uint8_t mxf_indirect_value_utf16le[]          = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
318 static const uint8_t mxf_indirect_value_utf16be[]          = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
319
320 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
321
322 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
323 {
324     MXFIndexTableSegment *seg;
325     switch ((*ctx)->type) {
326     case Descriptor:
327         av_freep(&((MXFDescriptor *)*ctx)->extradata);
328         break;
329     case MultipleDescriptor:
330         av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
331         break;
332     case Sequence:
333         av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
334         break;
335     case EssenceGroup:
336         av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
337         break;
338     case SourcePackage:
339     case MaterialPackage:
340         av_freep(&((MXFPackage *)*ctx)->tracks_refs);
341         av_freep(&((MXFPackage *)*ctx)->name);
342         av_freep(&((MXFPackage *)*ctx)->comment_refs);
343         break;
344     case TaggedValue:
345         av_freep(&((MXFTaggedValue *)*ctx)->name);
346         av_freep(&((MXFTaggedValue *)*ctx)->value);
347         break;
348     case Track:
349         av_freep(&((MXFTrack *)*ctx)->name);
350         break;
351     case IndexTableSegment:
352         seg = (MXFIndexTableSegment *)*ctx;
353         av_freep(&seg->temporal_offset_entries);
354         av_freep(&seg->flag_entries);
355         av_freep(&seg->stream_offset_entries);
356     default:
357         break;
358     }
359     if (freectx)
360     av_freep(ctx);
361 }
362
363 static int64_t klv_decode_ber_length(AVIOContext *pb)
364 {
365     uint64_t size = avio_r8(pb);
366     if (size & 0x80) { /* long form */
367         int bytes_num = size & 0x7f;
368         /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
369         if (bytes_num > 8)
370             return AVERROR_INVALIDDATA;
371         size = 0;
372         while (bytes_num--)
373             size = size << 8 | avio_r8(pb);
374     }
375     if (size > INT64_MAX)
376         return AVERROR_INVALIDDATA;
377     return size;
378 }
379
380 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
381 {
382     int i, b;
383     for (i = 0; i < size && !avio_feof(pb); i++) {
384         b = avio_r8(pb);
385         if (b == key[0])
386             i = 0;
387         else if (b != key[i])
388             i = -1;
389     }
390     return i == size;
391 }
392
393 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
394 {
395     int64_t length;
396     if (!mxf_read_sync(pb, mxf_klv_key, 4))
397         return AVERROR_INVALIDDATA;
398     klv->offset = avio_tell(pb) - 4;
399     memcpy(klv->key, mxf_klv_key, 4);
400     avio_read(pb, klv->key + 4, 12);
401     length = klv_decode_ber_length(pb);
402     if (length < 0)
403         return length;
404     klv->length = length;
405     return 0;
406 }
407
408 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
409 {
410     int i;
411
412     for (i = 0; i < s->nb_streams; i++) {
413         MXFTrack *track = s->streams[i]->priv_data;
414         /* SMPTE 379M 7.3 */
415         if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
416             return i;
417     }
418     /* return 0 if only one stream, for OP Atom files with 0 as track number */
419     return s->nb_streams == 1 ? 0 : -1;
420 }
421
422 static int find_body_sid_by_offset(MXFContext *mxf, int64_t offset)
423 {
424     // we look for partition where the offset is placed
425     int a, b, m;
426     int64_t this_partition;
427
428     a = -1;
429     b = mxf->partitions_count;
430
431     while (b - a > 1) {
432         m         = (a + b) >> 1;
433         this_partition = mxf->partitions[m].this_partition;
434         if (this_partition <= offset)
435             a = m;
436         else
437             b = m;
438     }
439
440     if (a == -1)
441         return 0;
442     return mxf->partitions[a].body_sid;
443 }
444
445 /* XXX: use AVBitStreamFilter */
446 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
447 {
448     const uint8_t *buf_ptr, *end_ptr;
449     uint8_t *data_ptr;
450     int i;
451
452     if (length > 61444) /* worst case PAL 1920 samples 8 channels */
453         return AVERROR_INVALIDDATA;
454     length = av_get_packet(pb, pkt, length);
455     if (length < 0)
456         return length;
457     data_ptr = pkt->data;
458     end_ptr = pkt->data + length;
459     buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
460     for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
461         for (i = 0; i < st->codecpar->channels; i++) {
462             uint32_t sample = bytestream_get_le32(&buf_ptr);
463             if (st->codecpar->bits_per_coded_sample == 24)
464                 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
465             else
466                 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
467         }
468         buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
469     }
470     av_shrink_packet(pkt, data_ptr - pkt->data);
471     return 0;
472 }
473
474 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
475 {
476     static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
477     MXFContext *mxf = s->priv_data;
478     AVIOContext *pb = s->pb;
479     int64_t end = avio_tell(pb) + klv->length;
480     int64_t size;
481     uint64_t orig_size;
482     uint64_t plaintext_size;
483     uint8_t ivec[16];
484     uint8_t tmpbuf[16];
485     int index;
486     int body_sid;
487
488     if (!mxf->aesc && s->key && s->keylen == 16) {
489         mxf->aesc = av_aes_alloc();
490         if (!mxf->aesc)
491             return AVERROR(ENOMEM);
492         av_aes_init(mxf->aesc, s->key, 128, 1);
493     }
494     // crypto context
495     size = klv_decode_ber_length(pb);
496     if (size < 0)
497         return size;
498     avio_skip(pb, size);
499     // plaintext offset
500     klv_decode_ber_length(pb);
501     plaintext_size = avio_rb64(pb);
502     // source klv key
503     klv_decode_ber_length(pb);
504     avio_read(pb, klv->key, 16);
505     if (!IS_KLV_KEY(klv, mxf_essence_element_key))
506         return AVERROR_INVALIDDATA;
507
508     body_sid = find_body_sid_by_offset(mxf, klv->offset);
509     index = mxf_get_stream_index(s, klv, body_sid);
510     if (index < 0)
511         return AVERROR_INVALIDDATA;
512     // source size
513     klv_decode_ber_length(pb);
514     orig_size = avio_rb64(pb);
515     if (orig_size < plaintext_size)
516         return AVERROR_INVALIDDATA;
517     // enc. code
518     size = klv_decode_ber_length(pb);
519     if (size < 32 || size - 32 < orig_size)
520         return AVERROR_INVALIDDATA;
521     avio_read(pb, ivec, 16);
522     avio_read(pb, tmpbuf, 16);
523     if (mxf->aesc)
524         av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
525     if (memcmp(tmpbuf, checkv, 16))
526         av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
527     size -= 32;
528     size = av_get_packet(pb, pkt, size);
529     if (size < 0)
530         return size;
531     else if (size < plaintext_size)
532         return AVERROR_INVALIDDATA;
533     size -= plaintext_size;
534     if (mxf->aesc)
535         av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
536                      &pkt->data[plaintext_size], size >> 4, ivec, 1);
537     av_shrink_packet(pkt, orig_size);
538     pkt->stream_index = index;
539     avio_skip(pb, end - avio_tell(pb));
540     return 0;
541 }
542
543 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
544 {
545     MXFContext *mxf = arg;
546     int item_num = avio_rb32(pb);
547     int item_len = avio_rb32(pb);
548
549     if (item_len != 18) {
550         avpriv_request_sample(pb, "Primer pack item length %d", item_len);
551         return AVERROR_PATCHWELCOME;
552     }
553     if (item_num > 65536 || item_num < 0) {
554         av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
555         return AVERROR_INVALIDDATA;
556     }
557     if (mxf->local_tags)
558         av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
559     av_free(mxf->local_tags);
560     mxf->local_tags_count = 0;
561     mxf->local_tags = av_calloc(item_num, item_len);
562     if (!mxf->local_tags)
563         return AVERROR(ENOMEM);
564     mxf->local_tags_count = item_num;
565     avio_read(pb, mxf->local_tags, item_num*item_len);
566     return 0;
567 }
568
569 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
570 {
571     MXFContext *mxf = arg;
572     MXFPartition *partition, *tmp_part;
573     UID op;
574     uint64_t footer_partition;
575     uint32_t nb_essence_containers;
576
577     if (mxf->partitions_count >= INT_MAX / 2)
578         return AVERROR_INVALIDDATA;
579
580     tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
581     if (!tmp_part)
582         return AVERROR(ENOMEM);
583     mxf->partitions = tmp_part;
584
585     if (mxf->parsing_backward) {
586         /* insert the new partition pack in the middle
587          * this makes the entries in mxf->partitions sorted by offset */
588         memmove(&mxf->partitions[mxf->last_forward_partition+1],
589                 &mxf->partitions[mxf->last_forward_partition],
590                 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
591         partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
592     } else {
593         mxf->last_forward_partition++;
594         partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
595     }
596
597     memset(partition, 0, sizeof(*partition));
598     mxf->partitions_count++;
599     partition->pack_length = avio_tell(pb) - klv_offset + size;
600     partition->pack_ofs    = klv_offset;
601
602     switch(uid[13]) {
603     case 2:
604         partition->type = Header;
605         break;
606     case 3:
607         partition->type = BodyPartition;
608         break;
609     case 4:
610         partition->type = Footer;
611         break;
612     default:
613         av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
614         return AVERROR_INVALIDDATA;
615     }
616
617     /* consider both footers to be closed (there is only Footer and CompleteFooter) */
618     partition->closed = partition->type == Footer || !(uid[14] & 1);
619     partition->complete = uid[14] > 2;
620     avio_skip(pb, 4);
621     partition->kag_size = avio_rb32(pb);
622     partition->this_partition = avio_rb64(pb);
623     partition->previous_partition = avio_rb64(pb);
624     footer_partition = avio_rb64(pb);
625     partition->header_byte_count = avio_rb64(pb);
626     partition->index_byte_count = avio_rb64(pb);
627     partition->index_sid = avio_rb32(pb);
628     partition->body_offset = avio_rb64(pb);
629     partition->body_sid = avio_rb32(pb);
630     if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
631         av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
632         return AVERROR_INVALIDDATA;
633     }
634     nb_essence_containers = avio_rb32(pb);
635
636     if (partition->this_partition &&
637         partition->previous_partition == partition->this_partition) {
638         av_log(mxf->fc, AV_LOG_ERROR,
639                "PreviousPartition equal to ThisPartition %"PRIx64"\n",
640                partition->previous_partition);
641         /* override with the actual previous partition offset */
642         if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
643             MXFPartition *prev =
644                 mxf->partitions + mxf->last_forward_partition - 2;
645             partition->previous_partition = prev->this_partition;
646         }
647         /* if no previous body partition are found point to the header
648          * partition */
649         if (partition->previous_partition == partition->this_partition)
650             partition->previous_partition = 0;
651         av_log(mxf->fc, AV_LOG_ERROR,
652                "Overriding PreviousPartition with %"PRIx64"\n",
653                partition->previous_partition);
654     }
655
656     /* some files don't have FooterPartition set in every partition */
657     if (footer_partition) {
658         if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
659             av_log(mxf->fc, AV_LOG_ERROR,
660                    "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
661                    mxf->footer_partition, footer_partition);
662         } else {
663             mxf->footer_partition = footer_partition;
664         }
665     }
666
667     av_log(mxf->fc, AV_LOG_TRACE,
668             "PartitionPack: ThisPartition = 0x%"PRIX64
669             ", PreviousPartition = 0x%"PRIX64", "
670             "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
671             partition->this_partition,
672             partition->previous_partition, footer_partition,
673             partition->index_sid, partition->body_sid);
674
675     /* sanity check PreviousPartition if set */
676     //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
677     if (partition->previous_partition &&
678         mxf->run_in + partition->previous_partition >= klv_offset) {
679         av_log(mxf->fc, AV_LOG_ERROR,
680                "PreviousPartition points to this partition or forward\n");
681         return AVERROR_INVALIDDATA;
682     }
683
684     if      (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
685     else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
686     else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
687     else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
688     else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
689     else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
690     else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
691     else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
692     else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
693     else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
694     else if (op[12] == 0x10) {
695         /* SMPTE 390m: "There shall be exactly one essence container"
696          * The following block deals with files that violate this, namely:
697          * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
698          * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
699         if (nb_essence_containers != 1) {
700             MXFOP op = nb_essence_containers ? OP1a : OPAtom;
701
702             /* only nag once */
703             if (!mxf->op)
704                 av_log(mxf->fc, AV_LOG_WARNING,
705                        "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
706                        nb_essence_containers,
707                        op == OP1a ? "OP1a" : "OPAtom");
708
709             mxf->op = op;
710         } else
711             mxf->op = OPAtom;
712     } else {
713         av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
714         mxf->op = OP1a;
715     }
716
717     if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
718         av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
719                partition->kag_size);
720
721         if (mxf->op == OPSONYOpt)
722             partition->kag_size = 512;
723         else
724             partition->kag_size = 1;
725
726         av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
727     }
728
729     return 0;
730 }
731
732 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
733 {
734     MXFMetadataSet **tmp;
735
736     tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
737     if (!tmp)
738         return AVERROR(ENOMEM);
739     mxf->metadata_sets = tmp;
740     mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
741     mxf->metadata_sets_count++;
742     return 0;
743 }
744
745 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
746 {
747     MXFCryptoContext *cryptocontext = arg;
748     if (size != 16)
749         return AVERROR_INVALIDDATA;
750     if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
751         avio_read(pb, cryptocontext->source_container_ul, 16);
752     return 0;
753 }
754
755 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
756 {
757     *count = avio_rb32(pb);
758     *refs = av_calloc(*count, sizeof(UID));
759     if (!*refs) {
760         *count = 0;
761         return AVERROR(ENOMEM);
762     }
763     avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
764     avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
765     return 0;
766 }
767
768 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
769 {
770     int ret;
771     size_t buf_size;
772
773     if (size < 0 || size > INT_MAX/2)
774         return AVERROR(EINVAL);
775
776     buf_size = size + size / 2 + 1;
777     *str = av_malloc(buf_size);
778     if (!*str)
779         return AVERROR(ENOMEM);
780
781     if (be)
782         ret = avio_get_str16be(pb, size, *str, buf_size);
783     else
784         ret = avio_get_str16le(pb, size, *str, buf_size);
785
786     if (ret < 0) {
787         av_freep(str);
788         return ret;
789     }
790
791     return ret;
792 }
793
794 #define READ_STR16(type, big_endian)                                               \
795 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
796 {                                                                                  \
797 return mxf_read_utf16_string(pb, size, str, big_endian);                           \
798 }
799 READ_STR16(be, 1)
800 READ_STR16(le, 0)
801 #undef READ_STR16
802
803 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
804 {
805     MXFContext *mxf = arg;
806     switch (tag) {
807     case 0x1901:
808         if (mxf->packages_refs)
809             av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
810         av_free(mxf->packages_refs);
811         return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
812     case 0x1902:
813         av_free(mxf->essence_container_data_refs);
814         return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
815     }
816     return 0;
817 }
818
819 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
820 {
821     MXFStructuralComponent *source_clip = arg;
822     switch(tag) {
823     case 0x0202:
824         source_clip->duration = avio_rb64(pb);
825         break;
826     case 0x1201:
827         source_clip->start_position = avio_rb64(pb);
828         break;
829     case 0x1101:
830         /* UMID, only get last 16 bytes */
831         avio_read(pb, source_clip->source_package_ul, 16);
832         avio_read(pb, source_clip->source_package_uid, 16);
833         break;
834     case 0x1102:
835         source_clip->source_track_id = avio_rb32(pb);
836         break;
837     }
838     return 0;
839 }
840
841 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
842 {
843     MXFTimecodeComponent *mxf_timecode = arg;
844     switch(tag) {
845     case 0x1501:
846         mxf_timecode->start_frame = avio_rb64(pb);
847         break;
848     case 0x1502:
849         mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
850         break;
851     case 0x1503:
852         mxf_timecode->drop_frame = avio_r8(pb);
853         break;
854     }
855     return 0;
856 }
857
858 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
859 {
860     MXFPulldownComponent *mxf_pulldown = arg;
861     switch(tag) {
862     case 0x0d01:
863         avio_read(pb, mxf_pulldown->input_segment_ref, 16);
864         break;
865     }
866     return 0;
867 }
868
869 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
870 {
871     MXFTrack *track = arg;
872     switch(tag) {
873     case 0x4801:
874         track->track_id = avio_rb32(pb);
875         break;
876     case 0x4804:
877         avio_read(pb, track->track_number, 4);
878         break;
879     case 0x4802:
880         mxf_read_utf16be_string(pb, size, &track->name);
881         break;
882     case 0x4b01:
883         track->edit_rate.num = avio_rb32(pb);
884         track->edit_rate.den = avio_rb32(pb);
885         break;
886     case 0x4803:
887         avio_read(pb, track->sequence_ref, 16);
888         break;
889     }
890     return 0;
891 }
892
893 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
894 {
895     MXFSequence *sequence = arg;
896     switch(tag) {
897     case 0x0202:
898         sequence->duration = avio_rb64(pb);
899         break;
900     case 0x0201:
901         avio_read(pb, sequence->data_definition_ul, 16);
902         break;
903         case 0x4b02:
904         sequence->origin = avio_r8(pb);
905         break;
906     case 0x1001:
907         return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
908                                              &sequence->structural_components_count);
909     }
910     return 0;
911 }
912
913 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
914 {
915     MXFEssenceGroup *essence_group = arg;
916     switch (tag) {
917     case 0x0202:
918         essence_group->duration = avio_rb64(pb);
919         break;
920     case 0x0501:
921         return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
922                                              &essence_group->structural_components_count);
923     }
924     return 0;
925 }
926
927 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
928 {
929     MXFPackage *package = arg;
930     switch(tag) {
931     case 0x4403:
932         return mxf_read_strong_ref_array(pb, &package->tracks_refs,
933                                              &package->tracks_count);
934     case 0x4401:
935         /* UMID */
936         avio_read(pb, package->package_ul, 16);
937         avio_read(pb, package->package_uid, 16);
938         break;
939     case 0x4701:
940         avio_read(pb, package->descriptor_ref, 16);
941         break;
942     case 0x4402:
943         return mxf_read_utf16be_string(pb, size, &package->name);
944     case 0x4406:
945         return mxf_read_strong_ref_array(pb, &package->comment_refs,
946                                              &package->comment_count);
947     }
948     return 0;
949 }
950
951 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
952 {
953     MXFEssenceContainerData *essence_data = arg;
954     switch(tag) {
955         case 0x2701:
956             /* linked package umid UMID */
957             avio_read(pb, essence_data->package_ul, 16);
958             avio_read(pb, essence_data->package_uid, 16);
959             break;
960         case 0x3f06:
961             essence_data->index_sid = avio_rb32(pb);
962             break;
963         case 0x3f07:
964             essence_data->body_sid = avio_rb32(pb);
965             break;
966     }
967     return 0;
968 }
969
970 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
971 {
972     int i, length;
973
974     segment->nb_index_entries = avio_rb32(pb);
975
976     length = avio_rb32(pb);
977     if(segment->nb_index_entries && length < 11)
978         return AVERROR_INVALIDDATA;
979
980     if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
981         !(segment->flag_entries          = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
982         !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
983         av_freep(&segment->temporal_offset_entries);
984         av_freep(&segment->flag_entries);
985         return AVERROR(ENOMEM);
986     }
987
988     for (i = 0; i < segment->nb_index_entries; i++) {
989         if(avio_feof(pb))
990             return AVERROR_INVALIDDATA;
991         segment->temporal_offset_entries[i] = avio_r8(pb);
992         avio_r8(pb);                                        /* KeyFrameOffset */
993         segment->flag_entries[i] = avio_r8(pb);
994         segment->stream_offset_entries[i] = avio_rb64(pb);
995         avio_skip(pb, length - 11);
996     }
997     return 0;
998 }
999
1000 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1001 {
1002     MXFIndexTableSegment *segment = arg;
1003     switch(tag) {
1004     case 0x3F05:
1005         segment->edit_unit_byte_count = avio_rb32(pb);
1006         av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1007         break;
1008     case 0x3F06:
1009         segment->index_sid = avio_rb32(pb);
1010         av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1011         break;
1012     case 0x3F07:
1013         segment->body_sid = avio_rb32(pb);
1014         av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1015         break;
1016     case 0x3F0A:
1017         av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1018         return mxf_read_index_entry_array(pb, segment);
1019     case 0x3F0B:
1020         segment->index_edit_rate.num = avio_rb32(pb);
1021         segment->index_edit_rate.den = avio_rb32(pb);
1022         av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1023                 segment->index_edit_rate.den);
1024         break;
1025     case 0x3F0C:
1026         segment->index_start_position = avio_rb64(pb);
1027         av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1028         break;
1029     case 0x3F0D:
1030         segment->index_duration = avio_rb64(pb);
1031         av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1032         break;
1033     }
1034     return 0;
1035 }
1036
1037 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1038 {
1039     int code, value, ofs = 0;
1040     char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1041
1042     do {
1043         code = avio_r8(pb);
1044         value = avio_r8(pb);
1045         av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1046
1047         if (ofs <= 14) {
1048             layout[ofs++] = code;
1049             layout[ofs++] = value;
1050         } else
1051             break;  /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1052     } while (code != 0); /* SMPTE 377M E.2.46 */
1053
1054     ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1055 }
1056
1057 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1058 {
1059     MXFDescriptor *descriptor = arg;
1060     int entry_count, entry_size;
1061
1062     switch(tag) {
1063     case 0x3F01:
1064         return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
1065                                              &descriptor->sub_descriptors_count);
1066     case 0x3002: /* ContainerDuration */
1067         descriptor->duration = avio_rb64(pb);
1068         break;
1069     case 0x3004:
1070         avio_read(pb, descriptor->essence_container_ul, 16);
1071         break;
1072     case 0x3005:
1073         avio_read(pb, descriptor->codec_ul, 16);
1074         break;
1075     case 0x3006:
1076         descriptor->linked_track_id = avio_rb32(pb);
1077         break;
1078     case 0x3201: /* PictureEssenceCoding */
1079         avio_read(pb, descriptor->essence_codec_ul, 16);
1080         break;
1081     case 0x3203:
1082         descriptor->width = avio_rb32(pb);
1083         break;
1084     case 0x3202:
1085         descriptor->height = avio_rb32(pb);
1086         break;
1087     case 0x320C:
1088         descriptor->frame_layout = avio_r8(pb);
1089         break;
1090     case 0x320D:
1091         entry_count = avio_rb32(pb);
1092         entry_size = avio_rb32(pb);
1093         if (entry_size == 4) {
1094             if (entry_count > 0)
1095                 descriptor->video_line_map[0] = avio_rb32(pb);
1096             else
1097                 descriptor->video_line_map[0] = 0;
1098             if (entry_count > 1)
1099                 descriptor->video_line_map[1] = avio_rb32(pb);
1100             else
1101                 descriptor->video_line_map[1] = 0;
1102         } else
1103             av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1104         break;
1105     case 0x320E:
1106         descriptor->aspect_ratio.num = avio_rb32(pb);
1107         descriptor->aspect_ratio.den = avio_rb32(pb);
1108         break;
1109     case 0x3212:
1110         descriptor->field_dominance = avio_r8(pb);
1111         break;
1112     case 0x3301:
1113         descriptor->component_depth = avio_rb32(pb);
1114         break;
1115     case 0x3302:
1116         descriptor->horiz_subsampling = avio_rb32(pb);
1117         break;
1118     case 0x3308:
1119         descriptor->vert_subsampling = avio_rb32(pb);
1120         break;
1121     case 0x3D03:
1122         descriptor->sample_rate.num = avio_rb32(pb);
1123         descriptor->sample_rate.den = avio_rb32(pb);
1124         break;
1125     case 0x3D06: /* SoundEssenceCompression */
1126         avio_read(pb, descriptor->essence_codec_ul, 16);
1127         break;
1128     case 0x3D07:
1129         descriptor->channels = avio_rb32(pb);
1130         break;
1131     case 0x3D01:
1132         descriptor->bits_per_sample = avio_rb32(pb);
1133         break;
1134     case 0x3401:
1135         mxf_read_pixel_layout(pb, descriptor);
1136         break;
1137     default:
1138         /* Private uid used by SONY C0023S01.mxf */
1139         if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1140             if (descriptor->extradata)
1141                 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1142             av_free(descriptor->extradata);
1143             descriptor->extradata_size = 0;
1144             descriptor->extradata = av_malloc(size);
1145             if (!descriptor->extradata)
1146                 return AVERROR(ENOMEM);
1147             descriptor->extradata_size = size;
1148             avio_read(pb, descriptor->extradata, size);
1149         }
1150         if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1151             uint32_t rsiz = avio_rb16(pb);
1152             if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1153                 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1154                 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1155         }
1156         break;
1157     }
1158     return 0;
1159 }
1160
1161 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1162 {
1163     MXFTaggedValue *tagged_value = arg;
1164     uint8_t key[17];
1165
1166     if (size <= 17)
1167         return 0;
1168
1169     avio_read(pb, key, 17);
1170     /* TODO: handle other types of of indirect values */
1171     if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1172         return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1173     } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1174         return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1175     }
1176     return 0;
1177 }
1178
1179 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1180 {
1181     MXFTaggedValue *tagged_value = arg;
1182     switch (tag){
1183     case 0x5001:
1184         return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1185     case 0x5003:
1186         return mxf_read_indirect_value(tagged_value, pb, size);
1187     }
1188     return 0;
1189 }
1190
1191 /*
1192  * Match an uid independently of the version byte and up to len common bytes
1193  * Returns: boolean
1194  */
1195 static int mxf_match_uid(const UID key, const UID uid, int len)
1196 {
1197     int i;
1198     for (i = 0; i < len; i++) {
1199         if (i != 7 && key[i] != uid[i])
1200             return 0;
1201     }
1202     return 1;
1203 }
1204
1205 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1206 {
1207     while (uls->uid[0]) {
1208         if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1209             break;
1210         uls++;
1211     }
1212     return uls;
1213 }
1214
1215 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1216 {
1217     int i;
1218
1219     if (!strong_ref)
1220         return NULL;
1221     for (i = 0; i < mxf->metadata_sets_count; i++) {
1222         if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1223             (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1224             return mxf->metadata_sets[i];
1225         }
1226     }
1227     return NULL;
1228 }
1229
1230 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1231     // video essence container uls
1232     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14,   AV_CODEC_ID_JPEG2000 },
1233     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14,       AV_CODEC_ID_H264 }, /* H.264 frame wrapped */
1234     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14,      AV_CODEC_ID_DNXHD }, /* VC-3 */
1235     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14,        AV_CODEC_ID_VC1 }, /* VC-1 frame wrapped */
1236     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14,       AV_CODEC_ID_TIFF }, /* TIFF */
1237     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14,      AV_CODEC_ID_DIRAC }, /* VC-2 */
1238     { { 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 */
1239     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* Type D-10 mapping of 40Mbps 525/60-I */
1240     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,    AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1241     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,   AV_CODEC_ID_RAWVIDEO }, /* uncompressed picture */
1242     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15,     AV_CODEC_ID_HQ_HQA },
1243     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15,        AV_CODEC_ID_HQX },
1244     { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14,   AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1245     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1246 };
1247
1248 /* EC ULs for intra-only formats */
1249 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1250     { { 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 */
1251     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1252 };
1253
1254 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1255 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1256     { { 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 */
1257     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14,   AV_CODEC_ID_JPEG2000 }, /* JPEG 2000 code stream */
1258     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1259 };
1260
1261 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1262 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1263     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1264     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1265     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1266     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1267     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,    0 },
1268 };
1269
1270 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1271     // sound essence container uls
1272     { { 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 */
1273     { { 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 */
1274     { { 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 */
1275     { { 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 */
1276     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14,       AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
1277     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1278 };
1279
1280 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1281     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16, AV_CODEC_ID_NONE,      "vbi_smpte_436M" },
1282     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_vanc_smpte_436M" },
1283     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1284     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0, AV_CODEC_ID_NONE },
1285 };
1286
1287 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1288 {
1289     int i, j, nb_segments = 0;
1290     MXFIndexTableSegment **unsorted_segments;
1291     int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1292
1293     /* count number of segments, allocate arrays and copy unsorted segments */
1294     for (i = 0; i < mxf->metadata_sets_count; i++)
1295         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1296             nb_segments++;
1297
1298     if (!nb_segments)
1299         return AVERROR_INVALIDDATA;
1300
1301     if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1302         !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1303         av_freep(sorted_segments);
1304         av_free(unsorted_segments);
1305         return AVERROR(ENOMEM);
1306     }
1307
1308     for (i = j = 0; i < mxf->metadata_sets_count; i++)
1309         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1310             unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1311
1312     *nb_sorted_segments = 0;
1313
1314     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1315     for (i = 0; i < nb_segments; i++) {
1316         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1317         uint64_t best_index_duration = 0;
1318
1319         for (j = 0; j < nb_segments; j++) {
1320             MXFIndexTableSegment *s = unsorted_segments[j];
1321
1322             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1323              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1324              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1325              */
1326             if ((i == 0 ||
1327                  s->body_sid >  last_body_sid ||
1328                  s->body_sid == last_body_sid && s->index_sid >  last_index_sid ||
1329                  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1330                 (best == -1 ||
1331                  s->body_sid <  best_body_sid ||
1332                  s->body_sid == best_body_sid && s->index_sid <  best_index_sid ||
1333                  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position <  best_index_start ||
1334                  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position == best_index_start && s->index_duration > best_index_duration)) {
1335                 best             = j;
1336                 best_body_sid    = s->body_sid;
1337                 best_index_sid   = s->index_sid;
1338                 best_index_start = s->index_start_position;
1339                 best_index_duration = s->index_duration;
1340             }
1341         }
1342
1343         /* no suitable entry found -> we're done */
1344         if (best == -1)
1345             break;
1346
1347         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1348         last_body_sid    = best_body_sid;
1349         last_index_sid   = best_index_sid;
1350         last_index_start = best_index_start;
1351     }
1352
1353     av_free(unsorted_segments);
1354
1355     return 0;
1356 }
1357
1358 /**
1359  * Computes the absolute file offset of the given essence container offset
1360  */
1361 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1362 {
1363     MXFPartition *last_p = NULL;
1364     int a, b, m, m0;
1365
1366     if (offset < 0)
1367         return AVERROR(EINVAL);
1368
1369     a = -1;
1370     b = mxf->partitions_count;
1371
1372     while (b - a > 1) {
1373         m0 = m = (a + b) >> 1;
1374
1375         while (m < b && mxf->partitions[m].body_sid != body_sid)
1376             m++;
1377
1378         if (m < b && mxf->partitions[m].body_offset <= offset)
1379             a = m;
1380         else
1381             b = m0;
1382     }
1383
1384     if (a >= 0)
1385         last_p = &mxf->partitions[a];
1386
1387     if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1388         *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1389         return 0;
1390     }
1391
1392     av_log(mxf->fc, AV_LOG_ERROR,
1393            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1394            offset, body_sid);
1395
1396     return AVERROR_INVALIDDATA;
1397 }
1398
1399 /**
1400  * Returns the end position of the essence container with given BodySID, or zero if unknown
1401  */
1402 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1403 {
1404     int x;
1405     int64_t ret = 0;
1406
1407     for (x = 0; x < mxf->partitions_count; x++) {
1408         MXFPartition *p = &mxf->partitions[x];
1409
1410         if (p->body_sid != body_sid)
1411             continue;
1412
1413         if (!p->essence_length)
1414             return 0;
1415
1416         ret = p->essence_offset + p->essence_length;
1417     }
1418
1419     return ret;
1420 }
1421
1422 /* EditUnit -> absolute offset */
1423 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)
1424 {
1425     int i;
1426     int64_t offset_temp = 0;
1427
1428     for (i = 0; i < index_table->nb_segments; i++) {
1429         MXFIndexTableSegment *s = index_table->segments[i];
1430
1431         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1432
1433         if (edit_unit < s->index_start_position + s->index_duration) {
1434             int64_t index = edit_unit - s->index_start_position;
1435
1436             if (s->edit_unit_byte_count)
1437                 offset_temp += s->edit_unit_byte_count * index;
1438             else if (s->nb_index_entries) {
1439                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1440                     index *= 2;     /* Avid index */
1441
1442                 if (index < 0 || index >= s->nb_index_entries) {
1443                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1444                            index_table->index_sid, s->index_start_position);
1445                     return AVERROR_INVALIDDATA;
1446                 }
1447
1448                 offset_temp = s->stream_offset_entries[index];
1449             } else {
1450                 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1451                        index_table->index_sid, s->index_start_position);
1452                 return AVERROR_INVALIDDATA;
1453             }
1454
1455             if (edit_unit_out)
1456                 *edit_unit_out = edit_unit;
1457
1458             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1459         } else {
1460             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1461             offset_temp += s->edit_unit_byte_count * s->index_duration;
1462         }
1463     }
1464
1465     if (nag)
1466         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);
1467
1468     return AVERROR_INVALIDDATA;
1469 }
1470
1471 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1472 {
1473     int i, j, x;
1474     int8_t max_temporal_offset = -128;
1475     uint8_t *flags;
1476
1477     /* first compute how many entries we have */
1478     for (i = 0; i < index_table->nb_segments; i++) {
1479         MXFIndexTableSegment *s = index_table->segments[i];
1480
1481         if (!s->nb_index_entries) {
1482             index_table->nb_ptses = 0;
1483             return 0;                               /* no TemporalOffsets */
1484         }
1485
1486         index_table->nb_ptses += s->index_duration;
1487     }
1488
1489     /* paranoid check */
1490     if (index_table->nb_ptses <= 0)
1491         return 0;
1492
1493     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1494         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1495         !(index_table->offsets    = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1496         !(flags                   = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1497         av_freep(&index_table->ptses);
1498         av_freep(&index_table->fake_index);
1499         av_freep(&index_table->offsets);
1500         return AVERROR(ENOMEM);
1501     }
1502
1503     /* we may have a few bad TemporalOffsets
1504      * make sure the corresponding PTSes don't have the bogus value 0 */
1505     for (x = 0; x < index_table->nb_ptses; x++)
1506         index_table->ptses[x] = AV_NOPTS_VALUE;
1507
1508     /**
1509      * We have this:
1510      *
1511      * x  TemporalOffset
1512      * 0:  0
1513      * 1:  1
1514      * 2:  1
1515      * 3: -2
1516      * 4:  1
1517      * 5:  1
1518      * 6: -2
1519      *
1520      * We want to transform it into this:
1521      *
1522      * x  DTS PTS
1523      * 0: -1   0
1524      * 1:  0   3
1525      * 2:  1   1
1526      * 3:  2   2
1527      * 4:  3   6
1528      * 5:  4   4
1529      * 6:  5   5
1530      *
1531      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1532      * then settings mxf->first_dts = -max(TemporalOffset[x]).
1533      * The latter makes DTS <= PTS.
1534      */
1535     for (i = x = 0; i < index_table->nb_segments; i++) {
1536         MXFIndexTableSegment *s = index_table->segments[i];
1537         int index_delta = 1;
1538         int n = s->nb_index_entries;
1539
1540         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1541             index_delta = 2;    /* Avid index */
1542             /* ignore the last entry - it's the size of the essence container */
1543             n--;
1544         }
1545
1546         for (j = 0; j < n; j += index_delta, x++) {
1547             int offset = s->temporal_offset_entries[j] / index_delta;
1548             int index  = x + offset;
1549
1550             if (x >= index_table->nb_ptses) {
1551                 av_log(mxf->fc, AV_LOG_ERROR,
1552                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1553                        s->nb_index_entries, s->index_duration);
1554                 break;
1555             }
1556
1557             flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1558
1559             if (index < 0 || index >= index_table->nb_ptses) {
1560                 av_log(mxf->fc, AV_LOG_ERROR,
1561                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1562                        x, offset, index);
1563                 continue;
1564             }
1565
1566             index_table->offsets[x] = offset;
1567             index_table->ptses[index] = x;
1568             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1569         }
1570     }
1571
1572     /* calculate the fake index table in display order */
1573     for (x = 0; x < index_table->nb_ptses; x++) {
1574         index_table->fake_index[x].timestamp = x;
1575         if (index_table->ptses[x] != AV_NOPTS_VALUE)
1576             index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1577     }
1578     av_freep(&flags);
1579
1580     index_table->first_dts = -max_temporal_offset;
1581
1582     return 0;
1583 }
1584
1585 /**
1586  * Sorts and collects index table segments into index tables.
1587  * Also computes PTSes if possible.
1588  */
1589 static int mxf_compute_index_tables(MXFContext *mxf)
1590 {
1591     int i, j, k, ret, nb_sorted_segments;
1592     MXFIndexTableSegment **sorted_segments = NULL;
1593
1594     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1595         nb_sorted_segments <= 0) {
1596         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1597         return 0;
1598     }
1599
1600     /* sanity check and count unique BodySIDs/IndexSIDs */
1601     for (i = 0; i < nb_sorted_segments; i++) {
1602         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1603             mxf->nb_index_tables++;
1604         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1605             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1606             ret = AVERROR_INVALIDDATA;
1607             goto finish_decoding_index;
1608         }
1609     }
1610
1611     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1612                                          sizeof(*mxf->index_tables));
1613     if (!mxf->index_tables) {
1614         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1615         ret = AVERROR(ENOMEM);
1616         goto finish_decoding_index;
1617     }
1618
1619     /* distribute sorted segments to index tables */
1620     for (i = j = 0; i < nb_sorted_segments; i++) {
1621         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1622             /* next IndexSID */
1623             j++;
1624         }
1625
1626         mxf->index_tables[j].nb_segments++;
1627     }
1628
1629     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1630         MXFIndexTable *t = &mxf->index_tables[j];
1631         MXFTrack *mxf_track = NULL;
1632
1633         t->segments = av_mallocz_array(t->nb_segments,
1634                                        sizeof(*t->segments));
1635
1636         if (!t->segments) {
1637             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1638                    " pointer array\n");
1639             ret = AVERROR(ENOMEM);
1640             goto finish_decoding_index;
1641         }
1642
1643         if (sorted_segments[i]->index_start_position)
1644             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1645                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1646
1647         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1648         t->index_sid = sorted_segments[i]->index_sid;
1649         t->body_sid = sorted_segments[i]->body_sid;
1650
1651         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1652             goto finish_decoding_index;
1653
1654         for (k = 0; k < mxf->fc->nb_streams; k++) {
1655             MXFTrack *track = mxf->fc->streams[k]->priv_data;
1656             if (track && track->index_sid == t->index_sid) {
1657                 mxf_track = track;
1658                 break;
1659             }
1660         }
1661
1662         /* fix zero IndexDurations */
1663         for (k = 0; k < t->nb_segments; k++) {
1664             if (t->segments[k]->index_duration)
1665                 continue;
1666
1667             if (t->nb_segments > 1)
1668                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1669                        t->index_sid, k);
1670
1671             if (!mxf_track) {
1672                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1673                 break;
1674             }
1675
1676             /* assume the first stream's duration is reasonable
1677              * leave index_duration = 0 on further segments in case we have any (unlikely)
1678              */
1679             t->segments[k]->index_duration = mxf_track->original_duration;
1680             break;
1681         }
1682     }
1683
1684     ret = 0;
1685 finish_decoding_index:
1686     av_free(sorted_segments);
1687     return ret;
1688 }
1689
1690 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1691 {
1692     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1693                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1694            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1695                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1696 }
1697
1698 static int mxf_uid_to_str(UID uid, char **str)
1699 {
1700     int i;
1701     char *p;
1702     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1703     if (!p)
1704         return AVERROR(ENOMEM);
1705     for (i = 0; i < sizeof(UID); i++) {
1706         snprintf(p, 2 + 1, "%.2x", uid[i]);
1707         p += 2;
1708         if (i == 3 || i == 5 || i == 7 || i == 9) {
1709             snprintf(p, 1 + 1, "-");
1710             p++;
1711         }
1712     }
1713     return 0;
1714 }
1715
1716 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1717 {
1718     int i;
1719     char *p;
1720     p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1721     if (!p)
1722         return AVERROR(ENOMEM);
1723     snprintf(p, 2 + 1, "0x");
1724     p += 2;
1725     for (i = 0; i < sizeof(UID); i++) {
1726         snprintf(p, 2 + 1, "%.2X", ul[i]);
1727         p += 2;
1728
1729     }
1730     for (i = 0; i < sizeof(UID); i++) {
1731         snprintf(p, 2 + 1, "%.2X", uid[i]);
1732         p += 2;
1733     }
1734     return 0;
1735 }
1736
1737 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1738 {
1739     char *str;
1740     int ret;
1741     if (!package)
1742         return 0;
1743     if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1744         return ret;
1745     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1746     return 0;
1747 }
1748
1749 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1750 {
1751     char buf[AV_TIMECODE_STR_SIZE];
1752     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1753
1754     return 0;
1755 }
1756
1757 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1758 {
1759     MXFStructuralComponent *component = NULL;
1760     MXFPulldownComponent *pulldown = NULL;
1761
1762     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1763     if (!component)
1764         return NULL;
1765
1766     switch (component->type) {
1767     case TimecodeComponent:
1768         return (MXFTimecodeComponent*)component;
1769     case PulldownComponent: /* timcode component may be located on a pulldown component */
1770         pulldown = (MXFPulldownComponent*)component;
1771         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1772     default:
1773         break;
1774     }
1775     return NULL;
1776 }
1777
1778 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1779 {
1780     MXFPackage *package = NULL;
1781     int i;
1782
1783     for (i = 0; i < mxf->packages_count; i++) {
1784         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1785         if (!package)
1786             continue;
1787
1788         if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1789             return package;
1790     }
1791     return NULL;
1792 }
1793
1794 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1795 {
1796     MXFDescriptor *sub_descriptor = NULL;
1797     int i;
1798
1799     if (!descriptor)
1800         return NULL;
1801
1802     if (descriptor->type == MultipleDescriptor) {
1803         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1804             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1805
1806             if (!sub_descriptor) {
1807                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1808                 continue;
1809             }
1810             if (sub_descriptor->linked_track_id == track_id) {
1811                 return sub_descriptor;
1812             }
1813         }
1814     } else if (descriptor->type == Descriptor)
1815         return descriptor;
1816
1817     return NULL;
1818 }
1819
1820 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1821 {
1822     MXFStructuralComponent *component = NULL;
1823     MXFPackage *package = NULL;
1824     MXFDescriptor *descriptor = NULL;
1825     int i;
1826
1827     if (!essence_group || !essence_group->structural_components_count)
1828         return NULL;
1829
1830     /* essence groups contains multiple representations of the same media,
1831        this return the first components with a valid Descriptor typically index 0 */
1832     for (i =0; i < essence_group->structural_components_count; i++){
1833         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1834         if (!component)
1835             continue;
1836
1837         if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1838             continue;
1839
1840         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1841         if (descriptor)
1842             return component;
1843     }
1844     return NULL;
1845 }
1846
1847 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1848 {
1849     MXFStructuralComponent *component = NULL;
1850
1851     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1852     if (!component)
1853         return NULL;
1854     switch (component->type) {
1855         case SourceClip:
1856             return component;
1857         case EssenceGroup:
1858             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1859         default:
1860             break;
1861     }
1862     return NULL;
1863 }
1864
1865 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1866 {
1867     MXFTaggedValue *tag;
1868     int size, i;
1869     char *key = NULL;
1870
1871     for (i = 0; i < package->comment_count; i++) {
1872         tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1873         if (!tag || !tag->name || !tag->value)
1874             continue;
1875
1876         size = strlen(tag->name) + 8 + 1;
1877         key = av_mallocz(size);
1878         if (!key)
1879             return AVERROR(ENOMEM);
1880
1881         snprintf(key, size, "comment_%s", tag->name);
1882         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1883     }
1884     return 0;
1885 }
1886
1887 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1888 {
1889     MXFPackage *physical_package = NULL;
1890     MXFTrack *physical_track = NULL;
1891     MXFStructuralComponent *sourceclip = NULL;
1892     MXFTimecodeComponent *mxf_tc = NULL;
1893     int i, j, k;
1894     AVTimecode tc;
1895     int flags;
1896     int64_t start_position;
1897
1898     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1899         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1900         if (!sourceclip)
1901             continue;
1902
1903         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
1904             break;
1905
1906         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1907
1908         /* the name of physical source package is name of the reel or tape */
1909         if (physical_package->name && physical_package->name[0])
1910             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1911
1912         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1913          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1914          */
1915         for (j = 0; j < physical_package->tracks_count; j++) {
1916             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1917                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1918                 continue;
1919             }
1920
1921             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1922                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1923                 continue;
1924             }
1925
1926         if (physical_track->edit_rate.num <= 0 ||
1927             physical_track->edit_rate.den <= 0) {
1928             av_log(mxf->fc, AV_LOG_WARNING,
1929                    "Invalid edit rate (%d/%d) found on structural"
1930                    " component #%d, defaulting to 25/1\n",
1931                    physical_track->edit_rate.num,
1932                    physical_track->edit_rate.den, i);
1933             physical_track->edit_rate = (AVRational){25, 1};
1934         }
1935
1936             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1937                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1938                     continue;
1939
1940                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1941                 /* scale sourceclip start_position to match physical track edit rate */
1942                 start_position = av_rescale_q(sourceclip->start_position,
1943                                               physical_track->edit_rate,
1944                                               source_track->edit_rate);
1945
1946                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1947                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1948                     return 0;
1949                 }
1950             }
1951         }
1952     }
1953
1954     return 0;
1955 }
1956
1957 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
1958 {
1959     MXFStructuralComponent *component = NULL;
1960     const MXFCodecUL *codec_ul = NULL;
1961     MXFPackage tmp_package;
1962     AVStream *st;
1963     int j;
1964
1965     for (j = 0; j < track->sequence->structural_components_count; j++) {
1966         component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
1967         if (!component)
1968             continue;
1969         break;
1970     }
1971     if (!component)
1972         return 0;
1973
1974     st = avformat_new_stream(mxf->fc, NULL);
1975     if (!st) {
1976         av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
1977         return AVERROR(ENOMEM);
1978     }
1979
1980     st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
1981     st->codecpar->codec_id = AV_CODEC_ID_NONE;
1982     st->id = track->track_id;
1983
1984     memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
1985     memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
1986     mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
1987     if (track->name && track->name[0])
1988         av_dict_set(&st->metadata, "track_name", track->name, 0);
1989
1990     codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
1991     av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
1992     return 0;
1993 }
1994
1995 static int mxf_parse_structural_metadata(MXFContext *mxf)
1996 {
1997     MXFPackage *material_package = NULL;
1998     int i, j, k, ret;
1999
2000     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2001     /* TODO: handle multiple material packages (OP3x) */
2002     for (i = 0; i < mxf->packages_count; i++) {
2003         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2004         if (material_package) break;
2005     }
2006     if (!material_package) {
2007         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2008         return AVERROR_INVALIDDATA;
2009     }
2010
2011     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2012     if (material_package->name && material_package->name[0])
2013         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2014     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2015
2016     for (i = 0; i < material_package->tracks_count; i++) {
2017         MXFPackage *source_package = NULL;
2018         MXFTrack *material_track = NULL;
2019         MXFTrack *source_track = NULL;
2020         MXFTrack *temp_track = NULL;
2021         MXFDescriptor *descriptor = NULL;
2022         MXFStructuralComponent *component = NULL;
2023         MXFTimecodeComponent *mxf_tc = NULL;
2024         UID *essence_container_ul = NULL;
2025         const MXFCodecUL *codec_ul = NULL;
2026         const MXFCodecUL *container_ul = NULL;
2027         const MXFCodecUL *pix_fmt_ul = NULL;
2028         AVStream *st;
2029         AVTimecode tc;
2030         int flags;
2031
2032         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2033             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2034             continue;
2035         }
2036
2037         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2038             mxf_tc = (MXFTimecodeComponent*)component;
2039             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2040             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2041                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2042             }
2043         }
2044
2045         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2046             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2047             continue;
2048         }
2049
2050         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2051             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2052             if (!component)
2053                 continue;
2054
2055             mxf_tc = (MXFTimecodeComponent*)component;
2056             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2057             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2058                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2059                 break;
2060             }
2061         }
2062
2063         /* TODO: handle multiple source clips, only finds first valid source clip */
2064         if(material_track->sequence->structural_components_count > 1)
2065             av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2066                        material_track->track_id, material_track->sequence->structural_components_count);
2067
2068         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2069             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2070             if (!component)
2071                 continue;
2072
2073             source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2074             if (!source_package) {
2075                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2076                 continue;
2077             }
2078             for (k = 0; k < source_package->tracks_count; k++) {
2079                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2080                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2081                     ret = AVERROR_INVALIDDATA;
2082                     goto fail_and_free;
2083                 }
2084                 if (temp_track->track_id == component->source_track_id) {
2085                     source_track = temp_track;
2086                     break;
2087                 }
2088             }
2089             if (!source_track) {
2090                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2091                 break;
2092             }
2093
2094             for (k = 0; k < mxf->essence_container_data_count; k++) {
2095                 MXFEssenceContainerData *essence_data;
2096
2097                 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2098                     av_log(mxf, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2099                     continue;
2100                 }
2101                 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2102                     source_track->body_sid = essence_data->body_sid;
2103                     source_track->index_sid = essence_data->index_sid;
2104                     break;
2105                 }
2106             }
2107
2108             if(source_track && component)
2109                 break;
2110         }
2111         if (!source_track || !component || !source_package) {
2112             if((ret = mxf_add_metadata_stream(mxf, material_track)))
2113                 goto fail_and_free;
2114             continue;
2115         }
2116
2117         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2118             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2119             ret = AVERROR_INVALIDDATA;
2120             goto fail_and_free;
2121         }
2122
2123         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2124          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2125         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2126             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2127             continue;
2128         }
2129
2130         st = avformat_new_stream(mxf->fc, NULL);
2131         if (!st) {
2132             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2133             ret = AVERROR(ENOMEM);
2134             goto fail_and_free;
2135         }
2136         st->id = material_track->track_id;
2137         st->priv_data = source_track;
2138
2139         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2140         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2141
2142         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2143          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2144         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2145             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2146         else
2147             source_track->original_duration = st->duration = component->duration;
2148
2149         if (st->duration == -1)
2150             st->duration = AV_NOPTS_VALUE;
2151         st->start_time = component->start_position;
2152         if (material_track->edit_rate.num <= 0 ||
2153             material_track->edit_rate.den <= 0) {
2154             av_log(mxf->fc, AV_LOG_WARNING,
2155                    "Invalid edit rate (%d/%d) found on stream #%d, "
2156                    "defaulting to 25/1\n",
2157                    material_track->edit_rate.num,
2158                    material_track->edit_rate.den, st->index);
2159             material_track->edit_rate = (AVRational){25, 1};
2160         }
2161         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2162
2163         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2164          * the former is accessible via st->priv_data */
2165         source_track->edit_rate = material_track->edit_rate;
2166
2167         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
2168         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2169         st->codecpar->codec_type = codec_ul->id;
2170
2171         if (!descriptor) {
2172             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2173             continue;
2174         }
2175         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
2176         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2177         essence_container_ul = &descriptor->essence_container_ul;
2178         /* HACK: replacing the original key with mxf_encrypted_essence_container
2179          * is not allowed according to s429-6, try to find correct information anyway */
2180         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2181             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2182             for (k = 0; k < mxf->metadata_sets_count; k++) {
2183                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2184                 if (metadata->type == CryptoContext) {
2185                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2186                     break;
2187                 }
2188             }
2189         }
2190
2191         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2192         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2193         st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2194         if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2195             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2196             st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2197         }
2198
2199         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2200                avcodec_get_name(st->codecpar->codec_id));
2201         for (k = 0; k < 16; k++) {
2202             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2203                    descriptor->essence_codec_ul[k]);
2204             if (!(k+1 & 19) || k == 5)
2205                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2206         }
2207         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2208
2209         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2210         if (source_package->name && source_package->name[0])
2211             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2212         if (material_track->name && material_track->name[0])
2213             av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2214
2215         mxf_parse_physical_source_package(mxf, source_track, st);
2216
2217         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2218             source_track->intra_only = mxf_is_intra_only(descriptor);
2219             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2220             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2221                 st->codecpar->codec_id = container_ul->id;
2222             st->codecpar->width = descriptor->width;
2223             st->codecpar->height = descriptor->height; /* Field height, not frame height */
2224             switch (descriptor->frame_layout) {
2225                 case FullFrame:
2226                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2227                     break;
2228                 case OneField:
2229                     /* Every other line is stored and needs to be duplicated. */
2230                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2231                     break; /* The correct thing to do here is fall through, but by breaking we might be
2232                               able to decode some streams at half the vertical resolution, rather than not al all.
2233                               It's also for compatibility with the old behavior. */
2234                 case MixedFields:
2235                     break;
2236                 case SegmentedFrame:
2237                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2238                 case SeparateFields:
2239                     av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2240                            descriptor->video_line_map[0], descriptor->video_line_map[1],
2241                            descriptor->field_dominance);
2242                     if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2243                         /* Detect coded field order from VideoLineMap:
2244                          *  (even, even) => bottom field coded first
2245                          *  (even, odd)  => top field coded first
2246                          *  (odd, even)  => top field coded first
2247                          *  (odd, odd)   => bottom field coded first
2248                          */
2249                         if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2250                             switch (descriptor->field_dominance) {
2251                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2252                                 case MXF_FIELD_DOMINANCE_FF:
2253                                     st->codecpar->field_order = AV_FIELD_TT;
2254                                     break;
2255                                 case MXF_FIELD_DOMINANCE_FL:
2256                                     st->codecpar->field_order = AV_FIELD_TB;
2257                                     break;
2258                                 default:
2259                                     avpriv_request_sample(mxf->fc,
2260                                                           "Field dominance %d support",
2261                                                           descriptor->field_dominance);
2262                             }
2263                         } else {
2264                             switch (descriptor->field_dominance) {
2265                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2266                                 case MXF_FIELD_DOMINANCE_FF:
2267                                     st->codecpar->field_order = AV_FIELD_BB;
2268                                     break;
2269                                 case MXF_FIELD_DOMINANCE_FL:
2270                                     st->codecpar->field_order = AV_FIELD_BT;
2271                                     break;
2272                                 default:
2273                                     avpriv_request_sample(mxf->fc,
2274                                                           "Field dominance %d support",
2275                                                           descriptor->field_dominance);
2276                             }
2277                         }
2278                     }
2279                     /* Turn field height into frame height. */
2280                     st->codecpar->height *= 2;
2281                     break;
2282                 default:
2283                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2284             }
2285             if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2286                 st->codecpar->format = descriptor->pix_fmt;
2287                 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2288                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2289                                                   &descriptor->essence_codec_ul);
2290                     st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2291                     if (st->codecpar->format== AV_PIX_FMT_NONE) {
2292                         st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2293                                                                    &descriptor->essence_codec_ul)->id;
2294                         if (!st->codecpar->codec_tag) {
2295                             /* support files created before RP224v10 by defaulting to UYVY422
2296                                if subsampling is 4:2:2 and component depth is 8-bit */
2297                             if (descriptor->horiz_subsampling == 2 &&
2298                                 descriptor->vert_subsampling == 1 &&
2299                                 descriptor->component_depth == 8) {
2300                                 st->codecpar->format = AV_PIX_FMT_UYVY422;
2301                             }
2302                         }
2303                     }
2304                 }
2305             }
2306             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2307             if (material_track->sequence->origin) {
2308                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2309             }
2310             if (source_track->sequence->origin) {
2311                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2312             }
2313             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2314                 st->display_aspect_ratio = descriptor->aspect_ratio;
2315         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2316             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2317             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2318             if (st->codecpar->codec_id == AV_CODEC_ID_NONE || (st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
2319                 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2320             st->codecpar->channels = descriptor->channels;
2321             st->codecpar->bits_per_coded_sample = descriptor->bits_per_sample;
2322
2323             if (descriptor->sample_rate.den > 0) {
2324                 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2325                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2326             } else {
2327                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2328                        "found for stream #%d, time base forced to 1/48000\n",
2329                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2330                        st->index);
2331                 avpriv_set_pts_info(st, 64, 1, 48000);
2332             }
2333
2334             /* if duration is set, rescale it from EditRate to SampleRate */
2335             if (st->duration != AV_NOPTS_VALUE)
2336                 st->duration = av_rescale_q(st->duration,
2337                                             av_inv_q(material_track->edit_rate),
2338                                             st->time_base);
2339
2340             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2341             if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2342                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2343                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2344                 else if (descriptor->bits_per_sample == 32)
2345                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2346             } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2347                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2348                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2349                 else if (descriptor->bits_per_sample == 32)
2350                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2351             } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2352                 st->need_parsing = AVSTREAM_PARSE_FULL;
2353             }
2354         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2355             enum AVMediaType type;
2356             container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2357             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2358                 st->codecpar->codec_id = container_ul->id;
2359             type = avcodec_get_type(st->codecpar->codec_id);
2360             if (type == AVMEDIA_TYPE_SUBTITLE)
2361                 st->codecpar->codec_type = type;
2362             if (container_ul->desc)
2363                 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2364         }
2365         if (descriptor->extradata) {
2366             if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2367                 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2368             }
2369         } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2370             int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2371                                                &descriptor->essence_codec_ul)->id;
2372             if (coded_width)
2373                 st->codecpar->width = coded_width;
2374             ret = ff_generate_avci_extradata(st);
2375             if (ret < 0)
2376                 return ret;
2377         }
2378         if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2379             /* TODO: decode timestamps */
2380             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2381         }
2382     }
2383
2384     ret = 0;
2385 fail_and_free:
2386     return ret;
2387 }
2388
2389 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2390 {
2391     struct tm time = { 0 };
2392     time.tm_year = (timestamp >> 48) - 1900;
2393     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2394     time.tm_mday = (timestamp >> 32 & 0xFF);
2395     time.tm_hour = (timestamp >> 24 & 0xFF);
2396     time.tm_min  = (timestamp >> 16 & 0xFF);
2397     time.tm_sec  = (timestamp >> 8  & 0xFF);
2398
2399     /* msvcrt versions of strftime calls the invalid parameter handler
2400      * (aborting the process if one isn't set) if the parameters are out
2401      * of range. */
2402     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2403     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2404     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2405     time.tm_min  = av_clip(time.tm_min,  0, 59);
2406     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2407
2408     return (int64_t)av_timegm(&time) * 1000000;
2409 }
2410
2411 #define SET_STR_METADATA(pb, name, str) do { \
2412     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2413         return ret; \
2414     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2415 } while (0)
2416
2417 #define SET_UID_METADATA(pb, name, var, str) do { \
2418     avio_read(pb, var, 16); \
2419     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2420         return ret; \
2421     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2422 } while (0)
2423
2424 #define SET_TS_METADATA(pb, name, var, str) do { \
2425     var = avio_rb64(pb); \
2426     if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2427         return ret; \
2428 } while (0)
2429
2430 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2431 {
2432     MXFContext *mxf = arg;
2433     AVFormatContext *s = mxf->fc;
2434     int ret;
2435     UID uid = { 0 };
2436     char *str = NULL;
2437     uint64_t ts;
2438     switch (tag) {
2439     case 0x3C01:
2440         SET_STR_METADATA(pb, "company_name", str);
2441         break;
2442     case 0x3C02:
2443         SET_STR_METADATA(pb, "product_name", str);
2444         break;
2445     case 0x3C04:
2446         SET_STR_METADATA(pb, "product_version", str);
2447         break;
2448     case 0x3C05:
2449         SET_UID_METADATA(pb, "product_uid", uid, str);
2450         break;
2451     case 0x3C06:
2452         SET_TS_METADATA(pb, "modification_date", ts, str);
2453         break;
2454     case 0x3C08:
2455         SET_STR_METADATA(pb, "application_platform", str);
2456         break;
2457     case 0x3C09:
2458         SET_UID_METADATA(pb, "generation_uid", uid, str);
2459         break;
2460     case 0x3C0A:
2461         SET_UID_METADATA(pb, "uid", uid, str);
2462         break;
2463     }
2464     return 0;
2465 }
2466
2467 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2468 {
2469     MXFContext *mxf = arg;
2470     AVFormatContext *s = mxf->fc;
2471     int ret;
2472     char *str = NULL;
2473
2474     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2475         SET_STR_METADATA(pb, "project_name", str);
2476     }
2477     return 0;
2478 }
2479
2480 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2481     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2482     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2483     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2484     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2485     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2486     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2487     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2488     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2489     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2490     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2491     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2492     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2493     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2494     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2495     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2496     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2497     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2498     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2499     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2500     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2501     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2502     { { 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 */
2503     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2504     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2505     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2506     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2507     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2508     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5b,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VBI - SMPTE 436M */
2509     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VANC/VBI - SMPTE 436M */
2510     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2511     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x64,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* DC Timed Text Descriptor */
2512     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2513     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2514     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2515     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2516     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2517     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2518     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2519     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2520 };
2521
2522 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2523 {
2524     switch (type){
2525     case MultipleDescriptor:
2526     case Descriptor:
2527         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2528         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2529         break;
2530     default:
2531         break;
2532     }
2533     return 0;
2534 }
2535
2536 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2537 {
2538     AVIOContext *pb = mxf->fc->pb;
2539     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2540     uint64_t klv_end = avio_tell(pb) + klv->length;
2541
2542     if (!ctx)
2543         return AVERROR(ENOMEM);
2544     mxf_metadataset_init(ctx, type);
2545     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2546         int ret;
2547         int tag = avio_rb16(pb);
2548         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2549         uint64_t next = avio_tell(pb) + size;
2550         UID uid = {0};
2551
2552         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2553         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2554             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2555             continue;
2556         }
2557         if (tag > 0x7FFF) { /* dynamic tag */
2558             int i;
2559             for (i = 0; i < mxf->local_tags_count; i++) {
2560                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2561                 if (local_tag == tag) {
2562                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2563                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2564                     PRINT_KEY(mxf->fc, "uid", uid);
2565                 }
2566             }
2567         }
2568         if (ctx_size && tag == 0x3C0A) {
2569             avio_read(pb, ctx->uid, 16);
2570         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2571             mxf_free_metadataset(&ctx, !!ctx_size);
2572             return ret;
2573         }
2574
2575         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2576          * it extending past the end of the KLV though (zzuf5.mxf). */
2577         if (avio_tell(pb) > klv_end) {
2578             if (ctx_size) {
2579                 ctx->type = type;
2580                 mxf_free_metadataset(&ctx, !!ctx_size);
2581             }
2582
2583             av_log(mxf->fc, AV_LOG_ERROR,
2584                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2585                    tag, klv->offset);
2586             return AVERROR_INVALIDDATA;
2587         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2588             avio_seek(pb, next, SEEK_SET);
2589     }
2590     if (ctx_size) ctx->type = type;
2591     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2592 }
2593
2594 /**
2595  * Matches any partition pack key, in other words:
2596  * - HeaderPartition
2597  * - BodyPartition
2598  * - FooterPartition
2599  * @return non-zero if the key is a partition pack key, zero otherwise
2600  */
2601 static int mxf_is_partition_pack_key(UID key)
2602 {
2603     //NOTE: this is a little lax since it doesn't constraint key[14]
2604     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2605             key[13] >= 2 && key[13] <= 4;
2606 }
2607
2608 /**
2609  * Parses a metadata KLV
2610  * @return <0 on error, 0 otherwise
2611  */
2612 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2613                                      int ctx_size, enum MXFMetadataSetType type)
2614 {
2615     AVFormatContext *s = mxf->fc;
2616     int res;
2617     if (klv.key[5] == 0x53) {
2618         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2619     } else {
2620         uint64_t next = avio_tell(s->pb) + klv.length;
2621         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2622
2623         /* only seek forward, else this can loop for a long time */
2624         if (avio_tell(s->pb) > next) {
2625             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2626                    klv.offset);
2627             return AVERROR_INVALIDDATA;
2628         }
2629
2630         avio_seek(s->pb, next, SEEK_SET);
2631     }
2632     if (res < 0) {
2633         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2634         return res;
2635     }
2636     return 0;
2637 }
2638
2639 /**
2640  * Seeks to the previous partition and parses it, if possible
2641  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2642  */
2643 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2644 {
2645     AVIOContext *pb = mxf->fc->pb;
2646     KLVPacket klv;
2647     int64_t current_partition_ofs;
2648     int ret;
2649
2650     if (!mxf->current_partition ||
2651         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2652         return 0;   /* we've parsed all partitions */
2653
2654     /* seek to previous partition */
2655     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2656     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2657     mxf->current_partition = NULL;
2658
2659     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2660
2661     /* Make sure this is actually a PartitionPack, and if so parse it.
2662      * See deadlock2.mxf
2663      */
2664     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2665         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2666         return ret;
2667     }
2668
2669     if (!mxf_is_partition_pack_key(klv.key)) {
2670         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2671         return AVERROR_INVALIDDATA;
2672     }
2673
2674     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2675      * can point to just before the current partition, causing klv_read_packet()
2676      * to sync back up to it. See deadlock3.mxf
2677      */
2678     if (klv.offset >= current_partition_ofs) {
2679         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2680                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2681         return AVERROR_INVALIDDATA;
2682     }
2683
2684     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2685         return ret;
2686
2687     return 1;
2688 }
2689
2690 /**
2691  * Called when essence is encountered
2692  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2693  */
2694 static int mxf_parse_handle_essence(MXFContext *mxf)
2695 {
2696     AVIOContext *pb = mxf->fc->pb;
2697     int64_t ret;
2698
2699     if (mxf->parsing_backward) {
2700         return mxf_seek_to_previous_partition(mxf);
2701     } else {
2702         if (!mxf->footer_partition) {
2703             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2704             return 0;
2705         }
2706
2707         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2708
2709         /* remember where we were so we don't end up seeking further back than this */
2710         mxf->last_forward_tell = avio_tell(pb);
2711
2712         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2713             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2714             return -1;
2715         }
2716
2717         /* seek to FooterPartition and parse backward */
2718         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2719             av_log(mxf->fc, AV_LOG_ERROR,
2720                    "failed to seek to FooterPartition @ 0x%" PRIx64
2721                    " (%"PRId64") - partial file?\n",
2722                    mxf->run_in + mxf->footer_partition, ret);
2723             return ret;
2724         }
2725
2726         mxf->current_partition = NULL;
2727         mxf->parsing_backward = 1;
2728     }
2729
2730     return 1;
2731 }
2732
2733 /**
2734  * Called when the next partition or EOF is encountered
2735  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2736  */
2737 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2738 {
2739     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2740 }
2741
2742 /**
2743  * Figures out the proper offset and length of the essence container in each partition
2744  */
2745 static void mxf_compute_essence_containers(MXFContext *mxf)
2746 {
2747     int x;
2748
2749     /* everything is already correct */
2750     if (mxf->op == OPAtom)
2751         return;
2752
2753     for (x = 0; x < mxf->partitions_count; x++) {
2754         MXFPartition *p = &mxf->partitions[x];
2755
2756         if (!p->body_sid)
2757             continue;       /* BodySID == 0 -> no essence */
2758
2759         if (x >= mxf->partitions_count - 1)
2760             break;          /* FooterPartition - can't compute length (and we don't need to) */
2761
2762         /* essence container spans to the next partition */
2763         p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2764
2765         if (p->essence_length < 0) {
2766             /* next ThisPartition < essence_offset */
2767             p->essence_length = 0;
2768             av_log(mxf->fc, AV_LOG_ERROR,
2769                    "partition %i: bad ThisPartition = %"PRIX64"\n",
2770                    x+1, mxf->partitions[x+1].this_partition);
2771         }
2772     }
2773 }
2774
2775 static int64_t round_to_kag(int64_t position, int kag_size)
2776 {
2777     /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2778     /* NOTE: kag_size may be any integer between 1 - 2^10 */
2779     int64_t ret = (position / kag_size) * kag_size;
2780     return ret == position ? ret : ret + kag_size;
2781 }
2782
2783 static int is_pcm(enum AVCodecID codec_id)
2784 {
2785     /* we only care about "normal" PCM codecs until we get samples */
2786     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2787 }
2788
2789 static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
2790 {
2791     int i;
2792
2793     if (mxf->op != OPAtom)
2794         return NULL;
2795
2796     for (i = 0; i < mxf->fc->nb_streams; i++) {
2797         if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2798             continue;
2799         return mxf->fc->streams[i];
2800     }
2801     return NULL;
2802 }
2803
2804 /**
2805  * Deal with the case where for some audio atoms EditUnitByteCount is
2806  * very small (2, 4..). In those cases we should read more than one
2807  * sample per call to mxf_read_packet().
2808  */
2809 static void mxf_handle_small_eubc(AVFormatContext *s)
2810 {
2811     MXFContext *mxf = s->priv_data;
2812     MXFTrack *track;
2813
2814     /* assuming non-OPAtom == frame wrapped
2815      * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2816     AVStream *st = mxf_get_opatom_stream(mxf);
2817     if (!st)
2818         return;
2819
2820     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2821     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
2822         !is_pcm(st->codecpar->codec_id)                        ||
2823         mxf->nb_index_tables != 1                              ||
2824         mxf->index_tables[0].nb_segments != 1                  ||
2825         mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2826         return;
2827
2828     /* arbitrarily default to 48 kHz PAL audio frame size */
2829     /* TODO: We could compute this from the ratio between the audio
2830      *       and video edit rates for 48 kHz NTSC we could use the
2831      *       1802-1802-1802-1802-1801 pattern. */
2832     track = st->priv_data;
2833     mxf->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
2834 }
2835
2836 /**
2837  * Deal with the case where OPAtom files does not have any IndexTableSegments.
2838  */
2839 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2840 {
2841     AVFormatContext *s = mxf->fc;
2842     AVStream *st = NULL;
2843     MXFIndexTableSegment *segment = NULL;
2844     MXFPartition *p = NULL;
2845     int essence_partition_count = 0;
2846     int i, ret;
2847
2848     st = mxf_get_opatom_stream(mxf);
2849     if (!st)
2850         return 0;
2851
2852     /* TODO: support raw video without an index if they exist */
2853     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id))
2854         return 0;
2855
2856     /* check if file already has a IndexTableSegment */
2857     for (i = 0; i < mxf->metadata_sets_count; i++) {
2858         if (mxf->metadata_sets[i]->type == IndexTableSegment)
2859             return 0;
2860     }
2861
2862     /* find the essence partition */
2863     for (i = 0; i < mxf->partitions_count; i++) {
2864         /* BodySID == 0 -> no essence */
2865         if (!mxf->partitions[i].body_sid)
2866             continue;
2867
2868         p = &mxf->partitions[i];
2869         essence_partition_count++;
2870     }
2871
2872     /* only handle files with a single essence partition */
2873     if (essence_partition_count != 1)
2874         return 0;
2875
2876     if (!(segment = av_mallocz(sizeof(*segment))))
2877         return AVERROR(ENOMEM);
2878
2879     if ((ret = mxf_add_metadata_set(mxf, segment))) {
2880         mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2881         return ret;
2882     }
2883
2884     segment->type = IndexTableSegment;
2885     /* stream will be treated as small EditUnitByteCount */
2886     segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2887     segment->index_start_position = 0;
2888     segment->index_duration = s->streams[0]->duration;
2889     segment->index_sid = p->index_sid;
2890     segment->body_sid = p->body_sid;
2891     return 0;
2892 }
2893
2894 static void mxf_read_random_index_pack(AVFormatContext *s)
2895 {
2896     MXFContext *mxf = s->priv_data;
2897     uint32_t length;
2898     int64_t file_size, max_rip_length, min_rip_length;
2899     KLVPacket klv;
2900
2901     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2902         return;
2903
2904     file_size = avio_size(s->pb);
2905
2906     /* S377m says to check the RIP length for "silly" values, without defining "silly".
2907      * The limit below assumes a file with nothing but partition packs and a RIP.
2908      * Before changing this, consider that a muxer may place each sample in its own partition.
2909      *
2910      * 105 is the size of the smallest possible PartitionPack
2911      * 12 is the size of each RIP entry
2912      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2913      */
2914     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2915     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2916
2917     /* We're only interested in RIPs with at least two entries.. */
2918     min_rip_length = 16+1+24+4;
2919
2920     /* See S377m section 11 */
2921     avio_seek(s->pb, file_size - 4, SEEK_SET);
2922     length = avio_rb32(s->pb);
2923
2924     if (length < min_rip_length || length > max_rip_length)
2925         goto end;
2926     avio_seek(s->pb, file_size - length, SEEK_SET);
2927     if (klv_read_packet(&klv, s->pb) < 0 ||
2928         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2929         klv.length != length - 20)
2930         goto end;
2931
2932     avio_skip(s->pb, klv.length - 12);
2933     mxf->footer_partition = avio_rb64(s->pb);
2934
2935     /* sanity check */
2936     if (mxf->run_in + mxf->footer_partition >= file_size) {
2937         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2938         mxf->footer_partition = 0;
2939     }
2940
2941 end:
2942     avio_seek(s->pb, mxf->run_in, SEEK_SET);
2943 }
2944
2945 static int mxf_read_header(AVFormatContext *s)
2946 {
2947     MXFContext *mxf = s->priv_data;
2948     KLVPacket klv;
2949     int64_t essence_offset = 0;
2950     int ret;
2951
2952     mxf->last_forward_tell = INT64_MAX;
2953     mxf->edit_units_per_packet = 1;
2954
2955     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2956         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2957         return AVERROR_INVALIDDATA;
2958     }
2959     avio_seek(s->pb, -14, SEEK_CUR);
2960     mxf->fc = s;
2961     mxf->run_in = avio_tell(s->pb);
2962
2963     mxf_read_random_index_pack(s);
2964
2965     while (!avio_feof(s->pb)) {
2966         const MXFMetadataReadTableEntry *metadata;
2967
2968         if (klv_read_packet(&klv, s->pb) < 0) {
2969             /* EOF - seek to previous partition or stop */
2970             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2971                 break;
2972             else
2973                 continue;
2974         }
2975
2976         PRINT_KEY(s, "read header", klv.key);
2977         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2978         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2979             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2980             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2981             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
2982             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
2983
2984             if (!mxf->current_partition) {
2985                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2986                 return AVERROR_INVALIDDATA;
2987             }
2988
2989             if (!mxf->current_partition->essence_offset) {
2990                 /* for OP1a we compute essence_offset
2991                  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2992                  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2993                  *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2994                  */
2995                 int64_t op1a_essence_offset =
2996                     mxf->current_partition->this_partition +
2997                     round_to_kag(mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
2998                     round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2999                     round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);
3000
3001                 if (mxf->op == OPAtom) {
3002                     /* point essence_offset to the actual data
3003                     * OPAtom has all the essence in one big KLV
3004                     */
3005                     mxf->current_partition->essence_offset = avio_tell(s->pb);
3006                     mxf->current_partition->essence_length = klv.length;
3007                 } else {
3008                     /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
3009                     if (IS_KLV_KEY(klv.key, mxf_system_item_key_cp) || IS_KLV_KEY(klv.key, mxf_system_item_key_gc))
3010                         mxf->current_partition->essence_offset = klv.offset;
3011                     else
3012                         mxf->current_partition->essence_offset = op1a_essence_offset;
3013                 }
3014             }
3015
3016             if (!essence_offset)
3017                 essence_offset = klv.offset;
3018
3019             /* seek to footer, previous partition or stop */
3020             if (mxf_parse_handle_essence(mxf) <= 0)
3021                 break;
3022             continue;
3023         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3024             /* next partition pack - keep going, seek to previous partition or stop */
3025             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3026                 break;
3027             else if (mxf->parsing_backward)
3028                 continue;
3029             /* we're still parsing forward. proceed to parsing this partition pack */
3030         }
3031
3032         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3033             if (IS_KLV_KEY(klv.key, metadata->key)) {
3034                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3035                     goto fail;
3036                 break;
3037             }
3038         }
3039         if (!metadata->read) {
3040             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3041                             UID_ARG(klv.key));
3042             avio_skip(s->pb, klv.length);
3043         }
3044     }
3045     /* FIXME avoid seek */
3046     if (!essence_offset)  {
3047         av_log(s, AV_LOG_ERROR, "no essence\n");
3048         ret = AVERROR_INVALIDDATA;
3049         goto fail;
3050     }
3051     avio_seek(s->pb, essence_offset, SEEK_SET);
3052
3053     mxf_compute_essence_containers(mxf);
3054
3055     /* we need to do this before computing the index tables
3056      * to be able to fill in zero IndexDurations with st->duration */
3057     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3058         goto fail;
3059
3060     mxf_handle_missing_index_segment(mxf);
3061     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3062         goto fail;
3063
3064     if (mxf->nb_index_tables > 1) {
3065         /* TODO: look up which IndexSID to use via EssenceContainerData */
3066         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3067                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3068     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
3069         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3070         ret = AVERROR_INVALIDDATA;
3071         goto fail;
3072     }
3073
3074     mxf_handle_small_eubc(s);
3075
3076     return 0;
3077 fail:
3078     mxf_read_close(s);
3079
3080     return ret;
3081 }
3082
3083 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3084 {
3085     int i;
3086     for (i = 0; i < mxf->nb_index_tables; i++)
3087         if (mxf->index_tables[i].index_sid == index_sid)
3088             return &mxf->index_tables[i];
3089     return NULL;
3090 }
3091
3092 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3093 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3094 {
3095     int64_t a, b, m, offset;
3096     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3097
3098     if (!t || track->original_duration <= 0)
3099         return -1;
3100
3101     a = -1;
3102     b = track->original_duration;
3103
3104     while (b - a > 1) {
3105         m = (a + b) >> 1;
3106         if (mxf_edit_unit_absolute_offset(mxf, t, m, NULL, &offset, 0) < 0)
3107             return -1;
3108         if (offset < current_offset)
3109             a = m;
3110         else
3111             b = m;
3112     }
3113
3114     *edit_unit_out = b;
3115
3116     return 0;
3117 }
3118
3119 /**
3120  * Sets mxf->current_edit_unit based on what offset we're currently at.
3121  * @return next_ofs if OK, <0 on error
3122  */
3123 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
3124 {
3125     int64_t last_ofs = -1, next_ofs = -1;
3126     MXFIndexTable *t = &mxf->index_tables[0];
3127
3128     /* this is called from the OP1a demuxing logic, which means there
3129      * may be no index tables */
3130     if (mxf->nb_index_tables <= 0)
3131         return -1;
3132
3133     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
3134     while (mxf->current_edit_unit >= 0) {
3135         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
3136             return -2;
3137
3138         if (next_ofs <= last_ofs) {
3139             /* large next_ofs didn't change or current_edit_unit wrapped
3140              * around this fixes the infinite loop on zzuf3.mxf */
3141             av_log(mxf->fc, AV_LOG_ERROR,
3142                    "next_ofs didn't change. not deriving packet timestamps\n");
3143             return -1;
3144         }
3145
3146         if (next_ofs > current_offset)
3147             break;
3148
3149         last_ofs = next_ofs;
3150         mxf->current_edit_unit++;
3151     }
3152
3153     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
3154     if (mxf->current_edit_unit < 0)
3155         return -1;
3156
3157     return next_ofs;
3158 }
3159
3160 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
3161                                     uint64_t *sample_count)
3162 {
3163     int i, total = 0, size = 0;
3164     AVStream *st = mxf->fc->streams[stream_index];
3165     MXFTrack *track = st->priv_data;
3166     AVRational time_base = av_inv_q(track->edit_rate);
3167     AVRational sample_rate = av_inv_q(st->time_base);
3168     const MXFSamplesPerFrame *spf = NULL;
3169
3170     if ((sample_rate.num / sample_rate.den) == 48000)
3171         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3172     if (!spf) {
3173         int remainder = (sample_rate.num * time_base.num) %
3174                         (time_base.den * sample_rate.den);
3175         *sample_count = av_rescale_q(mxf->current_edit_unit, sample_rate, track->edit_rate);
3176         if (remainder)
3177             av_log(mxf->fc, AV_LOG_WARNING,
3178                    "seeking detected on stream #%d with time base (%d/%d) and "
3179                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3180                    stream_index, time_base.num, time_base.den,
3181                    sample_rate.num, sample_rate.den);
3182         return 0;
3183     }
3184
3185     while (spf->samples_per_frame[size]) {
3186         total += spf->samples_per_frame[size];
3187         size++;
3188     }
3189
3190     av_assert2(size);
3191
3192     *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
3193     for (i = 0; i < mxf->current_edit_unit % size; i++) {
3194         *sample_count += spf->samples_per_frame[i];
3195     }
3196
3197     return 0;
3198 }
3199
3200 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3201                              AVPacket *pkt)
3202 {
3203     MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3204     int64_t bits_per_sample = par->bits_per_coded_sample;
3205
3206     if (!bits_per_sample)
3207         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3208
3209     pkt->pts = track->sample_count;
3210
3211     if (   par->channels <= 0
3212         || bits_per_sample <= 0
3213         || par->channels * (int64_t)bits_per_sample < 8)
3214         return AVERROR(EINVAL);
3215     track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3216     return 0;
3217 }
3218
3219 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
3220 {
3221     AVCodecParameters *par = st->codecpar;
3222     MXFTrack *track = st->priv_data;
3223
3224     if (par->codec_type == AVMEDIA_TYPE_VIDEO && (next_ofs >= 0 || next_ofs == -2 && st->duration == mxf->current_edit_unit + 1)) {
3225         /* mxf->current_edit_unit good - see if we have an
3226          * index table to derive timestamps from */
3227         MXFIndexTable *t = &mxf->index_tables[0];
3228
3229         if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3230             pkt->dts = mxf->current_edit_unit + t->first_dts;
3231             pkt->pts = t->ptses[mxf->current_edit_unit];
3232         } else if (track->intra_only) {
3233             /* intra-only -> PTS = EditUnit.
3234              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3235             pkt->pts = mxf->current_edit_unit;
3236         }
3237     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3238         int ret = mxf_set_audio_pts(mxf, par, pkt);
3239         if (ret < 0)
3240             return ret;
3241     }
3242     return 0;
3243 }
3244
3245 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
3246 {
3247     KLVPacket klv;
3248     MXFContext *mxf = s->priv_data;
3249     int ret;
3250
3251     while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3252         PRINT_KEY(s, "read packet", klv.key);
3253         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3254         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3255             ret = mxf_decrypt_triplet(s, pkt, &klv);
3256             if (ret < 0) {
3257                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3258                 return ret;
3259             }
3260             return 0;
3261         }
3262         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3263             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3264             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3265             int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3266             int index = mxf_get_stream_index(s, &klv, body_sid);
3267             int64_t next_ofs, next_klv;
3268             AVStream *st;
3269
3270             if (index < 0) {
3271                 av_log(s, AV_LOG_ERROR,
3272                        "error getting stream index %"PRIu32"\n",
3273                        AV_RB32(klv.key + 12));
3274                 goto skip;
3275             }
3276
3277             st = s->streams[index];
3278
3279             if (s->streams[index]->discard == AVDISCARD_ALL)
3280                 goto skip;
3281
3282             next_klv = avio_tell(s->pb) + klv.length;
3283             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3284
3285             if (next_ofs >= 0 && next_klv > next_ofs) {
3286                 /* if this check is hit then it's possible OPAtom was treated as OP1a
3287                  * truncate the packet since it's probably very large (>2 GiB is common) */
3288                 avpriv_request_sample(s,
3289                                       "OPAtom misinterpreted as OP1a? "
3290                                       "KLV for edit unit %"PRId64" extending into "
3291                                       "next edit unit",
3292                                       mxf->current_edit_unit);
3293                 klv.length = next_ofs - avio_tell(s->pb);
3294             }
3295
3296             /* check for 8 channels AES3 element */
3297             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3298                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3299                                               pkt, klv.length);
3300                 if (ret < 0) {
3301                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3302                     return ret;
3303                 }
3304             } else {
3305                 ret = av_get_packet(s->pb, pkt, klv.length);
3306                 if (ret < 0)
3307                     return ret;
3308             }
3309             pkt->stream_index = index;
3310             pkt->pos = klv.offset;
3311
3312             ret = mxf_set_pts(mxf, st, pkt, next_ofs);
3313             if (ret < 0)
3314                 return ret;
3315
3316             /* seek for truncated packets */
3317             avio_seek(s->pb, next_klv, SEEK_SET);
3318
3319             return 0;
3320         } else
3321         skip:
3322             avio_skip(s->pb, klv.length);
3323     }
3324     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3325 }
3326
3327 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3328 {
3329     MXFContext *mxf = s->priv_data;
3330     int ret, size;
3331     int64_t ret64, pos, next_pos;
3332     AVStream *st;
3333     MXFIndexTable *t;
3334     MXFTrack *track;
3335     int edit_units;
3336
3337     if (mxf->op != OPAtom)
3338         return mxf_read_packet_old(s, pkt);
3339
3340     // If we have no streams then we basically are at EOF
3341     st = mxf_get_opatom_stream(mxf);
3342     if (!st)
3343         return AVERROR_EOF;
3344
3345     track = st->priv_data;
3346
3347     /* OPAtom - clip wrapped demuxing */
3348     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3349     t = &mxf->index_tables[0];
3350
3351     if (mxf->current_edit_unit >= track->original_duration)
3352         return AVERROR_EOF;
3353
3354     edit_units = FFMIN(mxf->edit_units_per_packet, track->original_duration - mxf->current_edit_unit);
3355
3356     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3357         return ret;
3358
3359     /* compute size by finding the next edit unit or the end of the essence container
3360      * not pretty, but it works */
3361     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3362         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3363         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3364         return AVERROR_INVALIDDATA;
3365     }
3366
3367     if ((size = next_pos - pos) <= 0) {
3368         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3369         return AVERROR_INVALIDDATA;
3370     }
3371
3372     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3373         return ret64;
3374
3375     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3376         return size;
3377
3378     pkt->stream_index = st->index;
3379
3380     ret = mxf_set_pts(mxf, st, pkt, next_pos);
3381     if (ret < 0)
3382         return ret;
3383
3384     mxf->current_edit_unit += edit_units;
3385
3386     return 0;
3387 }
3388
3389 static int mxf_read_close(AVFormatContext *s)
3390 {
3391     MXFContext *mxf = s->priv_data;
3392     int i;
3393
3394     av_freep(&mxf->packages_refs);
3395     av_freep(&mxf->essence_container_data_refs);
3396
3397     for (i = 0; i < s->nb_streams; i++)
3398         s->streams[i]->priv_data = NULL;
3399
3400     for (i = 0; i < mxf->metadata_sets_count; i++) {
3401         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3402     }
3403     av_freep(&mxf->partitions);
3404     av_freep(&mxf->metadata_sets);
3405     av_freep(&mxf->aesc);
3406     av_freep(&mxf->local_tags);
3407
3408     if (mxf->index_tables) {
3409         for (i = 0; i < mxf->nb_index_tables; i++) {
3410             av_freep(&mxf->index_tables[i].segments);
3411             av_freep(&mxf->index_tables[i].ptses);
3412             av_freep(&mxf->index_tables[i].fake_index);
3413             av_freep(&mxf->index_tables[i].offsets);
3414         }
3415     }
3416     av_freep(&mxf->index_tables);
3417
3418     return 0;
3419 }
3420
3421 static int mxf_probe(AVProbeData *p) {
3422     const uint8_t *bufp = p->buf;
3423     const uint8_t *end = p->buf + p->buf_size;
3424
3425     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3426         return 0;
3427
3428     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3429     end -= sizeof(mxf_header_partition_pack_key);
3430
3431     for (; bufp < end;) {
3432         if (!((bufp[13] - 1) & 0xF2)){
3433             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3434                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3435                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3436                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3437                 return AVPROBE_SCORE_MAX;
3438             bufp ++;
3439         } else
3440             bufp += 10;
3441     }
3442
3443     return 0;
3444 }
3445
3446 /* rudimentary byte seek */
3447 /* XXX: use MXF Index */
3448 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3449 {
3450     AVStream *st = s->streams[stream_index];
3451     int64_t seconds;
3452     MXFContext* mxf = s->priv_data;
3453     int64_t seekpos;
3454     int i, ret;
3455     MXFIndexTable *t;
3456     MXFTrack *source_track = st->priv_data;
3457
3458     if (!source_track)
3459         return 0;
3460
3461     /* if audio then truncate sample_time to EditRate */
3462     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3463         sample_time = av_rescale_q(sample_time, st->time_base,
3464                                    av_inv_q(source_track->edit_rate));
3465
3466     if (mxf->nb_index_tables <= 0) {
3467         if (!s->bit_rate)
3468             return AVERROR_INVALIDDATA;
3469         if (sample_time < 0)
3470             sample_time = 0;
3471         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3472
3473         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3474         if (seekpos < 0)
3475             return seekpos;
3476
3477         ff_update_cur_dts(s, st, sample_time);
3478         mxf->current_edit_unit = sample_time;
3479     } else {
3480         t = &mxf->index_tables[0];
3481         if (t->index_sid != source_track->index_sid) {
3482             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3483             for (i = 0; i < s->nb_streams; i++) {
3484                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3485                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3486                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3487                     source_track = new_source_track;
3488                     st = s->streams[i];
3489                     break;
3490                 }
3491             }
3492             if (i == s->nb_streams)
3493                 return AVERROR_INVALIDDATA;
3494         }
3495
3496         /* clamp above zero, else ff_index_search_timestamp() returns negative
3497          * this also means we allow seeking before the start */
3498         sample_time = FFMAX(sample_time, 0);
3499
3500         if (t->fake_index) {
3501             /* The first frames may not be keyframes in presentation order, so
3502              * we have to advance the target to be able to find the first
3503              * keyframe backwards... */
3504             if (!(flags & AVSEEK_FLAG_ANY) &&
3505                 (flags & AVSEEK_FLAG_BACKWARD) &&
3506                 t->ptses[0] != AV_NOPTS_VALUE &&
3507                 sample_time < t->ptses[0] &&
3508                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3509                 sample_time = t->ptses[0];
3510
3511             /* behave as if we have a proper index */
3512             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3513                 return sample_time;
3514             /* get the stored order index from the display order index */
3515             sample_time += t->offsets[sample_time];
3516         } else {
3517             /* no IndexEntryArray (one or more CBR segments)
3518              * make sure we don't seek past the end */
3519             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3520         }
3521
3522         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3523             return ret;
3524
3525         ff_update_cur_dts(s, st, sample_time);
3526         mxf->current_edit_unit = sample_time;
3527         avio_seek(s->pb, seekpos, SEEK_SET);
3528     }
3529
3530     // Update all tracks sample count
3531     for (i = 0; i < s->nb_streams; i++) {
3532         AVStream *cur_st = s->streams[i];
3533         MXFTrack *cur_track = cur_st->priv_data;
3534         if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3535             int64_t track_edit_unit;
3536             if (st != cur_st && mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit) >= 0) {
3537                 cur_track->sample_count = av_rescale_q(track_edit_unit,
3538                                                        av_inv_q(cur_track->edit_rate),
3539                                                        cur_st->time_base);
3540             } else {
3541                 uint64_t current_sample_count = 0;
3542                 ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
3543                 if (ret < 0)
3544                     return ret;
3545                 cur_track->sample_count = current_sample_count;
3546             }
3547         }
3548     }
3549     return 0;
3550 }
3551
3552 AVInputFormat ff_mxf_demuxer = {
3553     .name           = "mxf",
3554     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3555     .flags          = AVFMT_SEEK_TO_PTS,
3556     .priv_data_size = sizeof(MXFContext),
3557     .read_probe     = mxf_probe,
3558     .read_header    = mxf_read_header,
3559     .read_packet    = mxf_read_packet,
3560     .read_close     = mxf_read_close,
3561     .read_seek      = mxf_read_seek,
3562 };