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