WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavformat/mxfdec.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* MXF demuxer.
		3	* Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier
		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 "libavutil/aes.h"
		47	#include "libavutil/avassert.h"
		48	#include "libavutil/mathematics.h"
		49	#include "libavcodec/bytestream.h"
		50	#include "libavutil/timecode.h"
		51	#include "avformat.h"
		52	#include "internal.h"
		53	#include "mxf.h"
		54
		55	typedef enum {
		56	Header,
		57	BodyPartition,
		58	Footer
		59	} MXFPartitionType;
		60
		61	typedef enum {
		62	OP1a = 1,
		63	OP1b,
		64	OP1c,
		65	OP2a,
		66	OP2b,
		67	OP2c,
		68	OP3a,
		69	OP3b,
		70	OP3c,
		71	OPAtom,
		72	OPSONYOpt, /* FATE sample, violates the spec in places */
		73	} MXFOP;
		74
		75	typedef struct {
		76	int closed;
		77	int complete;
		78	MXFPartitionType type;
		79	uint64_t previous_partition;
		80	int index_sid;
		81	int body_sid;
		82	int64_t this_partition;
		83	int64_t essence_offset; ///< absolute offset of essence
		84	int64_t essence_length;
		85	int32_t kag_size;
		86	int64_t header_byte_count;
		87	int64_t index_byte_count;
		88	int pack_length;
		89	} MXFPartition;
		90
		91	typedef struct {
		92	UID uid;
		93	enum MXFMetadataSetType type;
		94	UID source_container_ul;
		95	} MXFCryptoContext;
		96
		97	typedef struct {
		98	UID uid;
		99	enum MXFMetadataSetType type;
		100	UID source_package_uid;
		101	UID data_definition_ul;
		102	int64_t duration;
		103	int64_t start_position;
		104	int source_track_id;
		105	} MXFStructuralComponent;
		106
		107	typedef struct {
		108	UID uid;
		109	enum MXFMetadataSetType type;
		110	UID data_definition_ul;
		111	UID *structural_components_refs;
		112	int structural_components_count;
		113	int64_t duration;
		114	} MXFSequence;
		115
		116	typedef struct {
		117	UID uid;
		118	enum MXFMetadataSetType type;
		119	int drop_frame;
		120	int start_frame;
		121	struct AVRational rate;
		122	AVTimecode tc;
		123	} MXFTimecodeComponent;
		124
		125	typedef struct {
		126	UID uid;
		127	enum MXFMetadataSetType type;
		128	MXFSequence sequence; / mandatory, and only one */
		129	UID sequence_ref;
		130	int track_id;
		131	uint8_t track_number[4];
		132	AVRational edit_rate;
		133	int intra_only;
		134	uint64_t sample_count;
		135	int64_t original_duration; ///< duration before multiplying st->duration by SampleRate/EditRate
		136	} MXFTrack;
		137
		138	typedef struct {
		139	UID uid;
		140	enum MXFMetadataSetType type;
		141	UID essence_container_ul;
		142	UID essence_codec_ul;
		143	AVRational sample_rate;
		144	AVRational aspect_ratio;
		145	int width;
		146	int height; /* Field height, not frame height */
		147	int frame_layout; /* See MXFFrameLayout enum */
		148	int channels;
		149	int bits_per_sample;
		150	int field_dominance;
		151	unsigned int component_depth;
		152	unsigned int horiz_subsampling;
		153	unsigned int vert_subsampling;
		154	UID *sub_descriptors_refs;
		155	int sub_descriptors_count;
		156	int linked_track_id;
		157	uint8_t *extradata;
		158	int extradata_size;
		159	enum AVPixelFormat pix_fmt;
		160	} MXFDescriptor;
		161
		162	typedef struct {
		163	UID uid;
		164	enum MXFMetadataSetType type;
		165	int edit_unit_byte_count;
		166	int index_sid;
		167	int body_sid;
		168	AVRational index_edit_rate;
		169	uint64_t index_start_position;
		170	uint64_t index_duration;
		171	int8_t *temporal_offset_entries;
		172	int *flag_entries;
		173	uint64_t *stream_offset_entries;
		174	int nb_index_entries;
		175	} MXFIndexTableSegment;
		176
		177	typedef struct {
		178	UID uid;
		179	enum MXFMetadataSetType type;
		180	UID package_uid;
		181	UID *tracks_refs;
		182	int tracks_count;
		183	MXFDescriptor descriptor; / only one */
		184	UID descriptor_ref;
		185	} MXFPackage;
		186
		187	typedef struct {
		188	UID uid;
		189	enum MXFMetadataSetType type;
		190	} MXFMetadataSet;
		191
		192	/* decoded index table */
		193	typedef struct {
		194	int index_sid;
		195	int body_sid;
		196	int nb_ptses; /* number of PTSes or total duration of index */
		197	int64_t first_dts; /* DTS = EditUnit + first_dts */
		198	int64_t ptses; / maps EditUnit -> PTS */
		199	int nb_segments;
		200	MXFIndexTableSegment *segments; / sorted by IndexStartPosition */
		201	AVIndexEntry fake_index; / used for calling ff_index_search_timestamp() */
		202	} MXFIndexTable;
		203
		204	typedef struct {
		205	MXFPartition *partitions;
		206	unsigned partitions_count;
		207	MXFOP op;
		208	UID *packages_refs;
		209	int packages_count;
		210	MXFMetadataSet **metadata_sets;
		211	int metadata_sets_count;
		212	AVFormatContext *fc;
		213	struct AVAES *aesc;
		214	uint8_t *local_tags;
		215	int local_tags_count;
		216	uint64_t last_partition;
		217	uint64_t footer_partition;
		218	KLVPacket current_klv_data;
		219	int current_klv_index;
		220	int run_in;
		221	MXFPartition *current_partition;
		222	int parsing_backward;
		223	int64_t last_forward_tell;
		224	int last_forward_partition;
		225	int current_edit_unit;
		226	int nb_index_tables;
		227	MXFIndexTable *index_tables;
		228	int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
		229	} MXFContext;
		230
		231	enum MXFWrappingScheme {
		232	Frame,
		233	Clip,
		234	};
		235
		236	/* NOTE: klv_offset is not set (-1) for local keys */
		237	typedef int MXFMetadataReadFunc(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset);
		238
		239	typedef struct {
		240	const UID key;
		241	MXFMetadataReadFunc *read;
		242	int ctx_size;
		243	enum MXFMetadataSetType type;
		244	} MXFMetadataReadTableEntry;
		245
		246	static int mxf_read_close(AVFormatContext *s);
		247
		248	/* partial keys to match */
		249	static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
		250	static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
		251	static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
		252	static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
		253	static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
		254	/* complete keys to match */
		255	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 };
		256	static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
		257	static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
		258	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 };
		259	static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
		260
		261	#define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
		262
		263	static int64_t klv_decode_ber_length(AVIOContext *pb)
		264	{
		265	uint64_t size = avio_r8(pb);
		266	if (size & 0x80) { /* long form */
		267	int bytes_num = size & 0x7f;
		268	/* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
		269	if (bytes_num > 8)
		270	return AVERROR_INVALIDDATA;
		271	size = 0;
		272	while (bytes_num--)
		273	size = size << 8 \| avio_r8(pb);
		274	}
		275	return size;
		276	}
		277
		278	static int mxf_read_sync(AVIOContext pb, const uint8_t key, unsigned size)
		279	{
		280	int i, b;
		281	for (i = 0; i < size && !url_feof(pb); i++) {
		282	b = avio_r8(pb);
		283	if (b == key[0])
		284	i = 0;
		285	else if (b != key[i])
		286	i = -1;
		287	}
		288	return i == size;
		289	}
		290
		291	static int klv_read_packet(KLVPacket klv, AVIOContext pb)
		292	{
		293	if (!mxf_read_sync(pb, mxf_klv_key, 4))
		294	return AVERROR_INVALIDDATA;
		295	klv->offset = avio_tell(pb) - 4;
		296	memcpy(klv->key, mxf_klv_key, 4);
		297	avio_read(pb, klv->key + 4, 12);
		298	klv->length = klv_decode_ber_length(pb);
		299	return klv->length == -1 ? -1 : 0;
		300	}
		301
		302	static int mxf_get_stream_index(AVFormatContext s, KLVPacket klv)
		303	{
		304	int i;
		305
		306	for (i = 0; i < s->nb_streams; i++) {
		307	MXFTrack *track = s->streams[i]->priv_data;
		308	/* SMPTE 379M 7.3 */
		309	if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
		310	return i;
		311	}
		312	/* return 0 if only one stream, for OP Atom files with 0 as track number */
		313	return s->nb_streams == 1 ? 0 : -1;
		314	}
		315
		316	/* XXX: use AVBitStreamFilter */
		317	static int mxf_get_d10_aes3_packet(AVIOContext pb, AVStream st, AVPacket *pkt, int64_t length)
		318	{
		319	const uint8_t buf_ptr, end_ptr;
		320	uint8_t *data_ptr;
		321	int i;
		322
		323	if (length > 61444) /* worst case PAL 1920 samples 8 channels */
		324	return AVERROR_INVALIDDATA;
		325	length = av_get_packet(pb, pkt, length);
		326	if (length < 0)
		327	return length;
		328	data_ptr = pkt->data;
		329	end_ptr = pkt->data + length;
		330	buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
		331	for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
		332	for (i = 0; i < st->codec->channels; i++) {
		333	uint32_t sample = bytestream_get_le32(&buf_ptr);
		334	if (st->codec->bits_per_coded_sample == 24)
		335	bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
		336	else
		337	bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
		338	}
		339	buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
		340	}
		341	av_shrink_packet(pkt, data_ptr - pkt->data);
		342	return 0;
		343	}
		344
		345	static int mxf_decrypt_triplet(AVFormatContext s, AVPacket pkt, KLVPacket *klv)
		346	{
		347	static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
		348	MXFContext *mxf = s->priv_data;
		349	AVIOContext *pb = s->pb;
		350	int64_t end = avio_tell(pb) + klv->length;
		351	int64_t size;
		352	uint64_t orig_size;
		353	uint64_t plaintext_size;
		354	uint8_t ivec[16];
		355	uint8_t tmpbuf[16];
		356	int index;
		357
		358	if (!mxf->aesc && s->key && s->keylen == 16) {
		359	mxf->aesc = av_aes_alloc();
		360	if (!mxf->aesc)
		361	return AVERROR(ENOMEM);
		362	av_aes_init(mxf->aesc, s->key, 128, 1);
		363	}
		364	// crypto context
		365	avio_skip(pb, klv_decode_ber_length(pb));
		366	// plaintext offset
		367	klv_decode_ber_length(pb);
		368	plaintext_size = avio_rb64(pb);
		369	// source klv key
		370	klv_decode_ber_length(pb);
		371	avio_read(pb, klv->key, 16);
		372	if (!IS_KLV_KEY(klv, mxf_essence_element_key))
		373	return AVERROR_INVALIDDATA;
		374	index = mxf_get_stream_index(s, klv);
		375	if (index < 0)
		376	return AVERROR_INVALIDDATA;
		377	// source size
		378	klv_decode_ber_length(pb);
		379	orig_size = avio_rb64(pb);
		380	if (orig_size < plaintext_size)
		381	return AVERROR_INVALIDDATA;
		382	// enc. code
		383	size = klv_decode_ber_length(pb);
		384	if (size < 32 \|\| size - 32 < orig_size)
		385	return AVERROR_INVALIDDATA;
		386	avio_read(pb, ivec, 16);
		387	avio_read(pb, tmpbuf, 16);
		388	if (mxf->aesc)
		389	av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
		390	if (memcmp(tmpbuf, checkv, 16))
		391	av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
		392	size -= 32;
		393	size = av_get_packet(pb, pkt, size);
		394	if (size < 0)
		395	return size;
		396	else if (size < plaintext_size)
		397	return AVERROR_INVALIDDATA;
		398	size -= plaintext_size;
		399	if (mxf->aesc)
		400	av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
		401	&pkt->data[plaintext_size], size >> 4, ivec, 1);
		402	av_shrink_packet(pkt, orig_size);
		403	pkt->stream_index = index;
		404	avio_skip(pb, end - avio_tell(pb));
		405	return 0;
		406	}
		407
		408	static int mxf_read_primer_pack(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		409	{
		410	MXFContext *mxf = arg;
		411	int item_num = avio_rb32(pb);
		412	int item_len = avio_rb32(pb);
		413
		414	if (item_len != 18) {
		415	avpriv_request_sample(pb, "Primer pack item length %d", item_len);
		416	return AVERROR_PATCHWELCOME;
		417	}
		418	if (item_num > 65536) {
		419	av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
		420	return AVERROR_INVALIDDATA;
		421	}
		422	mxf->local_tags = av_calloc(item_num, item_len);
		423	if (!mxf->local_tags)
		424	return AVERROR(ENOMEM);
		425	mxf->local_tags_count = item_num;
		426	avio_read(pb, mxf->local_tags, item_num*item_len);
		427	return 0;
		428	}
		429
		430	static int mxf_read_partition_pack(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		431	{
		432	MXFContext *mxf = arg;
		433	MXFPartition partition, tmp_part;
		434	UID op;
		435	uint64_t footer_partition;
		436	uint32_t nb_essence_containers;
		437
		438	tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
		439	if (!tmp_part)
		440	return AVERROR(ENOMEM);
		441	mxf->partitions = tmp_part;
		442
		443	if (mxf->parsing_backward) {
		444	/* insert the new partition pack in the middle
		445	* this makes the entries in mxf->partitions sorted by offset */
		446	memmove(&mxf->partitions[mxf->last_forward_partition+1],
		447	&mxf->partitions[mxf->last_forward_partition],
		448	(mxf->partitions_count - mxf->last_forward_partition)sizeof(mxf->partitions));
		449	partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
		450	} else {
		451	mxf->last_forward_partition++;
		452	partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
		453	}
		454
		455	memset(partition, 0, sizeof(*partition));
		456	mxf->partitions_count++;
		457	partition->pack_length = avio_tell(pb) - klv_offset + size;
		458
		459	switch(uid[13]) {
		460	case 2:
		461	partition->type = Header;
		462	break;
		463	case 3:
		464	partition->type = BodyPartition;
		465	break;
		466	case 4:
		467	partition->type = Footer;
		468	break;
		469	default:
		470	av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
		471	return AVERROR_INVALIDDATA;
		472	}
		473
		474	/* consider both footers to be closed (there is only Footer and CompleteFooter) */
		475	partition->closed = partition->type == Footer \|\| !(uid[14] & 1);
		476	partition->complete = uid[14] > 2;
		477	avio_skip(pb, 4);
		478	partition->kag_size = avio_rb32(pb);
		479	partition->this_partition = avio_rb64(pb);
		480	partition->previous_partition = avio_rb64(pb);
		481	footer_partition = avio_rb64(pb);
		482	partition->header_byte_count = avio_rb64(pb);
		483	partition->index_byte_count = avio_rb64(pb);
		484	partition->index_sid = avio_rb32(pb);
		485	avio_skip(pb, 8);
		486	partition->body_sid = avio_rb32(pb);
		487	avio_read(pb, op, sizeof(UID));
		488	nb_essence_containers = avio_rb32(pb);
		489
		490	/* some files don'thave FooterPartition set in every partition */
		491	if (footer_partition) {
		492	if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
		493	av_log(mxf->fc, AV_LOG_ERROR,
		494	"inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
		495	mxf->footer_partition, footer_partition);
		496	} else {
		497	mxf->footer_partition = footer_partition;
		498	}
		499	}
		500
		501	av_dlog(mxf->fc,
		502	"PartitionPack: ThisPartition = 0x%"PRIX64
		503	", PreviousPartition = 0x%"PRIX64", "
		504	"FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
		505	partition->this_partition,
		506	partition->previous_partition, footer_partition,
		507	partition->index_sid, partition->body_sid);
		508
		509	/* sanity check PreviousPartition if set */
		510	if (partition->previous_partition &&
		511	mxf->run_in + partition->previous_partition >= klv_offset) {
		512	av_log(mxf->fc, AV_LOG_ERROR,
		513	"PreviousPartition points to this partition or forward\n");
		514	return AVERROR_INVALIDDATA;
		515	}
		516
		517	if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
		518	else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
		519	else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
		520	else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
		521	else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
		522	else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
		523	else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
		524	else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
		525	else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
		526	else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
		527	else if (op[12] == 0x10) {
		528	/* SMPTE 390m: "There shall be exactly one essence container"
		529	* The following block deals with files that violate this, namely:
		530	* 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
		531	* abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
		532	if (nb_essence_containers != 1) {
		533	MXFOP op = nb_essence_containers ? OP1a : OPAtom;
		534
		535	/* only nag once */
		536	if (!mxf->op)
		537	av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
		538	nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
		539
		540	mxf->op = op;
		541	} else
		542	mxf->op = OPAtom;
		543	} else {
		544	av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
		545	mxf->op = OP1a;
		546	}
		547
		548	if (partition->kag_size <= 0 \|\| partition->kag_size > (1 << 20)) {
		549	av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
		550
		551	if (mxf->op == OPSONYOpt)
		552	partition->kag_size = 512;
		553	else
		554	partition->kag_size = 1;
		555
		556	av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
		557	}
		558
		559	return 0;
		560	}
		561
		562	static int mxf_add_metadata_set(MXFContext mxf, void metadata_set)
		563	{
		564	MXFMetadataSet **tmp;
		565
		566	tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
		567	if (!tmp)
		568	return AVERROR(ENOMEM);
		569	mxf->metadata_sets = tmp;
		570	mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
		571	mxf->metadata_sets_count++;
		572	return 0;
		573	}
		574
		575	static int mxf_read_cryptographic_context(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		576	{
		577	MXFCryptoContext *cryptocontext = arg;
		578	if (size != 16)
		579	return AVERROR_INVALIDDATA;
		580	if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
		581	avio_read(pb, cryptocontext->source_container_ul, 16);
		582	return 0;
		583	}
		584
		585	static int mxf_read_content_storage(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		586	{
		587	MXFContext *mxf = arg;
		588	switch (tag) {
		589	case 0x1901:
		590	mxf->packages_count = avio_rb32(pb);
		591	mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
		592	if (!mxf->packages_refs)
		593	return AVERROR(ENOMEM);
		594	avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
		595	avio_read(pb, (uint8_t )mxf->packages_refs, mxf->packages_count sizeof(UID));
		596	break;
		597	}
		598	return 0;
		599	}
		600
		601	static int mxf_read_source_clip(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		602	{
		603	MXFStructuralComponent *source_clip = arg;
		604	switch(tag) {
		605	case 0x0202:
		606	source_clip->duration = avio_rb64(pb);
		607	break;
		608	case 0x1201:
		609	source_clip->start_position = avio_rb64(pb);
		610	break;
		611	case 0x1101:
		612	/* UMID, only get last 16 bytes */
		613	avio_skip(pb, 16);
		614	avio_read(pb, source_clip->source_package_uid, 16);
		615	break;
		616	case 0x1102:
		617	source_clip->source_track_id = avio_rb32(pb);
		618	break;
		619	}
		620	return 0;
		621	}
		622
		623	static int mxf_read_material_package(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		624	{
		625	MXFPackage *package = arg;
		626	switch(tag) {
		627	case 0x4403:
		628	package->tracks_count = avio_rb32(pb);
		629	package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
		630	if (!package->tracks_refs)
		631	return AVERROR(ENOMEM);
		632	avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
		633	avio_read(pb, (uint8_t )package->tracks_refs, package->tracks_count sizeof(UID));
		634	break;
		635	}
		636	return 0;
		637	}
		638
		639	static int mxf_read_timecode_component(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		640	{
		641	MXFTimecodeComponent *mxf_timecode = arg;
		642	switch(tag) {
		643	case 0x1501:
		644	mxf_timecode->start_frame = avio_rb64(pb);
		645	break;
		646	case 0x1502:
		647	mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
		648	break;
		649	case 0x1503:
		650	mxf_timecode->drop_frame = avio_r8(pb);
		651	break;
		652	}
		653	return 0;
		654	}
		655
		656	static int mxf_read_track(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		657	{
		658	MXFTrack *track = arg;
		659	switch(tag) {
		660	case 0x4801:
		661	track->track_id = avio_rb32(pb);
		662	break;
		663	case 0x4804:
		664	avio_read(pb, track->track_number, 4);
		665	break;
		666	case 0x4B01:
		667	track->edit_rate.num = avio_rb32(pb);
		668	track->edit_rate.den = avio_rb32(pb);
		669	break;
		670	case 0x4803:
		671	avio_read(pb, track->sequence_ref, 16);
		672	break;
		673	}
		674	return 0;
		675	}
		676
		677	static int mxf_read_sequence(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		678	{
		679	MXFSequence *sequence = arg;
		680	switch(tag) {
		681	case 0x0202:
		682	sequence->duration = avio_rb64(pb);
		683	break;
		684	case 0x0201:
		685	avio_read(pb, sequence->data_definition_ul, 16);
		686	break;
		687	case 0x1001:
		688	sequence->structural_components_count = avio_rb32(pb);
		689	sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
		690	if (!sequence->structural_components_refs)
		691	return AVERROR(ENOMEM);
		692	avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
		693	avio_read(pb, (uint8_t )sequence->structural_components_refs, sequence->structural_components_count sizeof(UID));
		694	break;
		695	}
		696	return 0;
		697	}
		698
		699	static int mxf_read_source_package(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		700	{
		701	MXFPackage *package = arg;
		702	switch(tag) {
		703	case 0x4403:
		704	package->tracks_count = avio_rb32(pb);
		705	package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
		706	if (!package->tracks_refs)
		707	return AVERROR(ENOMEM);
		708	avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
		709	avio_read(pb, (uint8_t )package->tracks_refs, package->tracks_count sizeof(UID));
		710	break;
		711	case 0x4401:
		712	/* UMID, only get last 16 bytes */
		713	avio_skip(pb, 16);
		714	avio_read(pb, package->package_uid, 16);
		715	break;
		716	case 0x4701:
		717	avio_read(pb, package->descriptor_ref, 16);
		718	break;
		719	}
		720	return 0;
		721	}
		722
		723	static int mxf_read_index_entry_array(AVIOContext pb, MXFIndexTableSegment segment)
		724	{
		725	int i, length;
		726
		727	segment->nb_index_entries = avio_rb32(pb);
		728
		729	length = avio_rb32(pb);
		730
		731	if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) \|\|
		732	!(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) \|\|
		733	!(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
		734	return AVERROR(ENOMEM);
		735
		736	for (i = 0; i < segment->nb_index_entries; i++) {
		737	segment->temporal_offset_entries[i] = avio_r8(pb);
		738	avio_r8(pb); /* KeyFrameOffset */
		739	segment->flag_entries[i] = avio_r8(pb);
		740	segment->stream_offset_entries[i] = avio_rb64(pb);
		741	avio_skip(pb, length - 11);
		742	}
		743	return 0;
		744	}
		745
		746	static int mxf_read_index_table_segment(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		747	{
		748	MXFIndexTableSegment *segment = arg;
		749	switch(tag) {
		750	case 0x3F05:
		751	segment->edit_unit_byte_count = avio_rb32(pb);
		752	av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
		753	break;
		754	case 0x3F06:
		755	segment->index_sid = avio_rb32(pb);
		756	av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
		757	break;
		758	case 0x3F07:
		759	segment->body_sid = avio_rb32(pb);
		760	av_dlog(NULL, "BodySID %d\n", segment->body_sid);
		761	break;
		762	case 0x3F0A:
		763	av_dlog(NULL, "IndexEntryArray found\n");
		764	return mxf_read_index_entry_array(pb, segment);
		765	case 0x3F0B:
		766	segment->index_edit_rate.num = avio_rb32(pb);
		767	segment->index_edit_rate.den = avio_rb32(pb);
		768	av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
		769	segment->index_edit_rate.den);
		770	break;
		771	case 0x3F0C:
		772	segment->index_start_position = avio_rb64(pb);
		773	av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
		774	break;
		775	case 0x3F0D:
		776	segment->index_duration = avio_rb64(pb);
		777	av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
		778	break;
		779	}
		780	return 0;
		781	}
		782
		783	static void mxf_read_pixel_layout(AVIOContext pb, MXFDescriptor descriptor)
		784	{
		785	int code, value, ofs = 0;
		786	char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
		787
		788	do {
		789	code = avio_r8(pb);
		790	value = avio_r8(pb);
		791	av_dlog(NULL, "pixel layout: code %#x\n", code);
		792
		793	if (ofs <= 14) {
		794	layout[ofs++] = code;
		795	layout[ofs++] = value;
		796	} else
		797	break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
		798	} while (code != 0); /* SMPTE 377M E.2.46 */
		799
		800	ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
		801	}
		802
		803	static int mxf_read_generic_descriptor(void arg, AVIOContext pb, int tag, int size, UID uid, int64_t klv_offset)
		804	{
		805	MXFDescriptor *descriptor = arg;
		806	descriptor->pix_fmt = AV_PIX_FMT_NONE;
		807	switch(tag) {
		808	case 0x3F01:
		809	descriptor->sub_descriptors_count = avio_rb32(pb);
		810	descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
		811	if (!descriptor->sub_descriptors_refs)
		812	return AVERROR(ENOMEM);
		813	avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
		814	avio_read(pb, (uint8_t )descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count sizeof(UID));
		815	break;
		816	case 0x3004:
		817	avio_read(pb, descriptor->essence_container_ul, 16);
		818	break;
		819	case 0x3006:
		820	descriptor->linked_track_id = avio_rb32(pb);
		821	break;
		822	case 0x3201: /* PictureEssenceCoding */
		823	avio_read(pb, descriptor->essence_codec_ul, 16);
		824	break;
		825	case 0x3203:
		826	descriptor->width = avio_rb32(pb);
		827	break;
		828	case 0x3202:
		829	descriptor->height = avio_rb32(pb);
		830	break;
		831	case 0x320C:
		832	descriptor->frame_layout = avio_r8(pb);
		833	break;
		834	case 0x320E:
		835	descriptor->aspect_ratio.num = avio_rb32(pb);
		836	descriptor->aspect_ratio.den = avio_rb32(pb);
		837	break;
		838	case 0x3212:
		839	descriptor->field_dominance = avio_r8(pb);
		840	break;
		841	case 0x3301:
		842	descriptor->component_depth = avio_rb32(pb);
		843	break;
		844	case 0x3302:
		845	descriptor->horiz_subsampling = avio_rb32(pb);
		846	break;
		847	case 0x3308:
		848	descriptor->vert_subsampling = avio_rb32(pb);
		849	break;
		850	case 0x3D03:
		851	descriptor->sample_rate.num = avio_rb32(pb);
		852	descriptor->sample_rate.den = avio_rb32(pb);
		853	break;
		854	case 0x3D06: /* SoundEssenceCompression */
		855	avio_read(pb, descriptor->essence_codec_ul, 16);
		856	break;
		857	case 0x3D07:
		858	descriptor->channels = avio_rb32(pb);
		859	break;
		860	case 0x3D01:
		861	descriptor->bits_per_sample = avio_rb32(pb);
		862	break;
		863	case 0x3401:
		864	mxf_read_pixel_layout(pb, descriptor);
		865	break;
		866	default:
		867	/* Private uid used by SONY C0023S01.mxf */
		868	if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
		869	if (descriptor->extradata)
		870	av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
		871	av_free(descriptor->extradata);
		872	descriptor->extradata_size = 0;
		873	descriptor->extradata = av_malloc(size);
		874	if (!descriptor->extradata)
		875	return AVERROR(ENOMEM);
		876	descriptor->extradata_size = size;
		877	avio_read(pb, descriptor->extradata, size);
		878	}
		879	break;
		880	}
		881	return 0;
		882	}
		883
		884	/*
		885	* Match an uid independently of the version byte and up to len common bytes
		886	* Returns: boolean
		887	*/
		888	static int mxf_match_uid(const UID key, const UID uid, int len)
		889	{
		890	int i;
		891	for (i = 0; i < len; i++) {
		892	if (i != 7 && key[i] != uid[i])
		893	return 0;
		894	}
		895	return 1;
		896	}
		897
		898	static const MXFCodecUL mxf_get_codec_ul(const MXFCodecUL uls, UID *uid)
		899	{
		900	while (uls->uid[0]) {
		901	if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
		902	break;
		903	uls++;
		904	}
		905	return uls;
		906	}
		907
		908	static void mxf_resolve_strong_ref(MXFContext mxf, UID *strong_ref, enum MXFMetadataSetType type)
		909	{
		910	int i;
		911
		912	if (!strong_ref)
		913	return NULL;
		914	for (i = 0; i < mxf->metadata_sets_count; i++) {
		915	if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
		916	(type == AnyType \|\| mxf->metadata_sets[i]->type == type)) {
		917	return mxf->metadata_sets[i];
		918	}
		919	}
		920	return NULL;
		921	}
		922
		923	static const MXFCodecUL mxf_picture_essence_container_uls[] = {
		924	// video essence container uls
		925	{ { 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 */
		926	{ { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
		927	{ { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
		928	{ { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
		929	};
		930
		931	/* EC ULs for intra-only formats */
		932	static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
		933	{ { 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 */
		934	{ { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
		935	};
		936
		937	/* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
		938	static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
		939	{ { 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 */
		940	{ { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
		941	{ { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
		942	};
		943
		944	static const MXFCodecUL mxf_sound_essence_container_uls[] = {
		945	// sound essence container uls
		946	{ { 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 */
		947	{ { 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 */
		948	{ { 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 */
		949	{ { 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 */
		950	{ { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
		951	};
		952
		953	static int mxf_get_sorted_table_segments(MXFContext mxf, int nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
		954	{
		955	int i, j, nb_segments = 0;
		956	MXFIndexTableSegment **unsorted_segments;
		957	int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
		958
		959	/* count number of segments, allocate arrays and copy unsorted segments */
		960	for (i = 0; i < mxf->metadata_sets_count; i++)
		961	if (mxf->metadata_sets[i]->type == IndexTableSegment)
		962	nb_segments++;
		963
		964	if (!nb_segments)
		965	return AVERROR_INVALIDDATA;
		966
		967	if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) \|\|
		968	!(sorted_segments = av_calloc(nb_segments, sizeof(*sorted_segments)))) {
		969	av_freep(sorted_segments);
		970	av_free(unsorted_segments);
		971	return AVERROR(ENOMEM);
		972	}
		973
		974	for (i = j = 0; i < mxf->metadata_sets_count; i++)
		975	if (mxf->metadata_sets[i]->type == IndexTableSegment)
		976	unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
		977
		978	*nb_sorted_segments = 0;
		979
		980	/* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
		981	for (i = 0; i < nb_segments; i++) {
		982	int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
		983	uint64_t best_index_duration = 0;
		984
		985	for (j = 0; j < nb_segments; j++) {
		986	MXFIndexTableSegment *s = unsorted_segments[j];
		987
		988	/* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
		989	* We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
		990	* If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
		991	*/
		992	if ((i == 0 \|\| s->body_sid > last_body_sid \|\| s->index_sid > last_index_sid \|\| s->index_start_position > last_index_start) &&
		993	(best == -1 \|\| s->body_sid < best_body_sid \|\| s->index_sid < best_index_sid \|\| s->index_start_position < best_index_start \|\|
		994	(s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
		995	best = j;
		996	best_body_sid = s->body_sid;
		997	best_index_sid = s->index_sid;
		998	best_index_start = s->index_start_position;
		999	best_index_duration = s->index_duration;
		1000	}
		1001	}
		1002
		1003	/* no suitable entry found -> we're done */
		1004	if (best == -1)
		1005	break;
		1006
		1007	(sorted_segments)[(nb_sorted_segments)++] = unsorted_segments[best];
		1008	last_body_sid = best_body_sid;
		1009	last_index_sid = best_index_sid;
		1010	last_index_start = best_index_start;
		1011	}
		1012
		1013	av_free(unsorted_segments);
		1014
		1015	return 0;
		1016	}
		1017
		1018	/**
		1019	* Computes the absolute file offset of the given essence container offset
		1020	*/
		1021	static int mxf_absolute_bodysid_offset(MXFContext mxf, int body_sid, int64_t offset, int64_t offset_out)
		1022	{
		1023	int x;
		1024	int64_t offset_in = offset; /* for logging */
		1025
		1026	for (x = 0; x < mxf->partitions_count; x++) {
		1027	MXFPartition *p = &mxf->partitions[x];
		1028
		1029	if (p->body_sid != body_sid)
		1030	continue;
		1031
		1032	if (offset < p->essence_length \|\| !p->essence_length) {
		1033	*offset_out = p->essence_offset + offset;
		1034	return 0;
		1035	}
		1036
		1037	offset -= p->essence_length;
		1038	}
		1039
		1040	av_log(mxf->fc, AV_LOG_ERROR,
		1041	"failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
		1042	offset_in, body_sid);
		1043
		1044	return AVERROR_INVALIDDATA;
		1045	}
		1046
		1047	/**
		1048	* Returns the end position of the essence container with given BodySID, or zero if unknown
		1049	*/
		1050	static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
		1051	{
		1052	int x;
		1053	int64_t ret = 0;
		1054
		1055	for (x = 0; x < mxf->partitions_count; x++) {
		1056	MXFPartition *p = &mxf->partitions[x];
		1057
		1058	if (p->body_sid != body_sid)
		1059	continue;
		1060
		1061	if (!p->essence_length)
		1062	return 0;
		1063
		1064	ret = p->essence_offset + p->essence_length;
		1065	}
		1066
		1067	return ret;
		1068	}
		1069
		1070	/* EditUnit -> absolute offset */
		1071	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)
		1072	{
		1073	int i;
		1074	int64_t offset_temp = 0;
		1075
		1076	for (i = 0; i < index_table->nb_segments; i++) {
		1077	MXFIndexTableSegment *s = index_table->segments[i];
		1078
		1079	edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
		1080
		1081	if (edit_unit < s->index_start_position + s->index_duration) {
		1082	int64_t index = edit_unit - s->index_start_position;
		1083
		1084	if (s->edit_unit_byte_count)
		1085	offset_temp += s->edit_unit_byte_count * index;
		1086	else if (s->nb_index_entries) {
		1087	if (s->nb_index_entries == 2 * s->index_duration + 1)
		1088	index = 2; / Avid index */
		1089
		1090	if (index < 0 \|\| index >= s->nb_index_entries) {
		1091	av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
		1092	index_table->index_sid, s->index_start_position);
		1093	return AVERROR_INVALIDDATA;
		1094	}
		1095
		1096	offset_temp = s->stream_offset_entries[index];
		1097	} else {
		1098	av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
		1099	index_table->index_sid, s->index_start_position);
		1100	return AVERROR_INVALIDDATA;
		1101	}
		1102
		1103	if (edit_unit_out)
		1104	*edit_unit_out = edit_unit;
		1105
		1106	return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
		1107	} else {
		1108	/* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
		1109	offset_temp += s->edit_unit_byte_count * s->index_duration;
		1110	}
		1111	}
		1112
		1113	if (nag)
		1114	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);
		1115
		1116	return AVERROR_INVALIDDATA;
		1117	}
		1118
		1119	static int mxf_compute_ptses_fake_index(MXFContext mxf, MXFIndexTable index_table)
		1120	{
		1121	int i, j, x;
		1122	int8_t max_temporal_offset = -128;
		1123
		1124	/* first compute how many entries we have */
		1125	for (i = 0; i < index_table->nb_segments; i++) {
		1126	MXFIndexTableSegment *s = index_table->segments[i];
		1127
		1128	if (!s->nb_index_entries) {
		1129	index_table->nb_ptses = 0;
		1130	return 0; /* no TemporalOffsets */
		1131	}
		1132
		1133	index_table->nb_ptses += s->index_duration;
		1134	}
		1135
		1136	/* paranoid check */
		1137	if (index_table->nb_ptses <= 0)
		1138	return 0;
		1139
		1140	if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) \|\|
		1141	!(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
		1142	av_freep(&index_table->ptses);
		1143	return AVERROR(ENOMEM);
		1144	}
		1145
		1146	/* we may have a few bad TemporalOffsets
		1147	* make sure the corresponding PTSes don't have the bogus value 0 */
		1148	for (x = 0; x < index_table->nb_ptses; x++)
		1149	index_table->ptses[x] = AV_NOPTS_VALUE;
		1150
		1151	/**
		1152	* We have this:
		1153	*
		1154	* x TemporalOffset
		1155	* 0: 0
		1156	* 1: 1
		1157	* 2: 1
		1158	* 3: -2
		1159	* 4: 1
		1160	* 5: 1
		1161	* 6: -2
		1162	*
		1163	* We want to transform it into this:
		1164	*
		1165	* x DTS PTS
		1166	* 0: -1 0
		1167	* 1: 0 3
		1168	* 2: 1 1
		1169	* 3: 2 2
		1170	* 4: 3 6
		1171	* 5: 4 4
		1172	* 6: 5 5
		1173	*
		1174	* We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
		1175	* then settings mxf->first_dts = -max(TemporalOffset[x]).
		1176	* The latter makes DTS <= PTS.
		1177	*/
		1178	for (i = x = 0; i < index_table->nb_segments; i++) {
		1179	MXFIndexTableSegment *s = index_table->segments[i];
		1180	int index_delta = 1;
		1181	int n = s->nb_index_entries;
		1182
		1183	if (s->nb_index_entries == 2 * s->index_duration + 1) {
		1184	index_delta = 2; /* Avid index */
		1185	/* ignore the last entry - it's the size of the essence container */
		1186	n--;
		1187	}
		1188
		1189	for (j = 0; j < n; j += index_delta, x++) {
		1190	int offset = s->temporal_offset_entries[j] / index_delta;
		1191	int index = x + offset;
		1192
		1193	if (x >= index_table->nb_ptses) {
		1194	av_log(mxf->fc, AV_LOG_ERROR,
		1195	"x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
		1196	s->nb_index_entries, s->index_duration);
		1197	break;
		1198	}
		1199
		1200	index_table->fake_index[x].timestamp = x;
		1201	index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
		1202
		1203	if (index < 0 \|\| index >= index_table->nb_ptses) {
		1204	av_log(mxf->fc, AV_LOG_ERROR,
		1205	"index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
		1206	x, offset, index);
		1207	continue;
		1208	}
		1209
		1210	index_table->ptses[index] = x;
		1211	max_temporal_offset = FFMAX(max_temporal_offset, offset);
		1212	}
		1213	}
		1214
		1215	index_table->first_dts = -max_temporal_offset;
		1216
		1217	return 0;
		1218	}
		1219
		1220	/**
		1221	* Sorts and collects index table segments into index tables.
		1222	* Also computes PTSes if possible.
		1223	*/
		1224	static int mxf_compute_index_tables(MXFContext *mxf)
		1225	{
		1226	int i, j, k, ret, nb_sorted_segments;
		1227	MXFIndexTableSegment **sorted_segments = NULL;
		1228
		1229	if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) \|\|
		1230	nb_sorted_segments <= 0) {
		1231	av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
		1232	return 0;
		1233	}
		1234
		1235	/* sanity check and count unique BodySIDs/IndexSIDs */
		1236	for (i = 0; i < nb_sorted_segments; i++) {
		1237	if (i == 0 \|\| sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
		1238	mxf->nb_index_tables++;
		1239	else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
		1240	av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
		1241	ret = AVERROR_INVALIDDATA;
		1242	goto finish_decoding_index;
		1243	}
		1244	}
		1245
		1246	if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
		1247	av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
		1248	ret = AVERROR(ENOMEM);
		1249	goto finish_decoding_index;
		1250	}
		1251
		1252	/* distribute sorted segments to index tables */
		1253	for (i = j = 0; i < nb_sorted_segments; i++) {
		1254	if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
		1255	/* next IndexSID */
		1256	j++;
		1257	}
		1258
		1259	mxf->index_tables[j].nb_segments++;
		1260	}
		1261
		1262	for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
		1263	MXFIndexTable *t = &mxf->index_tables[j];
		1264
		1265	if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
		1266	av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
		1267	ret = AVERROR(ENOMEM);
		1268	goto finish_decoding_index;
		1269	}
		1270
		1271	if (sorted_segments[i]->index_start_position)
		1272	av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
		1273	sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
		1274
		1275	memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
		1276	t->index_sid = sorted_segments[i]->index_sid;
		1277	t->body_sid = sorted_segments[i]->body_sid;
		1278
		1279	if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
		1280	goto finish_decoding_index;
		1281
		1282	/* fix zero IndexDurations */
		1283	for (k = 0; k < t->nb_segments; k++) {
		1284	if (t->segments[k]->index_duration)
		1285	continue;
		1286
		1287	if (t->nb_segments > 1)
		1288	av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
		1289	t->index_sid, k);
		1290
		1291	if (mxf->fc->nb_streams <= 0) {
		1292	av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
		1293	break;
		1294	}
		1295
		1296	/* assume the first stream's duration is reasonable
		1297	* leave index_duration = 0 on further segments in case we have any (unlikely)
		1298	*/
		1299	t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
		1300	break;
		1301	}
		1302	}
		1303
		1304	ret = 0;
		1305	finish_decoding_index:
		1306	av_free(sorted_segments);
		1307	return ret;
		1308	}
		1309
		1310	static int mxf_is_intra_only(MXFDescriptor *descriptor)
		1311	{
		1312	return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
		1313	&descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE \|\|
		1314	mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
		1315	&descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
		1316	}
		1317
		1318	static int mxf_add_timecode_metadata(AVDictionary *pm, const char key, AVTimecode *tc)
		1319	{
		1320	char buf[AV_TIMECODE_STR_SIZE];
		1321	av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
		1322
		1323	return 0;
		1324	}
		1325
		1326	static int mxf_parse_structural_metadata(MXFContext *mxf)
		1327	{
		1328	MXFPackage *material_package = NULL;
		1329	MXFPackage *temp_package = NULL;
		1330	int i, j, k, ret;
		1331
		1332	av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
		1333	/* TODO: handle multiple material packages (OP3x) */
		1334	for (i = 0; i < mxf->packages_count; i++) {
		1335	material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
		1336	if (material_package) break;
		1337	}
		1338	if (!material_package) {
		1339	av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
		1340	return AVERROR_INVALIDDATA;
		1341	}
		1342
		1343	for (i = 0; i < material_package->tracks_count; i++) {
		1344	MXFPackage *source_package = NULL;
		1345	MXFTrack *material_track = NULL;
		1346	MXFTrack *source_track = NULL;
		1347	MXFTrack *temp_track = NULL;
		1348	MXFDescriptor *descriptor = NULL;
		1349	MXFStructuralComponent *component = NULL;
		1350	MXFTimecodeComponent *mxf_tc = NULL;
		1351	UID *essence_container_ul = NULL;
		1352	const MXFCodecUL *codec_ul = NULL;
		1353	const MXFCodecUL *container_ul = NULL;
		1354	const MXFCodecUL *pix_fmt_ul = NULL;
		1355	AVStream *st;
		1356	AVTimecode tc;
		1357	int flags;
		1358
		1359	if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
		1360	av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
		1361	continue;
		1362	}
		1363
		1364	if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
		1365	mxf_tc = (MXFTimecodeComponent*)component;
		1366	flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
		1367	if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
		1368	mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
		1369	}
		1370	}
		1371
		1372	if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
		1373	av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
		1374	continue;
		1375	}
		1376
		1377	for (j = 0; j < material_track->sequence->structural_components_count; j++) {
		1378	component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
		1379	if (!component)
		1380	continue;
		1381
		1382	mxf_tc = (MXFTimecodeComponent*)component;
		1383	flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
		1384	if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
		1385	mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
		1386	break;
		1387	}
		1388	}
		1389
		1390	/* TODO: handle multiple source clips */
		1391	for (j = 0; j < material_track->sequence->structural_components_count; j++) {
		1392	component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
		1393	if (!component)
		1394	continue;
		1395
		1396	for (k = 0; k < mxf->packages_count; k++) {
		1397	temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
		1398	if (!temp_package)
		1399	continue;
		1400	if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
		1401	source_package = temp_package;
		1402	break;
		1403	}
		1404	}
		1405	if (!source_package) {
		1406	av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
		1407	break;
		1408	}
		1409	for (k = 0; k < source_package->tracks_count; k++) {
		1410	if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
		1411	av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
		1412	ret = AVERROR_INVALIDDATA;
		1413	goto fail_and_free;
		1414	}
		1415	if (temp_track->track_id == component->source_track_id) {
		1416	source_track = temp_track;
		1417	break;
		1418	}
		1419	}
		1420	if (!source_track) {
		1421	av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
		1422	break;
		1423	}
		1424	}
		1425	if (!source_track \|\| !component)
		1426	continue;
		1427
		1428	if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
		1429	av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
		1430	ret = AVERROR_INVALIDDATA;
		1431	goto fail_and_free;
		1432	}
		1433
		1434	/* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
		1435	* This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
		1436	if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
		1437	av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
		1438	continue;
		1439	}
		1440
		1441	st = avformat_new_stream(mxf->fc, NULL);
		1442	if (!st) {
		1443	av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
		1444	ret = AVERROR(ENOMEM);
		1445	goto fail_and_free;
		1446	}
		1447	st->id = source_track->track_id;
		1448	st->priv_data = source_track;
		1449	source_track->original_duration = st->duration = component->duration;
		1450	if (st->duration == -1)
		1451	st->duration = AV_NOPTS_VALUE;
		1452	st->start_time = component->start_position;
		1453	if (material_track->edit_rate.num <= 0 \|\| material_track->edit_rate.den <= 0) {
		1454	av_log(mxf->fc, AV_LOG_WARNING,
		1455	"invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
		1456	material_track->edit_rate.num, material_track->edit_rate.den, st->index);
		1457	material_track->edit_rate = (AVRational){25, 1};
		1458	}
		1459	avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
		1460
		1461	/* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
		1462	source_track->edit_rate = material_track->edit_rate;
		1463
		1464	PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
		1465	codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
		1466	st->codec->codec_type = codec_ul->id;
		1467
		1468	source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
		1469	if (source_package->descriptor) {
		1470	if (source_package->descriptor->type == MultipleDescriptor) {
		1471	for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
		1472	MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
		1473
		1474	if (!sub_descriptor) {
		1475	av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
		1476	continue;
		1477	}
		1478	if (sub_descriptor->linked_track_id == source_track->track_id) {
		1479	descriptor = sub_descriptor;
		1480	break;
		1481	}
		1482	}
		1483	} else if (source_package->descriptor->type == Descriptor)
		1484	descriptor = source_package->descriptor;
		1485	}
		1486	if (!descriptor) {
		1487	av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
		1488	continue;
		1489	}
		1490	PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
		1491	PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
		1492	essence_container_ul = &descriptor->essence_container_ul;
		1493	/* HACK: replacing the original key with mxf_encrypted_essence_container
		1494	* is not allowed according to s429-6, try to find correct information anyway */
		1495	if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
		1496	av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
		1497	for (k = 0; k < mxf->metadata_sets_count; k++) {
		1498	MXFMetadataSet *metadata = mxf->metadata_sets[k];
		1499	if (metadata->type == CryptoContext) {
		1500	essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
		1501	break;
		1502	}
		1503	}
		1504	}
		1505
		1506	/* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
		1507	codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
		1508	st->codec->codec_id = (enum AVCodecID)codec_ul->id;
		1509	av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
		1510	avcodec_get_name(st->codec->codec_id));
		1511	for (k = 0; k < 16; k++) {
		1512	av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
		1513	descriptor->essence_codec_ul[k]);
		1514	if (!(k+1 & 19) \|\| k == 5)
		1515	av_log(mxf->fc, AV_LOG_VERBOSE, ".");
		1516	}
		1517	av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
		1518	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
		1519	source_track->intra_only = mxf_is_intra_only(descriptor);
		1520	container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
		1521	if (st->codec->codec_id == AV_CODEC_ID_NONE)
		1522	st->codec->codec_id = container_ul->id;
		1523	st->codec->width = descriptor->width;
		1524	st->codec->height = descriptor->height; /* Field height, not frame height */
		1525	switch (descriptor->frame_layout) {
		1526	case SegmentedFrame:
		1527	/* This one is a weird layout I don't fully understand. */
		1528	av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
		1529	break;
		1530	case FullFrame:
		1531	st->codec->field_order = AV_FIELD_PROGRESSIVE;
		1532	break;
		1533	case OneField:
		1534	/* Every other line is stored and needs to be duplicated. */
		1535	av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
		1536	break; /* The correct thing to do here is fall through, but by breaking we might be
		1537	able to decode some streams at half the vertical resolution, rather than not al all.
		1538	It's also for compatibility with the old behavior. */
		1539	case MixedFields:
		1540	break;
		1541	case SeparateFields:
		1542	st->codec->height = 2; / Turn field height into frame height. */
		1543	break;
		1544	default:
		1545	av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
		1546	}
		1547	if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
		1548	st->codec->pix_fmt = descriptor->pix_fmt;
		1549	if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
		1550	pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
		1551	&descriptor->essence_codec_ul);
		1552	st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
		1553	if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
		1554	/* support files created before RP224v10 by defaulting to UYVY422
		1555	if subsampling is 4:2:2 and component depth is 8-bit */
		1556	if (descriptor->horiz_subsampling == 2 &&
		1557	descriptor->vert_subsampling == 1 &&
		1558	descriptor->component_depth == 8) {
		1559	st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
		1560	}
		1561	}
		1562	}
		1563	}
		1564	st->need_parsing = AVSTREAM_PARSE_HEADERS;
		1565	} else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
		1566	container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
		1567	/* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
		1568	if (st->codec->codec_id == AV_CODEC_ID_NONE \|\| (st->codec->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
		1569	st->codec->codec_id = (enum AVCodecID)container_ul->id;
		1570	st->codec->channels = descriptor->channels;
		1571	st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
		1572
		1573	if (descriptor->sample_rate.den > 0) {
		1574	st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
		1575	avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
		1576	} else {
		1577	av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
		1578	"found for stream #%d, time base forced to 1/48000\n",
		1579	descriptor->sample_rate.num, descriptor->sample_rate.den,
		1580	st->index);
		1581	avpriv_set_pts_info(st, 64, 1, 48000);
		1582	}
		1583
		1584	/* if duration is set, rescale it from EditRate to SampleRate */
		1585	if (st->duration != AV_NOPTS_VALUE)
		1586	st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
		1587
		1588	/* TODO: implement AV_CODEC_ID_RAWAUDIO */
		1589	if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
		1590	if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
		1591	st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
		1592	else if (descriptor->bits_per_sample == 32)
		1593	st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
		1594	} else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
		1595	if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
		1596	st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
		1597	else if (descriptor->bits_per_sample == 32)
		1598	st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
		1599	} else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
		1600	st->need_parsing = AVSTREAM_PARSE_FULL;
		1601	}
		1602	}
		1603	if (descriptor->extradata) {
		1604	if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
		1605	memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
		1606	}
		1607	} else if(st->codec->codec_id == AV_CODEC_ID_H264) {
		1608	ff_generate_avci_extradata(st);
		1609	}
		1610	if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
		1611	/* TODO: decode timestamps */
		1612	st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
		1613	}
		1614	}
		1615
		1616	ret = 0;
		1617	fail_and_free:
		1618	return ret;
		1619	}
		1620
		1621	static int mxf_read_utf16_string(AVIOContext pb, int size, char* str)
		1622	{
		1623	int ret;
		1624	size_t buf_size;
		1625
		1626	if (size < 0)
		1627	return AVERROR(EINVAL);
		1628
		1629	buf_size = size + size/2 + 1;
		1630	*str = av_malloc(buf_size);
		1631	if (!*str)
		1632	return AVERROR(ENOMEM);
		1633
		1634	if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
		1635	av_freep(str);
		1636	return ret;
		1637	}
		1638
		1639	return ret;
		1640	}
		1641
		1642	static int mxf_uid_to_str(UID uid, char **str)
		1643	{
		1644	int i;
		1645	char *p;
		1646	p = str = av_mallocz(sizeof(UID) 2 + 4 + 1);
		1647	if (!p)
		1648	return AVERROR(ENOMEM);
		1649	for (i = 0; i < sizeof(UID); i++) {
		1650	snprintf(p, 2 + 1, "%.2x", uid[i]);
		1651	p += 2;
		1652	if (i == 3 \|\| i == 5 \|\| i == 7 \|\| i == 9) {
		1653	snprintf(p, 1 + 1, "-");
		1654	p++;
		1655	}
		1656	}
		1657	return 0;
		1658	}
		1659
		1660	static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
		1661	{
		1662	struct tm time = {0};
		1663	time.tm_year = (timestamp >> 48) - 1900;
		1664	time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
		1665	time.tm_mday = (timestamp >> 32 & 0xFF);
		1666	time.tm_hour = (timestamp >> 24 & 0xFF);
		1667	time.tm_min = (timestamp >> 16 & 0xFF);
		1668	time.tm_sec = (timestamp >> 8 & 0xFF);
		1669
		1670	/* ensure month/day are valid */
		1671	time.tm_mon = FFMAX(time.tm_mon, 0);
		1672	time.tm_mday = FFMAX(time.tm_mday, 1);
		1673
		1674	*str = av_mallocz(32);
		1675	if (!*str)
		1676	return AVERROR(ENOMEM);
		1677	strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
		1678
		1679	return 0;
		1680	}
		1681
		1682	#define SET_STR_METADATA(pb, name, str) do { \
		1683	if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
		1684	return ret; \
		1685	av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
		1686	} while (0)
		1687
		1688	#define SET_UID_METADATA(pb, name, var, str) do { \
		1689	avio_read(pb, var, 16); \
		1690	if ((ret = mxf_uid_to_str(var, &str)) < 0) \
		1691	return ret; \
		1692	av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
		1693	} while (0)
		1694
		1695	#define SET_TS_METADATA(pb, name, var, str) do { \
		1696	var = avio_rb64(pb); \
		1697	if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
		1698	return ret; \
		1699	av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
		1700	} while (0)
		1701
		1702	static int mxf_read_identification_metadata(void arg, AVIOContext pb, int tag, int size, UID _uid, int64_t klv_offset)
		1703	{
		1704	MXFContext *mxf = arg;
		1705	AVFormatContext *s = mxf->fc;
		1706	int ret;
		1707	UID uid = { 0 };
		1708	char *str = NULL;
		1709	uint64_t ts;
		1710	switch (tag) {
		1711	case 0x3C01:
		1712	SET_STR_METADATA(pb, "company_name", str);
		1713	break;
		1714	case 0x3C02:
		1715	SET_STR_METADATA(pb, "product_name", str);
		1716	break;
		1717	case 0x3C04:
		1718	SET_STR_METADATA(pb, "product_version", str);
		1719	break;
		1720	case 0x3C05:
		1721	SET_UID_METADATA(pb, "product_uid", uid, str);
		1722	break;
		1723	case 0x3C06:
		1724	SET_TS_METADATA(pb, "modification_date", ts, str);
		1725	break;
		1726	case 0x3C08:
		1727	SET_STR_METADATA(pb, "application_platform", str);
		1728	break;
		1729	case 0x3C09:
		1730	SET_UID_METADATA(pb, "generation_uid", uid, str);
		1731	break;
		1732	case 0x3C0A:
		1733	SET_UID_METADATA(pb, "uid", uid, str);
		1734	break;
		1735	}
		1736	return 0;
		1737	}
		1738
		1739	static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
		1740	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
		1741	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
		1742	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
		1743	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
		1744	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
		1745	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
		1746	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
		1747	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
		1748	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
		1749	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
		1750	{ { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
		1751	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
		1752	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
		1753	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
		1754	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
		1755	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
		1756	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
		1757	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
		1758	{ { 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 */
		1759	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
		1760	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
		1761	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG 2 Video */
		1762	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
		1763	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
		1764	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
		1765	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
		1766	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
		1767	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
		1768	{ { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
		1769	{ { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
		1770	};
		1771
		1772	static int mxf_read_local_tags(MXFContext mxf, KLVPacket klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
		1773	{
		1774	AVIOContext *pb = mxf->fc->pb;
		1775	MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
		1776	uint64_t klv_end = avio_tell(pb) + klv->length;
		1777
		1778	if (!ctx)
		1779	return AVERROR(ENOMEM);
		1780	while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
		1781	int ret;
		1782	int tag = avio_rb16(pb);
		1783	int size = avio_rb16(pb); /* KLV specified by 0x53 */
		1784	uint64_t next = avio_tell(pb) + size;
		1785	UID uid = {0};
		1786
		1787	av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
		1788	if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
		1789	av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
		1790	continue;
		1791	}
		1792	if (tag > 0x7FFF) { /* dynamic tag */
		1793	int i;
		1794	for (i = 0; i < mxf->local_tags_count; i++) {
		1795	int local_tag = AV_RB16(mxf->local_tags+i*18);
		1796	if (local_tag == tag) {
		1797	memcpy(uid, mxf->local_tags+i*18+2, 16);
		1798	av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
		1799	PRINT_KEY(mxf->fc, "uid", uid);
		1800	}
		1801	}
		1802	}
		1803	if (ctx_size && tag == 0x3C0A)
		1804	avio_read(pb, ctx->uid, 16);
		1805	else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
		1806	return ret;
		1807
		1808	/* Accept the 64k local set limit being exceeded (Avid). Don't accept
		1809	* it extending past the end of the KLV though (zzuf5.mxf). */
		1810	if (avio_tell(pb) > klv_end) {
		1811	if (ctx_size)
		1812	av_free(ctx);
		1813
		1814	av_log(mxf->fc, AV_LOG_ERROR,
		1815	"local tag %#04x extends past end of local set @ %#"PRIx64"\n",
		1816	tag, klv->offset);
		1817	return AVERROR_INVALIDDATA;
		1818	} else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
		1819	avio_seek(pb, next, SEEK_SET);
		1820	}
		1821	if (ctx_size) ctx->type = type;
		1822	return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
		1823	}
		1824
		1825	/**
		1826	* Seeks to the previous partition, if possible
		1827	* @return <= 0 if we should stop parsing, > 0 if we should keep going
		1828	*/
		1829	static int mxf_seek_to_previous_partition(MXFContext *mxf)
		1830	{
		1831	AVIOContext *pb = mxf->fc->pb;
		1832
		1833	if (!mxf->current_partition \|\|
		1834	mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
		1835	return 0; /* we've parsed all partitions */
		1836
		1837	/* seek to previous partition */
		1838	avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
		1839	mxf->current_partition = NULL;
		1840
		1841	av_dlog(mxf->fc, "seeking to previous partition\n");
		1842
		1843	return 1;
		1844	}
		1845
		1846	/**
		1847	* Called when essence is encountered
		1848	* @return <= 0 if we should stop parsing, > 0 if we should keep going
		1849	*/
		1850	static int mxf_parse_handle_essence(MXFContext *mxf)
		1851	{
		1852	AVIOContext *pb = mxf->fc->pb;
		1853	int64_t ret;
		1854
		1855	if (mxf->parsing_backward) {
		1856	return mxf_seek_to_previous_partition(mxf);
		1857	} else if (mxf->footer_partition \|\| mxf->last_partition){
		1858	uint64_t offset;
		1859
		1860	offset = mxf->footer_partition ? mxf->footer_partition : mxf->last_partition;
		1861
		1862	av_dlog(mxf->fc, "seeking to last partition\n");
		1863
		1864	/* remember where we were so we don't end up seeking further back than this */
		1865	mxf->last_forward_tell = avio_tell(pb);
		1866
		1867	if (!pb->seekable) {
		1868	av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
		1869	return -1;
		1870	}
		1871
		1872	/* seek to last partition and parse backward */
		1873	if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
		1874	av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to last partition @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
		1875	mxf->run_in + offset, ret);
		1876	return ret;
		1877	}
		1878
		1879	mxf->current_partition = NULL;
		1880	mxf->parsing_backward = 1;
		1881	} else {
		1882	av_dlog(mxf->fc, "can't find last partition\n");
		1883	return 0;
		1884	}
		1885
		1886	return 1;
		1887	}
		1888
		1889	/**
		1890	* Called when the next partition or EOF is encountered
		1891	* @return <= 0 if we should stop parsing, > 0 if we should keep going
		1892	*/
		1893	static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
		1894	{
		1895	return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
		1896	}
		1897
		1898	/**
		1899	* Figures out the proper offset and length of the essence container in each partition
		1900	*/
		1901	static void mxf_compute_essence_containers(MXFContext *mxf)
		1902	{
		1903	int x;
		1904
		1905	/* everything is already correct */
		1906	if (mxf->op == OPAtom)
		1907	return;
		1908
		1909	for (x = 0; x < mxf->partitions_count; x++) {
		1910	MXFPartition *p = &mxf->partitions[x];
		1911
		1912	if (!p->body_sid)
		1913	continue; /* BodySID == 0 -> no essence */
		1914
		1915	if (x >= mxf->partitions_count - 1)
		1916	break; /* last partition - can't compute length (and we don't need to) */
		1917
		1918	/* essence container spans to the next partition */
		1919	p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
		1920
		1921	if (p->essence_length < 0) {
		1922	/* next ThisPartition < essence_offset */
		1923	p->essence_length = 0;
		1924	av_log(mxf->fc, AV_LOG_ERROR,
		1925	"partition %i: bad ThisPartition = %"PRIX64"\n",
		1926	x+1, mxf->partitions[x+1].this_partition);
		1927	}
		1928	}
		1929	}
		1930
		1931	static int64_t round_to_kag(int64_t position, int kag_size)
		1932	{
		1933	/* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
		1934	/* NOTE: kag_size may be any integer between 1 - 2^10 */
		1935	int64_t ret = (position / kag_size) * kag_size;
		1936	return ret == position ? ret : ret + kag_size;
		1937	}
		1938
		1939	static int is_pcm(enum AVCodecID codec_id)
		1940	{
		1941	/* we only care about "normal" PCM codecs until we get samples */
		1942	return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
		1943	}
		1944
		1945	/**
		1946	* Deal with the case where for some audio atoms EditUnitByteCount is
		1947	* very small (2, 4..). In those cases we should read more than one
		1948	* sample per call to mxf_read_packet().
		1949	*/
		1950	static void mxf_handle_small_eubc(AVFormatContext *s)
		1951	{
		1952	MXFContext *mxf = s->priv_data;
		1953
		1954	/* assuming non-OPAtom == frame wrapped
		1955	* no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
		1956	if (mxf->op != OPAtom)
		1957	return;
		1958
		1959	/* expect PCM with exactly one index table segment and a small (< 32) EUBC */
		1960	if (s->nb_streams != 1 \|\|
		1961	s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO \|\|
		1962	!is_pcm(s->streams[0]->codec->codec_id) \|\|
		1963	mxf->nb_index_tables != 1 \|\|
		1964	mxf->index_tables[0].nb_segments != 1 \|\|
		1965	mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
		1966	return;
		1967
		1968	/* arbitrarily default to 48 kHz PAL audio frame size */
		1969	/* TODO: We could compute this from the ratio between the audio
		1970	* and video edit rates for 48 kHz NTSC we could use the
		1971	* 1802-1802-1802-1802-1801 pattern. */
		1972	mxf->edit_units_per_packet = 1920;
		1973	}
		1974
		1975	static void mxf_read_random_index_pack(AVFormatContext *s)
		1976	{
		1977	MXFContext *mxf = s->priv_data;
		1978	uint32_t length;
		1979	int64_t file_size;
		1980	KLVPacket klv;
		1981
		1982	if (!s->pb->seekable)
		1983	return;
		1984
		1985	file_size = avio_size(s->pb);
		1986	avio_seek(s->pb, file_size - 4, SEEK_SET);
		1987	length = avio_rb32(s->pb);
		1988	if (length <= 32 \|\| length >= FFMIN(file_size, INT_MAX))
		1989	goto end;
		1990	avio_seek(s->pb, file_size - length, SEEK_SET);
		1991	if (klv_read_packet(&klv, s->pb) < 0 \|\|
		1992	!IS_KLV_KEY(klv.key, mxf_random_index_pack_key) \|\|
		1993	klv.length != length - 20)
		1994	goto end;
		1995
		1996	avio_skip(s->pb, klv.length - 12);
		1997	mxf->last_partition = avio_rb64(s->pb);
		1998
		1999	end:
		2000	avio_seek(s->pb, mxf->run_in, SEEK_SET);
		2001	}
		2002
		2003	static int mxf_read_header(AVFormatContext *s)
		2004	{
		2005	MXFContext *mxf = s->priv_data;
		2006	KLVPacket klv;
		2007	int64_t essence_offset = 0;
		2008	int ret;
		2009
		2010	mxf->last_forward_tell = INT64_MAX;
		2011	mxf->edit_units_per_packet = 1;
		2012
		2013	if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
		2014	av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
		2015	return AVERROR_INVALIDDATA;
		2016	}
		2017	avio_seek(s->pb, -14, SEEK_CUR);
		2018	mxf->fc = s;
		2019	mxf->run_in = avio_tell(s->pb);
		2020
		2021	mxf_read_random_index_pack(s);
		2022
		2023	while (!url_feof(s->pb)) {
		2024	const MXFMetadataReadTableEntry *metadata;
		2025
		2026	if (klv_read_packet(&klv, s->pb) < 0) {
		2027	/* EOF - seek to previous partition or stop */
		2028	if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
		2029	break;
		2030	else
		2031	continue;
		2032	}
		2033
		2034	PRINT_KEY(s, "read header", klv.key);
		2035	av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
		2036	if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) \|\|
		2037	IS_KLV_KEY(klv.key, mxf_essence_element_key) \|\|
		2038	IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) \|\|
		2039	IS_KLV_KEY(klv.key, mxf_system_item_key)) {
		2040
		2041	if (!mxf->current_partition) {
		2042	av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
		2043	return AVERROR_INVALIDDATA;
		2044	}
		2045
		2046	if (!mxf->current_partition->essence_offset) {
		2047	/* for OP1a we compute essence_offset
		2048	* for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
		2049	* TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
		2050	* for OPAtom we still need the actual essence_offset though (the KL's length can vary)
		2051	*/
		2052	int64_t op1a_essence_offset =
		2053	round_to_kag(mxf->current_partition->this_partition +
		2054	mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
		2055	round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
		2056	round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
		2057
		2058	if (mxf->op == OPAtom) {
		2059	/* point essence_offset to the actual data
		2060	* OPAtom has all the essence in one big KLV
		2061	*/
		2062	mxf->current_partition->essence_offset = avio_tell(s->pb);
		2063	mxf->current_partition->essence_length = klv.length;
		2064	} else {
		2065	/* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
		2066	mxf->current_partition->essence_offset = op1a_essence_offset;
		2067	}
		2068	}
		2069
		2070	if (!essence_offset)
		2071	essence_offset = klv.offset;
		2072
		2073	/* seek to footer, previous partition or stop */
		2074	if (mxf_parse_handle_essence(mxf) <= 0)
		2075	break;
		2076	continue;
		2077	} else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
		2078	klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
		2079	/* next partition pack - keep going, seek to previous partition or stop */
		2080	if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
		2081	break;
		2082	else if (mxf->parsing_backward)
		2083	continue;
		2084	/* we're still parsing forward. proceed to parsing this partition pack */
		2085	}
		2086
		2087	for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
		2088	if (IS_KLV_KEY(klv.key, metadata->key)) {
		2089	int res;
		2090	if (klv.key[5] == 0x53) {
		2091	res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
		2092	} else {
		2093	uint64_t next = avio_tell(s->pb) + klv.length;
		2094	res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
		2095
		2096	/* only seek forward, else this can loop for a long time */
		2097	if (avio_tell(s->pb) > next) {
		2098	av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
		2099	klv.offset);
		2100	return AVERROR_INVALIDDATA;
		2101	}
		2102
		2103	avio_seek(s->pb, next, SEEK_SET);
		2104	}
		2105	if (res < 0) {
		2106	av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
		2107	return res;
		2108	}
		2109	break;
		2110	}
		2111	}
		2112	if (!metadata->read)
		2113	avio_skip(s->pb, klv.length);
		2114	}
		2115	/* FIXME avoid seek */
		2116	if (!essence_offset) {
		2117	av_log(s, AV_LOG_ERROR, "no essence\n");
		2118	return AVERROR_INVALIDDATA;
		2119	}
		2120	avio_seek(s->pb, essence_offset, SEEK_SET);
		2121
		2122	mxf_compute_essence_containers(mxf);
		2123
		2124	/* we need to do this before computing the index tables
		2125	* to be able to fill in zero IndexDurations with st->duration */
		2126	if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
		2127	goto fail;
		2128
		2129	if ((ret = mxf_compute_index_tables(mxf)) < 0)
		2130	goto fail;
		2131
		2132	if (mxf->nb_index_tables > 1) {
		2133	/* TODO: look up which IndexSID to use via EssenceContainerData */
		2134	av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
		2135	mxf->nb_index_tables, mxf->index_tables[0].index_sid);
		2136	} else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
		2137	av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
		2138	ret = AVERROR_INVALIDDATA;
		2139	goto fail;
		2140	}
		2141
		2142	mxf_handle_small_eubc(s);
		2143
		2144	return 0;
		2145	fail:
		2146	mxf_read_close(s);
		2147
		2148	return ret;
		2149	}
		2150
		2151	/**
		2152	* Sets mxf->current_edit_unit based on what offset we're currently at.
		2153	* @return next_ofs if OK, <0 on error
		2154	*/
		2155	static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
		2156	{
		2157	int64_t last_ofs = -1, next_ofs = -1;
		2158	MXFIndexTable *t = &mxf->index_tables[0];
		2159
		2160	/* this is called from the OP1a demuxing logic, which means there
		2161	* may be no index tables */
		2162	if (mxf->nb_index_tables <= 0)
		2163	return -1;
		2164
		2165	/* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
		2166	while (mxf->current_edit_unit >= 0) {
		2167	if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
		2168	return -1;
		2169
		2170	if (next_ofs <= last_ofs) {
		2171	/* large next_ofs didn't change or current_edit_unit wrapped
		2172	* around this fixes the infinite loop on zzuf3.mxf */
		2173	av_log(mxf->fc, AV_LOG_ERROR,
		2174	"next_ofs didn't change. not deriving packet timestamps\n");
		2175	return -1;
		2176	}
		2177
		2178	if (next_ofs > current_offset)
		2179	break;
		2180
		2181	last_ofs = next_ofs;
		2182	mxf->current_edit_unit++;
		2183	}
		2184
		2185	/* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
		2186	if (mxf->current_edit_unit < 0)
		2187	return -1;
		2188
		2189	return next_ofs;
		2190	}
		2191
		2192	static int mxf_compute_sample_count(MXFContext mxf, int stream_index, uint64_t sample_count)
		2193	{
		2194	int i, total = 0, size = 0;
		2195	AVStream *st = mxf->fc->streams[stream_index];
		2196	MXFTrack *track = st->priv_data;
		2197	AVRational time_base = av_inv_q(track->edit_rate);
		2198	AVRational sample_rate = av_inv_q(st->time_base);
		2199	const MXFSamplesPerFrame *spf = NULL;
		2200
		2201	if ((sample_rate.num / sample_rate.den) == 48000)
		2202	spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
		2203	if (!spf) {
		2204	int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
		2205	*sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
		2206	av_mul_q(sample_rate, time_base)));
		2207	if (remainder)
		2208	av_log(mxf->fc, AV_LOG_WARNING,
		2209	"seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
		2210	stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
		2211	return 0;
		2212	}
		2213
		2214	while (spf->samples_per_frame[size]) {
		2215	total += spf->samples_per_frame[size];
		2216	size++;
		2217	}
		2218
		2219	av_assert2(size);
		2220
		2221	sample_count = (mxf->current_edit_unit / size) (uint64_t)total;
		2222	for (i = 0; i < mxf->current_edit_unit % size; i++) {
		2223	*sample_count += spf->samples_per_frame[i];
		2224	}
		2225
		2226	return 0;
		2227	}
		2228
		2229	static int mxf_set_audio_pts(MXFContext mxf, AVCodecContext codec, AVPacket *pkt)
		2230	{
		2231	MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
		2232	pkt->pts = track->sample_count;
		2233	if ( codec->channels <= 0
		2234	\|\| av_get_bits_per_sample(codec->codec_id) <= 0
		2235	\|\| codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) < 8)
		2236	return AVERROR(EINVAL);
		2237	track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
		2238	return 0;
		2239	}
		2240
		2241	static int mxf_read_packet_old(AVFormatContext s, AVPacket pkt)
		2242	{
		2243	KLVPacket klv;
		2244	MXFContext *mxf = s->priv_data;
		2245
		2246	while (klv_read_packet(&klv, s->pb) == 0) {
		2247	int ret;
		2248	PRINT_KEY(s, "read packet", klv.key);
		2249	av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
		2250	if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
		2251	ret = mxf_decrypt_triplet(s, pkt, &klv);
		2252	if (ret < 0) {
		2253	av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
		2254	return AVERROR_INVALIDDATA;
		2255	}
		2256	return 0;
		2257	}
		2258	if (IS_KLV_KEY(klv.key, mxf_essence_element_key) \|\|
		2259	IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
		2260	int index = mxf_get_stream_index(s, &klv);
		2261	int64_t next_ofs, next_klv;
		2262	AVStream *st;
		2263	MXFTrack *track;
		2264	AVCodecContext *codec;
		2265
		2266	if (index < 0) {
		2267	av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
		2268	goto skip;
		2269	}
		2270
		2271	st = s->streams[index];
		2272	track = st->priv_data;
		2273
		2274	if (s->streams[index]->discard == AVDISCARD_ALL)
		2275	goto skip;
		2276
		2277	next_klv = avio_tell(s->pb) + klv.length;
		2278	next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
		2279
		2280	if (next_ofs >= 0 && next_klv > next_ofs) {
		2281	/* if this check is hit then it's possible OPAtom was treated as OP1a
		2282	* truncate the packet since it's probably very large (>2 GiB is common) */
		2283	avpriv_request_sample(s,
		2284	"OPAtom misinterpreted as OP1a?"
		2285	"KLV for edit unit %i extending into "
		2286	"next edit unit",
		2287	mxf->current_edit_unit);
		2288	klv.length = next_ofs - avio_tell(s->pb);
		2289	}
		2290
		2291	/* check for 8 channels AES3 element */
		2292	if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
		2293	if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
		2294	av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
		2295	return AVERROR_INVALIDDATA;
		2296	}
		2297	} else {
		2298	ret = av_get_packet(s->pb, pkt, klv.length);
		2299	if (ret < 0)
		2300	return ret;
		2301	}
		2302	pkt->stream_index = index;
		2303	pkt->pos = klv.offset;
		2304
		2305	codec = s->streams[index]->codec;
		2306	if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
		2307	/* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
		2308	MXFIndexTable *t = &mxf->index_tables[0];
		2309
		2310	if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
		2311	pkt->dts = mxf->current_edit_unit + t->first_dts;
		2312	pkt->pts = t->ptses[mxf->current_edit_unit];
		2313	} else if (track->intra_only) {
		2314	/* intra-only -> PTS = EditUnit.
		2315	* let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
		2316	pkt->pts = mxf->current_edit_unit;
		2317	}
		2318	} else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
		2319	int ret = mxf_set_audio_pts(mxf, codec, pkt);
		2320	if (ret < 0)
		2321	return ret;
		2322	}
		2323
		2324	/* seek for truncated packets */
		2325	avio_seek(s->pb, next_klv, SEEK_SET);
		2326
		2327	return 0;
		2328	} else
		2329	skip:
		2330	avio_skip(s->pb, klv.length);
		2331	}
		2332	return url_feof(s->pb) ? AVERROR_EOF : -1;
		2333	}
		2334
		2335	static int mxf_read_packet(AVFormatContext s, AVPacket pkt)
		2336	{
		2337	MXFContext *mxf = s->priv_data;
		2338	int ret, size;
		2339	int64_t ret64, pos, next_pos;
		2340	AVStream *st;
		2341	MXFIndexTable *t;
		2342	int edit_units;
		2343
		2344	if (mxf->op != OPAtom)
		2345	return mxf_read_packet_old(s, pkt);
		2346
		2347	/* OPAtom - clip wrapped demuxing */
		2348	/* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
		2349	st = s->streams[0];
		2350	t = &mxf->index_tables[0];
		2351
		2352	if (mxf->current_edit_unit >= st->duration)
		2353	return AVERROR_EOF;
		2354
		2355	edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
		2356
		2357	if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
		2358	return ret;
		2359
		2360	/* compute size by finding the next edit unit or the end of the essence container
		2361	* not pretty, but it works */
		2362	if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
		2363	(next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
		2364	av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
		2365	return AVERROR_INVALIDDATA;
		2366	}
		2367
		2368	if ((size = next_pos - pos) <= 0) {
		2369	av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
		2370	return AVERROR_INVALIDDATA;
		2371	}
		2372
		2373	if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
		2374	return ret64;
		2375
		2376	if ((size = av_get_packet(s->pb, pkt, size)) < 0)
		2377	return size;
		2378
		2379	pkt->stream_index = 0;
		2380
		2381	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
		2382	mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
		2383	pkt->dts = mxf->current_edit_unit + t->first_dts;
		2384	pkt->pts = t->ptses[mxf->current_edit_unit];
		2385	} else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
		2386	int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
		2387	if (ret < 0)
		2388	return ret;
		2389	}
		2390
		2391	mxf->current_edit_unit += edit_units;
		2392
		2393	return 0;
		2394	}
		2395
		2396	static int mxf_read_close(AVFormatContext *s)
		2397	{
		2398	MXFContext *mxf = s->priv_data;
		2399	MXFIndexTableSegment *seg;
		2400	int i;
		2401
		2402	av_freep(&mxf->packages_refs);
		2403
		2404	for (i = 0; i < s->nb_streams; i++)
		2405	s->streams[i]->priv_data = NULL;
		2406
		2407	for (i = 0; i < mxf->metadata_sets_count; i++) {
		2408	switch (mxf->metadata_sets[i]->type) {
		2409	case Descriptor:
		2410	av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
		2411	break;
		2412	case MultipleDescriptor:
		2413	av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
		2414	break;
		2415	case Sequence:
		2416	av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
		2417	break;
		2418	case SourcePackage:
		2419	case MaterialPackage:
		2420	av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
		2421	break;
		2422	case IndexTableSegment:
		2423	seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
		2424	av_freep(&seg->temporal_offset_entries);
		2425	av_freep(&seg->flag_entries);
		2426	av_freep(&seg->stream_offset_entries);
		2427	break;
		2428	default:
		2429	break;
		2430	}
		2431	av_freep(&mxf->metadata_sets[i]);
		2432	}
		2433	av_freep(&mxf->partitions);
		2434	av_freep(&mxf->metadata_sets);
		2435	av_freep(&mxf->aesc);
		2436	av_freep(&mxf->local_tags);
		2437
		2438	if (mxf->index_tables) {
		2439	for (i = 0; i < mxf->nb_index_tables; i++) {
		2440	av_freep(&mxf->index_tables[i].segments);
		2441	av_freep(&mxf->index_tables[i].ptses);
		2442	av_freep(&mxf->index_tables[i].fake_index);
		2443	}
		2444	}
		2445	av_freep(&mxf->index_tables);
		2446
		2447	return 0;
		2448	}
		2449
		2450	static int mxf_probe(AVProbeData *p) {
		2451	const uint8_t *bufp = p->buf;
		2452	const uint8_t *end = p->buf + p->buf_size;
		2453
		2454	if (p->buf_size < sizeof(mxf_header_partition_pack_key))
		2455	return 0;
		2456
		2457	/* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
		2458	end -= sizeof(mxf_header_partition_pack_key);
		2459	for (; bufp < end; bufp++) {
		2460	if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
		2461	return AVPROBE_SCORE_MAX;
		2462	}
		2463	return 0;
		2464	}
		2465
		2466	/* rudimentary byte seek */
		2467	/* XXX: use MXF Index */
		2468	static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
		2469	{
		2470	AVStream *st = s->streams[stream_index];
		2471	int64_t seconds;
		2472	MXFContext* mxf = s->priv_data;
		2473	int64_t seekpos;
		2474	int i, ret;
		2475	int64_t ret64;
		2476	MXFIndexTable *t;
		2477	MXFTrack *source_track = st->priv_data;
		2478
		2479	/* if audio then truncate sample_time to EditRate */
		2480	if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
		2481	sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
		2482
		2483	if (mxf->nb_index_tables <= 0) {
		2484	if (!s->bit_rate)
		2485	return AVERROR_INVALIDDATA;
		2486	if (sample_time < 0)
		2487	sample_time = 0;
		2488	seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
		2489
		2490	if ((ret64 = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
		2491	return ret64;
		2492	ff_update_cur_dts(s, st, sample_time);
		2493	mxf->current_edit_unit = sample_time;
		2494	} else {
		2495	t = &mxf->index_tables[0];
		2496
		2497	/* clamp above zero, else ff_index_search_timestamp() returns negative
		2498	* this also means we allow seeking before the start */
		2499	sample_time = FFMAX(sample_time, 0);
		2500
		2501	if (t->fake_index) {
		2502	/* behave as if we have a proper index */
		2503	if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
		2504	return sample_time;
		2505	} else {
		2506	/* no IndexEntryArray (one or more CBR segments)
		2507	* make sure we don't seek past the end */
		2508	sample_time = FFMIN(sample_time, source_track->original_duration - 1);
		2509	}
		2510
		2511	if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
		2512	return ret;
		2513
		2514	ff_update_cur_dts(s, st, sample_time);
		2515	mxf->current_edit_unit = sample_time;
		2516	avio_seek(s->pb, seekpos, SEEK_SET);
		2517	}
		2518
		2519	// Update all tracks sample count
		2520	for (i = 0; i < s->nb_streams; i++) {
		2521	AVStream *cur_st = s->streams[i];
		2522	MXFTrack *cur_track = cur_st->priv_data;
		2523	uint64_t current_sample_count = 0;
		2524	if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
		2525	ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
		2526	if (ret < 0)
		2527	return ret;
		2528
		2529	cur_track->sample_count = current_sample_count;
		2530	}
		2531	}
		2532	return 0;
		2533	}
		2534
		2535	AVInputFormat ff_mxf_demuxer = {
		2536	.name = "mxf",
		2537	.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
		2538	.priv_data_size = sizeof(MXFContext),
		2539	.read_probe = mxf_probe,
		2540	.read_header = mxf_read_header,
		2541	.read_packet = mxf_read_packet,
		2542	.read_close = mxf_read_close,
		2543	.read_seek = mxf_read_seek,
		2544	};

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavformat/mxfdec.c @ 4361 – Rev