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