int mxf_read_header_pp_kl_with_runin(MXFFile *mxfFile, mxfKey *key, uint8_t *llen, uint64_t *len)
{
mxfKey tkey = MXF_PP_KEY(0x01, 0x00, 0x00);
uint8_t tllen;
uint64_t tlen;
uint8_t keyCompareByte = 0;
uint32_t runinCheckCount = 0;
int byte;
/* the run-in shall not contain the first 11 bytes of the partition pack label and so
read until the first 11 bytes are found or max run-in exceeded */
while (runinCheckCount <= MAX_RUNIN_LEN && keyCompareByte < 11) {
CHK_ORET((byte = mxf_file_getc(mxfFile)) != EOF);
if (byte == ((uint8_t*)(&tkey))[keyCompareByte]) {
keyCompareByte++;
} else {
runinCheckCount += keyCompareByte + 1;
keyCompareByte = 0;
}
}
CHK_ORET(runinCheckCount <= MAX_RUNIN_LEN);
CHK_ORET(mxf_file_read(mxfFile, &tkey.octet11, 5) == 5);
CHK_ORET(mxf_is_header_partition_pack(&tkey));
CHK_ORET(mxf_read_l(mxfFile, &tllen, &tlen));
mxf_set_runin_len(mxfFile, (uint16_t)runinCheckCount);
*key = tkey;
*llen = tllen;
*len = tlen;
return 1;
}
int mxf_read_essence_element_data(MXFFile *mxfFile, MXFEssenceElement *essenceElement,
uint32_t len, uint8_t *data, uint32_t *numRead)
{
uint32_t actualNumRead = 0;
uint32_t actualLen = len;
if ((uint64_t)(essenceElement->currentFilePos - essenceElement->startFilePos) >= essenceElement->totalLen)
{
*numRead = 0;
return 1;
}
if (actualLen + (uint64_t)(essenceElement->currentFilePos - essenceElement->startFilePos) > essenceElement->totalLen)
{
actualLen = (uint32_t)(essenceElement->totalLen -
(uint64_t)(essenceElement->currentFilePos - essenceElement->startFilePos));
}
actualNumRead = (uint32_t)mxf_file_read(mxfFile, data, actualLen);
essenceElement->currentFilePos += actualNumRead;
CHK_ORET(actualNumRead == actualLen);
*numRead = actualNumRead;
return 1;
}
int mxf_read_item(MXFFile* mxfFile, MXFMetadataItem* item, uint16_t len)
{
uint8_t buffer[65536];
CHK_ORET(mxf_file_read(mxfFile, buffer, len) == len);
CHK_MALLOC_ARRAY_ORET(item->value, uint8_t, len);
memcpy(item->value, buffer, len);
item->length = len;
return 1;
}
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;
}
int mxf_find_footer_partition(MXFFile *mxfFile)
{
const uint32_t maxIterations = 250; /* i.e. search maximum 8MB */
const uint32_t bufferSize = 32768 + 15;
unsigned char *buffer;
uint32_t numRead = 0;
int64_t offset;
int lastIteration = 0;
uint32_t i, j;
CHK_MALLOC_ARRAY_ORET(buffer, unsigned char, bufferSize);
if (!mxf_file_seek(mxfFile, 0, SEEK_END))
goto fail;
offset = mxf_file_tell(mxfFile);
for (i = 0; i < maxIterations; i++) {
if (offset < 17) /* file must start with a header partition pack */
break;
numRead = bufferSize - 15;
if (numRead > offset)
numRead = (uint32_t)offset;
/* first 15 bytes from last read are used for comparison in this read */
if (i > 0)
memcpy(buffer + numRead, buffer, 15);
if (!mxf_file_seek(mxfFile, offset - numRead, SEEK_SET) ||
mxf_file_read(mxfFile, buffer, numRead) != numRead)
{
break;
}
for (j = 0; j < numRead; j++) {
if (buffer[j] == g_PartitionPackPrefix_key.octet0 &&
buffer[j + 1] == g_PartitionPackPrefix_key.octet1 &&
memcmp(&buffer[j + 2], &g_PartitionPackPrefix_key.octet2, 11) == 0)
{
if (buffer[j + 13] == 0x04) {
/* found footer partition pack key - seek to it */
if (!mxf_file_seek(mxfFile, offset - numRead + j, SEEK_SET))
goto fail;
SAFE_FREE(buffer);
return 1;
} else if (buffer[j + 13] == 0x02 || buffer[j + 13] == 0x03) {
/* found a header or body partition pack key - continue search in this buffer only */
lastIteration = 1;
}
}
}
if (lastIteration)
break;
offset -= numRead;
}
fail:
SAFE_FREE(buffer);
return 0;
}
int test_read(const char *filename)
{
MXFFile *mxfFile = NULL;
MXFFilePartitions partitions;
MXFPartition *headerPartition = NULL;
MXFPartition *bodyPartition1 = NULL;
MXFPartition *bodyPartition2 = NULL;
MXFPartition *footerPartition = NULL;
mxfKey key;
uint8_t llen;
uint64_t len;
uint8_t essenceData[1024];
MXFEssenceElement *essenceElement = NULL;
uint32_t numRead;
if (!mxf_disk_file_open_read(filename, &mxfFile))
{
mxf_log_error("Failed to open '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
return 0;
}
mxf_initialise_file_partitions(&partitions);
/* TEST */
/* read header pp */
CHK_OFAIL(mxf_read_header_pp_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &headerPartition));
CHK_OFAIL(mxf_append_partition(&partitions, headerPartition));
/* read essence data directly */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_gc_essence_element(&key));
CHK_OFAIL(llen == 4 && len == 256);
CHK_OFAIL(mxf_file_read(mxfFile, essenceData, (uint32_t)len));
/* read body pp 1 */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_partition_pack(&key));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &bodyPartition1));
CHK_OFAIL(mxf_append_partition(&partitions, bodyPartition1));
/* read essence data using MXFEssenceElement */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_open_essence_element_read(mxfFile, &key, llen, len, &essenceElement));
CHK_OFAIL(llen == 8 && len == 1024);
CHK_OFAIL(mxf_read_essence_element_data(mxfFile, essenceElement, (uint32_t)len, essenceData, &numRead));
CHK_OFAIL(numRead == len);
mxf_close_essence_element(&essenceElement);
/* read body pp 2 */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_partition_pack(&key));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &bodyPartition2));
CHK_OFAIL(mxf_append_partition(&partitions, bodyPartition2));
/* read essence data using MXFEssenceElement */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_open_essence_element_read(mxfFile, &key, llen, len, &essenceElement));
CHK_OFAIL(llen == 8 && len == 1024);
CHK_OFAIL(mxf_read_essence_element_data(mxfFile, essenceElement, 256, essenceData, &numRead));
CHK_OFAIL(numRead == 256);
CHK_OFAIL(mxf_read_essence_element_data(mxfFile, essenceElement, 768, &essenceData[256], &numRead));
CHK_OFAIL(numRead == 768);
mxf_close_essence_element(&essenceElement);
/* read footer pp */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_partition_pack(&key));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &footerPartition));
CHK_OFAIL(mxf_append_partition(&partitions, footerPartition));
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
mxf_close_essence_element(&essenceElement);
return 1;
fail:
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
mxf_close_essence_element(&essenceElement);
return 0;
}
int main()
{
MXFPageFile *mxfPageFile;
MXFFile *mxfFile;
uint8_t *data;
int i;
data = malloc(DATA_SIZE);
remove_test_files();
CHECK(mxf_page_file_open_new(g_testFile, PAGE_SIZE, &mxfPageFile));
mxfFile = mxf_page_file_get_file(mxfPageFile);
memset(data, 0, DATA_SIZE);
CHECK(mxf_file_write(mxfFile, data, DATA_SIZE) == DATA_SIZE);
mxf_file_close(&mxfFile);
CHECK(mxf_page_file_open_modify(g_testFile, PAGE_SIZE, &mxfPageFile));
mxfFile = mxf_page_file_get_file(mxfPageFile);
memset(data, 1, DATA_SIZE);
CHECK(mxf_file_size(mxfFile) == DATA_SIZE);
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
CHECK(mxf_file_eof(mxfFile));
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE);
CHECK(mxf_file_write(mxfFile, data, DATA_SIZE) == DATA_SIZE);
CHECK(mxf_file_eof(mxfFile));
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE * 2);
CHECK(mxf_file_seek(mxfFile, 0, SEEK_SET));
CHECK(mxf_file_tell(mxfFile) == 0);
CHECK(mxf_file_write(mxfFile, data, DATA_SIZE) == DATA_SIZE);
mxf_file_close(&mxfFile);
CHECK(mxf_page_file_open_read(g_testFile, &mxfPageFile));
mxfFile = mxf_page_file_get_file(mxfPageFile);
memset(data, 1, DATA_SIZE);
CHECK(mxf_file_size(mxfFile) == DATA_SIZE * 2);
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE);
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
CHECK(mxf_file_eof(mxfFile));
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE * 2);
CHECK(mxf_file_seek(mxfFile, 0, SEEK_SET));
CHECK(mxf_file_tell(mxfFile) == 0);
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE);
CHECK(mxf_file_seek(mxfFile, DATA_SIZE + 1, SEEK_SET));
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE - 1) == DATA_SIZE - 1);
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE * 2);
CHECK(mxf_file_seek(mxfFile, DATA_SIZE - 1, SEEK_SET));
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE - 1);
CHECK(mxf_file_seek(mxfFile, DATA_SIZE * 2, SEEK_SET));
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE * 2);
CHECK(mxf_file_seek(mxfFile, 0, SEEK_END));
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE * 2);
CHECK(mxf_file_seek(mxfFile, -DATA_SIZE * 2, SEEK_END));
CHECK(mxf_file_tell(mxfFile) == 0);
CHECK(mxf_file_seek(mxfFile, DATA_SIZE - 5, SEEK_CUR));
CHECK(mxf_file_tell(mxfFile) == DATA_SIZE - 5);
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
mxf_file_close(&mxfFile);
CHECK(mxf_page_file_open_new("pagetest_out__%d.mxf", PAGE_SIZE, &mxfPageFile));
mxfFile = mxf_page_file_get_file(mxfPageFile);
CHECK(mxf_file_write(mxfFile, data, DATA_SIZE) == DATA_SIZE);
mxf_file_close(&mxfFile);
CHECK(mxf_page_file_remove("pagetest_out__%d.mxf"));
/* test forward truncate */
CHECK(mxf_page_file_open_new(g_testFile, PAGE_SIZE, &mxfPageFile));
mxfFile = mxf_page_file_get_file(mxfPageFile);
memset(data, 0, DATA_SIZE);
for (i = 0; i < 10; i++)
{
CHECK(mxf_file_write(mxfFile, data, DATA_SIZE) == DATA_SIZE);
}
mxf_file_close(&mxfFile);
CHECK(mxf_page_file_open_modify(g_testFile, PAGE_SIZE, &mxfPageFile));
mxfFile = mxf_page_file_get_file(mxfPageFile);
memset(data, 1, DATA_SIZE);
CHECK(mxf_page_file_forward_truncate(mxfPageFile));
for (i = 0; i < 5; i++)
{
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
}
CHECK(mxf_page_file_forward_truncate(mxfPageFile));
for (i = 0; i < 4; i++)
{
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
}
CHECK(mxf_page_file_forward_truncate(mxfPageFile));
CHECK(mxf_file_read(mxfFile, data, DATA_SIZE) == DATA_SIZE);
CHECK(mxf_page_file_forward_truncate(mxfPageFile));
mxf_file_close(&mxfFile);
CHECK(mxf_page_file_remove(g_testFile));
free(data);
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;
}
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;
}
