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