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