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