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