avformat/mxfdec: add support for determining essence wrapping scheme
[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,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15 }, /* MPEG-ES */
1245     { { 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 */
1246     { { 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 */
1247     { { 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 */
1248     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15,     AV_CODEC_ID_HQ_HQA },
1249     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15,        AV_CODEC_ID_HQX },
1250     { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14,   AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1251     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1252 };
1253
1254 /* EC ULs for intra-only formats */
1255 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1256     { { 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 */
1257     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1258 };
1259
1260 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1261 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1262     { { 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 */
1263     { { 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 */
1264     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1265 };
1266
1267 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1268 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1269     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1270     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1271     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1272     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1273     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,    0 },
1274 };
1275
1276 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1277     // sound essence container uls
1278     { { 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 */
1279     { { 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 */
1280     { { 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 */
1281     { { 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 */
1282     { { 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) */
1283     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1284 };
1285
1286 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1287     { { 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 },
1288     { { 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 },
1289     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1290     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0, AV_CODEC_ID_NONE },
1291 };
1292
1293 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1294 {
1295     int val;
1296     const MXFCodecUL *codec_ul;
1297
1298     codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1299     if (!codec_ul->uid[0])
1300         codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1301     if (!codec_ul->uid[0])
1302         codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1303     if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1304         return UnknownWrapped;
1305
1306     val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1307     switch (codec_ul->wrapping_indicator_type) {
1308         case RawVWrap:
1309             val = val % 4;
1310             break;
1311         case RawAWrap:
1312             if (val == 0x03 || val == 0x04)
1313                 val -= 0x02;
1314             break;
1315         case D10D11Wrap:
1316             if (val == 0x02)
1317                 val = 0x01;
1318             break;
1319     }
1320     if (val == 0x01)
1321         return FrameWrapped;
1322     if (val == 0x02)
1323         return ClipWrapped;
1324     return UnknownWrapped;
1325 }
1326
1327 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1328 {
1329     int i, j, nb_segments = 0;
1330     MXFIndexTableSegment **unsorted_segments;
1331     int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1332
1333     /* count number of segments, allocate arrays and copy unsorted segments */
1334     for (i = 0; i < mxf->metadata_sets_count; i++)
1335         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1336             nb_segments++;
1337
1338     if (!nb_segments)
1339         return AVERROR_INVALIDDATA;
1340
1341     if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1342         !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1343         av_freep(sorted_segments);
1344         av_free(unsorted_segments);
1345         return AVERROR(ENOMEM);
1346     }
1347
1348     for (i = j = 0; i < mxf->metadata_sets_count; i++)
1349         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1350             unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1351
1352     *nb_sorted_segments = 0;
1353
1354     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1355     for (i = 0; i < nb_segments; i++) {
1356         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1357         uint64_t best_index_duration = 0;
1358
1359         for (j = 0; j < nb_segments; j++) {
1360             MXFIndexTableSegment *s = unsorted_segments[j];
1361
1362             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1363              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1364              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1365              */
1366             if ((i == 0 ||
1367                  s->body_sid >  last_body_sid ||
1368                  s->body_sid == last_body_sid && s->index_sid >  last_index_sid ||
1369                  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1370                 (best == -1 ||
1371                  s->body_sid <  best_body_sid ||
1372                  s->body_sid == best_body_sid && s->index_sid <  best_index_sid ||
1373                  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position <  best_index_start ||
1374                  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)) {
1375                 best             = j;
1376                 best_body_sid    = s->body_sid;
1377                 best_index_sid   = s->index_sid;
1378                 best_index_start = s->index_start_position;
1379                 best_index_duration = s->index_duration;
1380             }
1381         }
1382
1383         /* no suitable entry found -> we're done */
1384         if (best == -1)
1385             break;
1386
1387         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1388         last_body_sid    = best_body_sid;
1389         last_index_sid   = best_index_sid;
1390         last_index_start = best_index_start;
1391     }
1392
1393     av_free(unsorted_segments);
1394
1395     return 0;
1396 }
1397
1398 /**
1399  * Computes the absolute file offset of the given essence container offset
1400  */
1401 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1402 {
1403     MXFPartition *last_p = NULL;
1404     int a, b, m, m0;
1405
1406     if (offset < 0)
1407         return AVERROR(EINVAL);
1408
1409     a = -1;
1410     b = mxf->partitions_count;
1411
1412     while (b - a > 1) {
1413         m0 = m = (a + b) >> 1;
1414
1415         while (m < b && mxf->partitions[m].body_sid != body_sid)
1416             m++;
1417
1418         if (m < b && mxf->partitions[m].body_offset <= offset)
1419             a = m;
1420         else
1421             b = m0;
1422     }
1423
1424     if (a >= 0)
1425         last_p = &mxf->partitions[a];
1426
1427     if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1428         *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1429         return 0;
1430     }
1431
1432     av_log(mxf->fc, AV_LOG_ERROR,
1433            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1434            offset, body_sid);
1435
1436     return AVERROR_INVALIDDATA;
1437 }
1438
1439 /**
1440  * Returns the end position of the essence container with given BodySID, or zero if unknown
1441  */
1442 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1443 {
1444     int x;
1445     int64_t ret = 0;
1446
1447     for (x = 0; x < mxf->partitions_count; x++) {
1448         MXFPartition *p = &mxf->partitions[x];
1449
1450         if (p->body_sid != body_sid)
1451             continue;
1452
1453         if (!p->essence_length)
1454             return 0;
1455
1456         ret = p->essence_offset + p->essence_length;
1457     }
1458
1459     return ret;
1460 }
1461
1462 /* EditUnit -> absolute offset */
1463 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)
1464 {
1465     int i;
1466     int64_t offset_temp = 0;
1467
1468     for (i = 0; i < index_table->nb_segments; i++) {
1469         MXFIndexTableSegment *s = index_table->segments[i];
1470
1471         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1472
1473         if (edit_unit < s->index_start_position + s->index_duration) {
1474             int64_t index = edit_unit - s->index_start_position;
1475
1476             if (s->edit_unit_byte_count)
1477                 offset_temp += s->edit_unit_byte_count * index;
1478             else if (s->nb_index_entries) {
1479                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1480                     index *= 2;     /* Avid index */
1481
1482                 if (index < 0 || index >= s->nb_index_entries) {
1483                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1484                            index_table->index_sid, s->index_start_position);
1485                     return AVERROR_INVALIDDATA;
1486                 }
1487
1488                 offset_temp = s->stream_offset_entries[index];
1489             } else {
1490                 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1491                        index_table->index_sid, s->index_start_position);
1492                 return AVERROR_INVALIDDATA;
1493             }
1494
1495             if (edit_unit_out)
1496                 *edit_unit_out = edit_unit;
1497
1498             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1499         } else {
1500             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1501             offset_temp += s->edit_unit_byte_count * s->index_duration;
1502         }
1503     }
1504
1505     if (nag)
1506         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);
1507
1508     return AVERROR_INVALIDDATA;
1509 }
1510
1511 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1512 {
1513     int i, j, x;
1514     int8_t max_temporal_offset = -128;
1515     uint8_t *flags;
1516
1517     /* first compute how many entries we have */
1518     for (i = 0; i < index_table->nb_segments; i++) {
1519         MXFIndexTableSegment *s = index_table->segments[i];
1520
1521         if (!s->nb_index_entries) {
1522             index_table->nb_ptses = 0;
1523             return 0;                               /* no TemporalOffsets */
1524         }
1525
1526         index_table->nb_ptses += s->index_duration;
1527     }
1528
1529     /* paranoid check */
1530     if (index_table->nb_ptses <= 0)
1531         return 0;
1532
1533     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1534         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1535         !(index_table->offsets    = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1536         !(flags                   = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1537         av_freep(&index_table->ptses);
1538         av_freep(&index_table->fake_index);
1539         av_freep(&index_table->offsets);
1540         return AVERROR(ENOMEM);
1541     }
1542
1543     /* we may have a few bad TemporalOffsets
1544      * make sure the corresponding PTSes don't have the bogus value 0 */
1545     for (x = 0; x < index_table->nb_ptses; x++)
1546         index_table->ptses[x] = AV_NOPTS_VALUE;
1547
1548     /**
1549      * We have this:
1550      *
1551      * x  TemporalOffset
1552      * 0:  0
1553      * 1:  1
1554      * 2:  1
1555      * 3: -2
1556      * 4:  1
1557      * 5:  1
1558      * 6: -2
1559      *
1560      * We want to transform it into this:
1561      *
1562      * x  DTS PTS
1563      * 0: -1   0
1564      * 1:  0   3
1565      * 2:  1   1
1566      * 3:  2   2
1567      * 4:  3   6
1568      * 5:  4   4
1569      * 6:  5   5
1570      *
1571      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1572      * then settings mxf->first_dts = -max(TemporalOffset[x]).
1573      * The latter makes DTS <= PTS.
1574      */
1575     for (i = x = 0; i < index_table->nb_segments; i++) {
1576         MXFIndexTableSegment *s = index_table->segments[i];
1577         int index_delta = 1;
1578         int n = s->nb_index_entries;
1579
1580         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1581             index_delta = 2;    /* Avid index */
1582             /* ignore the last entry - it's the size of the essence container */
1583             n--;
1584         }
1585
1586         for (j = 0; j < n; j += index_delta, x++) {
1587             int offset = s->temporal_offset_entries[j] / index_delta;
1588             int index  = x + offset;
1589
1590             if (x >= index_table->nb_ptses) {
1591                 av_log(mxf->fc, AV_LOG_ERROR,
1592                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1593                        s->nb_index_entries, s->index_duration);
1594                 break;
1595             }
1596
1597             flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1598
1599             if (index < 0 || index >= index_table->nb_ptses) {
1600                 av_log(mxf->fc, AV_LOG_ERROR,
1601                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1602                        x, offset, index);
1603                 continue;
1604             }
1605
1606             index_table->offsets[x] = offset;
1607             index_table->ptses[index] = x;
1608             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1609         }
1610     }
1611
1612     /* calculate the fake index table in display order */
1613     for (x = 0; x < index_table->nb_ptses; x++) {
1614         index_table->fake_index[x].timestamp = x;
1615         if (index_table->ptses[x] != AV_NOPTS_VALUE)
1616             index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1617     }
1618     av_freep(&flags);
1619
1620     index_table->first_dts = -max_temporal_offset;
1621
1622     return 0;
1623 }
1624
1625 /**
1626  * Sorts and collects index table segments into index tables.
1627  * Also computes PTSes if possible.
1628  */
1629 static int mxf_compute_index_tables(MXFContext *mxf)
1630 {
1631     int i, j, k, ret, nb_sorted_segments;
1632     MXFIndexTableSegment **sorted_segments = NULL;
1633
1634     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1635         nb_sorted_segments <= 0) {
1636         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1637         return 0;
1638     }
1639
1640     /* sanity check and count unique BodySIDs/IndexSIDs */
1641     for (i = 0; i < nb_sorted_segments; i++) {
1642         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1643             mxf->nb_index_tables++;
1644         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1645             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1646             ret = AVERROR_INVALIDDATA;
1647             goto finish_decoding_index;
1648         }
1649     }
1650
1651     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1652                                          sizeof(*mxf->index_tables));
1653     if (!mxf->index_tables) {
1654         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1655         ret = AVERROR(ENOMEM);
1656         goto finish_decoding_index;
1657     }
1658
1659     /* distribute sorted segments to index tables */
1660     for (i = j = 0; i < nb_sorted_segments; i++) {
1661         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1662             /* next IndexSID */
1663             j++;
1664         }
1665
1666         mxf->index_tables[j].nb_segments++;
1667     }
1668
1669     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1670         MXFIndexTable *t = &mxf->index_tables[j];
1671         MXFTrack *mxf_track = NULL;
1672
1673         t->segments = av_mallocz_array(t->nb_segments,
1674                                        sizeof(*t->segments));
1675
1676         if (!t->segments) {
1677             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1678                    " pointer array\n");
1679             ret = AVERROR(ENOMEM);
1680             goto finish_decoding_index;
1681         }
1682
1683         if (sorted_segments[i]->index_start_position)
1684             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1685                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1686
1687         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1688         t->index_sid = sorted_segments[i]->index_sid;
1689         t->body_sid = sorted_segments[i]->body_sid;
1690
1691         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1692             goto finish_decoding_index;
1693
1694         for (k = 0; k < mxf->fc->nb_streams; k++) {
1695             MXFTrack *track = mxf->fc->streams[k]->priv_data;
1696             if (track && track->index_sid == t->index_sid) {
1697                 mxf_track = track;
1698                 break;
1699             }
1700         }
1701
1702         /* fix zero IndexDurations */
1703         for (k = 0; k < t->nb_segments; k++) {
1704             if (t->segments[k]->index_duration)
1705                 continue;
1706
1707             if (t->nb_segments > 1)
1708                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1709                        t->index_sid, k);
1710
1711             if (!mxf_track) {
1712                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1713                 break;
1714             }
1715
1716             /* assume the first stream's duration is reasonable
1717              * leave index_duration = 0 on further segments in case we have any (unlikely)
1718              */
1719             t->segments[k]->index_duration = mxf_track->original_duration;
1720             break;
1721         }
1722     }
1723
1724     ret = 0;
1725 finish_decoding_index:
1726     av_free(sorted_segments);
1727     return ret;
1728 }
1729
1730 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1731 {
1732     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1733                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1734            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1735                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1736 }
1737
1738 static int mxf_uid_to_str(UID uid, char **str)
1739 {
1740     int i;
1741     char *p;
1742     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1743     if (!p)
1744         return AVERROR(ENOMEM);
1745     for (i = 0; i < sizeof(UID); i++) {
1746         snprintf(p, 2 + 1, "%.2x", uid[i]);
1747         p += 2;
1748         if (i == 3 || i == 5 || i == 7 || i == 9) {
1749             snprintf(p, 1 + 1, "-");
1750             p++;
1751         }
1752     }
1753     return 0;
1754 }
1755
1756 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1757 {
1758     int i;
1759     char *p;
1760     p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1761     if (!p)
1762         return AVERROR(ENOMEM);
1763     snprintf(p, 2 + 1, "0x");
1764     p += 2;
1765     for (i = 0; i < sizeof(UID); i++) {
1766         snprintf(p, 2 + 1, "%.2X", ul[i]);
1767         p += 2;
1768
1769     }
1770     for (i = 0; i < sizeof(UID); i++) {
1771         snprintf(p, 2 + 1, "%.2X", uid[i]);
1772         p += 2;
1773     }
1774     return 0;
1775 }
1776
1777 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1778 {
1779     char *str;
1780     int ret;
1781     if (!package)
1782         return 0;
1783     if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1784         return ret;
1785     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1786     return 0;
1787 }
1788
1789 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1790 {
1791     char buf[AV_TIMECODE_STR_SIZE];
1792     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1793
1794     return 0;
1795 }
1796
1797 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1798 {
1799     MXFStructuralComponent *component = NULL;
1800     MXFPulldownComponent *pulldown = NULL;
1801
1802     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1803     if (!component)
1804         return NULL;
1805
1806     switch (component->type) {
1807     case TimecodeComponent:
1808         return (MXFTimecodeComponent*)component;
1809     case PulldownComponent: /* timcode component may be located on a pulldown component */
1810         pulldown = (MXFPulldownComponent*)component;
1811         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1812     default:
1813         break;
1814     }
1815     return NULL;
1816 }
1817
1818 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1819 {
1820     MXFPackage *package = NULL;
1821     int i;
1822
1823     for (i = 0; i < mxf->packages_count; i++) {
1824         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1825         if (!package)
1826             continue;
1827
1828         if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1829             return package;
1830     }
1831     return NULL;
1832 }
1833
1834 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1835 {
1836     MXFDescriptor *sub_descriptor = NULL;
1837     int i;
1838
1839     if (!descriptor)
1840         return NULL;
1841
1842     if (descriptor->type == MultipleDescriptor) {
1843         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1844             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1845
1846             if (!sub_descriptor) {
1847                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1848                 continue;
1849             }
1850             if (sub_descriptor->linked_track_id == track_id) {
1851                 return sub_descriptor;
1852             }
1853         }
1854     } else if (descriptor->type == Descriptor)
1855         return descriptor;
1856
1857     return NULL;
1858 }
1859
1860 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1861 {
1862     MXFStructuralComponent *component = NULL;
1863     MXFPackage *package = NULL;
1864     MXFDescriptor *descriptor = NULL;
1865     int i;
1866
1867     if (!essence_group || !essence_group->structural_components_count)
1868         return NULL;
1869
1870     /* essence groups contains multiple representations of the same media,
1871        this return the first components with a valid Descriptor typically index 0 */
1872     for (i =0; i < essence_group->structural_components_count; i++){
1873         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1874         if (!component)
1875             continue;
1876
1877         if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1878             continue;
1879
1880         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1881         if (descriptor)
1882             return component;
1883     }
1884     return NULL;
1885 }
1886
1887 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1888 {
1889     MXFStructuralComponent *component = NULL;
1890
1891     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1892     if (!component)
1893         return NULL;
1894     switch (component->type) {
1895         case SourceClip:
1896             return component;
1897         case EssenceGroup:
1898             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1899         default:
1900             break;
1901     }
1902     return NULL;
1903 }
1904
1905 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1906 {
1907     MXFTaggedValue *tag;
1908     int size, i;
1909     char *key = NULL;
1910
1911     for (i = 0; i < package->comment_count; i++) {
1912         tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1913         if (!tag || !tag->name || !tag->value)
1914             continue;
1915
1916         size = strlen(tag->name) + 8 + 1;
1917         key = av_mallocz(size);
1918         if (!key)
1919             return AVERROR(ENOMEM);
1920
1921         snprintf(key, size, "comment_%s", tag->name);
1922         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1923     }
1924     return 0;
1925 }
1926
1927 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1928 {
1929     MXFPackage *physical_package = NULL;
1930     MXFTrack *physical_track = NULL;
1931     MXFStructuralComponent *sourceclip = NULL;
1932     MXFTimecodeComponent *mxf_tc = NULL;
1933     int i, j, k;
1934     AVTimecode tc;
1935     int flags;
1936     int64_t start_position;
1937
1938     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1939         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1940         if (!sourceclip)
1941             continue;
1942
1943         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
1944             break;
1945
1946         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1947
1948         /* the name of physical source package is name of the reel or tape */
1949         if (physical_package->name && physical_package->name[0])
1950             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1951
1952         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1953          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1954          */
1955         for (j = 0; j < physical_package->tracks_count; j++) {
1956             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1957                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1958                 continue;
1959             }
1960
1961             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1962                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1963                 continue;
1964             }
1965
1966         if (physical_track->edit_rate.num <= 0 ||
1967             physical_track->edit_rate.den <= 0) {
1968             av_log(mxf->fc, AV_LOG_WARNING,
1969                    "Invalid edit rate (%d/%d) found on structural"
1970                    " component #%d, defaulting to 25/1\n",
1971                    physical_track->edit_rate.num,
1972                    physical_track->edit_rate.den, i);
1973             physical_track->edit_rate = (AVRational){25, 1};
1974         }
1975
1976             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1977                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1978                     continue;
1979
1980                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1981                 /* scale sourceclip start_position to match physical track edit rate */
1982                 start_position = av_rescale_q(sourceclip->start_position,
1983                                               physical_track->edit_rate,
1984                                               source_track->edit_rate);
1985
1986                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1987                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1988                     return 0;
1989                 }
1990             }
1991         }
1992     }
1993
1994     return 0;
1995 }
1996
1997 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
1998 {
1999     MXFStructuralComponent *component = NULL;
2000     const MXFCodecUL *codec_ul = NULL;
2001     MXFPackage tmp_package;
2002     AVStream *st;
2003     int j;
2004
2005     for (j = 0; j < track->sequence->structural_components_count; j++) {
2006         component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2007         if (!component)
2008             continue;
2009         break;
2010     }
2011     if (!component)
2012         return 0;
2013
2014     st = avformat_new_stream(mxf->fc, NULL);
2015     if (!st) {
2016         av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2017         return AVERROR(ENOMEM);
2018     }
2019
2020     st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2021     st->codecpar->codec_id = AV_CODEC_ID_NONE;
2022     st->id = track->track_id;
2023
2024     memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2025     memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2026     mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2027     if (track->name && track->name[0])
2028         av_dict_set(&st->metadata, "track_name", track->name, 0);
2029
2030     codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2031     av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2032     return 0;
2033 }
2034
2035 static int mxf_parse_structural_metadata(MXFContext *mxf)
2036 {
2037     MXFPackage *material_package = NULL;
2038     int i, j, k, ret;
2039
2040     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2041     /* TODO: handle multiple material packages (OP3x) */
2042     for (i = 0; i < mxf->packages_count; i++) {
2043         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2044         if (material_package) break;
2045     }
2046     if (!material_package) {
2047         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2048         return AVERROR_INVALIDDATA;
2049     }
2050
2051     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2052     if (material_package->name && material_package->name[0])
2053         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2054     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2055
2056     for (i = 0; i < material_package->tracks_count; i++) {
2057         MXFPackage *source_package = NULL;
2058         MXFTrack *material_track = NULL;
2059         MXFTrack *source_track = NULL;
2060         MXFTrack *temp_track = NULL;
2061         MXFDescriptor *descriptor = NULL;
2062         MXFStructuralComponent *component = NULL;
2063         MXFTimecodeComponent *mxf_tc = NULL;
2064         UID *essence_container_ul = NULL;
2065         const MXFCodecUL *codec_ul = NULL;
2066         const MXFCodecUL *container_ul = NULL;
2067         const MXFCodecUL *pix_fmt_ul = NULL;
2068         AVStream *st;
2069         AVTimecode tc;
2070         int flags;
2071
2072         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2073             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2074             continue;
2075         }
2076
2077         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2078             mxf_tc = (MXFTimecodeComponent*)component;
2079             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2080             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2081                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2082             }
2083         }
2084
2085         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2086             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2087             continue;
2088         }
2089
2090         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2091             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2092             if (!component)
2093                 continue;
2094
2095             mxf_tc = (MXFTimecodeComponent*)component;
2096             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2097             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2098                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2099                 break;
2100             }
2101         }
2102
2103         /* TODO: handle multiple source clips, only finds first valid source clip */
2104         if(material_track->sequence->structural_components_count > 1)
2105             av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2106                        material_track->track_id, material_track->sequence->structural_components_count);
2107
2108         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2109             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2110             if (!component)
2111                 continue;
2112
2113             source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2114             if (!source_package) {
2115                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2116                 continue;
2117             }
2118             for (k = 0; k < source_package->tracks_count; k++) {
2119                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2120                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2121                     ret = AVERROR_INVALIDDATA;
2122                     goto fail_and_free;
2123                 }
2124                 if (temp_track->track_id == component->source_track_id) {
2125                     source_track = temp_track;
2126                     break;
2127                 }
2128             }
2129             if (!source_track) {
2130                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2131                 break;
2132             }
2133
2134             for (k = 0; k < mxf->essence_container_data_count; k++) {
2135                 MXFEssenceContainerData *essence_data;
2136
2137                 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2138                     av_log(mxf, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2139                     continue;
2140                 }
2141                 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2142                     source_track->body_sid = essence_data->body_sid;
2143                     source_track->index_sid = essence_data->index_sid;
2144                     break;
2145                 }
2146             }
2147
2148             if(source_track && component)
2149                 break;
2150         }
2151         if (!source_track || !component || !source_package) {
2152             if((ret = mxf_add_metadata_stream(mxf, material_track)))
2153                 goto fail_and_free;
2154             continue;
2155         }
2156
2157         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2158             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2159             ret = AVERROR_INVALIDDATA;
2160             goto fail_and_free;
2161         }
2162
2163         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2164          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2165         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2166             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2167             continue;
2168         }
2169
2170         st = avformat_new_stream(mxf->fc, NULL);
2171         if (!st) {
2172             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2173             ret = AVERROR(ENOMEM);
2174             goto fail_and_free;
2175         }
2176         st->id = material_track->track_id;
2177         st->priv_data = source_track;
2178
2179         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2180         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2181
2182         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2183          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2184         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2185             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2186         else
2187             source_track->original_duration = st->duration = component->duration;
2188
2189         if (st->duration == -1)
2190             st->duration = AV_NOPTS_VALUE;
2191         st->start_time = component->start_position;
2192         if (material_track->edit_rate.num <= 0 ||
2193             material_track->edit_rate.den <= 0) {
2194             av_log(mxf->fc, AV_LOG_WARNING,
2195                    "Invalid edit rate (%d/%d) found on stream #%d, "
2196                    "defaulting to 25/1\n",
2197                    material_track->edit_rate.num,
2198                    material_track->edit_rate.den, st->index);
2199             material_track->edit_rate = (AVRational){25, 1};
2200         }
2201         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2202
2203         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2204          * the former is accessible via st->priv_data */
2205         source_track->edit_rate = material_track->edit_rate;
2206
2207         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
2208         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2209         st->codecpar->codec_type = codec_ul->id;
2210
2211         if (!descriptor) {
2212             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2213             continue;
2214         }
2215         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
2216         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2217         essence_container_ul = &descriptor->essence_container_ul;
2218         source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2219         if (source_track->wrapping == UnknownWrapped)
2220             av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2221         /* HACK: replacing the original key with mxf_encrypted_essence_container
2222          * is not allowed according to s429-6, try to find correct information anyway */
2223         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2224             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2225             for (k = 0; k < mxf->metadata_sets_count; k++) {
2226                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2227                 if (metadata->type == CryptoContext) {
2228                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2229                     break;
2230                 }
2231             }
2232         }
2233
2234         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2235         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2236         st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2237         if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2238             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2239             st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2240         }
2241
2242         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2243                avcodec_get_name(st->codecpar->codec_id));
2244         for (k = 0; k < 16; k++) {
2245             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2246                    descriptor->essence_codec_ul[k]);
2247             if (!(k+1 & 19) || k == 5)
2248                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2249         }
2250         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2251
2252         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2253         if (source_package->name && source_package->name[0])
2254             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2255         if (material_track->name && material_track->name[0])
2256             av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2257
2258         mxf_parse_physical_source_package(mxf, source_track, st);
2259
2260         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2261             source_track->intra_only = mxf_is_intra_only(descriptor);
2262             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2263             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2264                 st->codecpar->codec_id = container_ul->id;
2265             st->codecpar->width = descriptor->width;
2266             st->codecpar->height = descriptor->height; /* Field height, not frame height */
2267             switch (descriptor->frame_layout) {
2268                 case FullFrame:
2269                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2270                     break;
2271                 case OneField:
2272                     /* Every other line is stored and needs to be duplicated. */
2273                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2274                     break; /* The correct thing to do here is fall through, but by breaking we might be
2275                               able to decode some streams at half the vertical resolution, rather than not al all.
2276                               It's also for compatibility with the old behavior. */
2277                 case MixedFields:
2278                     break;
2279                 case SegmentedFrame:
2280                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2281                 case SeparateFields:
2282                     av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2283                            descriptor->video_line_map[0], descriptor->video_line_map[1],
2284                            descriptor->field_dominance);
2285                     if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2286                         /* Detect coded field order from VideoLineMap:
2287                          *  (even, even) => bottom field coded first
2288                          *  (even, odd)  => top field coded first
2289                          *  (odd, even)  => top field coded first
2290                          *  (odd, odd)   => bottom field coded first
2291                          */
2292                         if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2293                             switch (descriptor->field_dominance) {
2294                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2295                                 case MXF_FIELD_DOMINANCE_FF:
2296                                     st->codecpar->field_order = AV_FIELD_TT;
2297                                     break;
2298                                 case MXF_FIELD_DOMINANCE_FL:
2299                                     st->codecpar->field_order = AV_FIELD_TB;
2300                                     break;
2301                                 default:
2302                                     avpriv_request_sample(mxf->fc,
2303                                                           "Field dominance %d support",
2304                                                           descriptor->field_dominance);
2305                             }
2306                         } else {
2307                             switch (descriptor->field_dominance) {
2308                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2309                                 case MXF_FIELD_DOMINANCE_FF:
2310                                     st->codecpar->field_order = AV_FIELD_BB;
2311                                     break;
2312                                 case MXF_FIELD_DOMINANCE_FL:
2313                                     st->codecpar->field_order = AV_FIELD_BT;
2314                                     break;
2315                                 default:
2316                                     avpriv_request_sample(mxf->fc,
2317                                                           "Field dominance %d support",
2318                                                           descriptor->field_dominance);
2319                             }
2320                         }
2321                     }
2322                     /* Turn field height into frame height. */
2323                     st->codecpar->height *= 2;
2324                     break;
2325                 default:
2326                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2327             }
2328             if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2329                 st->codecpar->format = descriptor->pix_fmt;
2330                 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2331                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2332                                                   &descriptor->essence_codec_ul);
2333                     st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2334                     if (st->codecpar->format== AV_PIX_FMT_NONE) {
2335                         st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2336                                                                    &descriptor->essence_codec_ul)->id;
2337                         if (!st->codecpar->codec_tag) {
2338                             /* support files created before RP224v10 by defaulting to UYVY422
2339                                if subsampling is 4:2:2 and component depth is 8-bit */
2340                             if (descriptor->horiz_subsampling == 2 &&
2341                                 descriptor->vert_subsampling == 1 &&
2342                                 descriptor->component_depth == 8) {
2343                                 st->codecpar->format = AV_PIX_FMT_UYVY422;
2344                             }
2345                         }
2346                     }
2347                 }
2348             }
2349             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2350             if (material_track->sequence->origin) {
2351                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2352             }
2353             if (source_track->sequence->origin) {
2354                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2355             }
2356             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2357                 st->display_aspect_ratio = descriptor->aspect_ratio;
2358         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2359             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2360             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2361             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))
2362                 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2363             st->codecpar->channels = descriptor->channels;
2364             st->codecpar->bits_per_coded_sample = descriptor->bits_per_sample;
2365
2366             if (descriptor->sample_rate.den > 0) {
2367                 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2368                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2369             } else {
2370                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2371                        "found for stream #%d, time base forced to 1/48000\n",
2372                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2373                        st->index);
2374                 avpriv_set_pts_info(st, 64, 1, 48000);
2375             }
2376
2377             /* if duration is set, rescale it from EditRate to SampleRate */
2378             if (st->duration != AV_NOPTS_VALUE)
2379                 st->duration = av_rescale_q(st->duration,
2380                                             av_inv_q(material_track->edit_rate),
2381                                             st->time_base);
2382
2383             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2384             if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2385                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2386                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2387                 else if (descriptor->bits_per_sample == 32)
2388                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2389             } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2390                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2391                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2392                 else if (descriptor->bits_per_sample == 32)
2393                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2394             } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2395                 st->need_parsing = AVSTREAM_PARSE_FULL;
2396             }
2397         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2398             enum AVMediaType type;
2399             container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2400             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2401                 st->codecpar->codec_id = container_ul->id;
2402             type = avcodec_get_type(st->codecpar->codec_id);
2403             if (type == AVMEDIA_TYPE_SUBTITLE)
2404                 st->codecpar->codec_type = type;
2405             if (container_ul->desc)
2406                 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2407         }
2408         if (descriptor->extradata) {
2409             if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2410                 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2411             }
2412         } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2413             int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2414                                                &descriptor->essence_codec_ul)->id;
2415             if (coded_width)
2416                 st->codecpar->width = coded_width;
2417             ret = ff_generate_avci_extradata(st);
2418             if (ret < 0)
2419                 return ret;
2420         }
2421         if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2422             /* TODO: decode timestamps */
2423             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2424         }
2425     }
2426
2427     ret = 0;
2428 fail_and_free:
2429     return ret;
2430 }
2431
2432 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2433 {
2434     struct tm time = { 0 };
2435     time.tm_year = (timestamp >> 48) - 1900;
2436     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2437     time.tm_mday = (timestamp >> 32 & 0xFF);
2438     time.tm_hour = (timestamp >> 24 & 0xFF);
2439     time.tm_min  = (timestamp >> 16 & 0xFF);
2440     time.tm_sec  = (timestamp >> 8  & 0xFF);
2441
2442     /* msvcrt versions of strftime calls the invalid parameter handler
2443      * (aborting the process if one isn't set) if the parameters are out
2444      * of range. */
2445     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2446     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2447     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2448     time.tm_min  = av_clip(time.tm_min,  0, 59);
2449     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2450
2451     return (int64_t)av_timegm(&time) * 1000000;
2452 }
2453
2454 #define SET_STR_METADATA(pb, name, str) do { \
2455     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2456         return ret; \
2457     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2458 } while (0)
2459
2460 #define SET_UID_METADATA(pb, name, var, str) do { \
2461     avio_read(pb, var, 16); \
2462     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2463         return ret; \
2464     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2465 } while (0)
2466
2467 #define SET_TS_METADATA(pb, name, var, str) do { \
2468     var = avio_rb64(pb); \
2469     if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2470         return ret; \
2471 } while (0)
2472
2473 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2474 {
2475     MXFContext *mxf = arg;
2476     AVFormatContext *s = mxf->fc;
2477     int ret;
2478     UID uid = { 0 };
2479     char *str = NULL;
2480     uint64_t ts;
2481     switch (tag) {
2482     case 0x3C01:
2483         SET_STR_METADATA(pb, "company_name", str);
2484         break;
2485     case 0x3C02:
2486         SET_STR_METADATA(pb, "product_name", str);
2487         break;
2488     case 0x3C04:
2489         SET_STR_METADATA(pb, "product_version", str);
2490         break;
2491     case 0x3C05:
2492         SET_UID_METADATA(pb, "product_uid", uid, str);
2493         break;
2494     case 0x3C06:
2495         SET_TS_METADATA(pb, "modification_date", ts, str);
2496         break;
2497     case 0x3C08:
2498         SET_STR_METADATA(pb, "application_platform", str);
2499         break;
2500     case 0x3C09:
2501         SET_UID_METADATA(pb, "generation_uid", uid, str);
2502         break;
2503     case 0x3C0A:
2504         SET_UID_METADATA(pb, "uid", uid, str);
2505         break;
2506     }
2507     return 0;
2508 }
2509
2510 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2511 {
2512     MXFContext *mxf = arg;
2513     AVFormatContext *s = mxf->fc;
2514     int ret;
2515     char *str = NULL;
2516
2517     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2518         SET_STR_METADATA(pb, "project_name", str);
2519     }
2520     return 0;
2521 }
2522
2523 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2524     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2525     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2526     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2527     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2528     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2529     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2530     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2531     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2532     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2533     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2534     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2535     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2536     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2537     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2538     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2539     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2540     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2541     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2542     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2543     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2544     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2545     { { 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 */
2546     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2547     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2548     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2549     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2550     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2551     { { 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 */
2552     { { 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 */
2553     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2554     { { 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 */
2555     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2556     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2557     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2558     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2559     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2560     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2561     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2562     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2563 };
2564
2565 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2566 {
2567     switch (type){
2568     case MultipleDescriptor:
2569     case Descriptor:
2570         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2571         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2572         break;
2573     default:
2574         break;
2575     }
2576     return 0;
2577 }
2578
2579 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2580 {
2581     AVIOContext *pb = mxf->fc->pb;
2582     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2583     uint64_t klv_end = avio_tell(pb) + klv->length;
2584
2585     if (!ctx)
2586         return AVERROR(ENOMEM);
2587     mxf_metadataset_init(ctx, type);
2588     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2589         int ret;
2590         int tag = avio_rb16(pb);
2591         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2592         uint64_t next = avio_tell(pb) + size;
2593         UID uid = {0};
2594
2595         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2596         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2597             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2598             continue;
2599         }
2600         if (tag > 0x7FFF) { /* dynamic tag */
2601             int i;
2602             for (i = 0; i < mxf->local_tags_count; i++) {
2603                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2604                 if (local_tag == tag) {
2605                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2606                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2607                     PRINT_KEY(mxf->fc, "uid", uid);
2608                 }
2609             }
2610         }
2611         if (ctx_size && tag == 0x3C0A) {
2612             avio_read(pb, ctx->uid, 16);
2613         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2614             mxf_free_metadataset(&ctx, !!ctx_size);
2615             return ret;
2616         }
2617
2618         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2619          * it extending past the end of the KLV though (zzuf5.mxf). */
2620         if (avio_tell(pb) > klv_end) {
2621             if (ctx_size) {
2622                 ctx->type = type;
2623                 mxf_free_metadataset(&ctx, !!ctx_size);
2624             }
2625
2626             av_log(mxf->fc, AV_LOG_ERROR,
2627                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2628                    tag, klv->offset);
2629             return AVERROR_INVALIDDATA;
2630         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2631             avio_seek(pb, next, SEEK_SET);
2632     }
2633     if (ctx_size) ctx->type = type;
2634     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2635 }
2636
2637 /**
2638  * Matches any partition pack key, in other words:
2639  * - HeaderPartition
2640  * - BodyPartition
2641  * - FooterPartition
2642  * @return non-zero if the key is a partition pack key, zero otherwise
2643  */
2644 static int mxf_is_partition_pack_key(UID key)
2645 {
2646     //NOTE: this is a little lax since it doesn't constraint key[14]
2647     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2648             key[13] >= 2 && key[13] <= 4;
2649 }
2650
2651 /**
2652  * Parses a metadata KLV
2653  * @return <0 on error, 0 otherwise
2654  */
2655 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2656                                      int ctx_size, enum MXFMetadataSetType type)
2657 {
2658     AVFormatContext *s = mxf->fc;
2659     int res;
2660     if (klv.key[5] == 0x53) {
2661         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2662     } else {
2663         uint64_t next = avio_tell(s->pb) + klv.length;
2664         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2665
2666         /* only seek forward, else this can loop for a long time */
2667         if (avio_tell(s->pb) > next) {
2668             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2669                    klv.offset);
2670             return AVERROR_INVALIDDATA;
2671         }
2672
2673         avio_seek(s->pb, next, SEEK_SET);
2674     }
2675     if (res < 0) {
2676         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2677         return res;
2678     }
2679     return 0;
2680 }
2681
2682 /**
2683  * Seeks to the previous partition and parses it, if possible
2684  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2685  */
2686 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2687 {
2688     AVIOContext *pb = mxf->fc->pb;
2689     KLVPacket klv;
2690     int64_t current_partition_ofs;
2691     int ret;
2692
2693     if (!mxf->current_partition ||
2694         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2695         return 0;   /* we've parsed all partitions */
2696
2697     /* seek to previous partition */
2698     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2699     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2700     mxf->current_partition = NULL;
2701
2702     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2703
2704     /* Make sure this is actually a PartitionPack, and if so parse it.
2705      * See deadlock2.mxf
2706      */
2707     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2708         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2709         return ret;
2710     }
2711
2712     if (!mxf_is_partition_pack_key(klv.key)) {
2713         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2714         return AVERROR_INVALIDDATA;
2715     }
2716
2717     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2718      * can point to just before the current partition, causing klv_read_packet()
2719      * to sync back up to it. See deadlock3.mxf
2720      */
2721     if (klv.offset >= current_partition_ofs) {
2722         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2723                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2724         return AVERROR_INVALIDDATA;
2725     }
2726
2727     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2728         return ret;
2729
2730     return 1;
2731 }
2732
2733 /**
2734  * Called when essence is encountered
2735  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2736  */
2737 static int mxf_parse_handle_essence(MXFContext *mxf)
2738 {
2739     AVIOContext *pb = mxf->fc->pb;
2740     int64_t ret;
2741
2742     if (mxf->parsing_backward) {
2743         return mxf_seek_to_previous_partition(mxf);
2744     } else {
2745         if (!mxf->footer_partition) {
2746             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2747             return 0;
2748         }
2749
2750         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2751
2752         /* remember where we were so we don't end up seeking further back than this */
2753         mxf->last_forward_tell = avio_tell(pb);
2754
2755         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2756             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2757             return -1;
2758         }
2759
2760         /* seek to FooterPartition and parse backward */
2761         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2762             av_log(mxf->fc, AV_LOG_ERROR,
2763                    "failed to seek to FooterPartition @ 0x%" PRIx64
2764                    " (%"PRId64") - partial file?\n",
2765                    mxf->run_in + mxf->footer_partition, ret);
2766             return ret;
2767         }
2768
2769         mxf->current_partition = NULL;
2770         mxf->parsing_backward = 1;
2771     }
2772
2773     return 1;
2774 }
2775
2776 /**
2777  * Called when the next partition or EOF is encountered
2778  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2779  */
2780 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2781 {
2782     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2783 }
2784
2785 /**
2786  * Figures out the proper offset and length of the essence container in each partition
2787  */
2788 static void mxf_compute_essence_containers(MXFContext *mxf)
2789 {
2790     int x;
2791
2792     /* everything is already correct */
2793     if (mxf->op == OPAtom)
2794         return;
2795
2796     for (x = 0; x < mxf->partitions_count; x++) {
2797         MXFPartition *p = &mxf->partitions[x];
2798
2799         if (!p->body_sid)
2800             continue;       /* BodySID == 0 -> no essence */
2801
2802         if (x >= mxf->partitions_count - 1)
2803             break;          /* FooterPartition - can't compute length (and we don't need to) */
2804
2805         /* essence container spans to the next partition */
2806         p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2807
2808         if (p->essence_length < 0) {
2809             /* next ThisPartition < essence_offset */
2810             p->essence_length = 0;
2811             av_log(mxf->fc, AV_LOG_ERROR,
2812                    "partition %i: bad ThisPartition = %"PRIX64"\n",
2813                    x+1, mxf->partitions[x+1].this_partition);
2814         }
2815     }
2816 }
2817
2818 static int64_t round_to_kag(int64_t position, int kag_size)
2819 {
2820     /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2821     /* NOTE: kag_size may be any integer between 1 - 2^10 */
2822     int64_t ret = (position / kag_size) * kag_size;
2823     return ret == position ? ret : ret + kag_size;
2824 }
2825
2826 static int is_pcm(enum AVCodecID codec_id)
2827 {
2828     /* we only care about "normal" PCM codecs until we get samples */
2829     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2830 }
2831
2832 static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
2833 {
2834     int i;
2835
2836     if (mxf->op != OPAtom)
2837         return NULL;
2838
2839     for (i = 0; i < mxf->fc->nb_streams; i++) {
2840         if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2841             continue;
2842         return mxf->fc->streams[i];
2843     }
2844     return NULL;
2845 }
2846
2847 /**
2848  * Deal with the case where for some audio atoms EditUnitByteCount is
2849  * very small (2, 4..). In those cases we should read more than one
2850  * sample per call to mxf_read_packet().
2851  */
2852 static void mxf_handle_small_eubc(AVFormatContext *s)
2853 {
2854     MXFContext *mxf = s->priv_data;
2855     MXFTrack *track;
2856
2857     /* assuming non-OPAtom == frame wrapped
2858      * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2859     AVStream *st = mxf_get_opatom_stream(mxf);
2860     if (!st)
2861         return;
2862
2863     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2864     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
2865         !is_pcm(st->codecpar->codec_id)                        ||
2866         mxf->nb_index_tables != 1                              ||
2867         mxf->index_tables[0].nb_segments != 1                  ||
2868         mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2869         return;
2870
2871     /* arbitrarily default to 48 kHz PAL audio frame size */
2872     /* TODO: We could compute this from the ratio between the audio
2873      *       and video edit rates for 48 kHz NTSC we could use the
2874      *       1802-1802-1802-1802-1801 pattern. */
2875     track = st->priv_data;
2876     mxf->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
2877 }
2878
2879 /**
2880  * Deal with the case where OPAtom files does not have any IndexTableSegments.
2881  */
2882 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2883 {
2884     AVFormatContext *s = mxf->fc;
2885     AVStream *st = NULL;
2886     MXFIndexTableSegment *segment = NULL;
2887     MXFPartition *p = NULL;
2888     int essence_partition_count = 0;
2889     int i, ret;
2890
2891     st = mxf_get_opatom_stream(mxf);
2892     if (!st)
2893         return 0;
2894
2895     /* TODO: support raw video without an index if they exist */
2896     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id))
2897         return 0;
2898
2899     /* check if file already has a IndexTableSegment */
2900     for (i = 0; i < mxf->metadata_sets_count; i++) {
2901         if (mxf->metadata_sets[i]->type == IndexTableSegment)
2902             return 0;
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)
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     segment->type = IndexTableSegment;
2928     /* stream will be treated as small EditUnitByteCount */
2929     segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2930     segment->index_start_position = 0;
2931     segment->index_duration = s->streams[0]->duration;
2932     segment->index_sid = p->index_sid;
2933     segment->body_sid = p->body_sid;
2934     return 0;
2935 }
2936
2937 static void mxf_read_random_index_pack(AVFormatContext *s)
2938 {
2939     MXFContext *mxf = s->priv_data;
2940     uint32_t length;
2941     int64_t file_size, max_rip_length, min_rip_length;
2942     KLVPacket klv;
2943
2944     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2945         return;
2946
2947     file_size = avio_size(s->pb);
2948
2949     /* S377m says to check the RIP length for "silly" values, without defining "silly".
2950      * The limit below assumes a file with nothing but partition packs and a RIP.
2951      * Before changing this, consider that a muxer may place each sample in its own partition.
2952      *
2953      * 105 is the size of the smallest possible PartitionPack
2954      * 12 is the size of each RIP entry
2955      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2956      */
2957     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2958     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2959
2960     /* We're only interested in RIPs with at least two entries.. */
2961     min_rip_length = 16+1+24+4;
2962
2963     /* See S377m section 11 */
2964     avio_seek(s->pb, file_size - 4, SEEK_SET);
2965     length = avio_rb32(s->pb);
2966
2967     if (length < min_rip_length || length > max_rip_length)
2968         goto end;
2969     avio_seek(s->pb, file_size - length, SEEK_SET);
2970     if (klv_read_packet(&klv, s->pb) < 0 ||
2971         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2972         klv.length != length - 20)
2973         goto end;
2974
2975     avio_skip(s->pb, klv.length - 12);
2976     mxf->footer_partition = avio_rb64(s->pb);
2977
2978     /* sanity check */
2979     if (mxf->run_in + mxf->footer_partition >= file_size) {
2980         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2981         mxf->footer_partition = 0;
2982     }
2983
2984 end:
2985     avio_seek(s->pb, mxf->run_in, SEEK_SET);
2986 }
2987
2988 static int mxf_read_header(AVFormatContext *s)
2989 {
2990     MXFContext *mxf = s->priv_data;
2991     KLVPacket klv;
2992     int64_t essence_offset = 0;
2993     int ret;
2994
2995     mxf->last_forward_tell = INT64_MAX;
2996     mxf->edit_units_per_packet = 1;
2997
2998     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2999         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3000         return AVERROR_INVALIDDATA;
3001     }
3002     avio_seek(s->pb, -14, SEEK_CUR);
3003     mxf->fc = s;
3004     mxf->run_in = avio_tell(s->pb);
3005
3006     mxf_read_random_index_pack(s);
3007
3008     while (!avio_feof(s->pb)) {
3009         const MXFMetadataReadTableEntry *metadata;
3010
3011         if (klv_read_packet(&klv, s->pb) < 0) {
3012             /* EOF - seek to previous partition or stop */
3013             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3014                 break;
3015             else
3016                 continue;
3017         }
3018
3019         PRINT_KEY(s, "read header", klv.key);
3020         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3021         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3022             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3023             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3024             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3025             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3026
3027             if (!mxf->current_partition) {
3028                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3029                 return AVERROR_INVALIDDATA;
3030             }
3031
3032             if (!mxf->current_partition->essence_offset) {
3033                 /* for OP1a we compute essence_offset
3034                  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
3035                  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
3036                  *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
3037                  */
3038                 int64_t op1a_essence_offset =
3039                     mxf->current_partition->this_partition +
3040                     round_to_kag(mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
3041                     round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
3042                     round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);
3043
3044                 if (mxf->op == OPAtom) {
3045                     /* point essence_offset to the actual data
3046                     * OPAtom has all the essence in one big KLV
3047                     */
3048                     mxf->current_partition->essence_offset = avio_tell(s->pb);
3049                     mxf->current_partition->essence_length = klv.length;
3050                 } else {
3051                     /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
3052                     if (IS_KLV_KEY(klv.key, mxf_system_item_key_cp) || IS_KLV_KEY(klv.key, mxf_system_item_key_gc))
3053                         mxf->current_partition->essence_offset = klv.offset;
3054                     else
3055                         mxf->current_partition->essence_offset = op1a_essence_offset;
3056                 }
3057             }
3058
3059             if (!essence_offset)
3060                 essence_offset = klv.offset;
3061
3062             /* seek to footer, previous partition or stop */
3063             if (mxf_parse_handle_essence(mxf) <= 0)
3064                 break;
3065             continue;
3066         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3067             /* next partition pack - keep going, seek to previous partition or stop */
3068             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3069                 break;
3070             else if (mxf->parsing_backward)
3071                 continue;
3072             /* we're still parsing forward. proceed to parsing this partition pack */
3073         }
3074
3075         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3076             if (IS_KLV_KEY(klv.key, metadata->key)) {
3077                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3078                     goto fail;
3079                 break;
3080             }
3081         }
3082         if (!metadata->read) {
3083             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3084                             UID_ARG(klv.key));
3085             avio_skip(s->pb, klv.length);
3086         }
3087     }
3088     /* FIXME avoid seek */
3089     if (!essence_offset)  {
3090         av_log(s, AV_LOG_ERROR, "no essence\n");
3091         ret = AVERROR_INVALIDDATA;
3092         goto fail;
3093     }
3094     avio_seek(s->pb, essence_offset, SEEK_SET);
3095
3096     mxf_compute_essence_containers(mxf);
3097
3098     /* we need to do this before computing the index tables
3099      * to be able to fill in zero IndexDurations with st->duration */
3100     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3101         goto fail;
3102
3103     mxf_handle_missing_index_segment(mxf);
3104     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3105         goto fail;
3106
3107     if (mxf->nb_index_tables > 1) {
3108         /* TODO: look up which IndexSID to use via EssenceContainerData */
3109         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3110                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3111     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
3112         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3113         ret = AVERROR_INVALIDDATA;
3114         goto fail;
3115     }
3116
3117     mxf_handle_small_eubc(s);
3118
3119     return 0;
3120 fail:
3121     mxf_read_close(s);
3122
3123     return ret;
3124 }
3125
3126 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3127 {
3128     int i;
3129     for (i = 0; i < mxf->nb_index_tables; i++)
3130         if (mxf->index_tables[i].index_sid == index_sid)
3131             return &mxf->index_tables[i];
3132     return NULL;
3133 }
3134
3135 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3136 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3137 {
3138     int64_t a, b, m, offset;
3139     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3140
3141     if (!t || track->original_duration <= 0)
3142         return -1;
3143
3144     a = -1;
3145     b = track->original_duration;
3146
3147     while (b - a > 1) {
3148         m = (a + b) >> 1;
3149         if (mxf_edit_unit_absolute_offset(mxf, t, m, NULL, &offset, 0) < 0)
3150             return -1;
3151         if (offset < current_offset)
3152             a = m;
3153         else
3154             b = m;
3155     }
3156
3157     *edit_unit_out = b;
3158
3159     return 0;
3160 }
3161
3162 /**
3163  * Sets mxf->current_edit_unit based on what offset we're currently at.
3164  * @return next_ofs if OK, <0 on error
3165  */
3166 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
3167 {
3168     int64_t last_ofs = -1, next_ofs = -1;
3169     MXFIndexTable *t = &mxf->index_tables[0];
3170
3171     /* this is called from the OP1a demuxing logic, which means there
3172      * may be no index tables */
3173     if (mxf->nb_index_tables <= 0)
3174         return -1;
3175
3176     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
3177     while (mxf->current_edit_unit >= 0) {
3178         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
3179             return -2;
3180
3181         if (next_ofs <= last_ofs) {
3182             /* large next_ofs didn't change or current_edit_unit wrapped
3183              * around this fixes the infinite loop on zzuf3.mxf */
3184             av_log(mxf->fc, AV_LOG_ERROR,
3185                    "next_ofs didn't change. not deriving packet timestamps\n");
3186             return -1;
3187         }
3188
3189         if (next_ofs > current_offset)
3190             break;
3191
3192         last_ofs = next_ofs;
3193         mxf->current_edit_unit++;
3194     }
3195
3196     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
3197     if (mxf->current_edit_unit < 0)
3198         return -1;
3199
3200     return next_ofs;
3201 }
3202
3203 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
3204                                     uint64_t *sample_count)
3205 {
3206     int i, total = 0, size = 0;
3207     AVStream *st = mxf->fc->streams[stream_index];
3208     MXFTrack *track = st->priv_data;
3209     AVRational time_base = av_inv_q(track->edit_rate);
3210     AVRational sample_rate = av_inv_q(st->time_base);
3211     const MXFSamplesPerFrame *spf = NULL;
3212
3213     if ((sample_rate.num / sample_rate.den) == 48000)
3214         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3215     if (!spf) {
3216         int remainder = (sample_rate.num * time_base.num) %
3217                         (time_base.den * sample_rate.den);
3218         *sample_count = av_rescale_q(mxf->current_edit_unit, sample_rate, track->edit_rate);
3219         if (remainder)
3220             av_log(mxf->fc, AV_LOG_WARNING,
3221                    "seeking detected on stream #%d with time base (%d/%d) and "
3222                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3223                    stream_index, time_base.num, time_base.den,
3224                    sample_rate.num, sample_rate.den);
3225         return 0;
3226     }
3227
3228     while (spf->samples_per_frame[size]) {
3229         total += spf->samples_per_frame[size];
3230         size++;
3231     }
3232
3233     av_assert2(size);
3234
3235     *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
3236     for (i = 0; i < mxf->current_edit_unit % size; i++) {
3237         *sample_count += spf->samples_per_frame[i];
3238     }
3239
3240     return 0;
3241 }
3242
3243 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3244                              AVPacket *pkt)
3245 {
3246     MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3247     int64_t bits_per_sample = par->bits_per_coded_sample;
3248
3249     if (!bits_per_sample)
3250         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3251
3252     pkt->pts = track->sample_count;
3253
3254     if (   par->channels <= 0
3255         || bits_per_sample <= 0
3256         || par->channels * (int64_t)bits_per_sample < 8)
3257         return AVERROR(EINVAL);
3258     track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3259     return 0;
3260 }
3261
3262 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
3263 {
3264     AVCodecParameters *par = st->codecpar;
3265     MXFTrack *track = st->priv_data;
3266
3267     if (par->codec_type == AVMEDIA_TYPE_VIDEO && (next_ofs >= 0 || next_ofs == -2 && st->duration == mxf->current_edit_unit + 1)) {
3268         /* mxf->current_edit_unit good - see if we have an
3269          * index table to derive timestamps from */
3270         MXFIndexTable *t = &mxf->index_tables[0];
3271
3272         if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3273             pkt->dts = mxf->current_edit_unit + t->first_dts;
3274             pkt->pts = t->ptses[mxf->current_edit_unit];
3275         } else if (track->intra_only) {
3276             /* intra-only -> PTS = EditUnit.
3277              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3278             pkt->pts = mxf->current_edit_unit;
3279         }
3280     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3281         int ret = mxf_set_audio_pts(mxf, par, pkt);
3282         if (ret < 0)
3283             return ret;
3284     }
3285     return 0;
3286 }
3287
3288 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
3289 {
3290     KLVPacket klv;
3291     MXFContext *mxf = s->priv_data;
3292     int ret;
3293
3294     while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3295         PRINT_KEY(s, "read packet", klv.key);
3296         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3297         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3298             ret = mxf_decrypt_triplet(s, pkt, &klv);
3299             if (ret < 0) {
3300                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3301                 return ret;
3302             }
3303             return 0;
3304         }
3305         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3306             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3307             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3308             int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3309             int index = mxf_get_stream_index(s, &klv, body_sid);
3310             int64_t next_ofs;
3311             AVStream *st;
3312
3313             if (index < 0) {
3314                 av_log(s, AV_LOG_ERROR,
3315                        "error getting stream index %"PRIu32"\n",
3316                        AV_RB32(klv.key + 12));
3317                 goto skip;
3318             }
3319
3320             st = s->streams[index];
3321
3322             if (s->streams[index]->discard == AVDISCARD_ALL)
3323                 goto skip;
3324
3325             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3326
3327             if (next_ofs >= 0 && klv.next_klv > next_ofs) {
3328                 /* if this check is hit then it's possible OPAtom was treated as OP1a
3329                  * truncate the packet since it's probably very large (>2 GiB is common) */
3330                 avpriv_request_sample(s,
3331                                       "OPAtom misinterpreted as OP1a? "
3332                                       "KLV for edit unit %"PRId64" extending into "
3333                                       "next edit unit",
3334                                       mxf->current_edit_unit);
3335                 klv.length = next_ofs - avio_tell(s->pb);
3336             }
3337
3338             /* check for 8 channels AES3 element */
3339             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3340                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3341                                               pkt, klv.length);
3342                 if (ret < 0) {
3343                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3344                     return ret;
3345                 }
3346             } else {
3347                 ret = av_get_packet(s->pb, pkt, klv.length);
3348                 if (ret < 0)
3349                     return ret;
3350             }
3351             pkt->stream_index = index;
3352             pkt->pos = klv.offset;
3353
3354             ret = mxf_set_pts(mxf, st, pkt, next_ofs);
3355             if (ret < 0)
3356                 return ret;
3357
3358             /* seek for truncated packets */
3359             avio_seek(s->pb, klv.next_klv, SEEK_SET);
3360
3361             return 0;
3362         } else
3363         skip:
3364             avio_skip(s->pb, klv.length);
3365     }
3366     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3367 }
3368
3369 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3370 {
3371     MXFContext *mxf = s->priv_data;
3372     int ret, size;
3373     int64_t ret64, pos, next_pos;
3374     AVStream *st;
3375     MXFIndexTable *t;
3376     MXFTrack *track;
3377     int edit_units;
3378
3379     if (mxf->op != OPAtom)
3380         return mxf_read_packet_old(s, pkt);
3381
3382     // If we have no streams then we basically are at EOF
3383     st = mxf_get_opatom_stream(mxf);
3384     if (!st)
3385         return AVERROR_EOF;
3386
3387     track = st->priv_data;
3388
3389     /* OPAtom - clip wrapped demuxing */
3390     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3391     t = &mxf->index_tables[0];
3392
3393     if (mxf->current_edit_unit >= track->original_duration)
3394         return AVERROR_EOF;
3395
3396     edit_units = FFMIN(mxf->edit_units_per_packet, track->original_duration - mxf->current_edit_unit);
3397
3398     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3399         return ret;
3400
3401     /* compute size by finding the next edit unit or the end of the essence container
3402      * not pretty, but it works */
3403     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3404         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3405         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3406         return AVERROR_INVALIDDATA;
3407     }
3408
3409     if ((size = next_pos - pos) <= 0) {
3410         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3411         return AVERROR_INVALIDDATA;
3412     }
3413
3414     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3415         return ret64;
3416
3417     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3418         return size;
3419
3420     pkt->stream_index = st->index;
3421
3422     ret = mxf_set_pts(mxf, st, pkt, next_pos);
3423     if (ret < 0)
3424         return ret;
3425
3426     mxf->current_edit_unit += edit_units;
3427
3428     return 0;
3429 }
3430
3431 static int mxf_read_close(AVFormatContext *s)
3432 {
3433     MXFContext *mxf = s->priv_data;
3434     int i;
3435
3436     av_freep(&mxf->packages_refs);
3437     av_freep(&mxf->essence_container_data_refs);
3438
3439     for (i = 0; i < s->nb_streams; i++)
3440         s->streams[i]->priv_data = NULL;
3441
3442     for (i = 0; i < mxf->metadata_sets_count; i++) {
3443         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3444     }
3445     av_freep(&mxf->partitions);
3446     av_freep(&mxf->metadata_sets);
3447     av_freep(&mxf->aesc);
3448     av_freep(&mxf->local_tags);
3449
3450     if (mxf->index_tables) {
3451         for (i = 0; i < mxf->nb_index_tables; i++) {
3452             av_freep(&mxf->index_tables[i].segments);
3453             av_freep(&mxf->index_tables[i].ptses);
3454             av_freep(&mxf->index_tables[i].fake_index);
3455             av_freep(&mxf->index_tables[i].offsets);
3456         }
3457     }
3458     av_freep(&mxf->index_tables);
3459
3460     return 0;
3461 }
3462
3463 static int mxf_probe(AVProbeData *p) {
3464     const uint8_t *bufp = p->buf;
3465     const uint8_t *end = p->buf + p->buf_size;
3466
3467     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3468         return 0;
3469
3470     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3471     end -= sizeof(mxf_header_partition_pack_key);
3472
3473     for (; bufp < end;) {
3474         if (!((bufp[13] - 1) & 0xF2)){
3475             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3476                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3477                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3478                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3479                 return AVPROBE_SCORE_MAX;
3480             bufp ++;
3481         } else
3482             bufp += 10;
3483     }
3484
3485     return 0;
3486 }
3487
3488 /* rudimentary byte seek */
3489 /* XXX: use MXF Index */
3490 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3491 {
3492     AVStream *st = s->streams[stream_index];
3493     int64_t seconds;
3494     MXFContext* mxf = s->priv_data;
3495     int64_t seekpos;
3496     int i, ret;
3497     MXFIndexTable *t;
3498     MXFTrack *source_track = st->priv_data;
3499
3500     if (!source_track)
3501         return 0;
3502
3503     /* if audio then truncate sample_time to EditRate */
3504     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3505         sample_time = av_rescale_q(sample_time, st->time_base,
3506                                    av_inv_q(source_track->edit_rate));
3507
3508     if (mxf->nb_index_tables <= 0) {
3509         if (!s->bit_rate)
3510             return AVERROR_INVALIDDATA;
3511         if (sample_time < 0)
3512             sample_time = 0;
3513         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3514
3515         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3516         if (seekpos < 0)
3517             return seekpos;
3518
3519         ff_update_cur_dts(s, st, sample_time);
3520         mxf->current_edit_unit = sample_time;
3521     } else {
3522         t = &mxf->index_tables[0];
3523         if (t->index_sid != source_track->index_sid) {
3524             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3525             for (i = 0; i < s->nb_streams; i++) {
3526                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3527                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3528                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3529                     source_track = new_source_track;
3530                     st = s->streams[i];
3531                     break;
3532                 }
3533             }
3534             if (i == s->nb_streams)
3535                 return AVERROR_INVALIDDATA;
3536         }
3537
3538         /* clamp above zero, else ff_index_search_timestamp() returns negative
3539          * this also means we allow seeking before the start */
3540         sample_time = FFMAX(sample_time, 0);
3541
3542         if (t->fake_index) {
3543             /* The first frames may not be keyframes in presentation order, so
3544              * we have to advance the target to be able to find the first
3545              * keyframe backwards... */
3546             if (!(flags & AVSEEK_FLAG_ANY) &&
3547                 (flags & AVSEEK_FLAG_BACKWARD) &&
3548                 t->ptses[0] != AV_NOPTS_VALUE &&
3549                 sample_time < t->ptses[0] &&
3550                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3551                 sample_time = t->ptses[0];
3552
3553             /* behave as if we have a proper index */
3554             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3555                 return sample_time;
3556             /* get the stored order index from the display order index */
3557             sample_time += t->offsets[sample_time];
3558         } else {
3559             /* no IndexEntryArray (one or more CBR segments)
3560              * make sure we don't seek past the end */
3561             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3562         }
3563
3564         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3565             return ret;
3566
3567         ff_update_cur_dts(s, st, sample_time);
3568         mxf->current_edit_unit = sample_time;
3569         avio_seek(s->pb, seekpos, SEEK_SET);
3570     }
3571
3572     // Update all tracks sample count
3573     for (i = 0; i < s->nb_streams; i++) {
3574         AVStream *cur_st = s->streams[i];
3575         MXFTrack *cur_track = cur_st->priv_data;
3576         if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3577             int64_t track_edit_unit;
3578             if (st != cur_st && mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit) >= 0) {
3579                 cur_track->sample_count = av_rescale_q(track_edit_unit,
3580                                                        av_inv_q(cur_track->edit_rate),
3581                                                        cur_st->time_base);
3582             } else {
3583                 uint64_t current_sample_count = 0;
3584                 ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
3585                 if (ret < 0)
3586                     return ret;
3587                 cur_track->sample_count = current_sample_count;
3588             }
3589         }
3590     }
3591     return 0;
3592 }
3593
3594 AVInputFormat ff_mxf_demuxer = {
3595     .name           = "mxf",
3596     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3597     .flags          = AVFMT_SEEK_TO_PTS,
3598     .priv_data_size = sizeof(MXFContext),
3599     .read_probe     = mxf_probe,
3600     .read_header    = mxf_read_header,
3601     .read_packet    = mxf_read_packet,
3602     .read_close     = mxf_read_close,
3603     .read_seek      = mxf_read_seek,
3604 };