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