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