avcodec/libdav1d: pass auto threads value to libdav1d
[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, J2KWrap },
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         case J2KWrap:
1499             if (val != 0x02)
1500                 val = 0x01;
1501             break;
1502     }
1503     if (val == 0x01)
1504         return FrameWrapped;
1505     if (val == 0x02)
1506         return ClipWrapped;
1507     return UnknownWrapped;
1508 }
1509
1510 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1511 {
1512     int i, j, nb_segments = 0;
1513     MXFIndexTableSegment **unsorted_segments;
1514     int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1515
1516     /* count number of segments, allocate arrays and copy unsorted segments */
1517     for (i = 0; i < mxf->metadata_sets_count; i++)
1518         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1519             nb_segments++;
1520
1521     if (!nb_segments)
1522         return AVERROR_INVALIDDATA;
1523
1524     if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1525         !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1526         av_freep(sorted_segments);
1527         av_free(unsorted_segments);
1528         return AVERROR(ENOMEM);
1529     }
1530
1531     for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1532         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1533             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1534             if (s->edit_unit_byte_count || s->nb_index_entries)
1535                 unsorted_segments[nb_segments++] = s;
1536             else
1537                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1538                        s->index_sid, s->index_start_position);
1539         }
1540     }
1541
1542     if (!nb_segments) {
1543         av_freep(sorted_segments);
1544         av_free(unsorted_segments);
1545         return AVERROR_INVALIDDATA;
1546     }
1547
1548     *nb_sorted_segments = 0;
1549
1550     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1551     for (i = 0; i < nb_segments; i++) {
1552         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1553         uint64_t best_index_duration = 0;
1554
1555         for (j = 0; j < nb_segments; j++) {
1556             MXFIndexTableSegment *s = unsorted_segments[j];
1557
1558             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1559              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1560              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1561              */
1562             if ((i == 0 ||
1563                  s->body_sid >  last_body_sid ||
1564                  s->body_sid == last_body_sid && s->index_sid >  last_index_sid ||
1565                  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1566                 (best == -1 ||
1567                  s->body_sid <  best_body_sid ||
1568                  s->body_sid == best_body_sid && s->index_sid <  best_index_sid ||
1569                  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position <  best_index_start ||
1570                  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)) {
1571                 best             = j;
1572                 best_body_sid    = s->body_sid;
1573                 best_index_sid   = s->index_sid;
1574                 best_index_start = s->index_start_position;
1575                 best_index_duration = s->index_duration;
1576             }
1577         }
1578
1579         /* no suitable entry found -> we're done */
1580         if (best == -1)
1581             break;
1582
1583         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1584         last_body_sid    = best_body_sid;
1585         last_index_sid   = best_index_sid;
1586         last_index_start = best_index_start;
1587     }
1588
1589     av_free(unsorted_segments);
1590
1591     return 0;
1592 }
1593
1594 /**
1595  * Computes the absolute file offset of the given essence container offset
1596  */
1597 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1598 {
1599     MXFPartition *last_p = NULL;
1600     int a, b, m, m0;
1601
1602     if (offset < 0)
1603         return AVERROR(EINVAL);
1604
1605     a = -1;
1606     b = mxf->partitions_count;
1607
1608     while (b - a > 1) {
1609         m0 = m = (a + b) >> 1;
1610
1611         while (m < b && mxf->partitions[m].body_sid != body_sid)
1612             m++;
1613
1614         if (m < b && mxf->partitions[m].body_offset <= offset)
1615             a = m;
1616         else
1617             b = m0;
1618     }
1619
1620     if (a >= 0)
1621         last_p = &mxf->partitions[a];
1622
1623     if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1624         *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1625         if (partition_out)
1626             *partition_out = last_p;
1627         return 0;
1628     }
1629
1630     av_log(mxf->fc, AV_LOG_ERROR,
1631            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1632            offset, body_sid);
1633
1634     return AVERROR_INVALIDDATA;
1635 }
1636
1637 /**
1638  * Returns the end position of the essence container with given BodySID, or zero if unknown
1639  */
1640 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1641 {
1642     for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1643         MXFPartition *p = &mxf->partitions[x];
1644
1645         if (p->body_sid != body_sid)
1646             continue;
1647
1648         if (!p->essence_length)
1649             return 0;
1650
1651         return p->essence_offset + p->essence_length;
1652     }
1653
1654     return 0;
1655 }
1656
1657 /* EditUnit -> absolute offset */
1658 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)
1659 {
1660     int i;
1661     int64_t offset_temp = 0;
1662
1663     edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1664
1665     for (i = 0; i < index_table->nb_segments; i++) {
1666         MXFIndexTableSegment *s = index_table->segments[i];
1667
1668         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1669
1670         if (edit_unit < s->index_start_position + s->index_duration) {
1671             int64_t index = edit_unit - s->index_start_position;
1672
1673             if (s->edit_unit_byte_count)
1674                 offset_temp += s->edit_unit_byte_count * index;
1675             else {
1676                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1677                     index *= 2;     /* Avid index */
1678
1679                 if (index < 0 || index >= s->nb_index_entries) {
1680                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1681                            index_table->index_sid, s->index_start_position);
1682                     return AVERROR_INVALIDDATA;
1683                 }
1684
1685                 offset_temp = s->stream_offset_entries[index];
1686             }
1687
1688             if (edit_unit_out)
1689                 *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1690
1691             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1692         } else {
1693             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1694             offset_temp += s->edit_unit_byte_count * s->index_duration;
1695         }
1696     }
1697
1698     if (nag)
1699         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);
1700
1701     return AVERROR_INVALIDDATA;
1702 }
1703
1704 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1705 {
1706     int i, j, x;
1707     int8_t max_temporal_offset = -128;
1708     uint8_t *flags;
1709
1710     /* first compute how many entries we have */
1711     for (i = 0; i < index_table->nb_segments; i++) {
1712         MXFIndexTableSegment *s = index_table->segments[i];
1713
1714         if (!s->nb_index_entries) {
1715             index_table->nb_ptses = 0;
1716             return 0;                               /* no TemporalOffsets */
1717         }
1718
1719         if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1720             index_table->nb_ptses = 0;
1721             av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1722             return 0;
1723         }
1724
1725         index_table->nb_ptses += s->index_duration;
1726     }
1727
1728     /* paranoid check */
1729     if (index_table->nb_ptses <= 0)
1730         return 0;
1731
1732     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1733         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1734         !(index_table->offsets    = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1735         !(flags                   = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1736         av_freep(&index_table->ptses);
1737         av_freep(&index_table->fake_index);
1738         av_freep(&index_table->offsets);
1739         return AVERROR(ENOMEM);
1740     }
1741
1742     /* we may have a few bad TemporalOffsets
1743      * make sure the corresponding PTSes don't have the bogus value 0 */
1744     for (x = 0; x < index_table->nb_ptses; x++)
1745         index_table->ptses[x] = AV_NOPTS_VALUE;
1746
1747     /**
1748      * We have this:
1749      *
1750      * x  TemporalOffset
1751      * 0:  0
1752      * 1:  1
1753      * 2:  1
1754      * 3: -2
1755      * 4:  1
1756      * 5:  1
1757      * 6: -2
1758      *
1759      * We want to transform it into this:
1760      *
1761      * x  DTS PTS
1762      * 0: -1   0
1763      * 1:  0   3
1764      * 2:  1   1
1765      * 3:  2   2
1766      * 4:  3   6
1767      * 5:  4   4
1768      * 6:  5   5
1769      *
1770      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1771      * then settings mxf->internal->first_dts = -max(TemporalOffset[x]).
1772      * The latter makes DTS <= PTS.
1773      */
1774     for (i = x = 0; i < index_table->nb_segments; i++) {
1775         MXFIndexTableSegment *s = index_table->segments[i];
1776         int index_delta = 1;
1777         int n = s->nb_index_entries;
1778
1779         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1780             index_delta = 2;    /* Avid index */
1781             /* ignore the last entry - it's the size of the essence container */
1782             n--;
1783         }
1784
1785         for (j = 0; j < n; j += index_delta, x++) {
1786             int offset = s->temporal_offset_entries[j] / index_delta;
1787             int index  = x + offset;
1788
1789             if (x >= index_table->nb_ptses) {
1790                 av_log(mxf->fc, AV_LOG_ERROR,
1791                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1792                        s->nb_index_entries, s->index_duration);
1793                 break;
1794             }
1795
1796             flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1797
1798             if (index < 0 || index >= index_table->nb_ptses) {
1799                 av_log(mxf->fc, AV_LOG_ERROR,
1800                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1801                        x, offset, index);
1802                 continue;
1803             }
1804
1805             index_table->offsets[x] = offset;
1806             index_table->ptses[index] = x;
1807             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1808         }
1809     }
1810
1811     /* calculate the fake index table in display order */
1812     for (x = 0; x < index_table->nb_ptses; x++) {
1813         index_table->fake_index[x].timestamp = x;
1814         if (index_table->ptses[x] != AV_NOPTS_VALUE)
1815             index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1816     }
1817     av_freep(&flags);
1818
1819     index_table->first_dts = -max_temporal_offset;
1820
1821     return 0;
1822 }
1823
1824 /**
1825  * Sorts and collects index table segments into index tables.
1826  * Also computes PTSes if possible.
1827  */
1828 static int mxf_compute_index_tables(MXFContext *mxf)
1829 {
1830     int i, j, k, ret, nb_sorted_segments;
1831     MXFIndexTableSegment **sorted_segments = NULL;
1832
1833     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1834         nb_sorted_segments <= 0) {
1835         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1836         return 0;
1837     }
1838
1839     /* sanity check and count unique BodySIDs/IndexSIDs */
1840     for (i = 0; i < nb_sorted_segments; i++) {
1841         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1842             mxf->nb_index_tables++;
1843         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1844             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1845             ret = AVERROR_INVALIDDATA;
1846             goto finish_decoding_index;
1847         }
1848     }
1849
1850     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1851                                          sizeof(*mxf->index_tables));
1852     if (!mxf->index_tables) {
1853         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1854         ret = AVERROR(ENOMEM);
1855         goto finish_decoding_index;
1856     }
1857
1858     /* distribute sorted segments to index tables */
1859     for (i = j = 0; i < nb_sorted_segments; i++) {
1860         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1861             /* next IndexSID */
1862             j++;
1863         }
1864
1865         mxf->index_tables[j].nb_segments++;
1866     }
1867
1868     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1869         MXFIndexTable *t = &mxf->index_tables[j];
1870         MXFTrack *mxf_track = NULL;
1871
1872         t->segments = av_mallocz_array(t->nb_segments,
1873                                        sizeof(*t->segments));
1874
1875         if (!t->segments) {
1876             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1877                    " pointer array\n");
1878             ret = AVERROR(ENOMEM);
1879             goto finish_decoding_index;
1880         }
1881
1882         if (sorted_segments[i]->index_start_position)
1883             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1884                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1885
1886         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1887         t->index_sid = sorted_segments[i]->index_sid;
1888         t->body_sid = sorted_segments[i]->body_sid;
1889
1890         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1891             goto finish_decoding_index;
1892
1893         for (k = 0; k < mxf->fc->nb_streams; k++) {
1894             MXFTrack *track = mxf->fc->streams[k]->priv_data;
1895             if (track && track->index_sid == t->index_sid) {
1896                 mxf_track = track;
1897                 break;
1898             }
1899         }
1900
1901         /* fix zero IndexDurations */
1902         for (k = 0; k < t->nb_segments; k++) {
1903             if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
1904                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
1905                        t->index_sid, k);
1906                 if (mxf_track)
1907                     t->segments[k]->index_edit_rate = mxf_track->edit_rate;
1908             }
1909
1910             if (t->segments[k]->index_duration)
1911                 continue;
1912
1913             if (t->nb_segments > 1)
1914                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1915                        t->index_sid, k);
1916
1917             if (!mxf_track) {
1918                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1919                 break;
1920             }
1921
1922             /* assume the first stream's duration is reasonable
1923              * leave index_duration = 0 on further segments in case we have any (unlikely)
1924              */
1925             t->segments[k]->index_duration = mxf_track->original_duration;
1926             break;
1927         }
1928     }
1929
1930     ret = 0;
1931 finish_decoding_index:
1932     av_free(sorted_segments);
1933     return ret;
1934 }
1935
1936 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1937 {
1938     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1939                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1940            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1941                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1942 }
1943
1944 static int mxf_uid_to_str(UID uid, char **str)
1945 {
1946     int i;
1947     char *p;
1948     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1949     if (!p)
1950         return AVERROR(ENOMEM);
1951     for (i = 0; i < sizeof(UID); i++) {
1952         snprintf(p, 2 + 1, "%.2x", uid[i]);
1953         p += 2;
1954         if (i == 3 || i == 5 || i == 7 || i == 9) {
1955             snprintf(p, 1 + 1, "-");
1956             p++;
1957         }
1958     }
1959     return 0;
1960 }
1961
1962 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1963 {
1964     int i;
1965     char *p;
1966     p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1967     if (!p)
1968         return AVERROR(ENOMEM);
1969     snprintf(p, 2 + 1, "0x");
1970     p += 2;
1971     for (i = 0; i < sizeof(UID); i++) {
1972         snprintf(p, 2 + 1, "%.2X", ul[i]);
1973         p += 2;
1974
1975     }
1976     for (i = 0; i < sizeof(UID); i++) {
1977         snprintf(p, 2 + 1, "%.2X", uid[i]);
1978         p += 2;
1979     }
1980     return 0;
1981 }
1982
1983 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
1984                               uint16_t patch, uint16_t release, char **str)
1985 {
1986     *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
1987     if (!*str)
1988         return AVERROR(ENOMEM);
1989     return 0;
1990 }
1991
1992 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1993 {
1994     char *str;
1995     int ret;
1996     if (!package)
1997         return 0;
1998     if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1999         return ret;
2000     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
2001     return 0;
2002 }
2003
2004 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2005 {
2006     char buf[AV_TIMECODE_STR_SIZE];
2007     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2008
2009     return 0;
2010 }
2011
2012 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2013 {
2014     MXFStructuralComponent *component = NULL;
2015     MXFPulldownComponent *pulldown = NULL;
2016
2017     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2018     if (!component)
2019         return NULL;
2020
2021     switch (component->type) {
2022     case TimecodeComponent:
2023         return (MXFTimecodeComponent*)component;
2024     case PulldownComponent: /* timcode component may be located on a pulldown component */
2025         pulldown = (MXFPulldownComponent*)component;
2026         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2027     default:
2028         break;
2029     }
2030     return NULL;
2031 }
2032
2033 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2034 {
2035     MXFPackage *package = NULL;
2036     int i;
2037
2038     for (i = 0; i < mxf->packages_count; i++) {
2039         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2040         if (!package)
2041             continue;
2042
2043         if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2044             return package;
2045     }
2046     return NULL;
2047 }
2048
2049 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
2050 {
2051     MXFDescriptor *sub_descriptor = NULL;
2052     int i;
2053
2054     if (!descriptor)
2055         return NULL;
2056
2057     if (descriptor->type == MultipleDescriptor) {
2058         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
2059             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
2060
2061             if (!sub_descriptor) {
2062                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
2063                 continue;
2064             }
2065             if (sub_descriptor->linked_track_id == track_id) {
2066                 return sub_descriptor;
2067             }
2068         }
2069     } else if (descriptor->type == Descriptor)
2070         return descriptor;
2071
2072     return NULL;
2073 }
2074
2075 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
2076 {
2077     MXFStructuralComponent *component = NULL;
2078     MXFPackage *package = NULL;
2079     MXFDescriptor *descriptor = NULL;
2080     int i;
2081
2082     if (!essence_group || !essence_group->structural_components_count)
2083         return NULL;
2084
2085     /* essence groups contains multiple representations of the same media,
2086        this return the first components with a valid Descriptor typically index 0 */
2087     for (i =0; i < essence_group->structural_components_count; i++){
2088         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2089         if (!component)
2090             continue;
2091
2092         if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2093             continue;
2094
2095         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2096         if (descriptor)
2097             return component;
2098     }
2099     return NULL;
2100 }
2101
2102 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2103 {
2104     MXFStructuralComponent *component = NULL;
2105
2106     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2107     if (!component)
2108         return NULL;
2109     switch (component->type) {
2110         case SourceClip:
2111             return component;
2112         case EssenceGroup:
2113             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
2114         default:
2115             break;
2116     }
2117     return NULL;
2118 }
2119
2120 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2121 {
2122     MXFTaggedValue *tag;
2123     int i;
2124     char *key = NULL;
2125
2126     for (i = 0; i < package->comment_count; i++) {
2127         tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2128         if (!tag || !tag->name || !tag->value)
2129             continue;
2130
2131         key = av_asprintf("comment_%s", tag->name);
2132         if (!key)
2133             return AVERROR(ENOMEM);
2134
2135         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2136     }
2137     return 0;
2138 }
2139
2140 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2141 {
2142     MXFPackage *physical_package = NULL;
2143     MXFTrack *physical_track = NULL;
2144     MXFStructuralComponent *sourceclip = NULL;
2145     MXFTimecodeComponent *mxf_tc = NULL;
2146     int i, j, k;
2147     AVTimecode tc;
2148     int flags;
2149     int64_t start_position;
2150
2151     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2152         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2153         if (!sourceclip)
2154             continue;
2155
2156         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2157             break;
2158
2159         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2160
2161         /* the name of physical source package is name of the reel or tape */
2162         if (physical_package->name && physical_package->name[0])
2163             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2164
2165         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2166          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2167          */
2168         for (j = 0; j < physical_package->tracks_count; j++) {
2169             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2170                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2171                 continue;
2172             }
2173
2174             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2175                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2176                 continue;
2177             }
2178
2179             if (physical_track->edit_rate.num <= 0 ||
2180                 physical_track->edit_rate.den <= 0) {
2181                 av_log(mxf->fc, AV_LOG_WARNING,
2182                        "Invalid edit rate (%d/%d) found on structural"
2183                        " component #%d, defaulting to 25/1\n",
2184                        physical_track->edit_rate.num,
2185                        physical_track->edit_rate.den, i);
2186                 physical_track->edit_rate = (AVRational){25, 1};
2187             }
2188
2189             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2190                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2191                     continue;
2192
2193                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2194                 /* scale sourceclip start_position to match physical track edit rate */
2195                 start_position = av_rescale_q(sourceclip->start_position,
2196                                               physical_track->edit_rate,
2197                                               source_track->edit_rate);
2198
2199                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2200                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2201                     return 0;
2202                 }
2203             }
2204         }
2205     }
2206
2207     return 0;
2208 }
2209
2210 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2211 {
2212     MXFStructuralComponent *component = NULL;
2213     const MXFCodecUL *codec_ul = NULL;
2214     MXFPackage tmp_package;
2215     AVStream *st;
2216     int j;
2217
2218     for (j = 0; j < track->sequence->structural_components_count; j++) {
2219         component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2220         if (!component)
2221             continue;
2222         break;
2223     }
2224     if (!component)
2225         return 0;
2226
2227     st = avformat_new_stream(mxf->fc, NULL);
2228     if (!st) {
2229         av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2230         return AVERROR(ENOMEM);
2231     }
2232
2233     st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2234     st->codecpar->codec_id = AV_CODEC_ID_NONE;
2235     st->id = track->track_id;
2236
2237     memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2238     memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2239     mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2240     if (track->name && track->name[0])
2241         av_dict_set(&st->metadata, "track_name", track->name, 0);
2242
2243     codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2244     av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2245     return 0;
2246 }
2247
2248 static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2249 {
2250     if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2251         /* CDCI range metadata */
2252         if (!descriptor->component_depth)
2253             return AVCOL_RANGE_UNSPECIFIED;
2254         if (descriptor->black_ref_level == 0 &&
2255             descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2256             (descriptor->color_range    == (1<<descriptor->component_depth) ||
2257              descriptor->color_range    == ((1<<descriptor->component_depth) - 1)))
2258             return AVCOL_RANGE_JPEG;
2259         if (descriptor->component_depth >= 8 &&
2260             descriptor->black_ref_level == (1  <<(descriptor->component_depth - 4)) &&
2261             descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2262             descriptor->color_range     == ((14<<(descriptor->component_depth - 4)) + 1))
2263             return AVCOL_RANGE_MPEG;
2264         avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2265                               descriptor->color_range, descriptor->black_ref_level,
2266                               descriptor->white_ref_level, descriptor->component_depth);
2267     }
2268
2269     return AVCOL_RANGE_UNSPECIFIED;
2270 }
2271
2272 static int mxf_parse_structural_metadata(MXFContext *mxf)
2273 {
2274     MXFPackage *material_package = NULL;
2275     int i, j, k, ret;
2276
2277     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2278     /* TODO: handle multiple material packages (OP3x) */
2279     for (i = 0; i < mxf->packages_count; i++) {
2280         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2281         if (material_package) break;
2282     }
2283     if (!material_package) {
2284         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2285         return AVERROR_INVALIDDATA;
2286     }
2287
2288     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2289     if (material_package->name && material_package->name[0])
2290         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2291     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2292
2293     for (i = 0; i < material_package->tracks_count; i++) {
2294         MXFPackage *source_package = NULL;
2295         MXFTrack *material_track = NULL;
2296         MXFTrack *source_track = NULL;
2297         MXFTrack *temp_track = NULL;
2298         MXFDescriptor *descriptor = NULL;
2299         MXFStructuralComponent *component = NULL;
2300         MXFTimecodeComponent *mxf_tc = NULL;
2301         UID *essence_container_ul = NULL;
2302         const MXFCodecUL *codec_ul = NULL;
2303         const MXFCodecUL *container_ul = NULL;
2304         const MXFCodecUL *pix_fmt_ul = NULL;
2305         AVStream *st;
2306         AVTimecode tc;
2307         int flags;
2308
2309         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2310             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2311             continue;
2312         }
2313
2314         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2315             mxf_tc = (MXFTimecodeComponent*)component;
2316             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2317             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2318                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2319             }
2320         }
2321
2322         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2323             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2324             continue;
2325         }
2326
2327         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2328             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2329             if (!component)
2330                 continue;
2331
2332             mxf_tc = (MXFTimecodeComponent*)component;
2333             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2334             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2335                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2336                 break;
2337             }
2338         }
2339
2340         /* TODO: handle multiple source clips, only finds first valid source clip */
2341         if(material_track->sequence->structural_components_count > 1)
2342             av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2343                        material_track->track_id, material_track->sequence->structural_components_count);
2344
2345         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2346             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2347             if (!component)
2348                 continue;
2349
2350             source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2351             if (!source_package) {
2352                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2353                 continue;
2354             }
2355             for (k = 0; k < source_package->tracks_count; k++) {
2356                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2357                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2358                     ret = AVERROR_INVALIDDATA;
2359                     goto fail_and_free;
2360                 }
2361                 if (temp_track->track_id == component->source_track_id) {
2362                     source_track = temp_track;
2363                     break;
2364                 }
2365             }
2366             if (!source_track) {
2367                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2368                 break;
2369             }
2370
2371             for (k = 0; k < mxf->essence_container_data_count; k++) {
2372                 MXFEssenceContainerData *essence_data;
2373
2374                 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2375                     av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2376                     continue;
2377                 }
2378                 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2379                     source_track->body_sid = essence_data->body_sid;
2380                     source_track->index_sid = essence_data->index_sid;
2381                     break;
2382                 }
2383             }
2384
2385             if(source_track && component)
2386                 break;
2387         }
2388         if (!source_track || !component || !source_package) {
2389             if((ret = mxf_add_metadata_stream(mxf, material_track)))
2390                 goto fail_and_free;
2391             continue;
2392         }
2393
2394         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2395             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2396             ret = AVERROR_INVALIDDATA;
2397             goto fail_and_free;
2398         }
2399
2400         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2401          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2402         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2403             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2404             continue;
2405         }
2406
2407         st = avformat_new_stream(mxf->fc, NULL);
2408         if (!st) {
2409             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2410             ret = AVERROR(ENOMEM);
2411             goto fail_and_free;
2412         }
2413         st->id = material_track->track_id;
2414         st->priv_data = source_track;
2415
2416         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2417         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2418
2419         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2420          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2421         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2422             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2423         else
2424             source_track->original_duration = st->duration = component->duration;
2425
2426         if (st->duration == -1)
2427             st->duration = AV_NOPTS_VALUE;
2428         st->start_time = component->start_position;
2429         if (material_track->edit_rate.num <= 0 ||
2430             material_track->edit_rate.den <= 0) {
2431             av_log(mxf->fc, AV_LOG_WARNING,
2432                    "Invalid edit rate (%d/%d) found on stream #%d, "
2433                    "defaulting to 25/1\n",
2434                    material_track->edit_rate.num,
2435                    material_track->edit_rate.den, st->index);
2436             material_track->edit_rate = (AVRational){25, 1};
2437         }
2438         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2439
2440         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2441          * the former is accessible via st->priv_data */
2442         source_track->edit_rate = material_track->edit_rate;
2443
2444         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
2445         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2446         st->codecpar->codec_type = codec_ul->id;
2447
2448         if (!descriptor) {
2449             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2450             continue;
2451         }
2452         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
2453         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2454         essence_container_ul = &descriptor->essence_container_ul;
2455         source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2456         if (source_track->wrapping == UnknownWrapped)
2457             av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2458         /* HACK: replacing the original key with mxf_encrypted_essence_container
2459          * is not allowed according to s429-6, try to find correct information anyway */
2460         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2461             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2462             for (k = 0; k < mxf->metadata_sets_count; k++) {
2463                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2464                 if (metadata->type == CryptoContext) {
2465                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2466                     break;
2467                 }
2468             }
2469         }
2470
2471         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2472         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2473         st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2474         if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2475             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2476             st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2477         }
2478
2479         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2480                avcodec_get_name(st->codecpar->codec_id));
2481         for (k = 0; k < 16; k++) {
2482             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2483                    descriptor->essence_codec_ul[k]);
2484             if (!(k+1 & 19) || k == 5)
2485                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2486         }
2487         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2488
2489         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2490         if (source_package->name && source_package->name[0])
2491             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2492         if (material_track->name && material_track->name[0])
2493             av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2494
2495         mxf_parse_physical_source_package(mxf, source_track, st);
2496
2497         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2498             source_track->intra_only = mxf_is_intra_only(descriptor);
2499             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2500             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2501                 st->codecpar->codec_id = container_ul->id;
2502             st->codecpar->width = descriptor->width;
2503             st->codecpar->height = descriptor->height; /* Field height, not frame height */
2504             switch (descriptor->frame_layout) {
2505                 case FullFrame:
2506                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2507                     break;
2508                 case OneField:
2509                     /* Every other line is stored and needs to be duplicated. */
2510                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2511                     break; /* The correct thing to do here is fall through, but by breaking we might be
2512                               able to decode some streams at half the vertical resolution, rather than not al all.
2513                               It's also for compatibility with the old behavior. */
2514                 case MixedFields:
2515                     break;
2516                 case SegmentedFrame:
2517                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2518                 case SeparateFields:
2519                     av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2520                            descriptor->video_line_map[0], descriptor->video_line_map[1],
2521                            descriptor->field_dominance);
2522                     if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2523                         /* Detect coded field order from VideoLineMap:
2524                          *  (even, even) => bottom field coded first
2525                          *  (even, odd)  => top field coded first
2526                          *  (odd, even)  => top field coded first
2527                          *  (odd, odd)   => bottom field coded first
2528                          */
2529                         if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2530                             switch (descriptor->field_dominance) {
2531                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2532                                 case MXF_FIELD_DOMINANCE_FF:
2533                                     st->codecpar->field_order = AV_FIELD_TT;
2534                                     break;
2535                                 case MXF_FIELD_DOMINANCE_FL:
2536                                     st->codecpar->field_order = AV_FIELD_TB;
2537                                     break;
2538                                 default:
2539                                     avpriv_request_sample(mxf->fc,
2540                                                           "Field dominance %d support",
2541                                                           descriptor->field_dominance);
2542                             }
2543                         } else {
2544                             switch (descriptor->field_dominance) {
2545                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2546                                 case MXF_FIELD_DOMINANCE_FF:
2547                                     st->codecpar->field_order = AV_FIELD_BB;
2548                                     break;
2549                                 case MXF_FIELD_DOMINANCE_FL:
2550                                     st->codecpar->field_order = AV_FIELD_BT;
2551                                     break;
2552                                 default:
2553                                     avpriv_request_sample(mxf->fc,
2554                                                           "Field dominance %d support",
2555                                                           descriptor->field_dominance);
2556                             }
2557                         }
2558                     }
2559                     /* Turn field height into frame height. */
2560                     st->codecpar->height *= 2;
2561                     break;
2562                 default:
2563                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2564             }
2565
2566             if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2567                 switch (descriptor->essence_codec_ul[14]) {
2568                 case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2569                 case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2570                 case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2571                 case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2572                 case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2573                 case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2574                 }
2575             }
2576
2577             if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2578                 st->codecpar->format = descriptor->pix_fmt;
2579                 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2580                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2581                                                   &descriptor->essence_codec_ul);
2582                     st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2583                     if (st->codecpar->format== AV_PIX_FMT_NONE) {
2584                         st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2585                                                                    &descriptor->essence_codec_ul)->id;
2586                         if (!st->codecpar->codec_tag) {
2587                             /* support files created before RP224v10 by defaulting to UYVY422
2588                                if subsampling is 4:2:2 and component depth is 8-bit */
2589                             if (descriptor->horiz_subsampling == 2 &&
2590                                 descriptor->vert_subsampling == 1 &&
2591                                 descriptor->component_depth == 8) {
2592                                 st->codecpar->format = AV_PIX_FMT_UYVY422;
2593                             }
2594                         }
2595                     }
2596                 }
2597             }
2598             st->internal->need_parsing = AVSTREAM_PARSE_HEADERS;
2599             if (material_track->sequence->origin) {
2600                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2601             }
2602             if (source_track->sequence->origin) {
2603                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2604             }
2605             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2606                 st->internal->display_aspect_ratio = descriptor->aspect_ratio;
2607             st->codecpar->color_range     = mxf_get_color_range(mxf, descriptor);
2608             st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
2609             st->codecpar->color_trc       = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
2610             st->codecpar->color_space     = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
2611             if (descriptor->mastering) {
2612                 ret = av_stream_add_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
2613                                               (uint8_t *)descriptor->mastering,
2614                                               sizeof(*descriptor->mastering));
2615                 if (ret < 0)
2616                     goto fail_and_free;
2617                 descriptor->mastering = NULL;
2618             }
2619             if (descriptor->coll) {
2620                 ret = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
2621                                               (uint8_t *)descriptor->coll,
2622                                               descriptor->coll_size);
2623                 if (ret < 0)
2624                     goto fail_and_free;
2625                 descriptor->coll = NULL;
2626             }
2627         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2628             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2629             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2630             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))
2631                 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2632             st->codecpar->channels = descriptor->channels;
2633
2634             if (descriptor->sample_rate.den > 0) {
2635                 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2636                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2637             } else {
2638                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2639                        "found for stream #%d, time base forced to 1/48000\n",
2640                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2641                        st->index);
2642                 avpriv_set_pts_info(st, 64, 1, 48000);
2643             }
2644
2645             /* if duration is set, rescale it from EditRate to SampleRate */
2646             if (st->duration != AV_NOPTS_VALUE)
2647                 st->duration = av_rescale_q(st->duration,
2648                                             av_inv_q(material_track->edit_rate),
2649                                             st->time_base);
2650
2651             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2652             if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2653                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2654                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2655                 else if (descriptor->bits_per_sample == 32)
2656                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2657             } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2658                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2659                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2660                 else if (descriptor->bits_per_sample == 32)
2661                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2662             } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2663                 st->internal->need_parsing = AVSTREAM_PARSE_FULL;
2664             }
2665             st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2666         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2667             enum AVMediaType type;
2668             container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2669             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2670                 st->codecpar->codec_id = container_ul->id;
2671             type = avcodec_get_type(st->codecpar->codec_id);
2672             if (type == AVMEDIA_TYPE_SUBTITLE)
2673                 st->codecpar->codec_type = type;
2674             if (container_ul->desc)
2675                 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2676             if (mxf->eia608_extract &&
2677                 !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2678                 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2679                 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
2680             }
2681         }
2682         if (descriptor->extradata) {
2683             if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2684                 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2685             }
2686         } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2687             int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2688                                                &descriptor->essence_codec_ul)->id;
2689             if (coded_width)
2690                 st->codecpar->width = coded_width;
2691             ret = ff_generate_avci_extradata(st);
2692             if (ret < 0)
2693                 return ret;
2694         }
2695         if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2696             /* TODO: decode timestamps */
2697             st->internal->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2698         }
2699     }
2700
2701     for (int i = 0; i < mxf->fc->nb_streams; i++) {
2702         MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
2703         if (track1 && track1->body_sid) {
2704             for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
2705                 MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
2706                 if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
2707                     if (track1->wrapping == UnknownWrapped)
2708                         track1->wrapping = track2->wrapping;
2709                     else if (track2->wrapping == UnknownWrapped)
2710                         track2->wrapping = track1->wrapping;
2711                     else
2712                         av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
2713                                                       "with different wrapping\n", i, j, track1->body_sid);
2714                 }
2715             }
2716         }
2717     }
2718
2719     ret = 0;
2720 fail_and_free:
2721     return ret;
2722 }
2723
2724 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2725 {
2726     struct tm time = { 0 };
2727     int msecs;
2728     time.tm_year = (timestamp >> 48) - 1900;
2729     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2730     time.tm_mday = (timestamp >> 32 & 0xFF);
2731     time.tm_hour = (timestamp >> 24 & 0xFF);
2732     time.tm_min  = (timestamp >> 16 & 0xFF);
2733     time.tm_sec  = (timestamp >> 8  & 0xFF);
2734     msecs        = (timestamp & 0xFF) * 4;
2735
2736     /* Clip values for legacy reasons. Maybe we should return error instead? */
2737     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2738     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2739     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2740     time.tm_min  = av_clip(time.tm_min,  0, 59);
2741     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2742     msecs        = av_clip(msecs, 0, 999);
2743
2744     return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
2745 }
2746
2747 #define SET_STR_METADATA(pb, name, str) do { \
2748     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2749         return ret; \
2750     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2751 } while (0)
2752
2753 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
2754     major = avio_rb16(pb); \
2755     minor = avio_rb16(pb); \
2756     tertiary = avio_rb16(pb); \
2757     patch = avio_rb16(pb); \
2758     release = avio_rb16(pb); \
2759     if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
2760         return ret; \
2761     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2762 } while (0)
2763
2764 #define SET_UID_METADATA(pb, name, var, str) do { \
2765     avio_read(pb, var, 16); \
2766     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2767         return ret; \
2768     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2769 } while (0)
2770
2771 #define SET_TS_METADATA(pb, name, var, str) do { \
2772     var = avio_rb64(pb); \
2773     if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2774         return ret; \
2775 } while (0)
2776
2777 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2778 {
2779     MXFContext *mxf = arg;
2780     AVFormatContext *s = mxf->fc;
2781     int ret;
2782     UID uid = { 0 };
2783     char *str = NULL;
2784     uint64_t ts;
2785     uint16_t major, minor, tertiary, patch, release;
2786     switch (tag) {
2787     case 0x3C01:
2788         SET_STR_METADATA(pb, "company_name", str);
2789         break;
2790     case 0x3C02:
2791         SET_STR_METADATA(pb, "product_name", str);
2792         break;
2793     case 0x3C03:
2794         SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
2795         break;
2796     case 0x3C04:
2797         SET_STR_METADATA(pb, "product_version", str);
2798         break;
2799     case 0x3C05:
2800         SET_UID_METADATA(pb, "product_uid", uid, str);
2801         break;
2802     case 0x3C06:
2803         SET_TS_METADATA(pb, "modification_date", ts, str);
2804         break;
2805     case 0x3C07:
2806         SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
2807         break;
2808     case 0x3C08:
2809         SET_STR_METADATA(pb, "application_platform", str);
2810         break;
2811     case 0x3C09:
2812         SET_UID_METADATA(pb, "generation_uid", uid, str);
2813         break;
2814     case 0x3C0A:
2815         SET_UID_METADATA(pb, "uid", uid, str);
2816         break;
2817     }
2818     return 0;
2819 }
2820
2821 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2822 {
2823     MXFContext *mxf = arg;
2824     AVFormatContext *s = mxf->fc;
2825     int ret;
2826     char *str = NULL;
2827
2828     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2829         SET_STR_METADATA(pb, "project_name", str);
2830     }
2831     return 0;
2832 }
2833
2834 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2835     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2836     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2837     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2838     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2839     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2840     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2841     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2842     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2843     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2844     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2845     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2846     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2847     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2848     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2849     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2850     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2851     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2852     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2853     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2854     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2855     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2856     { { 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 */
2857     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2858     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2859     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2860     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2861     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2862     { { 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 */
2863     { { 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 */
2864     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2865     { { 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 */
2866     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2867     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2868     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2869     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2870     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2871     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2872     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2873     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2874 };
2875
2876 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2877 {
2878     ctx->type = type;
2879     switch (type){
2880     case MultipleDescriptor:
2881     case Descriptor:
2882         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2883         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2884         break;
2885     default:
2886         break;
2887     }
2888     return 0;
2889 }
2890
2891 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2892 {
2893     AVIOContext *pb = mxf->fc->pb;
2894     uint64_t klv_end = avio_tell(pb) + klv->length;
2895     MXFMetadataSet *meta;
2896     void *ctx;
2897
2898     if (ctx_size) {
2899         meta = av_mallocz(ctx_size);
2900         if (!meta)
2901             return AVERROR(ENOMEM);
2902         ctx  = meta;
2903         mxf_metadataset_init(meta, type);
2904     } else {
2905         meta = NULL;
2906         ctx  = mxf;
2907     }
2908     while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
2909         int ret;
2910         int tag = avio_rb16(pb);
2911         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2912         int64_t next = avio_tell(pb);
2913         UID uid = {0};
2914         if (next < 0 || next > INT64_MAX - size) {
2915             if (meta) {
2916                 mxf_free_metadataset(&meta, 1);
2917             }
2918             return next < 0 ? next : AVERROR_INVALIDDATA;
2919         }
2920         next += size;
2921
2922         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2923         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2924             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2925             continue;
2926         }
2927         if (tag > 0x7FFF) { /* dynamic tag */
2928             int i;
2929             for (i = 0; i < mxf->local_tags_count; i++) {
2930                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2931                 if (local_tag == tag) {
2932                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2933                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2934                     PRINT_KEY(mxf->fc, "uid", uid);
2935                 }
2936             }
2937         }
2938         if (meta && tag == 0x3C0A) {
2939             avio_read(pb, meta->uid, 16);
2940         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2941             if (meta) {
2942                 mxf_free_metadataset(&meta, 1);
2943             }
2944             return ret;
2945         }
2946
2947         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2948          * it extending past the end of the KLV though (zzuf5.mxf). */
2949         if (avio_tell(pb) > klv_end) {
2950             if (meta) {
2951                 mxf_free_metadataset(&meta, 1);
2952             }
2953
2954             av_log(mxf->fc, AV_LOG_ERROR,
2955                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2956                    tag, klv->offset);
2957             return AVERROR_INVALIDDATA;
2958         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2959             avio_seek(pb, next, SEEK_SET);
2960     }
2961     return meta ? mxf_add_metadata_set(mxf, &meta) : 0;
2962 }
2963
2964 /**
2965  * Matches any partition pack key, in other words:
2966  * - HeaderPartition
2967  * - BodyPartition
2968  * - FooterPartition
2969  * @return non-zero if the key is a partition pack key, zero otherwise
2970  */
2971 static int mxf_is_partition_pack_key(UID key)
2972 {
2973     //NOTE: this is a little lax since it doesn't constraint key[14]
2974     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2975             key[13] >= 2 && key[13] <= 4;
2976 }
2977
2978 /**
2979  * Parses a metadata KLV
2980  * @return <0 on error, 0 otherwise
2981  */
2982 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2983                                      int ctx_size, enum MXFMetadataSetType type)
2984 {
2985     AVFormatContext *s = mxf->fc;
2986     int res;
2987     if (klv.key[5] == 0x53) {
2988         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2989     } else {
2990         uint64_t next = avio_tell(s->pb) + klv.length;
2991         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2992
2993         /* only seek forward, else this can loop for a long time */
2994         if (avio_tell(s->pb) > next) {
2995             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2996                    klv.offset);
2997             return AVERROR_INVALIDDATA;
2998         }
2999
3000         avio_seek(s->pb, next, SEEK_SET);
3001     }
3002     if (res < 0) {
3003         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3004         return res;
3005     }
3006     return 0;
3007 }
3008
3009 /**
3010  * Seeks to the previous partition and parses it, if possible
3011  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3012  */
3013 static int mxf_seek_to_previous_partition(MXFContext *mxf)
3014 {
3015     AVIOContext *pb = mxf->fc->pb;
3016     KLVPacket klv;
3017     int64_t current_partition_ofs;
3018     int ret;
3019
3020     if (!mxf->current_partition ||
3021         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3022         return 0;   /* we've parsed all partitions */
3023
3024     /* seek to previous partition */
3025     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
3026     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3027     mxf->current_partition = NULL;
3028
3029     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3030
3031     /* Make sure this is actually a PartitionPack, and if so parse it.
3032      * See deadlock2.mxf
3033      */
3034     if ((ret = klv_read_packet(&klv, pb)) < 0) {
3035         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3036         return ret;
3037     }
3038
3039     if (!mxf_is_partition_pack_key(klv.key)) {
3040         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3041         return AVERROR_INVALIDDATA;
3042     }
3043
3044     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3045      * can point to just before the current partition, causing klv_read_packet()
3046      * to sync back up to it. See deadlock3.mxf
3047      */
3048     if (klv.offset >= current_partition_ofs) {
3049         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3050                PRIx64 " indirectly points to itself\n", current_partition_ofs);
3051         return AVERROR_INVALIDDATA;
3052     }
3053
3054     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3055         return ret;
3056
3057     return 1;
3058 }
3059
3060 /**
3061  * Called when essence is encountered
3062  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3063  */
3064 static int mxf_parse_handle_essence(MXFContext *mxf)
3065 {
3066     AVIOContext *pb = mxf->fc->pb;
3067     int64_t ret;
3068
3069     if (mxf->parsing_backward) {
3070         return mxf_seek_to_previous_partition(mxf);
3071     } else {
3072         if (!mxf->footer_partition) {
3073             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3074             return 0;
3075         }
3076
3077         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3078
3079         /* remember where we were so we don't end up seeking further back than this */
3080         mxf->last_forward_tell = avio_tell(pb);
3081
3082         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3083             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3084             return -1;
3085         }
3086
3087         /* seek to FooterPartition and parse backward */
3088         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3089             av_log(mxf->fc, AV_LOG_ERROR,
3090                    "failed to seek to FooterPartition @ 0x%" PRIx64
3091                    " (%"PRId64") - partial file?\n",
3092                    mxf->run_in + mxf->footer_partition, ret);
3093             return ret;
3094         }
3095
3096         mxf->current_partition = NULL;
3097         mxf->parsing_backward = 1;
3098     }
3099
3100     return 1;
3101 }
3102
3103 /**
3104  * Called when the next partition or EOF is encountered
3105  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3106  */
3107 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
3108 {
3109     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3110 }
3111
3112 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3113 {
3114     for (int i = 0; i < s->nb_streams; i++) {
3115         MXFTrack *track = s->streams[i]->priv_data;
3116         if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3117             return track->wrapping;
3118     }
3119     return UnknownWrapped;
3120 }
3121
3122 /**
3123  * Figures out the proper offset and length of the essence container in each partition
3124  */
3125 static void mxf_compute_essence_containers(AVFormatContext *s)
3126 {
3127     MXFContext *mxf = s->priv_data;
3128     int x;
3129
3130     for (x = 0; x < mxf->partitions_count; x++) {
3131         MXFPartition *p = &mxf->partitions[x];
3132         MXFWrappingScheme wrapping;
3133
3134         if (!p->body_sid)
3135             continue;       /* BodySID == 0 -> no essence */
3136
3137         /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3138          * otherwise we point essence_offset at the key of the first essence KLV.
3139          */
3140
3141         wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3142
3143         if (wrapping == ClipWrapped) {
3144             p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3145             p->essence_length = p->first_essence_klv.length;
3146         } else {
3147             p->essence_offset = p->first_essence_klv.offset;
3148
3149             /* essence container spans to the next partition */
3150             if (x < mxf->partitions_count - 1)
3151                 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
3152
3153             if (p->essence_length < 0) {
3154                 /* next ThisPartition < essence_offset */
3155                 p->essence_length = 0;
3156                 av_log(mxf->fc, AV_LOG_ERROR,
3157                        "partition %i: bad ThisPartition = %"PRIX64"\n",
3158                        x+1, mxf->partitions[x+1].this_partition);
3159             }
3160         }
3161     }
3162 }
3163
3164 static int is_pcm(enum AVCodecID codec_id)
3165 {
3166     /* we only care about "normal" PCM codecs until we get samples */
3167     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
3168 }
3169
3170 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3171 {
3172     int i;
3173     for (i = 0; i < mxf->nb_index_tables; i++)
3174         if (mxf->index_tables[i].index_sid == index_sid)
3175             return &mxf->index_tables[i];
3176     return NULL;
3177 }
3178
3179 /**
3180  * Deal with the case where for some audio atoms EditUnitByteCount is
3181  * very small (2, 4..). In those cases we should read more than one
3182  * sample per call to mxf_read_packet().
3183  */
3184 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3185 {
3186     MXFTrack *track = st->priv_data;
3187     MXFIndexTable *t;
3188
3189     if (!track)
3190         return;
3191     track->edit_units_per_packet = 1;
3192     if (track->wrapping != ClipWrapped)
3193         return;
3194
3195     t = mxf_find_index_table(mxf, track->index_sid);
3196
3197     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3198     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
3199         !is_pcm(st->codecpar->codec_id)                        ||
3200         !t                                                     ||
3201         t->nb_segments != 1                                    ||
3202         t->segments[0]->edit_unit_byte_count >= 32)
3203         return;
3204
3205     /* arbitrarily default to 48 kHz PAL audio frame size */
3206     /* TODO: We could compute this from the ratio between the audio
3207      *       and video edit rates for 48 kHz NTSC we could use the
3208      *       1802-1802-1802-1802-1801 pattern. */
3209     track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3210 }
3211
3212 /**
3213  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3214  */
3215 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3216 {
3217     MXFTrack *track = st->priv_data;
3218     MXFIndexTableSegment *segment = NULL;
3219     MXFPartition *p = NULL;
3220     int essence_partition_count = 0;
3221     int edit_unit_byte_count = 0;
3222     int i, ret;
3223
3224     if (!track || track->wrapping != ClipWrapped)
3225         return 0;
3226
3227     /* check if track already has an IndexTableSegment */
3228     for (i = 0; i < mxf->metadata_sets_count; i++) {
3229         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3230             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3231             if (s->body_sid == track->body_sid)
3232                 return 0;
3233         }
3234     }
3235
3236     /* find the essence partition */
3237     for (i = 0; i < mxf->partitions_count; i++) {
3238         /* BodySID == 0 -> no essence */
3239         if (mxf->partitions[i].body_sid != track->body_sid)
3240             continue;
3241
3242         p = &mxf->partitions[i];
3243         essence_partition_count++;
3244     }
3245
3246     /* only handle files with a single essence partition */
3247     if (essence_partition_count != 1)
3248         return 0;
3249
3250     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3251         edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3252     } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3253         edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3254     }
3255
3256     if (edit_unit_byte_count <= 0)
3257         return 0;
3258
3259     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);
3260
3261     if (!(segment = av_mallocz(sizeof(*segment))))
3262         return AVERROR(ENOMEM);
3263
3264     if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3265         return ret;
3266
3267     /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3268      * using the same SID for index is forbidden in MXF. */
3269     if (!track->index_sid)
3270         track->index_sid = track->body_sid;
3271
3272     segment->type = IndexTableSegment;
3273     /* stream will be treated as small EditUnitByteCount */
3274     segment->edit_unit_byte_count = edit_unit_byte_count;
3275     segment->index_start_position = 0;
3276     segment->index_duration = st->duration;
3277     segment->index_edit_rate = av_inv_q(st->time_base);
3278     segment->index_sid = track->index_sid;
3279     segment->body_sid = p->body_sid;
3280     return 0;
3281 }
3282
3283 static void mxf_read_random_index_pack(AVFormatContext *s)
3284 {
3285     MXFContext *mxf = s->priv_data;
3286     uint32_t length;
3287     int64_t file_size, max_rip_length, min_rip_length;
3288     KLVPacket klv;
3289
3290     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3291         return;
3292
3293     file_size = avio_size(s->pb);
3294
3295     /* S377m says to check the RIP length for "silly" values, without defining "silly".
3296      * The limit below assumes a file with nothing but partition packs and a RIP.
3297      * Before changing this, consider that a muxer may place each sample in its own partition.
3298      *
3299      * 105 is the size of the smallest possible PartitionPack
3300      * 12 is the size of each RIP entry
3301      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3302      */
3303     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3304     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3305
3306     /* We're only interested in RIPs with at least two entries.. */
3307     min_rip_length = 16+1+24+4;
3308
3309     /* See S377m section 11 */
3310     avio_seek(s->pb, file_size - 4, SEEK_SET);
3311     length = avio_rb32(s->pb);
3312
3313     if (length < min_rip_length || length > max_rip_length)
3314         goto end;
3315     avio_seek(s->pb, file_size - length, SEEK_SET);
3316     if (klv_read_packet(&klv, s->pb) < 0 ||
3317         !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3318         goto end;
3319     if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3320         av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3321         goto end;
3322     }
3323
3324     avio_skip(s->pb, klv.length - 12);
3325     mxf->footer_partition = avio_rb64(s->pb);
3326
3327     /* sanity check */
3328     if (mxf->run_in + mxf->footer_partition >= file_size) {
3329         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3330         mxf->footer_partition = 0;
3331     }
3332
3333 end:
3334     avio_seek(s->pb, mxf->run_in, SEEK_SET);
3335 }
3336
3337 static int mxf_read_header(AVFormatContext *s)
3338 {
3339     MXFContext *mxf = s->priv_data;
3340     KLVPacket klv;
3341     int64_t essence_offset = 0;
3342     int ret;
3343
3344     mxf->last_forward_tell = INT64_MAX;
3345
3346     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3347         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3348         return AVERROR_INVALIDDATA;
3349     }
3350     avio_seek(s->pb, -14, SEEK_CUR);
3351     mxf->fc = s;
3352     mxf->run_in = avio_tell(s->pb);
3353
3354     mxf_read_random_index_pack(s);
3355
3356     while (!avio_feof(s->pb)) {
3357         const MXFMetadataReadTableEntry *metadata;
3358
3359         if (klv_read_packet(&klv, s->pb) < 0) {
3360             /* EOF - seek to previous partition or stop */
3361             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3362                 break;
3363             else
3364                 continue;
3365         }
3366
3367         PRINT_KEY(s, "read header", klv.key);
3368         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3369         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3370             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3371             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3372             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3373             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3374             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3375
3376             if (!mxf->current_partition) {
3377                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3378                 return AVERROR_INVALIDDATA;
3379             }
3380
3381             if (!mxf->current_partition->first_essence_klv.offset)
3382                 mxf->current_partition->first_essence_klv = klv;
3383
3384             if (!essence_offset)
3385                 essence_offset = klv.offset;
3386
3387             /* seek to footer, previous partition or stop */
3388             if (mxf_parse_handle_essence(mxf) <= 0)
3389                 break;
3390             continue;
3391         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3392             /* next partition pack - keep going, seek to previous partition or stop */
3393             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3394                 break;
3395             else if (mxf->parsing_backward)
3396                 continue;
3397             /* we're still parsing forward. proceed to parsing this partition pack */
3398         }
3399
3400         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3401             if (IS_KLV_KEY(klv.key, metadata->key)) {
3402                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3403                     return ret;
3404                 break;
3405             }
3406         }
3407         if (!metadata->read) {
3408             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3409                             UID_ARG(klv.key));
3410             avio_skip(s->pb, klv.length);
3411         }
3412     }
3413     /* FIXME avoid seek */
3414     if (!essence_offset)  {
3415         av_log(s, AV_LOG_ERROR, "no essence\n");
3416         return AVERROR_INVALIDDATA;
3417     }
3418     avio_seek(s->pb, essence_offset, SEEK_SET);
3419
3420     /* we need to do this before computing the index tables
3421      * to be able to fill in zero IndexDurations with st->duration */
3422     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3423         return ret;
3424
3425     for (int i = 0; i < s->nb_streams; i++)
3426         mxf_handle_missing_index_segment(mxf, s->streams[i]);
3427
3428     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3429         return ret;
3430
3431     if (mxf->nb_index_tables > 1) {
3432         /* TODO: look up which IndexSID to use via EssenceContainerData */
3433         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3434                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3435     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3436         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3437         return AVERROR_INVALIDDATA;
3438     }
3439
3440     mxf_compute_essence_containers(s);
3441
3442     for (int i = 0; i < s->nb_streams; i++)
3443         mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3444
3445     return 0;
3446 }
3447
3448 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3449 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3450 {
3451     int64_t a, b, m, offset;
3452     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3453
3454     if (!t || track->original_duration <= 0)
3455         return -1;
3456
3457     a = -1;
3458     b = track->original_duration;
3459
3460     while (b - a > 1) {
3461         m = (a + b) >> 1;
3462         if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3463             return -1;
3464         if (offset < current_offset)
3465             a = m;
3466         else
3467             b = m;
3468     }
3469
3470     *edit_unit_out = b;
3471
3472     return 0;
3473 }
3474
3475 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3476                                         int64_t edit_unit)
3477 {
3478     MXFTrack *track = st->priv_data;
3479     AVRational time_base = av_inv_q(track->edit_rate);
3480     AVRational sample_rate = av_inv_q(st->time_base);
3481
3482     // For non-audio sample_count equals current edit unit
3483     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3484         return edit_unit;
3485
3486     if ((sample_rate.num / sample_rate.den) == 48000) {
3487         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3488     } else {
3489         int remainder = (sample_rate.num * time_base.num) %
3490                         (time_base.den * sample_rate.den);
3491         if (remainder)
3492             av_log(mxf->fc, AV_LOG_WARNING,
3493                    "seeking detected on stream #%d with time base (%d/%d) and "
3494                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3495                    st->index, time_base.num, time_base.den,
3496                    sample_rate.num, sample_rate.den);
3497         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3498     }
3499 }
3500
3501 /**
3502  * Make sure track->sample_count is correct based on what offset we're currently at.
3503  * Also determine the next edit unit (or packet) offset.
3504  * @return next_ofs if OK, <0 on error
3505  */
3506 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3507 {
3508     int64_t next_ofs = -1;
3509     MXFTrack *track = st->priv_data;
3510     int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3511     int64_t new_edit_unit;
3512     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3513
3514     if (!t || track->wrapping == UnknownWrapped)
3515         return -1;
3516
3517     if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3518         (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3519         av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3520         return -1;
3521     }
3522
3523     /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3524     if (next_ofs > current_offset)
3525         return next_ofs;
3526
3527     if (!resync) {
3528         av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3529         return -1;
3530     }
3531
3532     if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3533         av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3534         return -1;
3535     }
3536
3537     new_edit_unit--;
3538     track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3539     av_log(mxf->fc, AV_LOG_WARNING, "edit unit sync lost on stream %d, jumping from %"PRId64" to %"PRId64"\n", st->index, edit_unit, new_edit_unit);
3540
3541     return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3542 }
3543
3544 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3545                              AVPacket *pkt)
3546 {
3547     AVStream *st = mxf->fc->streams[pkt->stream_index];
3548     MXFTrack *track = st->priv_data;
3549     int64_t bits_per_sample = par->bits_per_coded_sample;
3550
3551     if (!bits_per_sample)
3552         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3553
3554     pkt->pts = track->sample_count;
3555
3556     if (   par->channels <= 0
3557         || bits_per_sample <= 0
3558         || par->channels * (int64_t)bits_per_sample < 8)
3559         track->sample_count = mxf_compute_sample_count(mxf, st, av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate)) + 1);
3560     else
3561         track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3562
3563     return 0;
3564 }
3565
3566 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3567 {
3568     AVCodecParameters *par = st->codecpar;
3569     MXFTrack *track = st->priv_data;
3570
3571     if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3572         /* see if we have an index table to derive timestamps from */
3573         MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3574
3575         if (t && track->sample_count < t->nb_ptses) {
3576             pkt->dts = track->sample_count + t->first_dts;
3577             pkt->pts = t->ptses[track->sample_count];
3578         } else if (track->intra_only) {
3579             /* intra-only -> PTS = EditUnit.
3580              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3581             pkt->pts = track->sample_count;
3582         }
3583         track->sample_count++;
3584     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3585         int ret = mxf_set_audio_pts(mxf, par, pkt);
3586         if (ret < 0)
3587             return ret;
3588     } else if (track) {
3589         pkt->dts = pkt->pts = track->sample_count;
3590         pkt->duration = 1;
3591         track->sample_count++;
3592     }
3593     return 0;
3594 }
3595
3596 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3597 {
3598     KLVPacket klv;
3599     MXFContext *mxf = s->priv_data;
3600     int ret;
3601
3602     while (1) {
3603         int64_t max_data_size;
3604         int64_t pos = avio_tell(s->pb);
3605
3606         if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3607             mxf->current_klv_data = (KLVPacket){{0}};
3608             ret = klv_read_packet(&klv, s->pb);
3609             if (ret < 0)
3610                 break;
3611             max_data_size = klv.length;
3612             pos = klv.next_klv - klv.length;
3613             PRINT_KEY(s, "read packet", klv.key);
3614             av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3615             if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3616                 ret = mxf_decrypt_triplet(s, pkt, &klv);
3617                 if (ret < 0) {
3618                     av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3619                     return ret;
3620                 }
3621                 return 0;
3622             }
3623         } else {
3624             klv = mxf->current_klv_data;
3625             max_data_size = klv.next_klv - pos;
3626         }
3627         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3628             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3629             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3630             int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3631             int index = mxf_get_stream_index(s, &klv, body_sid);
3632             int64_t next_ofs;
3633             AVStream *st;
3634             MXFTrack *track;
3635
3636             if (index < 0) {
3637                 av_log(s, AV_LOG_ERROR,
3638                        "error getting stream index %"PRIu32"\n",
3639                        AV_RB32(klv.key + 12));
3640                 goto skip;
3641             }
3642
3643             st = s->streams[index];
3644             track = st->priv_data;
3645
3646             if (s->streams[index]->discard == AVDISCARD_ALL)
3647                 goto skip;
3648
3649             next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3650
3651             if (track->wrapping != FrameWrapped) {
3652                 int64_t size;
3653
3654                 if (next_ofs <= 0) {
3655                     // If we have no way to packetize the data, then return it in chunks...
3656                     if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3657                         st->internal->need_parsing = AVSTREAM_PARSE_FULL;
3658                         avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3659                     }
3660                     size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3661                 } else {
3662                     if ((size = next_ofs - pos) <= 0) {
3663                         av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3664                         mxf->current_klv_data = (KLVPacket){{0}};
3665                         return AVERROR_INVALIDDATA;
3666                     }
3667                     // We must not overread, because the next edit unit might be in another KLV
3668                     if (size > max_data_size)
3669                         size = max_data_size;
3670                 }
3671
3672                 mxf->current_klv_data = klv;
3673                 klv.offset = pos;
3674                 klv.length = size;
3675                 klv.next_klv = klv.offset + klv.length;
3676             }
3677
3678             /* check for 8 channels AES3 element */
3679             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3680                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3681                                               pkt, klv.length);
3682                 if (ret < 0) {
3683                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3684                     mxf->current_klv_data = (KLVPacket){{0}};
3685                     return ret;
3686                 }
3687             } else if (mxf->eia608_extract &&
3688                        s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3689                 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3690                 if (ret < 0) {
3691                     mxf->current_klv_data = (KLVPacket){{0}};
3692