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