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