libavformat/mxfdec: don't assume first stream index to be primary
[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     AVStream *st = NULL;
1495
1496     for (i = 0; i < mxf->fc->nb_streams; i++) {
1497         if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
1498             continue;
1499         st = mxf->fc->streams[i];
1500         break;
1501     }
1502
1503     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1504         nb_sorted_segments <= 0) {
1505         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1506         return 0;
1507     }
1508
1509     /* sanity check and count unique BodySIDs/IndexSIDs */
1510     for (i = 0; i < nb_sorted_segments; i++) {
1511         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1512             mxf->nb_index_tables++;
1513         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1514             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1515             ret = AVERROR_INVALIDDATA;
1516             goto finish_decoding_index;
1517         }
1518     }
1519
1520     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1521                                          sizeof(*mxf->index_tables));
1522     if (!mxf->index_tables) {
1523         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1524         ret = AVERROR(ENOMEM);
1525         goto finish_decoding_index;
1526     }
1527
1528     /* distribute sorted segments to index tables */
1529     for (i = j = 0; i < nb_sorted_segments; i++) {
1530         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1531             /* next IndexSID */
1532             j++;
1533         }
1534
1535         mxf->index_tables[j].nb_segments++;
1536     }
1537
1538     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1539         MXFIndexTable *t = &mxf->index_tables[j];
1540
1541         t->segments = av_mallocz_array(t->nb_segments,
1542                                        sizeof(*t->segments));
1543
1544         if (!t->segments) {
1545             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1546                    " pointer array\n");
1547             ret = AVERROR(ENOMEM);
1548             goto finish_decoding_index;
1549         }
1550
1551         if (sorted_segments[i]->index_start_position)
1552             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1553                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1554
1555         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1556         t->index_sid = sorted_segments[i]->index_sid;
1557         t->body_sid = sorted_segments[i]->body_sid;
1558
1559         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1560             goto finish_decoding_index;
1561
1562         /* fix zero IndexDurations */
1563         for (k = 0; k < t->nb_segments; k++) {
1564             if (t->segments[k]->index_duration)
1565                 continue;
1566
1567             if (t->nb_segments > 1)
1568                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1569                        t->index_sid, k);
1570
1571             if (!st) {
1572                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1573                 break;
1574             }
1575
1576             /* assume the first stream's duration is reasonable
1577              * leave index_duration = 0 on further segments in case we have any (unlikely)
1578              */
1579             t->segments[k]->index_duration = st->duration;
1580             break;
1581         }
1582     }
1583
1584     ret = 0;
1585 finish_decoding_index:
1586     av_free(sorted_segments);
1587     return ret;
1588 }
1589
1590 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1591 {
1592     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1593                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1594            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1595                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1596 }
1597
1598 static int mxf_uid_to_str(UID uid, char **str)
1599 {
1600     int i;
1601     char *p;
1602     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1603     if (!p)
1604         return AVERROR(ENOMEM);
1605     for (i = 0; i < sizeof(UID); i++) {
1606         snprintf(p, 2 + 1, "%.2x", uid[i]);
1607         p += 2;
1608         if (i == 3 || i == 5 || i == 7 || i == 9) {
1609             snprintf(p, 1 + 1, "-");
1610             p++;
1611         }
1612     }
1613     return 0;
1614 }
1615
1616 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1617 {
1618     int i;
1619     char *p;
1620     p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1621     if (!p)
1622         return AVERROR(ENOMEM);
1623     snprintf(p, 2 + 1, "0x");
1624     p += 2;
1625     for (i = 0; i < sizeof(UID); i++) {
1626         snprintf(p, 2 + 1, "%.2X", ul[i]);
1627         p += 2;
1628
1629     }
1630     for (i = 0; i < sizeof(UID); i++) {
1631         snprintf(p, 2 + 1, "%.2X", uid[i]);
1632         p += 2;
1633     }
1634     return 0;
1635 }
1636
1637 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1638 {
1639     char *str;
1640     int ret;
1641     if (!package)
1642         return 0;
1643     if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1644         return ret;
1645     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1646     return 0;
1647 }
1648
1649 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1650 {
1651     char buf[AV_TIMECODE_STR_SIZE];
1652     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1653
1654     return 0;
1655 }
1656
1657 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1658 {
1659     MXFStructuralComponent *component = NULL;
1660     MXFPulldownComponent *pulldown = NULL;
1661
1662     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1663     if (!component)
1664         return NULL;
1665
1666     switch (component->type) {
1667     case TimecodeComponent:
1668         return (MXFTimecodeComponent*)component;
1669     case PulldownComponent: /* timcode component may be located on a pulldown component */
1670         pulldown = (MXFPulldownComponent*)component;
1671         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1672     default:
1673         break;
1674     }
1675     return NULL;
1676 }
1677
1678 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
1679 {
1680     MXFPackage *package = NULL;
1681     int i;
1682
1683     for (i = 0; i < mxf->packages_count; i++) {
1684         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1685         if (!package)
1686             continue;
1687
1688         if (!memcmp(package->package_uid, package_uid, 16))
1689             return package;
1690     }
1691     return NULL;
1692 }
1693
1694 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1695 {
1696     MXFDescriptor *sub_descriptor = NULL;
1697     int i;
1698
1699     if (!descriptor)
1700         return NULL;
1701
1702     if (descriptor->type == MultipleDescriptor) {
1703         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1704             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1705
1706             if (!sub_descriptor) {
1707                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1708                 continue;
1709             }
1710             if (sub_descriptor->linked_track_id == track_id) {
1711                 return sub_descriptor;
1712             }
1713         }
1714     } else if (descriptor->type == Descriptor)
1715         return descriptor;
1716
1717     return NULL;
1718 }
1719
1720 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1721 {
1722     MXFStructuralComponent *component = NULL;
1723     MXFPackage *package = NULL;
1724     MXFDescriptor *descriptor = NULL;
1725     int i;
1726
1727     if (!essence_group || !essence_group->structural_components_count)
1728         return NULL;
1729
1730     /* essence groups contains multiple representations of the same media,
1731        this return the first components with a valid Descriptor typically index 0 */
1732     for (i =0; i < essence_group->structural_components_count; i++){
1733         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1734         if (!component)
1735             continue;
1736
1737         if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1738             continue;
1739
1740         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1741         if (descriptor)
1742             return component;
1743     }
1744     return NULL;
1745 }
1746
1747 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1748 {
1749     MXFStructuralComponent *component = NULL;
1750
1751     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1752     if (!component)
1753         return NULL;
1754     switch (component->type) {
1755         case SourceClip:
1756             return component;
1757         case EssenceGroup:
1758             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1759         default:
1760             break;
1761     }
1762     return NULL;
1763 }
1764
1765 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1766 {
1767     MXFTaggedValue *tag;
1768     int size, i;
1769     char *key = NULL;
1770
1771     for (i = 0; i < package->comment_count; i++) {
1772         tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1773         if (!tag || !tag->name || !tag->value)
1774             continue;
1775
1776         size = strlen(tag->name) + 8 + 1;
1777         key = av_mallocz(size);
1778         if (!key)
1779             return AVERROR(ENOMEM);
1780
1781         snprintf(key, size, "comment_%s", tag->name);
1782         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1783     }
1784     return 0;
1785 }
1786
1787 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1788 {
1789     MXFPackage *physical_package = NULL;
1790     MXFTrack *physical_track = NULL;
1791     MXFStructuralComponent *sourceclip = NULL;
1792     MXFTimecodeComponent *mxf_tc = NULL;
1793     int i, j, k;
1794     AVTimecode tc;
1795     int flags;
1796     int64_t start_position;
1797
1798     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1799         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1800         if (!sourceclip)
1801             continue;
1802
1803         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1804             break;
1805
1806         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1807
1808         /* the name of physical source package is name of the reel or tape */
1809         if (physical_package->name && physical_package->name[0])
1810             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1811
1812         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1813          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1814          */
1815         for (j = 0; j < physical_package->tracks_count; j++) {
1816             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1817                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1818                 continue;
1819             }
1820
1821             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1822                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1823                 continue;
1824             }
1825
1826         if (physical_track->edit_rate.num <= 0 ||
1827             physical_track->edit_rate.den <= 0) {
1828             av_log(mxf->fc, AV_LOG_WARNING,
1829                    "Invalid edit rate (%d/%d) found on structural"
1830                    " component #%d, defaulting to 25/1\n",
1831                    physical_track->edit_rate.num,
1832                    physical_track->edit_rate.den, i);
1833             physical_track->edit_rate = (AVRational){25, 1};
1834         }
1835
1836             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1837                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1838                     continue;
1839
1840                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1841                 /* scale sourceclip start_position to match physical track edit rate */
1842                 start_position = av_rescale_q(sourceclip->start_position,
1843                                               physical_track->edit_rate,
1844                                               source_track->edit_rate);
1845
1846                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1847                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1848                     return 0;
1849                 }
1850             }
1851         }
1852     }
1853
1854     return 0;
1855 }
1856
1857 static int mxf_parse_structural_metadata(MXFContext *mxf)
1858 {
1859     MXFPackage *material_package = NULL;
1860     int i, j, k, ret;
1861
1862     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
1863     /* TODO: handle multiple material packages (OP3x) */
1864     for (i = 0; i < mxf->packages_count; i++) {
1865         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1866         if (material_package) break;
1867     }
1868     if (!material_package) {
1869         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1870         return AVERROR_INVALIDDATA;
1871     }
1872
1873     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
1874     if (material_package->name && material_package->name[0])
1875         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1876     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
1877
1878     for (i = 0; i < material_package->tracks_count; i++) {
1879         MXFPackage *source_package = NULL;
1880         MXFTrack *material_track = NULL;
1881         MXFTrack *source_track = NULL;
1882         MXFTrack *temp_track = NULL;
1883         MXFDescriptor *descriptor = NULL;
1884         MXFStructuralComponent *component = NULL;
1885         MXFTimecodeComponent *mxf_tc = NULL;
1886         UID *essence_container_ul = NULL;
1887         const MXFCodecUL *codec_ul = NULL;
1888         const MXFCodecUL *container_ul = NULL;
1889         const MXFCodecUL *pix_fmt_ul = NULL;
1890         AVStream *st;
1891         AVTimecode tc;
1892         int flags;
1893
1894         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1895             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1896             continue;
1897         }
1898
1899         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1900             mxf_tc = (MXFTimecodeComponent*)component;
1901             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1902             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1903                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1904             }
1905         }
1906
1907         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1908             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1909             continue;
1910         }
1911
1912         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1913             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1914             if (!component)
1915                 continue;
1916
1917             mxf_tc = (MXFTimecodeComponent*)component;
1918             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1919             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1920                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1921                 break;
1922             }
1923         }
1924
1925         /* TODO: handle multiple source clips, only finds first valid source clip */
1926         if(material_track->sequence->structural_components_count > 1)
1927             av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
1928                        material_track->track_id, material_track->sequence->structural_components_count);
1929
1930         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1931             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1932             if (!component)
1933                 continue;
1934
1935             source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1936             if (!source_package) {
1937                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
1938                 break;
1939             }
1940             for (k = 0; k < source_package->tracks_count; k++) {
1941                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1942                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1943                     ret = AVERROR_INVALIDDATA;
1944                     goto fail_and_free;
1945                 }
1946                 if (temp_track->track_id == component->source_track_id) {
1947                     source_track = temp_track;
1948                     break;
1949                 }
1950             }
1951             if (!source_track) {
1952                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1953                 break;
1954             }
1955             if(source_track && component)
1956                 break;
1957         }
1958         if (!source_track || !component || !source_package)
1959             continue;
1960
1961         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1962             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1963             ret = AVERROR_INVALIDDATA;
1964             goto fail_and_free;
1965         }
1966
1967         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1968          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1969         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1970             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1971             continue;
1972         }
1973
1974         st = avformat_new_stream(mxf->fc, NULL);
1975         if (!st) {
1976             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1977             ret = AVERROR(ENOMEM);
1978             goto fail_and_free;
1979         }
1980         st->id = source_track->track_id;
1981         st->priv_data = source_track;
1982
1983         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1984         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
1985
1986         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
1987          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
1988         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
1989             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
1990         else
1991             source_track->original_duration = st->duration = component->duration;
1992
1993         if (st->duration == -1)
1994             st->duration = AV_NOPTS_VALUE;
1995         st->start_time = component->start_position;
1996         if (material_track->edit_rate.num <= 0 ||
1997             material_track->edit_rate.den <= 0) {
1998             av_log(mxf->fc, AV_LOG_WARNING,
1999                    "Invalid edit rate (%d/%d) found on stream #%d, "
2000                    "defaulting to 25/1\n",
2001                    material_track->edit_rate.num,
2002                    material_track->edit_rate.den, st->index);
2003             material_track->edit_rate = (AVRational){25, 1};
2004         }
2005         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2006
2007         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2008          * the former is accessible via st->priv_data */
2009         source_track->edit_rate = material_track->edit_rate;
2010
2011         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
2012         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2013         st->codecpar->codec_type = codec_ul->id;
2014
2015         if (!descriptor) {
2016             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2017             continue;
2018         }
2019         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
2020         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2021         essence_container_ul = &descriptor->essence_container_ul;
2022         /* HACK: replacing the original key with mxf_encrypted_essence_container
2023          * is not allowed according to s429-6, try to find correct information anyway */
2024         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2025             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2026             for (k = 0; k < mxf->metadata_sets_count; k++) {
2027                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2028                 if (metadata->type == CryptoContext) {
2029                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2030                     break;
2031                 }
2032             }
2033         }
2034
2035         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2036         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2037         st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2038         if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2039             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2040             st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2041         }
2042
2043         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2044                avcodec_get_name(st->codecpar->codec_id));
2045         for (k = 0; k < 16; k++) {
2046             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2047                    descriptor->essence_codec_ul[k]);
2048             if (!(k+1 & 19) || k == 5)
2049                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2050         }
2051         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2052
2053         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2054         if (source_package->name && source_package->name[0])
2055             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2056         if (material_track->name && material_track->name[0])
2057             av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2058
2059         mxf_parse_physical_source_package(mxf, source_track, st);
2060
2061         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2062             source_track->intra_only = mxf_is_intra_only(descriptor);
2063             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2064             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2065                 st->codecpar->codec_id = container_ul->id;
2066             st->codecpar->width = descriptor->width;
2067             st->codecpar->height = descriptor->height; /* Field height, not frame height */
2068             switch (descriptor->frame_layout) {
2069                 case FullFrame:
2070                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2071                     break;
2072                 case OneField:
2073                     /* Every other line is stored and needs to be duplicated. */
2074                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2075                     break; /* The correct thing to do here is fall through, but by breaking we might be
2076                               able to decode some streams at half the vertical resolution, rather than not al all.
2077                               It's also for compatibility with the old behavior. */
2078                 case MixedFields:
2079                     break;
2080                 case SegmentedFrame:
2081                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2082                 case SeparateFields:
2083                     av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2084                            descriptor->video_line_map[0], descriptor->video_line_map[1],
2085                            descriptor->field_dominance);
2086                     if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2087                         /* Detect coded field order from VideoLineMap:
2088                          *  (even, even) => bottom field coded first
2089                          *  (even, odd)  => top field coded first
2090                          *  (odd, even)  => top field coded first
2091                          *  (odd, odd)   => bottom field coded first
2092                          */
2093                         if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2094                             switch (descriptor->field_dominance) {
2095                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2096                                 case MXF_FIELD_DOMINANCE_FF:
2097                                     st->codecpar->field_order = AV_FIELD_TT;
2098                                     break;
2099                                 case MXF_FIELD_DOMINANCE_FL:
2100                                     st->codecpar->field_order = AV_FIELD_TB;
2101                                     break;
2102                                 default:
2103                                     avpriv_request_sample(mxf->fc,
2104                                                           "Field dominance %d support",
2105                                                           descriptor->field_dominance);
2106                             }
2107                         } else {
2108                             switch (descriptor->field_dominance) {
2109                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2110                                 case MXF_FIELD_DOMINANCE_FF:
2111                                     st->codecpar->field_order = AV_FIELD_BB;
2112                                     break;
2113                                 case MXF_FIELD_DOMINANCE_FL:
2114                                     st->codecpar->field_order = AV_FIELD_BT;
2115                                     break;
2116                                 default:
2117                                     avpriv_request_sample(mxf->fc,
2118                                                           "Field dominance %d support",
2119                                                           descriptor->field_dominance);
2120                             }
2121                         }
2122                     }
2123                     /* Turn field height into frame height. */
2124                     st->codecpar->height *= 2;
2125                     break;
2126                 default:
2127                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2128             }
2129             if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2130                 st->codecpar->format = descriptor->pix_fmt;
2131                 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2132                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2133                                                   &descriptor->essence_codec_ul);
2134                     st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2135                     if (st->codecpar->format== AV_PIX_FMT_NONE) {
2136                         st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2137                                                                    &descriptor->essence_codec_ul)->id;
2138                         if (!st->codecpar->codec_tag) {
2139                             /* support files created before RP224v10 by defaulting to UYVY422
2140                                if subsampling is 4:2:2 and component depth is 8-bit */
2141                             if (descriptor->horiz_subsampling == 2 &&
2142                                 descriptor->vert_subsampling == 1 &&
2143                                 descriptor->component_depth == 8) {
2144                                 st->codecpar->format = AV_PIX_FMT_UYVY422;
2145                             }
2146                         }
2147                     }
2148                 }
2149             }
2150             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2151             if (material_track->sequence->origin) {
2152                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2153             }
2154             if (source_track->sequence->origin) {
2155                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2156             }
2157             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2158                 st->display_aspect_ratio = descriptor->aspect_ratio;
2159         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2160             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2161             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2162             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))
2163                 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2164             st->codecpar->channels = descriptor->channels;
2165             st->codecpar->bits_per_coded_sample = descriptor->bits_per_sample;
2166
2167             if (descriptor->sample_rate.den > 0) {
2168                 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2169                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2170             } else {
2171                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2172                        "found for stream #%d, time base forced to 1/48000\n",
2173                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2174                        st->index);
2175                 avpriv_set_pts_info(st, 64, 1, 48000);
2176             }
2177
2178             /* if duration is set, rescale it from EditRate to SampleRate */
2179             if (st->duration != AV_NOPTS_VALUE)
2180                 st->duration = av_rescale_q(st->duration,
2181                                             av_inv_q(material_track->edit_rate),
2182                                             st->time_base);
2183
2184             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2185             if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2186                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2187                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2188                 else if (descriptor->bits_per_sample == 32)
2189                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2190             } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2191                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2192                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2193                 else if (descriptor->bits_per_sample == 32)
2194                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2195             } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2196                 st->need_parsing = AVSTREAM_PARSE_FULL;
2197             }
2198         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2199             int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2200                                             essence_container_ul)->id;
2201             if (codec_id >= 0 &&
2202                 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2203                 av_dict_set(&st->metadata, "data_type",
2204                             mxf_data_essence_descriptor[codec_id], 0);
2205             }
2206         }
2207         if (descriptor->extradata) {
2208             if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2209                 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2210             }
2211         } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2212             int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2213                                                &descriptor->essence_codec_ul)->id;
2214             if (coded_width)
2215                 st->codecpar->width = coded_width;
2216             ret = ff_generate_avci_extradata(st);
2217             if (ret < 0)
2218                 return ret;
2219         }
2220         if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2221             /* TODO: decode timestamps */
2222             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2223         }
2224     }
2225
2226     ret = 0;
2227 fail_and_free:
2228     return ret;
2229 }
2230
2231 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2232 {
2233     struct tm time = { 0 };
2234     time.tm_year = (timestamp >> 48) - 1900;
2235     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2236     time.tm_mday = (timestamp >> 32 & 0xFF);
2237     time.tm_hour = (timestamp >> 24 & 0xFF);
2238     time.tm_min  = (timestamp >> 16 & 0xFF);
2239     time.tm_sec  = (timestamp >> 8  & 0xFF);
2240
2241     /* msvcrt versions of strftime calls the invalid parameter handler
2242      * (aborting the process if one isn't set) if the parameters are out
2243      * of range. */
2244     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2245     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2246     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2247     time.tm_min  = av_clip(time.tm_min,  0, 59);
2248     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2249
2250     return (int64_t)av_timegm(&time) * 1000000;
2251 }
2252
2253 #define SET_STR_METADATA(pb, name, str) do { \
2254     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2255         return ret; \
2256     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2257 } while (0)
2258
2259 #define SET_UID_METADATA(pb, name, var, str) do { \
2260     avio_read(pb, var, 16); \
2261     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2262         return ret; \
2263     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2264 } while (0)
2265
2266 #define SET_TS_METADATA(pb, name, var, str) do { \
2267     var = avio_rb64(pb); \
2268     if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2269         return ret; \
2270 } while (0)
2271
2272 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2273 {
2274     MXFContext *mxf = arg;
2275     AVFormatContext *s = mxf->fc;
2276     int ret;
2277     UID uid = { 0 };
2278     char *str = NULL;
2279     uint64_t ts;
2280     switch (tag) {
2281     case 0x3C01:
2282         SET_STR_METADATA(pb, "company_name", str);
2283         break;
2284     case 0x3C02:
2285         SET_STR_METADATA(pb, "product_name", str);
2286         break;
2287     case 0x3C04:
2288         SET_STR_METADATA(pb, "product_version", str);
2289         break;
2290     case 0x3C05:
2291         SET_UID_METADATA(pb, "product_uid", uid, str);
2292         break;
2293     case 0x3C06:
2294         SET_TS_METADATA(pb, "modification_date", ts, str);
2295         break;
2296     case 0x3C08:
2297         SET_STR_METADATA(pb, "application_platform", str);
2298         break;
2299     case 0x3C09:
2300         SET_UID_METADATA(pb, "generation_uid", uid, str);
2301         break;
2302     case 0x3C0A:
2303         SET_UID_METADATA(pb, "uid", uid, str);
2304         break;
2305     }
2306     return 0;
2307 }
2308
2309 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2310 {
2311     MXFContext *mxf = arg;
2312     AVFormatContext *s = mxf->fc;
2313     int ret;
2314     char *str = NULL;
2315
2316     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2317         SET_STR_METADATA(pb, "project_name", str);
2318     }
2319     return 0;
2320 }
2321
2322 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2323     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2324     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2325     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2326     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2327     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2328     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2329     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2330     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2331     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2332     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2333     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2334     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2335     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2336     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2337     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2338     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2339     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2340     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2341     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2342     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2343     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2344     { { 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 */
2345     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2346     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2347     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2348     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2349     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2350     { { 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 */
2351     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2352     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2353     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2354     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2355     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2356     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2357     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2358     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2359 };
2360
2361 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2362 {
2363     switch (type){
2364     case MultipleDescriptor:
2365     case Descriptor:
2366         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2367         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2368         break;
2369     default:
2370         break;
2371     }
2372     return 0;
2373 }
2374
2375 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2376 {
2377     AVIOContext *pb = mxf->fc->pb;
2378     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2379     uint64_t klv_end = avio_tell(pb) + klv->length;
2380
2381     if (!ctx)
2382         return AVERROR(ENOMEM);
2383     mxf_metadataset_init(ctx, type);
2384     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2385         int ret;
2386         int tag = avio_rb16(pb);
2387         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2388         uint64_t next = avio_tell(pb) + size;
2389         UID uid = {0};
2390
2391         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2392         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2393             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2394             continue;
2395         }
2396         if (tag > 0x7FFF) { /* dynamic tag */
2397             int i;
2398             for (i = 0; i < mxf->local_tags_count; i++) {
2399                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2400                 if (local_tag == tag) {
2401                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2402                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2403                     PRINT_KEY(mxf->fc, "uid", uid);
2404                 }
2405             }
2406         }
2407         if (ctx_size && tag == 0x3C0A) {
2408             avio_read(pb, ctx->uid, 16);
2409         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2410             mxf_free_metadataset(&ctx, !!ctx_size);
2411             return ret;
2412         }
2413
2414         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2415          * it extending past the end of the KLV though (zzuf5.mxf). */
2416         if (avio_tell(pb) > klv_end) {
2417             if (ctx_size) {
2418                 ctx->type = type;
2419                 mxf_free_metadataset(&ctx, !!ctx_size);
2420             }
2421
2422             av_log(mxf->fc, AV_LOG_ERROR,
2423                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2424                    tag, klv->offset);
2425             return AVERROR_INVALIDDATA;
2426         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2427             avio_seek(pb, next, SEEK_SET);
2428     }
2429     if (ctx_size) ctx->type = type;
2430     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2431 }
2432
2433 /**
2434  * Matches any partition pack key, in other words:
2435  * - HeaderPartition
2436  * - BodyPartition
2437  * - FooterPartition
2438  * @return non-zero if the key is a partition pack key, zero otherwise
2439  */
2440 static int mxf_is_partition_pack_key(UID key)
2441 {
2442     //NOTE: this is a little lax since it doesn't constraint key[14]
2443     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2444             key[13] >= 2 && key[13] <= 4;
2445 }
2446
2447 /**
2448  * Parses a metadata KLV
2449  * @return <0 on error, 0 otherwise
2450  */
2451 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2452                                      int ctx_size, enum MXFMetadataSetType type)
2453 {
2454     AVFormatContext *s = mxf->fc;
2455     int res;
2456     if (klv.key[5] == 0x53) {
2457         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2458     } else {
2459         uint64_t next = avio_tell(s->pb) + klv.length;
2460         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2461
2462         /* only seek forward, else this can loop for a long time */
2463         if (avio_tell(s->pb) > next) {
2464             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2465                    klv.offset);
2466             return AVERROR_INVALIDDATA;
2467         }
2468
2469         avio_seek(s->pb, next, SEEK_SET);
2470     }
2471     if (res < 0) {
2472         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2473         return res;
2474     }
2475     return 0;
2476 }
2477
2478 /**
2479  * Seeks to the previous partition and parses it, if possible
2480  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2481  */
2482 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2483 {
2484     AVIOContext *pb = mxf->fc->pb;
2485     KLVPacket klv;
2486     int64_t current_partition_ofs;
2487     int ret;
2488
2489     if (!mxf->current_partition ||
2490         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2491         return 0;   /* we've parsed all partitions */
2492
2493     /* seek to previous partition */
2494     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2495     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2496     mxf->current_partition = NULL;
2497
2498     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2499
2500     /* Make sure this is actually a PartitionPack, and if so parse it.
2501      * See deadlock2.mxf
2502      */
2503     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2504         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2505         return ret;
2506     }
2507
2508     if (!mxf_is_partition_pack_key(klv.key)) {
2509         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2510         return AVERROR_INVALIDDATA;
2511     }
2512
2513     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2514      * can point to just before the current partition, causing klv_read_packet()
2515      * to sync back up to it. See deadlock3.mxf
2516      */
2517     if (klv.offset >= current_partition_ofs) {
2518         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2519                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2520         return AVERROR_INVALIDDATA;
2521     }
2522
2523     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2524         return ret;
2525
2526     return 1;
2527 }
2528
2529 /**
2530  * Called when essence is encountered
2531  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2532  */
2533 static int mxf_parse_handle_essence(MXFContext *mxf)
2534 {
2535     AVIOContext *pb = mxf->fc->pb;
2536     int64_t ret;
2537
2538     if (mxf->parsing_backward) {
2539         return mxf_seek_to_previous_partition(mxf);
2540     } else {
2541         if (!mxf->footer_partition) {
2542             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2543             return 0;
2544         }
2545
2546         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2547
2548         /* remember where we were so we don't end up seeking further back than this */
2549         mxf->last_forward_tell = avio_tell(pb);
2550
2551         if (!pb->seekable) {
2552             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2553             return -1;
2554         }
2555
2556         /* seek to FooterPartition and parse backward */
2557         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2558             av_log(mxf->fc, AV_LOG_ERROR,
2559                    "failed to seek to FooterPartition @ 0x%" PRIx64
2560                    " (%"PRId64") - partial file?\n",
2561                    mxf->run_in + mxf->footer_partition, ret);
2562             return ret;
2563         }
2564
2565         mxf->current_partition = NULL;
2566         mxf->parsing_backward = 1;
2567     }
2568
2569     return 1;
2570 }
2571
2572 /**
2573  * Called when the next partition or EOF is encountered
2574  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2575  */
2576 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2577 {
2578     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2579 }
2580
2581 /**
2582  * Figures out the proper offset and length of the essence container in each partition
2583  */
2584 static void mxf_compute_essence_containers(MXFContext *mxf)
2585 {
2586     int x;
2587
2588     /* everything is already correct */
2589     if (mxf->op == OPAtom)
2590         return;
2591
2592     for (x = 0; x < mxf->partitions_count; x++) {
2593         MXFPartition *p = &mxf->partitions[x];
2594
2595         if (!p->body_sid)
2596             continue;       /* BodySID == 0 -> no essence */
2597
2598         if (x >= mxf->partitions_count - 1)
2599             break;          /* FooterPartition - can't compute length (and we don't need to) */
2600
2601         /* essence container spans to the next partition */
2602         p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2603
2604         if (p->essence_length < 0) {
2605             /* next ThisPartition < essence_offset */
2606             p->essence_length = 0;
2607             av_log(mxf->fc, AV_LOG_ERROR,
2608                    "partition %i: bad ThisPartition = %"PRIX64"\n",
2609                    x+1, mxf->partitions[x+1].this_partition);
2610         }
2611     }
2612 }
2613
2614 static int64_t round_to_kag(int64_t position, int kag_size)
2615 {
2616     /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2617     /* NOTE: kag_size may be any integer between 1 - 2^10 */
2618     int64_t ret = (position / kag_size) * kag_size;
2619     return ret == position ? ret : ret + kag_size;
2620 }
2621
2622 static int is_pcm(enum AVCodecID codec_id)
2623 {
2624     /* we only care about "normal" PCM codecs until we get samples */
2625     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2626 }
2627
2628 static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
2629 {
2630     if (mxf->op != OPAtom)
2631         return NULL;
2632
2633     for (int i = 0; i < mxf->fc->nb_streams; i++) {
2634         if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2635             continue;
2636         return mxf->fc->streams[i];
2637     }
2638     return NULL;
2639 }
2640
2641 /**
2642  * Deal with the case where for some audio atoms EditUnitByteCount is
2643  * very small (2, 4..). In those cases we should read more than one
2644  * sample per call to mxf_read_packet().
2645  */
2646 static void mxf_handle_small_eubc(AVFormatContext *s)
2647 {
2648     MXFContext *mxf = s->priv_data;
2649
2650     /* assuming non-OPAtom == frame wrapped
2651      * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2652     AVStream *st = mxf_get_opatom_stream(mxf);
2653     if (!st)
2654         return;
2655
2656     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2657     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
2658         !is_pcm(st->codecpar->codec_id)                        ||
2659         mxf->nb_index_tables != 1                              ||
2660         mxf->index_tables[0].nb_segments != 1                  ||
2661         mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2662         return;
2663
2664     /* arbitrarily default to 48 kHz PAL audio frame size */
2665     /* TODO: We could compute this from the ratio between the audio
2666      *       and video edit rates for 48 kHz NTSC we could use the
2667      *       1802-1802-1802-1802-1801 pattern. */
2668     mxf->edit_units_per_packet = 1920;
2669 }
2670
2671 /**
2672  * Deal with the case where OPAtom files does not have any IndexTableSegments.
2673  */
2674 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2675 {
2676     AVFormatContext *s = mxf->fc;
2677     AVStream *st = NULL;
2678     MXFIndexTableSegment *segment = NULL;
2679     MXFPartition *p = NULL;
2680     int essence_partition_count = 0;
2681     int i, ret;
2682
2683     st = mxf_get_opatom_stream(mxf);
2684     if (!st)
2685         return 0;
2686
2687     /* TODO: support raw video without an index if they exist */
2688     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id))
2689         return 0;
2690
2691     /* check if file already has a IndexTableSegment */
2692     for (i = 0; i < mxf->metadata_sets_count; i++) {
2693         if (mxf->metadata_sets[i]->type == IndexTableSegment)
2694             return 0;
2695     }
2696
2697     /* find the essence partition */
2698     for (i = 0; i < mxf->partitions_count; i++) {
2699         /* BodySID == 0 -> no essence */
2700         if (!mxf->partitions[i].body_sid)
2701             continue;
2702
2703         p = &mxf->partitions[i];
2704         essence_partition_count++;
2705     }
2706
2707     /* only handle files with a single essence partition */
2708     if (essence_partition_count != 1)
2709         return 0;
2710
2711     if (!(segment = av_mallocz(sizeof(*segment))))
2712         return AVERROR(ENOMEM);
2713
2714     if ((ret = mxf_add_metadata_set(mxf, segment))) {
2715         mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2716         return ret;
2717     }
2718
2719     segment->type = IndexTableSegment;
2720     /* stream will be treated as small EditUnitByteCount */
2721     segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2722     segment->index_start_position = 0;
2723     segment->index_duration = s->streams[0]->duration;
2724     segment->index_sid = p->index_sid;
2725     segment->body_sid = p->body_sid;
2726     return 0;
2727 }
2728
2729 static void mxf_read_random_index_pack(AVFormatContext *s)
2730 {
2731     MXFContext *mxf = s->priv_data;
2732     uint32_t length;
2733     int64_t file_size, max_rip_length, min_rip_length;
2734     KLVPacket klv;
2735
2736     if (!s->pb->seekable)
2737         return;
2738
2739     file_size = avio_size(s->pb);
2740
2741     /* S377m says to check the RIP length for "silly" values, without defining "silly".
2742      * The limit below assumes a file with nothing but partition packs and a RIP.
2743      * Before changing this, consider that a muxer may place each sample in its own partition.
2744      *
2745      * 105 is the size of the smallest possible PartitionPack
2746      * 12 is the size of each RIP entry
2747      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2748      */
2749     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2750     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2751
2752     /* We're only interested in RIPs with at least two entries.. */
2753     min_rip_length = 16+1+24+4;
2754
2755     /* See S377m section 11 */
2756     avio_seek(s->pb, file_size - 4, SEEK_SET);
2757     length = avio_rb32(s->pb);
2758
2759     if (length < min_rip_length || length > max_rip_length)
2760         goto end;
2761     avio_seek(s->pb, file_size - length, SEEK_SET);
2762     if (klv_read_packet(&klv, s->pb) < 0 ||
2763         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2764         klv.length != length - 20)
2765         goto end;
2766
2767     avio_skip(s->pb, klv.length - 12);
2768     mxf->footer_partition = avio_rb64(s->pb);
2769
2770     /* sanity check */
2771     if (mxf->run_in + mxf->footer_partition >= file_size) {
2772         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2773         mxf->footer_partition = 0;
2774     }
2775
2776 end:
2777     avio_seek(s->pb, mxf->run_in, SEEK_SET);
2778 }
2779
2780 static int mxf_read_header(AVFormatContext *s)
2781 {
2782     MXFContext *mxf = s->priv_data;
2783     KLVPacket klv;
2784     int64_t essence_offset = 0;
2785     int ret;
2786
2787     mxf->last_forward_tell = INT64_MAX;
2788     mxf->edit_units_per_packet = 1;
2789
2790     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2791         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2792         return AVERROR_INVALIDDATA;
2793     }
2794     avio_seek(s->pb, -14, SEEK_CUR);
2795     mxf->fc = s;
2796     mxf->run_in = avio_tell(s->pb);
2797
2798     mxf_read_random_index_pack(s);
2799
2800     while (!avio_feof(s->pb)) {
2801         const MXFMetadataReadTableEntry *metadata;
2802
2803         if (klv_read_packet(&klv, s->pb) < 0) {
2804             /* EOF - seek to previous partition or stop */
2805             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2806                 break;
2807             else
2808                 continue;
2809         }
2810
2811         PRINT_KEY(s, "read header", klv.key);
2812         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2813         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2814             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2815             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2816             IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2817
2818             if (!mxf->current_partition) {
2819                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2820                 return AVERROR_INVALIDDATA;
2821             }
2822
2823             if (!mxf->current_partition->essence_offset) {
2824                 /* for OP1a we compute essence_offset
2825                  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2826                  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2827                  *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2828                  */
2829                 int64_t op1a_essence_offset =
2830                     round_to_kag(mxf->current_partition->this_partition +
2831                                  mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
2832                     round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2833                     round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);
2834
2835                 if (mxf->op == OPAtom) {
2836                     /* point essence_offset to the actual data
2837                     * OPAtom has all the essence in one big KLV
2838                     */
2839                     mxf->current_partition->essence_offset = avio_tell(s->pb);
2840                     mxf->current_partition->essence_length = klv.length;
2841                 } else {
2842                     /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
2843                     mxf->current_partition->essence_offset = op1a_essence_offset;
2844                 }
2845             }
2846
2847             if (!essence_offset)
2848                 essence_offset = klv.offset;
2849
2850             /* seek to footer, previous partition or stop */
2851             if (mxf_parse_handle_essence(mxf) <= 0)
2852                 break;
2853             continue;
2854         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2855             /* next partition pack - keep going, seek to previous partition or stop */
2856             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2857                 break;
2858             else if (mxf->parsing_backward)
2859                 continue;
2860             /* we're still parsing forward. proceed to parsing this partition pack */
2861         }
2862
2863         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2864             if (IS_KLV_KEY(klv.key, metadata->key)) {
2865                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2866                     goto fail;
2867                 break;
2868             }
2869         }
2870         if (!metadata->read) {
2871             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2872                             UID_ARG(klv.key));
2873             avio_skip(s->pb, klv.length);
2874         }
2875     }
2876     /* FIXME avoid seek */
2877     if (!essence_offset)  {
2878         av_log(s, AV_LOG_ERROR, "no essence\n");
2879         ret = AVERROR_INVALIDDATA;
2880         goto fail;
2881     }
2882     avio_seek(s->pb, essence_offset, SEEK_SET);
2883
2884     mxf_compute_essence_containers(mxf);
2885
2886     /* we need to do this before computing the index tables
2887      * to be able to fill in zero IndexDurations with st->duration */
2888     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2889         goto fail;
2890
2891     mxf_handle_missing_index_segment(mxf);
2892     if ((ret = mxf_compute_index_tables(mxf)) < 0)
2893         goto fail;
2894
2895     if (mxf->nb_index_tables > 1) {
2896         /* TODO: look up which IndexSID to use via EssenceContainerData */
2897         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2898                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2899     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2900         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2901         ret = AVERROR_INVALIDDATA;
2902         goto fail;
2903     }
2904
2905     mxf_handle_small_eubc(s);
2906
2907     return 0;
2908 fail:
2909     mxf_read_close(s);
2910
2911     return ret;
2912 }
2913
2914 /**
2915  * Sets mxf->current_edit_unit based on what offset we're currently at.
2916  * @return next_ofs if OK, <0 on error
2917  */
2918 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2919 {
2920     int64_t last_ofs = -1, next_ofs = -1;
2921     MXFIndexTable *t = &mxf->index_tables[0];
2922
2923     /* this is called from the OP1a demuxing logic, which means there
2924      * may be no index tables */
2925     if (mxf->nb_index_tables <= 0)
2926         return -1;
2927
2928     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2929     while (mxf->current_edit_unit >= 0) {
2930         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2931             return -1;
2932
2933         if (next_ofs <= last_ofs) {
2934             /* large next_ofs didn't change or current_edit_unit wrapped
2935              * around this fixes the infinite loop on zzuf3.mxf */
2936             av_log(mxf->fc, AV_LOG_ERROR,
2937                    "next_ofs didn't change. not deriving packet timestamps\n");
2938             return -1;
2939         }
2940
2941         if (next_ofs > current_offset)
2942             break;
2943
2944         last_ofs = next_ofs;
2945         mxf->current_edit_unit++;
2946     }
2947
2948     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2949     if (mxf->current_edit_unit < 0)
2950         return -1;
2951
2952     return next_ofs;
2953 }
2954
2955 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2956                                     uint64_t *sample_count)
2957 {
2958     int i, total = 0, size = 0;
2959     AVStream *st = mxf->fc->streams[stream_index];
2960     MXFTrack *track = st->priv_data;
2961     AVRational time_base = av_inv_q(track->edit_rate);
2962     AVRational sample_rate = av_inv_q(st->time_base);
2963     const MXFSamplesPerFrame *spf = NULL;
2964
2965     if ((sample_rate.num / sample_rate.den) == 48000)
2966         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2967     if (!spf) {
2968         int remainder = (sample_rate.num * time_base.num) %
2969                         (time_base.den * sample_rate.den);
2970         *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2971                                         av_mul_q(sample_rate, time_base)));
2972         if (remainder)
2973             av_log(mxf->fc, AV_LOG_WARNING,
2974                    "seeking detected on stream #%d with time base (%d/%d) and "
2975                    "sample rate (%d/%d), audio pts won't be accurate.\n",
2976                    stream_index, time_base.num, time_base.den,
2977                    sample_rate.num, sample_rate.den);
2978         return 0;
2979     }
2980
2981     while (spf->samples_per_frame[size]) {
2982         total += spf->samples_per_frame[size];
2983         size++;
2984     }
2985
2986     av_assert2(size);
2987
2988     *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2989     for (i = 0; i < mxf->current_edit_unit % size; i++) {
2990         *sample_count += spf->samples_per_frame[i];
2991     }
2992
2993     return 0;
2994 }
2995
2996 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
2997                              AVPacket *pkt)
2998 {
2999     MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3000     int64_t bits_per_sample = par->bits_per_coded_sample;
3001
3002     if (!bits_per_sample)
3003         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3004
3005     pkt->pts = track->sample_count;
3006
3007     if (   par->channels <= 0
3008         || bits_per_sample <= 0
3009         || par->channels * (int64_t)bits_per_sample < 8)
3010         return AVERROR(EINVAL);
3011     track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3012     return 0;
3013 }
3014
3015 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
3016 {
3017     KLVPacket klv;
3018     MXFContext *mxf = s->priv_data;
3019     int ret;
3020
3021     while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3022         PRINT_KEY(s, "read packet", klv.key);
3023         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3024         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3025             ret = mxf_decrypt_triplet(s, pkt, &klv);
3026             if (ret < 0) {
3027                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3028                 return ret;
3029             }
3030             return 0;
3031         }
3032         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3033             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3034             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3035             int index = mxf_get_stream_index(s, &klv);
3036             int64_t next_ofs, next_klv;
3037             AVStream *st;
3038             MXFTrack *track;
3039             AVCodecParameters *par;
3040
3041             if (index < 0) {
3042                 av_log(s, AV_LOG_ERROR,
3043                        "error getting stream index %"PRIu32"\n",
3044                        AV_RB32(klv.key + 12));
3045                 goto skip;
3046             }
3047
3048             st = s->streams[index];
3049             track = st->priv_data;
3050
3051             if (s->streams[index]->discard == AVDISCARD_ALL)
3052                 goto skip;
3053
3054             next_klv = avio_tell(s->pb) + klv.length;
3055             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3056
3057             if (next_ofs >= 0 && next_klv > next_ofs) {
3058                 /* if this check is hit then it's possible OPAtom was treated as OP1a
3059                  * truncate the packet since it's probably very large (>2 GiB is common) */
3060                 avpriv_request_sample(s,
3061                                       "OPAtom misinterpreted as OP1a? "
3062                                       "KLV for edit unit %i extending into "
3063                                       "next edit unit",
3064                                       mxf->current_edit_unit);
3065                 klv.length = next_ofs - avio_tell(s->pb);
3066             }
3067
3068             /* check for 8 channels AES3 element */
3069             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3070                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3071                                               pkt, klv.length);
3072                 if (ret < 0) {
3073                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3074                     return ret;
3075                 }
3076             } else {
3077                 ret = av_get_packet(s->pb, pkt, klv.length);
3078                 if (ret < 0)
3079                     return ret;
3080             }
3081             pkt->stream_index = index;
3082             pkt->pos = klv.offset;
3083
3084             par = st->codecpar;
3085
3086             if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
3087                 /* mxf->current_edit_unit good - see if we have an
3088                  * index table to derive timestamps from */
3089                 MXFIndexTable *t = &mxf->index_tables[0];
3090
3091                 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3092                     pkt->dts = mxf->current_edit_unit + t->first_dts;
3093                     pkt->pts = t->ptses[mxf->current_edit_unit];
3094                 } else if (track->intra_only) {
3095                     /* intra-only -> PTS = EditUnit.
3096                      * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3097                     pkt->pts = mxf->current_edit_unit;
3098                 }
3099             } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3100                 ret = mxf_set_audio_pts(mxf, par, pkt);
3101                 if (ret < 0)
3102                     return ret;
3103             }
3104
3105             /* seek for truncated packets */
3106             avio_seek(s->pb, next_klv, SEEK_SET);
3107
3108             return 0;
3109         } else
3110         skip:
3111             avio_skip(s->pb, klv.length);
3112     }
3113     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3114 }
3115
3116 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3117 {
3118     MXFContext *mxf = s->priv_data;
3119     int ret, size;
3120     int64_t ret64, pos, next_pos;
3121     AVStream *st;
3122     MXFIndexTable *t;
3123     int edit_units;
3124
3125     if (mxf->op != OPAtom)
3126         return mxf_read_packet_old(s, pkt);
3127
3128     // If we have no streams then we basically are at EOF
3129     st = mxf_get_opatom_stream(mxf);
3130     if (!st)
3131         return AVERROR_EOF;
3132
3133     /* OPAtom - clip wrapped demuxing */
3134     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3135     t = &mxf->index_tables[0];
3136
3137     if (mxf->current_edit_unit >= st->duration)
3138         return AVERROR_EOF;
3139
3140     edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
3141
3142     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3143         return ret;
3144
3145     /* compute size by finding the next edit unit or the end of the essence container
3146      * not pretty, but it works */
3147     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3148         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3149         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3150         return AVERROR_INVALIDDATA;
3151     }
3152
3153     if ((size = next_pos - pos) <= 0) {
3154         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3155         return AVERROR_INVALIDDATA;
3156     }
3157
3158     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3159         return ret64;
3160
3161     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3162         return size;
3163
3164     pkt->stream_index = st->index;
3165
3166     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
3167         mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
3168         pkt->dts = mxf->current_edit_unit + t->first_dts;
3169         pkt->pts = t->ptses[mxf->current_edit_unit];
3170     } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3171         int ret = mxf_set_audio_pts(mxf, st->codecpar, pkt);
3172         if (ret < 0)
3173             return ret;
3174     }
3175
3176     mxf->current_edit_unit += edit_units;
3177
3178     return 0;
3179 }
3180
3181 static int mxf_read_close(AVFormatContext *s)
3182 {
3183     MXFContext *mxf = s->priv_data;
3184     int i;
3185
3186     av_freep(&mxf->packages_refs);
3187
3188     for (i = 0; i < s->nb_streams; i++)
3189         s->streams[i]->priv_data = NULL;
3190
3191     for (i = 0; i < mxf->metadata_sets_count; i++) {
3192         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3193     }
3194     av_freep(&mxf->partitions);
3195     av_freep(&mxf->metadata_sets);
3196     av_freep(&mxf->aesc);
3197     av_freep(&mxf->local_tags);
3198
3199     if (mxf->index_tables) {
3200         for (i = 0; i < mxf->nb_index_tables; i++) {
3201             av_freep(&mxf->index_tables[i].segments);
3202             av_freep(&mxf->index_tables[i].ptses);
3203             av_freep(&mxf->index_tables[i].fake_index);
3204             av_freep(&mxf->index_tables[i].offsets);
3205         }
3206     }
3207     av_freep(&mxf->index_tables);
3208
3209     return 0;
3210 }
3211
3212 static int mxf_probe(AVProbeData *p) {
3213     const uint8_t *bufp = p->buf;
3214     const uint8_t *end = p->buf + p->buf_size;
3215
3216     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3217         return 0;
3218
3219     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3220     end -= sizeof(mxf_header_partition_pack_key);
3221
3222     for (; bufp < end;) {
3223         if (!((bufp[13] - 1) & 0xF2)){
3224             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3225                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3226                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3227                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3228                 return AVPROBE_SCORE_MAX;
3229             bufp ++;
3230         } else
3231             bufp += 10;
3232     }
3233
3234     return 0;
3235 }
3236
3237 /* rudimentary byte seek */
3238 /* XXX: use MXF Index */
3239 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3240 {
3241     AVStream *st = s->streams[stream_index];
3242     int64_t seconds;
3243     MXFContext* mxf = s->priv_data;
3244     int64_t seekpos;
3245     int i, ret;
3246     MXFIndexTable *t;
3247     MXFTrack *source_track = st->priv_data;
3248
3249     if(st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
3250         return 0;
3251
3252     /* if audio then truncate sample_time to EditRate */
3253     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3254         sample_time = av_rescale_q(sample_time, st->time_base,
3255                                    av_inv_q(source_track->edit_rate));
3256
3257     if (mxf->nb_index_tables <= 0) {
3258     if (!s->bit_rate)
3259         return AVERROR_INVALIDDATA;
3260     if (sample_time < 0)
3261         sample_time = 0;
3262     seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3263
3264     seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3265     if (seekpos < 0)
3266         return seekpos;
3267
3268     ff_update_cur_dts(s, st, sample_time);
3269     mxf->current_edit_unit = sample_time;
3270     } else {
3271         t = &mxf->index_tables[0];
3272
3273         /* clamp above zero, else ff_index_search_timestamp() returns negative
3274          * this also means we allow seeking before the start */
3275         sample_time = FFMAX(sample_time, 0);
3276
3277         if (t->fake_index) {
3278             /* The first frames may not be keyframes in presentation order, so
3279              * we have to advance the target to be able to find the first
3280              * keyframe backwards... */
3281             if (!(flags & AVSEEK_FLAG_ANY) &&
3282                 (flags & AVSEEK_FLAG_BACKWARD) &&
3283                 t->ptses[0] != AV_NOPTS_VALUE &&
3284                 sample_time < t->ptses[0] &&
3285                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3286                 sample_time = t->ptses[0];
3287
3288             /* behave as if we have a proper index */
3289             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3290                 return sample_time;
3291             /* get the stored order index from the display order index */
3292             sample_time += t->offsets[sample_time];
3293         } else {
3294             /* no IndexEntryArray (one or more CBR segments)
3295              * make sure we don't seek past the end */
3296             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3297         }
3298
3299         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3300             return ret;
3301
3302         ff_update_cur_dts(s, st, sample_time);
3303         mxf->current_edit_unit = sample_time;
3304         avio_seek(s->pb, seekpos, SEEK_SET);
3305     }
3306
3307     // Update all tracks sample count
3308     for (i = 0; i < s->nb_streams; i++) {
3309         AVStream *cur_st = s->streams[i];
3310         MXFTrack *cur_track = cur_st->priv_data;
3311         uint64_t current_sample_count = 0;
3312         if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3313             ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
3314             if (ret < 0)
3315                 return ret;
3316
3317             cur_track->sample_count = current_sample_count;
3318         }
3319     }
3320     return 0;
3321 }
3322
3323 AVInputFormat ff_mxf_demuxer = {
3324     .name           = "mxf",
3325     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3326     .flags          = AVFMT_SEEK_TO_PTS,
3327     .priv_data_size = sizeof(MXFContext),
3328     .read_probe     = mxf_probe,
3329     .read_header    = mxf_read_header,
3330     .read_packet    = mxf_read_packet,
3331     .read_close     = mxf_read_close,
3332     .read_seek      = mxf_read_seek,
3333 };