int mxf_create_list(MXFList **list, free_func_type freeFunc)
{
MXFList *newList;
CHK_MALLOC_ORET(newList, MXFList);
mxf_initialise_list(newList, freeFunc);
*list = newList;
return 1;
}
int mxf_create_partition(MXFPartition **partition)
{
MXFPartition *newPartition;
CHK_MALLOC_ORET(newPartition, MXFPartition);
mxf_initialise_partition(newPartition);
*partition = newPartition;
return 1;
}
static int create_essence_element(const mxfKey *key, uint8_t llen, MXFEssenceElement **essenceElement)
{
MXFEssenceElement *newEssenceElement = NULL;
CHK_MALLOC_ORET(newEssenceElement, MXFEssenceElement);
memset(newEssenceElement, 0, sizeof(MXFEssenceElement));
newEssenceElement->key = *key;
newEssenceElement->llen = llen;
*essenceElement = newEssenceElement;
return 1;
}
static int create_empty_set(const mxfKey* key, MXFMetadataSet** set)
{
MXFMetadataSet* newSet;
CHK_MALLOC_ORET(newSet, MXFMetadataSet);
memset(newSet, 0, sizeof(MXFMetadataSet));
newSet->key = *key;
newSet->instanceUID = g_Null_UUID;
mxf_initialise_list(&newSet->items, free_metadata_item_in_list);
*set = newSet;
return 1;
}
int mxf_append_partition_esscont_label(MXFPartition *partition, const mxfUL *label)
{
mxfUL *newLabel;
CHK_MALLOC_ORET(newLabel, mxfUL);
*newLabel = *label;
CHK_OFAIL(mxf_append_list_element(&partition->essenceContainers, newLabel));
return 1;
fail:
SAFE_FREE(newLabel);
return 0;
}
static int add_metadef_to_list(MXFList* list, const mxfUL* identification, const mxfUUID* instanceUID)
{
MetaDefData* data = NULL;
CHK_MALLOC_ORET(data, MetaDefData);
data->identification = *identification;
data->instanceUID = *instanceUID;
CHK_OFAIL(mxf_append_list_element(list, (void*)data));
data = NULL;
return 1;
fail:
SAFE_FREE(&data);
return 0;
}
int mxf_create_from_partition(const MXFPartition *sourcePartition, MXFPartition **partition)
{
MXFPartition *newPartition;
CHK_MALLOC_ORET(newPartition, MXFPartition);
if (!mxf_initialise_with_partition(sourcePartition, newPartition))
{
goto fail;
}
*partition = newPartition;
return 1;
fail:
mxf_free_partition(&newPartition);
return 0;
}
int mxf_create_header_metadata(MXFHeaderMetadata** headerMetadata, MXFDataModel* dataModel)
{
MXFHeaderMetadata* newHeaderMetadata;
CHK_MALLOC_ORET(newHeaderMetadata, MXFHeaderMetadata);
memset(newHeaderMetadata, 0, sizeof(MXFHeaderMetadata));
newHeaderMetadata->dataModel = dataModel;
mxf_initialise_list(&newHeaderMetadata->sets, free_metadata_set_in_list);
CHK_OFAIL(mxf_create_primer_pack(&newHeaderMetadata->primerPack));
*headerMetadata = newHeaderMetadata;
return 1;
fail:
mxf_free_header_metadata(&newHeaderMetadata);
return 0;
}
int mxf_page_file_open_new(const char *filenameTemplate, int64_t pageSize, MXFPageFile **mxfPageFile)
{
MXFFile *newMXFFile = NULL;
if (strstr(filenameTemplate, "%d") == NULL)
{
mxf_log_error("Filename template '%s' doesn't contain %%d\n", filenameTemplate);
return 0;
}
CHK_MALLOC_ORET(newMXFFile, MXFFile);
memset(newMXFFile, 0, sizeof(*newMXFFile));
newMXFFile->close = page_file_close;
newMXFFile->read = page_file_read;
newMXFFile->write = page_file_write;
newMXFFile->get_char = page_file_getchar;
newMXFFile->put_char = page_file_putchar;
newMXFFile->eof = page_file_eof;
newMXFFile->seek = page_file_seek;
newMXFFile->tell = page_file_tell;
newMXFFile->is_seekable = page_file_is_seekable;
newMXFFile->size = page_file_size;
newMXFFile->free_sys_data = free_page_file;
CHK_MALLOC_OFAIL(newMXFFile->sysData, MXFFileSysData);
memset(newMXFFile->sysData, 0, sizeof(*newMXFFile->sysData));
CHK_OFAIL((newMXFFile->sysData->filenameTemplate = strdup(filenameTemplate)) != NULL);
newMXFFile->sysData->pageSize = pageSize;
newMXFFile->sysData->mode = WRITE_MODE;
newMXFFile->sysData->mxfPageFile.mxfFile = newMXFFile;
*mxfPageFile = &newMXFFile->sysData->mxfPageFile;
return 1;
fail:
if (newMXFFile != NULL)
{
mxf_file_close(&newMXFFile);
}
return 0;
}
static int add_weakref_to_list(MXFList* list, MXFMetadataItem* item, int arrayIndex, const mxfUL* targetIdentification)
{
WeakRefData* data = NULL;
CHK_MALLOC_ORET(data, WeakRefData);
data->item = item;
data->arrayIndex = arrayIndex;
data->targetIdentification = *targetIdentification;
CHK_OFAIL(mxf_append_list_element(list, (void*)data));
data = NULL;
return 1;
fail:
SAFE_FREE(&data);
return 0;
}
int mxf_mem_file_open_read(const unsigned char *data, int64_t size, int64_t virtualStartPos, MXFMemoryFile **mxfMemFile)
{
MXFFile *newMXFFile = NULL;
CHK_MALLOC_ORET(newMXFFile, MXFFile);
memset(newMXFFile, 0, sizeof(*newMXFFile));
newMXFFile->close = mem_file_close;
newMXFFile->read = mem_file_read;
newMXFFile->write = mem_file_write;
newMXFFile->get_char = mem_file_getchar;
newMXFFile->put_char = mem_file_putchar;
newMXFFile->eof = mem_file_eof;
newMXFFile->seek = mem_file_seek;
newMXFFile->tell = mem_file_tell;
newMXFFile->is_seekable = mem_file_is_seekable;
newMXFFile->size = mem_file_size;
newMXFFile->free_sys_data = free_mem_file;
CHK_MALLOC_OFAIL(newMXFFile->sysData, MXFFileSysData);
memset(newMXFFile->sysData, 0, sizeof(*newMXFFile->sysData));
newMXFFile->sysData->virtualStartPos = virtualStartPos;
newMXFFile->sysData->readOnly = 1;
newMXFFile->sysData->mxfMemFile.mxfFile = newMXFFile;
CHK_MALLOC_OFAIL(newMXFFile->sysData->chunks, Chunk);
newMXFFile->sysData->chunks->data = (unsigned char*)data;
newMXFFile->sysData->chunks->allocSize = size;
newMXFFile->sysData->chunks->size = size;
newMXFFile->sysData->numChunks++;
*mxfMemFile = &newMXFFile->sysData->mxfMemFile;
return 1;
fail:
if (newMXFFile)
mxf_file_close(&newMXFFile);
return 0;
}
int mxf_create_item(MXFMetadataSet* set, const mxfKey* key, mxfLocalTag tag, MXFMetadataItem** item)
{
MXFMetadataItem* newItem;
CHK_MALLOC_ORET(newItem, MXFMetadataItem);
memset(newItem, 0, sizeof(MXFMetadataItem));
newItem->tag = tag;
newItem->isPersistent = 0;
newItem->key = *key;
CHK_OFAIL(add_item(set, newItem));
*item = newItem;
return 1;
fail:
mxf_free_item(&newItem);
return 0;
}
int mxf_append_list_element(MXFList *list, void *data)
{
MXFListElement *newElement;
CHK_ORET(list->len + 1 != MXF_LIST_NPOS);
CHK_MALLOC_ORET(newElement, MXFListElement);
memset(newElement, 0, sizeof(MXFListElement));
newElement->data = data;
if (!list->elements)
list->elements = newElement;
else
list->lastElement->next = newElement;
list->lastElement = newElement;
list->len++;
return 1;
}
int mxf_append_list_element(MXFList* list, void* data)
{
MXFListElement* newElement;
CHK_MALLOC_ORET(newElement, MXFListElement);
memset(newElement, 0, sizeof(MXFListElement));
newElement->data = data;
if (list->elements == NULL)
{
list->elements = newElement;
}
else
{
list->lastElement->next = newElement;
}
list->lastElement = newElement;
list->len++;
return 1;
}
int xml_writer_open(const char* filename, XMLWriter** writer)
{
XMLWriter* newWriter;
CHK_MALLOC_ORET(newWriter, XMLWriter);
memset(newWriter, 0, sizeof(XMLWriter));
newWriter->previousWrite = ELEMENT_END;
if ((newWriter->file = fopen(filename, "wb")) == NULL)
{
mxf_log_error("Failed to open xml file '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
goto fail;
}
CHK_OFAIL(fprintf(newWriter->file, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>") > 0);
*writer = newWriter;
return 1;
fail:
SAFE_FREE(&newWriter);
return 0;
}
int mxf_mem_file_open_new(uint32_t chunkSize, int64_t virtualStartPos, MXFMemoryFile **mxfMemFile)
{
MXFFile *newMXFFile = NULL;
CHK_MALLOC_ORET(newMXFFile, MXFFile);
memset(newMXFFile, 0, sizeof(*newMXFFile));
newMXFFile->close = mem_file_close;
newMXFFile->read = mem_file_read;
newMXFFile->write = mem_file_write;
newMXFFile->get_char = mem_file_getchar;
newMXFFile->put_char = mem_file_putchar;
newMXFFile->eof = mem_file_eof;
newMXFFile->seek = mem_file_seek;
newMXFFile->tell = mem_file_tell;
newMXFFile->is_seekable = mem_file_is_seekable;
newMXFFile->size = mem_file_size;
newMXFFile->free_sys_data = free_mem_file;
CHK_MALLOC_OFAIL(newMXFFile->sysData, MXFFileSysData);
memset(newMXFFile->sysData, 0, sizeof(*newMXFFile->sysData));
newMXFFile->sysData->chunkSize = (chunkSize == 0 ? DEFAULT_CHUNK_SIZE : chunkSize);
newMXFFile->sysData->virtualStartPos = virtualStartPos;
newMXFFile->sysData->mxfMemFile.mxfFile = newMXFFile;
*mxfMemFile = &newMXFFile->sysData->mxfMemFile;
return 1;
fail:
if (newMXFFile)
mxf_file_close(&newMXFFile);
return 0;
}
int mxf_insert_list_element(MXFList* list, long index, int before, void* data)
{
MXFListElement* newElement;
MXFListElement* nextElement;
MXFListElement* prevElement;
long currentIndex;
/* create new element */
CHK_MALLOC_ORET(newElement, MXFListElement);
memset(newElement, 0, sizeof(MXFListElement));
newElement->data = data;
/* special case when list is empty */
if (list->elements == NULL)
{
list->elements = newElement;
list->lastElement = newElement;
list->len++;
return 1;
}
nextElement = list->elements;
prevElement = NULL;
currentIndex = 0;
if (before)
{
/* move to index position */
while (currentIndex < index && nextElement != NULL)
{
prevElement = nextElement;
nextElement = nextElement->next;
currentIndex++;
}
if (currentIndex != index)
{
goto fail;
}
}
else
{
/* move to after index position */
while (currentIndex <= index && nextElement != NULL)
{
prevElement = nextElement;
nextElement = nextElement->next;
currentIndex++;
}
if (currentIndex != index + 1)
{
goto fail;
}
}
/* insert element */
if (prevElement == NULL)
{
list->elements = newElement;
}
else
{
prevElement->next = newElement;
}
newElement->next = nextElement;
if (newElement->next == NULL)
{
list->lastElement = newElement;
}
list->len++;
return 1;
fail:
SAFE_FREE(&newElement);
return 0;
}
int mxf_insert_list_element(MXFList *list, size_t index, int before, void *data)
{
MXFListElement *newElement;
MXFListElement *nextElement;
MXFListElement *prevElement;
size_t currentIndex;
CHK_ORET(list->len + 1 != MXF_LIST_NPOS);
if (index == MXF_LIST_NPOS)
return 0;
/* create new element */
CHK_MALLOC_ORET(newElement, MXFListElement);
memset(newElement, 0, sizeof(MXFListElement));
newElement->data = data;
/* special case when list is empty */
if (!list->elements) {
list->elements = newElement;
list->lastElement = newElement;
list->len++;
return 1;
}
nextElement = list->elements;
prevElement = NULL;
currentIndex = 0;
if (before) {
/* move to index position */
while (currentIndex < index && nextElement) {
prevElement = nextElement;
nextElement = nextElement->next;
currentIndex++;
}
if (currentIndex != index)
goto fail;
} else {
/* move to after index position */
while (currentIndex <= index && nextElement) {
prevElement = nextElement;
nextElement = nextElement->next;
currentIndex++;
}
if (currentIndex != index + 1)
goto fail;
}
/* insert element */
if (!prevElement)
list->elements = newElement;
else
prevElement->next = newElement;
newElement->next = nextElement;
if (!newElement->next)
list->lastElement = newElement;
list->len++;
return 1;
fail:
SAFE_FREE(newElement);
return 0;
}
int mxf_page_file_open_modify(const char *filenameTemplate, int64_t pageSize, MXFPageFile **mxfPageFile)
{
MXFFile *newMXFFile = NULL;
int pageCount;
int allocatedPages;
char filename[4096];
FILE *file;
int64_t fileSize;
if (strstr(filenameTemplate, "%d") == NULL)
{
mxf_log_error("Filename template '%s' doesn't contain %%d\n", filenameTemplate);
return 0;
}
/* count number of page files */
pageCount = 0;
for(;;)
{
mxf_snprintf(filename, sizeof(filename), filenameTemplate, pageCount);
if ((file = fopen(filename, "rb")) == NULL)
{
break;
}
fclose(file);
pageCount++;
}
if (pageCount == 0)
{
/* file not found */
return 0;
}
/* check the size of the first file equals the pageSize */
if (pageCount > 1)
{
mxf_snprintf(filename, sizeof(filename), filenameTemplate, 0);
fileSize = disk_file_size(filename);
if (fileSize < 0)
{
mxf_log_error("Failed to stat file '%s': %s\n", filename, strerror(errno));
return 0;
}
if (pageSize != fileSize)
{
mxf_log_error("Size of first file '%s' (%"PRId64" does not equal page size %"PRId64"\n", filename, fileSize, pageSize);
return 0;
}
}
CHK_MALLOC_ORET(newMXFFile, MXFFile);
memset(newMXFFile, 0, sizeof(*newMXFFile));
newMXFFile->close = page_file_close;
newMXFFile->read = page_file_read;
newMXFFile->write = page_file_write;
newMXFFile->get_char = page_file_getchar;
newMXFFile->put_char = page_file_putchar;
newMXFFile->eof = page_file_eof;
newMXFFile->seek = page_file_seek;
newMXFFile->tell = page_file_tell;
newMXFFile->is_seekable = page_file_is_seekable;
newMXFFile->size = page_file_size;
newMXFFile->free_sys_data = free_page_file;
CHK_MALLOC_OFAIL(newMXFFile->sysData, MXFFileSysData);
memset(newMXFFile->sysData, 0, sizeof(*newMXFFile->sysData));
CHK_OFAIL((newMXFFile->sysData->filenameTemplate = strdup(filenameTemplate)) != NULL);
newMXFFile->sysData->pageSize = pageSize;
newMXFFile->sysData->mode = MODIFY_MODE;
newMXFFile->sysData->mxfPageFile.mxfFile = newMXFFile;
/* allocate pages */
allocatedPages = (pageCount < PAGE_ALLOC_INCR) ? PAGE_ALLOC_INCR : pageCount;
CHK_MALLOC_ARRAY_ORET(newMXFFile->sysData->pages, Page, allocatedPages);
memset(newMXFFile->sysData->pages, 0, allocatedPages * sizeof(Page));
newMXFFile->sysData->numPages = pageCount;
newMXFFile->sysData->numPagesAllocated = allocatedPages;
for (pageCount = 0; pageCount < newMXFFile->sysData->numPages; pageCount++)
{
newMXFFile->sysData->pages[pageCount].index = pageCount;
newMXFFile->sysData->pages[pageCount].size = pageSize;
}
/* set the files size of the last file, which could have size < pageSize */
mxf_snprintf(filename, sizeof(filename), filenameTemplate, newMXFFile->sysData->numPages - 1);
fileSize = disk_file_size(filename);
if (fileSize < 0)
{
mxf_log_error("Failed to stat file '%s': %s\n", filename, strerror(errno));
goto fail;
}
newMXFFile->sysData->pages[newMXFFile->sysData->numPages - 1].size = fileSize;
*mxfPageFile = &newMXFFile->sysData->mxfPageFile;
return 1;
fail:
if (newMXFFile != NULL)
{
mxf_file_close(&newMXFFile);
}
return 0;
}
