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