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