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