int mxf_read_rip_and_size(MXFFile *mxfFile, MXFRIP *rip, uint32_t* size)
{
uint32_t rip_size;
mxfKey key;
uint8_t llen;
uint64_t len;
uint32_t numEntries;
MXFRIPEntry *newEntry = NULL;
MXFRIPEntry *entry;
uint32_t i;
mxf_initialise_list(&rip->entries, free);
/* read RIP size (min is 16 + 1 + (4 + 8) * 1 + 4) at end of file */
if (!mxf_file_seek(mxfFile, -4, SEEK_END) ||
!mxf_read_uint32(mxfFile, &rip_size) ||
rip_size < 33)
{
return 0;
}
/* seek, read and check RIP key */
if (!mxf_file_seek(mxfFile, (int64_t)0 - rip_size, SEEK_CUR) ||
!mxf_read_k(mxfFile, &key) ||
!mxf_equals_key(&key, &g_RandomIndexPack_key) ||
!mxf_read_l(mxfFile, &llen, &len))
{
return 0;
}
/* read RIP */
numEntries = ((uint32_t)len - 4) / 12;
CHK_ORET(((uint32_t)len - 4) % 12 == 0);
for (i = 0; i < numEntries; i++)
{
CHK_MALLOC_OFAIL(newEntry, MXFRIPEntry);
CHK_OFAIL(mxf_append_list_element(&rip->entries, newEntry));
entry = newEntry;
newEntry = NULL; /* entry assigned to list so set to NULL so not free'ed in fail */
CHK_OFAIL(mxf_read_uint32(mxfFile, &entry->bodySID));
CHK_OFAIL(mxf_read_uint64(mxfFile, &entry->thisPartition));
}
*size = rip_size;
return 1;
fail:
if (newEntry != NULL)
{
free(newEntry);
}
mxf_clear_list(&rip->entries);
return 0;
}
int mxf_write_header_sets(MXFFile* mxfFile, MXFHeaderMetadata* headerMetadata)
{
MXFListIterator iter;
MXFMetadataSet* prefaceSet;
/* must write the Preface set first (and there must be a Preface set) */
CHK_ORET(mxf_find_singular_set_by_key(headerMetadata, &MXF_SET_K(Preface), &prefaceSet));
CHK_ORET(mxf_write_set(mxfFile, prefaceSet));
mxf_initialise_list_iter(&iter, &headerMetadata->sets);
while (mxf_next_list_iter_element(&iter))
{
MXFMetadataSet* set = (MXFMetadataSet*)mxf_get_iter_element(&iter);
if (!mxf_equals_key(&set->key, &MXF_SET_K(Preface)))
{
CHK_ORET(mxf_write_set(mxfFile, set));
}
}
return 1;
}
int mxf_find_set_by_key(MXFHeaderMetadata* headerMetadata, const mxfKey* key, MXFList** setList)
{
MXFListIterator iter;
MXFList* newList = NULL;
CHK_ORET(mxf_create_list(&newList, NULL)); /* free func == NULL because newList doesn't own the data */
mxf_initialise_list_iter(&iter, &headerMetadata->sets);
while (mxf_next_list_iter_element(&iter))
{
MXFMetadataSet* set = (MXFMetadataSet*)mxf_get_iter_element(&iter);
if (mxf_equals_key(key, &set->key))
{
CHK_OFAIL(mxf_append_list_element(newList, (void*)set));
}
}
*setList = newList;
return 1;
fail:
mxf_free_list(&newList);
return 0;
}
static int item_eq_key(void* data, void* info)
{
assert(data != NULL && info != NULL);
return mxf_equals_key((mxfKey*)info, &((MXFMetadataItem*)data)->key);
}
int mxf_read_and_return_set(MXFFile* mxfFile, const mxfKey* key, uint64_t len,
MXFHeaderMetadata* headerMetadata, int addToHeaderMetadata, MXFMetadataSet** set)
{
MXFMetadataSet* newSet = NULL;
MXFSetDef* setDef = NULL;
uint64_t totalLen = 0;
mxfLocalTag itemTag;
uint16_t itemLen;
int haveInstanceUID = 0;
mxfKey itemKey;
MXFItemDef* itemDef = NULL;
MXFMetadataItem* newItem;
assert(headerMetadata->primerPack != NULL);
/* only read sets with known definitions */
if (mxf_find_set_def(headerMetadata->dataModel, key, &setDef))
{
CHK_ORET(create_empty_set(key, &newSet));
/* read each item in the set*/
haveInstanceUID = 0;
do
{
CHK_OFAIL(mxf_read_item_tl(mxfFile, &itemTag, &itemLen));
/* check the item tag is registered in the primer */
if (mxf_get_item_key(headerMetadata->primerPack, itemTag, &itemKey))
{
/* only read items with known definition */
if (mxf_find_item_def_in_set_def(&itemKey, setDef, &itemDef))
{
CHK_OFAIL(mxf_create_item(newSet, &itemKey, itemTag, &newItem));
newItem->isPersistent = 1;
CHK_OFAIL(mxf_read_item(mxfFile, newItem, itemLen));
if (mxf_equals_key(&MXF_ITEM_K(InterchangeObject, InstanceUID), &itemKey))
{
mxf_get_uuid(newItem->value, &newSet->instanceUID);
haveInstanceUID = 1;
}
}
/* skip items with unknown definition */
else
{
CHK_OFAIL(mxf_skip(mxfFile, (int64_t)itemLen));
}
}
/* skip items not registered in the primer. Log warning because the file is invalid */
else
{
mxf_log_warn("Encountered item with tag %d not registered in the primer" LOG_LOC_FORMAT,
itemTag, LOG_LOC_PARAMS);
CHK_OFAIL(mxf_skip(mxfFile, (int64_t)itemLen));
}
totalLen += 4 + itemLen;
}
while (totalLen < len);
if (totalLen != len)
{
mxf_log_error("Incorrect metadata set length encountered" LOG_LOC_FORMAT, LOG_LOC_PARAMS);
goto fail;
}
if (!haveInstanceUID)
{
mxf_log_error("Metadata set does not have InstanceUID item" LOG_LOC_FORMAT, LOG_LOC_PARAMS);
goto fail;
}
/* ok to add set */
if (addToHeaderMetadata)
{
CHK_OFAIL(mxf_add_set(headerMetadata, newSet));
}
*set = newSet;
return 1;
}
/* skip the set if the def is unknown */
CHK_ORET(mxf_skip(mxfFile, (int64_t)len));
*set = NULL;
return 2;
fail:
mxf_free_set(&newSet);
return 0;
}
int test_read(const char* filename)
{
MXFFile* mxfFile = NULL;
mxfKey key;
uint8_t llen;
uint64_t len;
mxfLocalTag tag;
uint8_t indata[256];
uint8_t valueu8;
uint16_t valueu16;
uint32_t valueu32;
uint64_t valueu64;
int8_t value8;
int16_t value16;
int32_t value32;
int64_t value64;
mxfUL ul;
mxfUID uid;
mxfUUID uuid;
uint32_t ablen;
uint32_t abelen;
if (!mxf_disk_file_open_read(filename, &mxfFile))
{
mxf_log_error("Failed to open '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
return 0;
}
/* TEST */
CHK_OFAIL(mxf_file_read(mxfFile, indata, 100) == 100);
CHK_OFAIL(memcmp(data, indata, 100) == 0);
CHK_OFAIL(mxf_file_getc(mxfFile) == 0xff);
CHK_OFAIL(mxf_file_getc(mxfFile) == 0xff);
CHK_OFAIL(mxf_read_uint8(mxfFile, &valueu8));
CHK_OFAIL(valueu8 == 0x0f);
CHK_OFAIL(mxf_read_uint16(mxfFile, &valueu16));
CHK_OFAIL(valueu16 == 0x0f00);
CHK_OFAIL(mxf_read_uint32(mxfFile, &valueu32));
CHK_OFAIL(valueu32 == 0x0f000000);
CHK_OFAIL(mxf_read_uint64(mxfFile, &valueu64));
CHK_OFAIL(valueu64 == 0x0f00000000000000LL);
CHK_OFAIL(mxf_read_int8(mxfFile, &value8));
CHK_OFAIL(value8 == -0x0f);
CHK_OFAIL(mxf_read_int16(mxfFile, &value16));
CHK_OFAIL(value16 == -0x0f00);
CHK_OFAIL(mxf_read_int32(mxfFile, &value32));
CHK_OFAIL(value32 == -0x0f000000);
CHK_OFAIL(mxf_read_int64(mxfFile, &value64));
CHK_OFAIL(value64 == -0x0f00000000000000LL);
CHK_OFAIL(mxf_read_local_tag(mxfFile, &tag));
CHK_OFAIL(tag == 0xffaa);
CHK_OFAIL(mxf_read_k(mxfFile, &key));
CHK_OFAIL(mxf_equals_key(&key, &someKey));
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 1 && len == 0x01);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 2 && len == 0x80);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 3 && len == 0x8000);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 4 && len == 0x800000);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 5 && len == 0x80000000);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 6 && len == 0x8000000000LL);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 7 && len == 0x800000000000LL);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 8 && len == 0x80000000000000LL);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 9 && len == 0x8000000000000000LL);
CHK_OFAIL(mxf_read_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_equals_key(&key, &someKey));
CHK_OFAIL(llen == 3 && len == 0xf100);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 8 && len == 0x10);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 4 && len == 0x10);
CHK_OFAIL(mxf_read_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_equals_key(&key, &someKey));
CHK_OFAIL(llen == 8 && len == 0x1000);
CHK_OFAIL(mxf_read_ul(mxfFile, &ul));
CHK_OFAIL(mxf_equals_ul(&ul, &someUL));
CHK_OFAIL(mxf_read_uid(mxfFile, &uid));
CHK_OFAIL(mxf_equals_uid(&uid, &someUID));
CHK_OFAIL(mxf_read_uuid(mxfFile, &uuid));
CHK_OFAIL(mxf_equals_uuid(&uuid, &someUUID));
CHK_OFAIL(mxf_read_batch_header(mxfFile, &ablen, &abelen));
CHK_OFAIL(ablen == 2 && abelen == 16);
CHK_OFAIL(mxf_read_array_header(mxfFile, &ablen, &abelen));
CHK_OFAIL(ablen == 4 && abelen == 32);
mxf_file_close(&mxfFile);
/* test reading from a byte buffer */
const uint8_t data[5] = {1, 2, 3, 4, 5};
if (!mxf_byte_array_wrap_read(data, sizeof(data), &mxfFile))
{
mxf_log_error("Failed to open byte array as MXF file" LOG_LOC_FORMAT, LOG_LOC_PARAMS);
return 0;
}
CHK_OFAIL(mxf_file_tell(mxfFile) == 0);
CHK_OFAIL(mxf_file_getc(mxfFile) == 1);
CHK_OFAIL(mxf_file_tell(mxfFile) == 1);
CHK_OFAIL(mxf_file_read(mxfFile, indata, 4));
CHK_OFAIL(indata[0] == 2 && indata[1] == 3 && indata[2] == 4 && indata[3] == 5);
CHK_OFAIL(mxf_file_tell(mxfFile) == 5);
CHK_OFAIL(mxf_file_eof(mxfFile));
CHK_OFAIL(mxf_file_getc(mxfFile) == EOF);
CHK_OFAIL(mxf_file_seek(mxfFile, 0, SEEK_SET));
CHK_OFAIL(mxf_file_tell(mxfFile) == 0);
CHK_OFAIL(mxf_file_getc(mxfFile) == 1);
CHK_OFAIL(mxf_file_seek(mxfFile, 2, SEEK_CUR));
CHK_OFAIL(mxf_file_tell(mxfFile) == 3);
CHK_OFAIL(mxf_file_getc(mxfFile) == 4);
CHK_OFAIL(mxf_file_seek(mxfFile, 0, SEEK_END));
CHK_OFAIL(mxf_file_tell(mxfFile) == 4);
CHK_OFAIL(mxf_file_getc(mxfFile) == 5);
CHK_OFAIL(!mxf_file_seek(mxfFile, 5, SEEK_END)); /* should fail */
CHK_OFAIL(mxf_file_tell(mxfFile) == 5);
mxf_file_close(&mxfFile);
return 1;
fail:
mxf_file_close(&mxfFile);
return 0;
}
static int ns_read_content_package(MXFReader *reader, int skip, MXFReaderListener *listener)
{
MXFFile *mxfFile = reader->mxfFile;
EssenceReader *essenceReader = reader->essenceReader;
EssenceReaderData *data = essenceReader->data;
NSFileIndex *nsIndex = &data->nsIndex;
EssenceTrack *essenceTrack;
uint8_t *buffer;
mxfKey key;
uint8_t llen;
uint64_t len;
uint64_t cpCount;
int trackIndex;
/* must be positioned at start of a content package */
CHK_ORET(mxf_equals_key(&nsIndex->nextKey, &nsIndex->startContentPackageKey));
/* get KL read previously */
key = nsIndex->nextKey;
llen = nsIndex->nextLLen;
len = nsIndex->nextLen;
cpCount = mxfKey_extlen + llen;
/* process essence elements in content package */
while (nsIndex->contentPackageLen == 0 || cpCount <= nsIndex->contentPackageLen)
{
if (!skip && mxf_is_gc_essence_element(&key))
{
if (get_essence_track_with_tracknumber(essenceReader, mxf_get_track_number(&key), &essenceTrack,
&trackIndex))
{
/* send data to listener */
if (accept_frame(listener, trackIndex))
{
if (listener && listener->allocate_buffer(listener, trackIndex, &buffer, len))
{
CHK_ORET(mxf_file_read(mxfFile, buffer, len) == len);
CHK_ORET(send_frame(reader, listener, trackIndex, buffer, len));
}
else
{
CHK_ORET(mxf_skip(mxfFile, len));
}
}
else
{
CHK_ORET(mxf_skip(mxfFile, len));
}
cpCount += len;
}
else if (element_is_known_system_item(&key))
{
CHK_ORET(extract_system_item_info(reader, &key, len,
reader->essenceReader->data->nsIndex.currentPosition));
cpCount += len;
}
else
{
CHK_ORET(mxf_skip(mxfFile, len));
cpCount += len;
}
}
else
{
CHK_ORET(mxf_skip(mxfFile, len));
cpCount += len;
}
if (!mxf_read_kl(mxfFile, &key, &llen, &len))
{
CHK_ORET(mxf_file_eof(mxfFile));
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
break;
}
ns_set_next_kl(nsIndex, &key, llen, len);
cpCount += mxfKey_extlen + llen;
/* if don't know the length of the content package then look out for the first element key
or the start of a new partition */
if (nsIndex->contentPackageLen == 0 &&
(mxf_is_partition_pack(&key) || mxf_equals_key(&key, &nsIndex->startContentPackageKey)))
{
break;
}
}
CHK_ORET(nsIndex->contentPackageLen == 0 || cpCount == nsIndex->contentPackageLen + mxfKey_extlen + llen);
/* set content package length if it was unknown */
if (nsIndex->contentPackageLen == 0)
{
nsIndex->contentPackageLen = cpCount - mxfKey_extlen - llen;
}
return 1;
}
static int ns_pos_at_next_frame(MXFReader *reader)
{
MXFFile *mxfFile = reader->mxfFile;
EssenceReader *essenceReader = reader->essenceReader;
EssenceReaderData *data = essenceReader->data;
NSFileIndex *nsIndex = &data->nsIndex;
MXFPartition *partition = NULL;
mxfKey key;
uint8_t llen;
uint64_t len;
int atEOF;
/* move to next partition if at end of current partition */
if (mxf_is_partition_pack(&nsIndex->nextKey))
{
key = nsIndex->nextKey;
llen = nsIndex->nextLLen;
len = nsIndex->nextLen;
atEOF = 0;
while (!atEOF)
{
/* read partition pack and check if it contains essence */
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &partition));
if (data->bodySID == partition->bodySID)
{
CHK_OFAIL(ns_position_at_first_frame(reader));
mxf_free_partition(&partition);
break;
}
mxf_free_partition(&partition);
/* skip this partition */
while (!atEOF)
{
if (!mxf_read_kl(mxfFile, &key, &llen, &len))
{
/* if we fail to read then we must be at eof */
CHK_OFAIL(mxf_file_eof(mxfFile));
atEOF = 1;
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
break;
}
ns_set_next_kl(nsIndex, &key, llen, len);
if (mxf_is_partition_pack(&key))
{
break;
}
CHK_OFAIL(mxf_skip(mxfFile, len));
}
}
CHK_ORET(atEOF || mxf_equals_key(&key, &nsIndex->startContentPackageKey));
}
return 1;
fail:
mxf_free_partition(&partition);
return 0;
}
static int ns_position_at_first_frame(MXFReader *reader)
{
MXFFile *mxfFile = reader->mxfFile;
EssenceReader *essenceReader = reader->essenceReader;
EssenceReaderData *data = essenceReader->data;
NSFileIndex *nsIndex = &data->nsIndex;
MXFPartition *partition = data->headerPartition;
mxfKey key;
uint8_t llen;
uint64_t len;
/* move to the first partition that contains essence data */
while (data->bodySID != partition->bodySID)
{
if (!mxf_read_kl(mxfFile, &key, &llen, &len))
{
CHK_OFAIL(mxf_file_eof(mxfFile));
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
return 1;
}
while (!mxf_is_partition_pack(&key))
{
CHK_OFAIL(mxf_skip(mxfFile, len));
if (!mxf_read_kl(mxfFile, &key, &llen, &len))
{
CHK_OFAIL(mxf_file_eof(mxfFile));
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
return 1;
}
}
if (partition != NULL && partition != data->headerPartition)
{
mxf_free_partition(&partition);
}
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &partition));
}
/* move to start of essence data in partition */
/* if we are in the header partition then the file is positioned after the header metadata,
otherwise we are positioned after the partition pack that was just read */
if (partition != data->headerPartition)
{
/* skip initial filler which is not included in any header or index byte counts */
if (!mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len))
{
CHK_ORET(mxf_file_eof(mxfFile));
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
return 1;
}
/* skip header metadata */
if (partition->headerByteCount > 0)
{
CHK_ORET(mxf_skip(mxfFile, partition->headerByteCount - mxfKey_extlen - llen));
if (!mxf_read_kl(mxfFile, &key, &llen, &len))
{
CHK_ORET(mxf_file_eof(mxfFile));
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
return 1;
}
}
else
{
CHK_ORET(!mxf_is_header_metadata(&key));
}
}
else
{
if (!mxf_read_kl(mxfFile, &key, &llen, &len))
{
CHK_ORET(mxf_file_eof(mxfFile));
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
return 1;
}
}
/* skip index table segments. Note: we are not checking for segment key because it
could be non-standard, eg. MXF V10 indexes */
if (partition->indexByteCount > 0)
{
CHK_ORET(mxf_skip(mxfFile, partition->indexByteCount - mxfKey_extlen - llen));
if (!mxf_read_kl(mxfFile, &key, &llen, &len))
{
CHK_ORET(mxf_file_eof(mxfFile));
ns_set_next_kl(nsIndex, &g_Null_Key, 0, 0);
return 1;
}
}
/* check the first essence element KL and position after */
CHK_ORET(mxf_is_gc_essence_element(&key));
if (mxf_equals_key(&nsIndex->startContentPackageKey, &g_Null_Key))
{
nsIndex->startContentPackageKey = key;
nsIndex->currentPosition = 0;
}
else
{
CHK_ORET(mxf_equals_key(&nsIndex->startContentPackageKey, &key));
}
ns_set_next_kl(nsIndex, &key, llen, len);
if (partition != NULL && partition != data->headerPartition)
{
mxf_free_partition(&partition);
}
return 1;
fail:
if (partition != NULL && partition != data->headerPartition)
{
mxf_free_partition(&partition);
}
return 0;
}
static int ns_end_of_essence(NSFileIndex *nsIndex)
{
return !mxf_equals_key(&nsIndex->nextKey, &nsIndex->startContentPackageKey);
}
int test_read(const char *filename)
{
MXFFile *mxfFile = NULL;
mxfKey key;
uint8_t llen;
uint64_t len;
mxfLocalTag tag;
uint8_t indata[256];
uint8_t valueu8;
uint16_t valueu16;
uint32_t valueu32;
uint64_t valueu64;
int8_t value8;
int16_t value16;
int32_t value32;
int64_t value64;
mxfUL ul;
mxfUID uid;
mxfUUID uuid;
uint32_t ablen;
uint32_t abelen;
if (!mxf_disk_file_open_read(filename, &mxfFile))
{
mxf_log_error("Failed to open '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
return 0;
}
/* TEST */
CHK_OFAIL(mxf_file_read(mxfFile, indata, 100) == 100);
CHK_OFAIL(memcmp(data, indata, 100) == 0);
CHK_OFAIL(mxf_file_getc(mxfFile) == 0xff);
CHK_OFAIL(mxf_file_getc(mxfFile) == 0xff);
CHK_OFAIL(mxf_read_uint8(mxfFile, &valueu8));
CHK_OFAIL(valueu8 == 0x0f);
CHK_OFAIL(mxf_read_uint16(mxfFile, &valueu16));
CHK_OFAIL(valueu16 == 0x0f00);
CHK_OFAIL(mxf_read_uint32(mxfFile, &valueu32));
CHK_OFAIL(valueu32 == 0x0f000000);
CHK_OFAIL(mxf_read_uint64(mxfFile, &valueu64));
CHK_OFAIL(valueu64 == 0x0f00000000000000LL);
CHK_OFAIL(mxf_read_int8(mxfFile, &value8));
CHK_OFAIL(value8 == -0x0f);
CHK_OFAIL(mxf_read_int16(mxfFile, &value16));
CHK_OFAIL(value16 == -0x0f00);
CHK_OFAIL(mxf_read_int32(mxfFile, &value32));
CHK_OFAIL(value32 == -0x0f000000);
CHK_OFAIL(mxf_read_int64(mxfFile, &value64));
CHK_OFAIL(value64 == -0x0f00000000000000LL);
CHK_OFAIL(mxf_read_local_tag(mxfFile, &tag));
CHK_OFAIL(tag == 0xffaa);
CHK_OFAIL(mxf_read_k(mxfFile, &key));
CHK_OFAIL(mxf_equals_key(&key, &someKey));
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 1 && len == 0x01);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 2 && len == 0x80);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 3 && len == 0x8000);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 4 && len == 0x800000);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 5 && len == 0x80000000);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 6 && len == 0x8000000000LL);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 7 && len == 0x800000000000LL);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 8 && len == 0x80000000000000LL);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 9 && len == 0x8000000000000000LL);
CHK_OFAIL(mxf_read_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_equals_key(&key, &someKey));
CHK_OFAIL(llen == 3 && len == 0xf100);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 8 && len == 0x10);
CHK_OFAIL(mxf_read_l(mxfFile, &llen, &len));
CHK_OFAIL(llen == 4 && len == 0x10);
CHK_OFAIL(mxf_read_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_equals_key(&key, &someKey));
CHK_OFAIL(llen == 8 && len == 0x1000);
CHK_OFAIL(mxf_read_ul(mxfFile, &ul));
CHK_OFAIL(mxf_equals_ul(&ul, &someUL));
CHK_OFAIL(mxf_read_uid(mxfFile, &uid));
CHK_OFAIL(mxf_equals_uid(&uid, &someUID));
CHK_OFAIL(mxf_read_uuid(mxfFile, &uuid));
CHK_OFAIL(mxf_equals_uuid(&uuid, &someUUID));
CHK_OFAIL(mxf_read_batch_header(mxfFile, &ablen, &abelen));
CHK_OFAIL(ablen == 2 && abelen == 16);
CHK_OFAIL(mxf_read_array_header(mxfFile, &ablen, &abelen));
CHK_OFAIL(ablen == 4 && abelen == 32);
mxf_file_close(&mxfFile);
return 1;
fail:
mxf_file_close(&mxfFile);
return 0;
}
