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