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