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