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