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