path: root/libavformat/mxfdec.c (plain)
blob: f8d0f9e0570bb99796d054d1222c85a86858c798

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