int mxf_partition_is_closed_and_complete(const mxfKey *key)
{
if (!mxf_is_partition_pack(key))
{
return 0;
}
return key->octet14 == 0x04;
}
int mxf_partition_is_closed(const mxfKey *key)
{
if (!mxf_is_partition_pack(key))
{
return 0;
}
return key->octet14 == 0x02 || key->octet14 == 0x04;
}
int test_read(const char *filename)
{
MXFFile *mxfFile = NULL;
MXFFilePartitions partitions;
MXFPartition *headerPartition = NULL;
MXFPartition *bodyPartition1 = NULL;
MXFPartition *bodyPartition2 = NULL;
MXFPartition *footerPartition = NULL;
MXFListIterator iter;
mxfKey key;
uint8_t llen;
uint64_t len;
int i;
MXFRIP rip;
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 RIP */
CHK_OFAIL(mxf_read_rip(mxfFile, &rip));
CHK_OFAIL(mxf_get_list_length(&rip.entries) == 4);
CHK_OFAIL(mxf_file_seek(mxfFile, 0, SEEK_SET));
mxf_initialise_list_iter(&iter, &rip.entries);
i = 0;
while (mxf_next_list_iter_element(&iter))
{
MXFRIPEntry *entry = (MXFRIPEntry*)mxf_get_iter_element(&iter);
if (i == 0)
{
CHK_OFAIL(entry->bodySID == 0);
CHK_OFAIL(entry->thisPartition == RUNIN_LEN);
}
else if (i == 1)
{
CHK_OFAIL(entry->bodySID == 2);
CHK_OFAIL(entry->thisPartition == RUNIN_LEN + 1161);
}
else if (i == 2)
{
CHK_OFAIL(entry->bodySID == 3);
CHK_OFAIL(entry->thisPartition == RUNIN_LEN + 1298);
}
else
{
CHK_OFAIL(entry->bodySID == 0);
CHK_OFAIL(entry->thisPartition == RUNIN_LEN + 1554);
}
i++;
}
/* read header pp, allowing for runin */
CHK_OFAIL(mxf_read_header_pp_kl_with_runin(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &headerPartition));
CHK_OFAIL(mxf_append_partition(&partitions, headerPartition));
CHK_OFAIL(headerPartition->indexSID == 1);
CHK_OFAIL(headerPartition->bodySID == 0);
CHK_OFAIL(mxf_get_list_length(&headerPartition->essenceContainers) == 2);
mxf_initialise_list_iter(&iter, &headerPartition->essenceContainers);
i = 0;
while (mxf_next_list_iter_element(&iter))
{
mxfUL *label = (mxfUL*)mxf_get_iter_element(&iter);
if (i == 0)
{
CHK_OFAIL(mxf_equals_ul(label, &MXF_EC_L(SD_Unc_625_50i_422_135_FrameWrapped)));
}
else
{
CHK_OFAIL(mxf_equals_ul(label, &MXF_EC_L(BWFFrameWrapped)));
}
i++;
}
/* skip filler and 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(bodyPartition1->indexSID == 0);
CHK_OFAIL(bodyPartition1->bodySID == 2);
CHK_OFAIL(mxf_append_partition(&partitions, bodyPartition1));
/* skip filler and 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(bodyPartition2->indexSID == 0);
CHK_OFAIL(bodyPartition2->bodySID == 3);
CHK_OFAIL(mxf_append_partition(&partitions, bodyPartition2));
/* skip filler and 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(footerPartition->bodySID == 0);
CHK_OFAIL(footerPartition->indexSID == 1);
CHK_OFAIL(mxf_append_partition(&partitions, footerPartition));
mxf_initialise_list_iter(&iter, &footerPartition->essenceContainers);
i = 0;
while (mxf_next_list_iter_element(&iter))
{
mxfUL *label = (mxfUL*)mxf_get_iter_element(&iter);
if (i == 0)
{
CHK_OFAIL(mxf_equals_ul(label, &MXF_EC_L(SD_Unc_625_50i_422_135_FrameWrapped)));
}
else
{
CHK_OFAIL(mxf_equals_ul(label, &MXF_EC_L(BWFFrameWrapped)));
}
i++;
}
mxf_clear_rip(&rip);
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
return 1;
fail:
mxf_clear_rip(&rip);
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
return 0;
}
int archive_mxf_read_footer_metadata(const char* filename, MXFDataModel* dataModel, MXFHeaderMetadata** headerMetadata)
{
MXFPageFile* mxfPageFile = NULL;
MXFFile* mxfFile = NULL;
MXFRIP rip;
MXFRIPEntry* lastRIPEntry = NULL;
mxfKey key;
uint8_t llen;
uint64_t len;
MXFPartition* footerPartition = NULL;
int result = 0;
MXFHeaderMetadata* newHeaderMetadata = NULL;
memset(&rip, 0, sizeof(rip));
/* open MXF file */
if (strstr(filename, "%d") != NULL)
{
CHK_OFAIL_NOMSG(mxf_page_file_open_read(filename, &mxfPageFile));
mxfFile = mxf_page_file_get_file(mxfPageFile);
}
else
{
CHK_OFAIL_NOMSG(mxf_disk_file_open_read(filename, &mxfFile));
}
/* read the RIP */
CHK_OFAIL_NOMSG(mxf_read_rip(mxfFile, &rip));
/* read footer partition pack */
CHK_OFAIL_NOMSG((lastRIPEntry = (MXFRIPEntry*)mxf_get_last_list_element(&rip.entries)) != NULL);
CHK_OFAIL_NOMSG(mxf_file_seek(mxfFile, mxf_get_runin_len(mxfFile) + lastRIPEntry->thisPartition, SEEK_SET));
CHK_OFAIL_NOMSG(mxf_read_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL_NOMSG(mxf_is_partition_pack(&key));
result = 2; /* the file is complete and the presence, or not, of the header metadata will not change */
*headerMetadata = NULL;
CHK_OFAIL_NOMSG(mxf_is_footer_partition_pack(&key));
CHK_OFAIL_NOMSG(mxf_read_partition(mxfFile, &key, &footerPartition));
/* read the header metadata */
CHK_OFAIL_NOMSG(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL_NOMSG(mxf_is_header_metadata(&key));
CHK_OFAIL_NOMSG(mxf_create_header_metadata(&newHeaderMetadata, dataModel));
CHK_OFAIL_NOMSG(mxf_read_header_metadata(mxfFile, newHeaderMetadata,
footerPartition->headerByteCount, &key, llen, len));
mxf_free_partition(&footerPartition);
mxf_clear_rip(&rip);
mxf_file_close(&mxfFile);
*headerMetadata = newHeaderMetadata;
newHeaderMetadata = NULL;
return 1;
fail:
mxf_free_header_metadata(&newHeaderMetadata);
mxf_free_partition(&footerPartition);
mxf_clear_rip(&rip);
mxf_file_close(&mxfFile);
return result;
}
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;
}
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 get_file_partitions(MXFFile *mxfFile, MXFPartition *headerPartition, MXFList *partitions)
{
mxfKey key;
uint8_t llen;
uint64_t len;
MXFPartition *partition = NULL;
MXFPartition *partitionRef;
uint64_t thisPartition;
MXFRIP rip;
MXFRIPEntry *ripEntry;
MXFListIterator iter;
mxf_initialise_list(partitions, free_partition_in_list);
memset(&rip, 0, sizeof(MXFRIP));
/* use the RIP if there is one */
if (mxf_read_rip(mxfFile, &rip))
{
mxf_initialise_list_iter(&iter, &rip.entries);
while (mxf_next_list_iter_element(&iter))
{
ripEntry = (MXFRIPEntry*)mxf_get_iter_element(&iter);
/* seek to partition and read and add to list */
CHK_OFAIL(mxf_file_seek(mxfFile, mxf_get_runin_len(mxfFile) + ripEntry->thisPartition,
SEEK_SET));
CHK_OFAIL(mxf_read_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_partition_pack(&key));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &partition));
CHK_OFAIL(mxf_append_list_element(partitions, partition));
partition = NULL; /* owned by list */
}
}
/* start from footer partition and index back to the header partition */
else
{
if (headerPartition->footerPartition == 0)
{
/* no footer partition or at unknown position, so we only index the header partition */
goto fail;
}
thisPartition = headerPartition->footerPartition;
do
{
/* seek to partition and read and add to list */
CHK_OFAIL(mxf_file_seek(mxfFile, mxf_get_runin_len(mxfFile) + thisPartition, SEEK_SET));
CHK_OFAIL(mxf_read_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_partition_pack(&key));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, &partition));
CHK_OFAIL(mxf_prepend_list_element(partitions, partition));
partitionRef = partition;
partition = NULL; /* owned by list */
thisPartition = partitionRef->previousPartition;
}
while (partitionRef->thisPartition != partitionRef->previousPartition);
}
mxf_clear_rip(&rip);
return 1;
fail:
/* if something failed then just add the header partition
Note: some Omneon files had references to a footer partition which was not
actually present in the file */
mxf_clear_list(partitions);
mxf_free_partition(&partition);
mxf_clear_rip(&rip);
/* create copy of header partition pack */
CHK_ORET(mxf_create_from_partition(headerPartition, &partition));
partition->key = headerPartition->key;
partition->majorVersion = headerPartition->majorVersion;
partition->minorVersion = headerPartition->minorVersion;
partition->kagSize = headerPartition->kagSize;
partition->thisPartition = headerPartition->thisPartition;
partition->previousPartition = headerPartition->previousPartition;
partition->footerPartition = headerPartition->footerPartition;
partition->headerByteCount = headerPartition->headerByteCount;
partition->indexByteCount = headerPartition->indexByteCount;
partition->indexSID = headerPartition->indexSID;
partition->bodyOffset = headerPartition->bodyOffset;
partition->bodySID = headerPartition->bodySID;
/* add partition to list */
if (!mxf_append_list_element(partitions, partition))
{
mxf_free_partition(&partition);
mxf_log_error("Failed to append header partition to list" LOG_LOC_FORMAT, LOG_LOC_PARAMS);
return 0;
}
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;
}
