avformat/mxfdec: make edit_units_per_packet a track property
[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     int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
177 } MXFTrack;
178
179 typedef struct MXFDescriptor {
180     UID uid;
181     enum MXFMetadataSetType type;
182     UID essence_container_ul;
183     UID essence_codec_ul;
184     UID codec_ul;
185     AVRational sample_rate;
186     AVRational aspect_ratio;
187     int width;
188     int height; /* Field height, not frame height */
189     int frame_layout; /* See MXFFrameLayout enum */
190     int video_line_map[2];
191 #define MXF_FIELD_DOMINANCE_DEFAULT 0
192 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
193 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
194     int field_dominance;
195     int channels;
196     int bits_per_sample;
197     int64_t duration; /* ContainerDuration optional property */
198     unsigned int component_depth;
199     unsigned int horiz_subsampling;
200     unsigned int vert_subsampling;
201     UID *sub_descriptors_refs;
202     int sub_descriptors_count;
203     int linked_track_id;
204     uint8_t *extradata;
205     int extradata_size;
206     enum AVPixelFormat pix_fmt;
207 } MXFDescriptor;
208
209 typedef struct MXFIndexTableSegment {
210     UID uid;
211     enum MXFMetadataSetType type;
212     int edit_unit_byte_count;
213     int index_sid;
214     int body_sid;
215     AVRational index_edit_rate;
216     uint64_t index_start_position;
217     uint64_t index_duration;
218     int8_t *temporal_offset_entries;
219     int *flag_entries;
220     uint64_t *stream_offset_entries;
221     int nb_index_entries;
222 } MXFIndexTableSegment;
223
224 typedef struct MXFPackage {
225     UID uid;
226     enum MXFMetadataSetType type;
227     UID package_uid;
228     UID package_ul;
229     UID *tracks_refs;
230     int tracks_count;
231     MXFDescriptor *descriptor; /* only one */
232     UID descriptor_ref;
233     char *name;
234     UID *comment_refs;
235     int comment_count;
236 } MXFPackage;
237
238 typedef struct MXFEssenceContainerData {
239     UID uid;
240     enum MXFMetadataSetType type;
241     UID package_uid;
242     UID package_ul;
243     int index_sid;
244     int body_sid;
245 } MXFEssenceContainerData;
246
247 typedef struct MXFMetadataSet {
248     UID uid;
249     enum MXFMetadataSetType type;
250 } MXFMetadataSet;
251
252 /* decoded index table */
253 typedef struct MXFIndexTable {
254     int index_sid;
255     int body_sid;
256     int nb_ptses;               /* number of PTSes or total duration of index */
257     int64_t first_dts;          /* DTS = EditUnit + first_dts */
258     int64_t *ptses;             /* maps EditUnit -> PTS */
259     int nb_segments;
260     MXFIndexTableSegment **segments;    /* sorted by IndexStartPosition */
261     AVIndexEntry *fake_index;   /* used for calling ff_index_search_timestamp() */
262     int8_t *offsets;            /* temporal offsets for display order to stored order conversion */
263 } MXFIndexTable;
264
265 typedef struct MXFContext {
266     MXFPartition *partitions;
267     unsigned partitions_count;
268     MXFOP op;
269     UID *packages_refs;
270     int packages_count;
271     UID *essence_container_data_refs;
272     int essence_container_data_count;
273     MXFMetadataSet **metadata_sets;
274     int metadata_sets_count;
275     AVFormatContext *fc;
276     struct AVAES *aesc;
277     uint8_t *local_tags;
278     int local_tags_count;
279     uint64_t footer_partition;
280     KLVPacket current_klv_data;
281     int current_klv_index;
282     int run_in;
283     MXFPartition *current_partition;
284     int parsing_backward;
285     int64_t last_forward_tell;
286     int last_forward_partition;
287     int64_t current_edit_unit;
288     int nb_index_tables;
289     MXFIndexTable *index_tables;
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 MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
2789 {
2790     for (int i = 0; i < s->nb_streams; i++) {
2791         MXFTrack *track = s->streams[i]->priv_data;
2792         if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2793             return track->wrapping;
2794     }
2795     return UnknownWrapped;
2796 }
2797
2798 /**
2799  * Figures out the proper offset and length of the essence container in each partition
2800  */
2801 static void mxf_compute_essence_containers(AVFormatContext *s)
2802 {
2803     MXFContext *mxf = s->priv_data;
2804     int x;
2805
2806     for (x = 0; x < mxf->partitions_count; x++) {
2807         MXFPartition *p = &mxf->partitions[x];
2808         MXFWrappingScheme wrapping;
2809
2810         if (!p->body_sid)
2811             continue;       /* BodySID == 0 -> no essence */
2812
2813         /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2814          * otherwise we point essence_offset at the key of the first essence KLV.
2815          */
2816
2817         wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
2818
2819         if (wrapping == ClipWrapped) {
2820             p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
2821             p->essence_length = p->first_essence_klv.length;
2822         } else {
2823             p->essence_offset = p->first_essence_klv.offset;
2824
2825             /* essence container spans to the next partition */
2826             if (x < mxf->partitions_count - 1)
2827                 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2828
2829             if (p->essence_length < 0) {
2830                 /* next ThisPartition < essence_offset */
2831                 p->essence_length = 0;
2832                 av_log(mxf->fc, AV_LOG_ERROR,
2833                        "partition %i: bad ThisPartition = %"PRIX64"\n",
2834                        x+1, mxf->partitions[x+1].this_partition);
2835             }
2836         }
2837     }
2838 }
2839
2840 static int is_pcm(enum AVCodecID codec_id)
2841 {
2842     /* we only care about "normal" PCM codecs until we get samples */
2843     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2844 }
2845
2846 static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
2847 {
2848     int i;
2849
2850     if (mxf->op != OPAtom)
2851         return NULL;
2852
2853     for (i = 0; i < mxf->fc->nb_streams; i++) {
2854         if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2855             continue;
2856         return mxf->fc->streams[i];
2857     }
2858     return NULL;
2859 }
2860
2861 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
2862 {
2863     int i;
2864     for (i = 0; i < mxf->nb_index_tables; i++)
2865         if (mxf->index_tables[i].index_sid == index_sid)
2866             return &mxf->index_tables[i];
2867     return NULL;
2868 }
2869
2870 /**
2871  * Deal with the case where for some audio atoms EditUnitByteCount is
2872  * very small (2, 4..). In those cases we should read more than one
2873  * sample per call to mxf_read_packet().
2874  */
2875 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
2876 {
2877     MXFTrack *track = st->priv_data;
2878     MXFIndexTable *t;
2879
2880     if (!track)
2881         return;
2882     track->edit_units_per_packet = 1;
2883     if (track->wrapping != ClipWrapped)
2884         return;
2885
2886     t = mxf_find_index_table(mxf, track->index_sid);
2887
2888     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2889     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
2890         !is_pcm(st->codecpar->codec_id)                        ||
2891         !t                                                     ||
2892         t->nb_segments != 1                                    ||
2893         t->segments[0]->edit_unit_byte_count >= 32)
2894         return;
2895
2896     /* arbitrarily default to 48 kHz PAL audio frame size */
2897     /* TODO: We could compute this from the ratio between the audio
2898      *       and video edit rates for 48 kHz NTSC we could use the
2899      *       1802-1802-1802-1802-1801 pattern. */
2900     track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
2901 }
2902
2903 /**
2904  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
2905  */
2906 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
2907 {
2908     MXFTrack *track = st->priv_data;
2909     MXFIndexTableSegment *segment = NULL;
2910     MXFPartition *p = NULL;
2911     int essence_partition_count = 0;
2912     int i, ret;
2913
2914     /* TODO: support raw video without an index if they exist */
2915     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id) || track->wrapping != ClipWrapped)
2916         return 0;
2917
2918     /* check if track already has an IndexTableSegment */
2919     for (i = 0; i < mxf->metadata_sets_count; i++) {
2920         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
2921             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
2922             if (s->body_sid == track->body_sid)
2923                 return 0;
2924         }
2925     }
2926
2927     /* find the essence partition */
2928     for (i = 0; i < mxf->partitions_count; i++) {
2929         /* BodySID == 0 -> no essence */
2930         if (mxf->partitions[i].body_sid != track->body_sid)
2931             continue;
2932
2933         p = &mxf->partitions[i];
2934         essence_partition_count++;
2935     }
2936
2937     /* only handle files with a single essence partition */
2938     if (essence_partition_count != 1)
2939         return 0;
2940
2941     if (!(segment = av_mallocz(sizeof(*segment))))
2942         return AVERROR(ENOMEM);
2943
2944     if ((ret = mxf_add_metadata_set(mxf, segment))) {
2945         mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2946         return ret;
2947     }
2948
2949     /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
2950      * using the same SID for index is forbidden in MXF. */
2951     if (!track->index_sid)
2952         track->index_sid = track->body_sid;
2953     track->edit_rate = av_inv_q(st->time_base);
2954
2955     segment->type = IndexTableSegment;
2956     /* stream will be treated as small EditUnitByteCount */
2957     segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2958     segment->index_start_position = 0;
2959     segment->index_duration = st->duration;
2960     segment->index_edit_rate = track->edit_rate;
2961     segment->index_sid = track->index_sid;
2962     segment->body_sid = p->body_sid;
2963     return 0;
2964 }
2965
2966 static void mxf_read_random_index_pack(AVFormatContext *s)
2967 {
2968     MXFContext *mxf = s->priv_data;
2969     uint32_t length;
2970     int64_t file_size, max_rip_length, min_rip_length;
2971     KLVPacket klv;
2972
2973     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2974         return;
2975
2976     file_size = avio_size(s->pb);
2977
2978     /* S377m says to check the RIP length for "silly" values, without defining "silly".
2979      * The limit below assumes a file with nothing but partition packs and a RIP.
2980      * Before changing this, consider that a muxer may place each sample in its own partition.
2981      *
2982      * 105 is the size of the smallest possible PartitionPack
2983      * 12 is the size of each RIP entry
2984      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2985      */
2986     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2987     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2988
2989     /* We're only interested in RIPs with at least two entries.. */
2990     min_rip_length = 16+1+24+4;
2991
2992     /* See S377m section 11 */
2993     avio_seek(s->pb, file_size - 4, SEEK_SET);
2994     length = avio_rb32(s->pb);
2995
2996     if (length < min_rip_length || length > max_rip_length)
2997         goto end;
2998     avio_seek(s->pb, file_size - length, SEEK_SET);
2999     if (klv_read_packet(&klv, s->pb) < 0 ||
3000         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
3001         klv.length != length - 20)
3002         goto end;
3003
3004     avio_skip(s->pb, klv.length - 12);
3005     mxf->footer_partition = avio_rb64(s->pb);
3006
3007     /* sanity check */
3008     if (mxf->run_in + mxf->footer_partition >= file_size) {
3009         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3010         mxf->footer_partition = 0;
3011     }
3012
3013 end:
3014     avio_seek(s->pb, mxf->run_in, SEEK_SET);
3015 }
3016
3017 static int mxf_read_header(AVFormatContext *s)
3018 {
3019     MXFContext *mxf = s->priv_data;
3020     KLVPacket klv;
3021     int64_t essence_offset = 0;
3022     int ret;
3023
3024     mxf->last_forward_tell = INT64_MAX;
3025
3026     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3027         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3028         return AVERROR_INVALIDDATA;
3029     }
3030     avio_seek(s->pb, -14, SEEK_CUR);
3031     mxf->fc = s;
3032     mxf->run_in = avio_tell(s->pb);
3033
3034     mxf_read_random_index_pack(s);
3035
3036     while (!avio_feof(s->pb)) {
3037         const MXFMetadataReadTableEntry *metadata;
3038
3039         if (klv_read_packet(&klv, s->pb) < 0) {
3040             /* EOF - seek to previous partition or stop */
3041             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3042                 break;
3043             else
3044                 continue;
3045         }
3046
3047         PRINT_KEY(s, "read header", klv.key);
3048         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3049         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3050             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3051             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3052             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3053             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3054             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3055
3056             if (!mxf->current_partition) {
3057                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3058                 return AVERROR_INVALIDDATA;
3059             }
3060
3061             if (!mxf->current_partition->first_essence_klv.offset)
3062                 mxf->current_partition->first_essence_klv = klv;
3063
3064             if (!essence_offset)
3065                 essence_offset = klv.offset;
3066
3067             /* seek to footer, previous partition or stop */
3068             if (mxf_parse_handle_essence(mxf) <= 0)
3069                 break;
3070             continue;
3071         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3072             /* next partition pack - keep going, seek to previous partition or stop */
3073             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3074                 break;
3075             else if (mxf->parsing_backward)
3076                 continue;
3077             /* we're still parsing forward. proceed to parsing this partition pack */
3078         }
3079
3080         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3081             if (IS_KLV_KEY(klv.key, metadata->key)) {
3082                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3083                     goto fail;
3084                 break;
3085             }
3086         }
3087         if (!metadata->read) {
3088             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3089                             UID_ARG(klv.key));
3090             avio_skip(s->pb, klv.length);
3091         }
3092     }
3093     /* FIXME avoid seek */
3094     if (!essence_offset)  {
3095         av_log(s, AV_LOG_ERROR, "no essence\n");
3096         ret = AVERROR_INVALIDDATA;
3097         goto fail;
3098     }
3099     avio_seek(s->pb, essence_offset, SEEK_SET);
3100
3101     /* we need to do this before computing the index tables
3102      * to be able to fill in zero IndexDurations with st->duration */
3103     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3104         goto fail;
3105
3106     for (int i = 0; i < s->nb_streams; i++)
3107         mxf_handle_missing_index_segment(mxf, s->streams[i]);
3108
3109     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3110         goto fail;
3111
3112     if (mxf->nb_index_tables > 1) {
3113         /* TODO: look up which IndexSID to use via EssenceContainerData */
3114         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3115                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3116     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
3117         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3118         ret = AVERROR_INVALIDDATA;
3119         goto fail;
3120     }
3121
3122     mxf_compute_essence_containers(s);
3123
3124     for (int i = 0; i < s->nb_streams; i++)
3125         mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3126
3127     return 0;
3128 fail:
3129     mxf_read_close(s);
3130
3131     return ret;
3132 }
3133
3134 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3135 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3136 {
3137     int64_t a, b, m, offset;
3138     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3139
3140     if (!t || track->original_duration <= 0)
3141         return -1;
3142
3143     a = -1;
3144     b = track->original_duration;
3145
3146     while (b - a > 1) {
3147         m = (a + b) >> 1;
3148         if (mxf_edit_unit_absolute_offset(mxf, t, m, NULL, &offset, 0) < 0)
3149             return -1;
3150         if (offset < current_offset)
3151             a = m;
3152         else
3153             b = m;
3154     }
3155
3156     *edit_unit_out = b;
3157
3158     return 0;
3159 }
3160
3161 /**
3162  * Sets mxf->current_edit_unit based on what offset we're currently at.
3163  * @return next_ofs if OK, <0 on error
3164  */
3165 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
3166 {
3167     int64_t last_ofs = -1, next_ofs = -1;
3168     MXFIndexTable *t = &mxf->index_tables[0];
3169
3170     /* this is called from the OP1a demuxing logic, which means there
3171      * may be no index tables */
3172     if (mxf->nb_index_tables <= 0)
3173         return -1;
3174
3175     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
3176     while (mxf->current_edit_unit >= 0) {
3177         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
3178             return -2;
3179
3180         if (next_ofs <= last_ofs) {
3181             /* large next_ofs didn't change or current_edit_unit wrapped
3182              * around this fixes the infinite loop on zzuf3.mxf */
3183             av_log(mxf->fc, AV_LOG_ERROR,
3184                    "next_ofs didn't change. not deriving packet timestamps\n");
3185             return -1;
3186         }
3187
3188         if (next_ofs > current_offset)
3189             break;
3190
3191         last_ofs = next_ofs;
3192         mxf->current_edit_unit++;
3193     }
3194
3195     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
3196     if (mxf->current_edit_unit < 0)
3197         return -1;
3198
3199     return next_ofs;
3200 }
3201
3202 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
3203                                     uint64_t *sample_count)
3204 {
3205     int i, total = 0, size = 0;
3206     AVStream *st = mxf->fc->streams[stream_index];
3207     MXFTrack *track = st->priv_data;
3208     AVRational time_base = av_inv_q(track->edit_rate);
3209     AVRational sample_rate = av_inv_q(st->time_base);
3210     const MXFSamplesPerFrame *spf = NULL;
3211
3212     if ((sample_rate.num / sample_rate.den) == 48000)
3213         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3214     if (!spf) {
3215         int remainder = (sample_rate.num * time_base.num) %
3216                         (time_base.den * sample_rate.den);
3217         *sample_count = av_rescale_q(mxf->current_edit_unit, sample_rate, track->edit_rate);
3218         if (remainder)
3219             av_log(mxf->fc, AV_LOG_WARNING,
3220                    "seeking detected on stream #%d with time base (%d/%d) and "
3221                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3222                    stream_index, time_base.num, time_base.den,
3223                    sample_rate.num, sample_rate.den);
3224         return 0;
3225     }
3226
3227     while (spf->samples_per_frame[size]) {
3228         total += spf->samples_per_frame[size];
3229         size++;
3230     }
3231
3232     av_assert2(size);
3233
3234     *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
3235     for (i = 0; i < mxf->current_edit_unit % size; i++) {
3236         *sample_count += spf->samples_per_frame[i];
3237     }
3238
3239     return 0;
3240 }
3241
3242 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3243                              AVPacket *pkt)
3244 {
3245     MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3246     int64_t bits_per_sample = par->bits_per_coded_sample;
3247
3248     if (!bits_per_sample)
3249         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3250
3251     pkt->pts = track->sample_count;
3252
3253     if (   par->channels <= 0
3254         || bits_per_sample <= 0
3255         || par->channels * (int64_t)bits_per_sample < 8)
3256         return AVERROR(EINVAL);
3257     track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3258     return 0;
3259 }
3260
3261 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
3262 {
3263     AVCodecParameters *par = st->codecpar;
3264     MXFTrack *track = st->priv_data;
3265
3266     if (par->codec_type == AVMEDIA_TYPE_VIDEO && (next_ofs >= 0 || next_ofs == -2 && st->duration == mxf->current_edit_unit + 1)) {
3267         /* mxf->current_edit_unit good - see if we have an
3268          * index table to derive timestamps from */
3269         MXFIndexTable *t = &mxf->index_tables[0];
3270
3271         if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3272             pkt->dts = mxf->current_edit_unit + t->first_dts;
3273             pkt->pts = t->ptses[mxf->current_edit_unit];
3274         } else if (track->intra_only) {
3275             /* intra-only -> PTS = EditUnit.
3276              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3277             pkt->pts = mxf->current_edit_unit;
3278         }
3279     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3280         int ret = mxf_set_audio_pts(mxf, par, pkt);
3281         if (ret < 0)
3282             return ret;
3283     }
3284     return 0;
3285 }
3286
3287 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
3288 {
3289     KLVPacket klv;
3290     MXFContext *mxf = s->priv_data;
3291     int ret;
3292
3293     while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3294         PRINT_KEY(s, "read packet", klv.key);
3295         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3296         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3297             ret = mxf_decrypt_triplet(s, pkt, &klv);
3298             if (ret < 0) {
3299                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3300                 return ret;
3301             }
3302             return 0;
3303         }
3304         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3305             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3306             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3307             int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3308             int index = mxf_get_stream_index(s, &klv, body_sid);
3309             int64_t next_ofs;
3310             AVStream *st;
3311
3312             if (index < 0) {
3313                 av_log(s, AV_LOG_ERROR,
3314                        "error getting stream index %"PRIu32"\n",
3315                        AV_RB32(klv.key + 12));
3316                 goto skip;
3317             }
3318
3319             st = s->streams[index];
3320
3321             if (s->streams[index]->discard == AVDISCARD_ALL)
3322                 goto skip;
3323
3324             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3325
3326             if (next_ofs >= 0 && klv.next_klv > next_ofs) {
3327                 /* if this check is hit then it's possible OPAtom was treated as OP1a
3328                  * truncate the packet since it's probably very large (>2 GiB is common) */
3329                 avpriv_request_sample(s,
3330                                       "OPAtom misinterpreted as OP1a? "
3331                                       "KLV for edit unit %"PRId64" extending into "
3332                                       "next edit unit",
3333                                       mxf->current_edit_unit);
3334                 klv.length = next_ofs - avio_tell(s->pb);
3335             }
3336
3337             /* check for 8 channels AES3 element */
3338             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3339                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3340                                               pkt, klv.length);
3341                 if (ret < 0) {
3342                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3343                     return ret;
3344                 }
3345             } else {
3346                 ret = av_get_packet(s->pb, pkt, klv.length);
3347                 if (ret < 0)
3348                     return ret;
3349             }
3350             pkt->stream_index = index;
3351             pkt->pos = klv.offset;
3352
3353             ret = mxf_set_pts(mxf, st, pkt, next_ofs);
3354             if (ret < 0)
3355                 return ret;
3356
3357             /* seek for truncated packets */
3358             avio_seek(s->pb, klv.next_klv, SEEK_SET);
3359
3360             return 0;
3361         } else
3362         skip:
3363             avio_skip(s->pb, klv.length);
3364     }
3365     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3366 }
3367
3368 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3369 {
3370     MXFContext *mxf = s->priv_data;
3371     int ret, size;
3372     int64_t ret64, pos, next_pos;
3373     AVStream *st;
3374     MXFIndexTable *t;
3375     MXFTrack *track;
3376     int edit_units;
3377
3378     if (mxf->op != OPAtom)
3379         return mxf_read_packet_old(s, pkt);
3380
3381     // If we have no streams then we basically are at EOF
3382     st = mxf_get_opatom_stream(mxf);
3383     if (!st)
3384         return AVERROR_EOF;
3385
3386     track = st->priv_data;
3387
3388     /* OPAtom - clip wrapped demuxing */
3389     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3390     t = &mxf->index_tables[0];
3391
3392     if (mxf->current_edit_unit >= track->original_duration)
3393         return AVERROR_EOF;
3394
3395     edit_units = FFMIN(track->edit_units_per_packet, track->original_duration - mxf->current_edit_unit);
3396
3397     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3398         return ret;
3399
3400     /* compute size by finding the next edit unit or the end of the essence container
3401      * not pretty, but it works */
3402     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3403         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3404         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3405         return AVERROR_INVALIDDATA;
3406     }
3407
3408     if ((size = next_pos - pos) <= 0) {
3409         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3410         return AVERROR_INVALIDDATA;
3411     }
3412
3413     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3414         return ret64;
3415
3416     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3417         return size;
3418
3419     pkt->stream_index = st->index;
3420
3421     ret = mxf_set_pts(mxf, st, pkt, next_pos);
3422     if (ret < 0)
3423         return ret;
3424
3425     mxf->current_edit_unit += edit_units;
3426
3427     return 0;
3428 }
3429
3430 static int mxf_read_close(AVFormatContext *s)
3431 {
3432     MXFContext *mxf = s->priv_data;
3433     int i;
3434
3435     av_freep(&mxf->packages_refs);
3436     av_freep(&mxf->essence_container_data_refs);
3437
3438     for (i = 0; i < s->nb_streams; i++)
3439         s->streams[i]->priv_data = NULL;
3440
3441     for (i = 0; i < mxf->metadata_sets_count; i++) {
3442         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3443     }
3444     av_freep(&mxf->partitions);
3445     av_freep(&mxf->metadata_sets);
3446     av_freep(&mxf->aesc);
3447     av_freep(&mxf->local_tags);
3448
3449     if (mxf->index_tables) {
3450         for (i = 0; i < mxf->nb_index_tables; i++) {
3451             av_freep(&mxf->index_tables[i].segments);
3452             av_freep(&mxf->index_tables[i].ptses);
3453             av_freep(&mxf->index_tables[i].fake_index);
3454             av_freep(&mxf->index_tables[i].offsets);
3455         }
3456     }
3457     av_freep(&mxf->index_tables);
3458
3459     return 0;
3460 }
3461
3462 static int mxf_probe(AVProbeData *p) {
3463     const uint8_t *bufp = p->buf;
3464     const uint8_t *end = p->buf + p->buf_size;
3465
3466     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3467         return 0;
3468
3469     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3470     end -= sizeof(mxf_header_partition_pack_key);
3471
3472     for (; bufp < end;) {
3473         if (!((bufp[13] - 1) & 0xF2)){
3474             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3475                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3476                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3477                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3478                 return AVPROBE_SCORE_MAX;
3479             bufp ++;
3480         } else
3481             bufp += 10;
3482     }
3483
3484     return 0;
3485 }
3486
3487 /* rudimentary byte seek */
3488 /* XXX: use MXF Index */
3489 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3490 {
3491     AVStream *st = s->streams[stream_index];
3492     int64_t seconds;
3493     MXFContext* mxf = s->priv_data;
3494     int64_t seekpos;
3495     int i, ret;
3496     MXFIndexTable *t;
3497     MXFTrack *source_track = st->priv_data;
3498
3499     if (!source_track)
3500         return 0;
3501
3502     /* if audio then truncate sample_time to EditRate */
3503     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3504         sample_time = av_rescale_q(sample_time, st->time_base,
3505                                    av_inv_q(source_track->edit_rate));
3506
3507     if (mxf->nb_index_tables <= 0) {
3508         if (!s->bit_rate)
3509             return AVERROR_INVALIDDATA;
3510         if (sample_time < 0)
3511             sample_time = 0;
3512         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3513
3514         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3515         if (seekpos < 0)
3516             return seekpos;
3517
3518         ff_update_cur_dts(s, st, sample_time);
3519         mxf->current_edit_unit = sample_time;
3520     } else {
3521         t = &mxf->index_tables[0];
3522         if (t->index_sid != source_track->index_sid) {
3523             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3524             for (i = 0; i < s->nb_streams; i++) {
3525                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3526                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3527                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3528                     source_track = new_source_track;
3529                     st = s->streams[i];
3530                     break;
3531                 }
3532             }
3533             if (i == s->nb_streams)
3534                 return AVERROR_INVALIDDATA;
3535         }
3536
3537         /* clamp above zero, else ff_index_search_timestamp() returns negative
3538          * this also means we allow seeking before the start */
3539         sample_time = FFMAX(sample_time, 0);
3540
3541         if (t->fake_index) {
3542             /* The first frames may not be keyframes in presentation order, so
3543              * we have to advance the target to be able to find the first
3544              * keyframe backwards... */
3545             if (!(flags & AVSEEK_FLAG_ANY) &&
3546                 (flags & AVSEEK_FLAG_BACKWARD) &&
3547                 t->ptses[0] != AV_NOPTS_VALUE &&
3548                 sample_time < t->ptses[0] &&
3549                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3550                 sample_time = t->ptses[0];
3551
3552             /* behave as if we have a proper index */
3553             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3554                 return sample_time;
3555             /* get the stored order index from the display order index */
3556             sample_time += t->offsets[sample_time];
3557         } else {
3558             /* no IndexEntryArray (one or more CBR segments)
3559              * make sure we don't seek past the end */
3560             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3561         }
3562
3563         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3564             return ret;
3565
3566         ff_update_cur_dts(s, st, sample_time);
3567         mxf->current_edit_unit = sample_time;
3568         avio_seek(s->pb, seekpos, SEEK_SET);
3569     }
3570
3571     // Update all tracks sample count
3572     for (i = 0; i < s->nb_streams; i++) {
3573         AVStream *cur_st = s->streams[i];
3574         MXFTrack *cur_track = cur_st->priv_data;
3575         if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3576             int64_t track_edit_unit;
3577             if (st != cur_st && mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit) >= 0) {
3578                 cur_track->sample_count = av_rescale_q(track_edit_unit,
3579                                                        av_inv_q(cur_track->edit_rate),
3580                                                        cur_st->time_base);
3581             } else {
3582                 uint64_t current_sample_count = 0;
3583                 ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
3584                 if (ret < 0)
3585                     return ret;
3586                 cur_track->sample_count = current_sample_count;
3587             }
3588         }
3589     }
3590     return 0;
3591 }
3592
3593 AVInputFormat ff_mxf_demuxer = {
3594     .name           = "mxf",
3595     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3596     .flags          = AVFMT_SEEK_TO_PTS,
3597     .priv_data_size = sizeof(MXFContext),
3598     .read_probe     = mxf_probe,
3599     .read_header    = mxf_read_header,
3600     .read_packet    = mxf_read_packet,
3601     .read_close     = mxf_read_close,
3602     .read_seek      = mxf_read_seek,
3603 };