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