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