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