int test_modify(const char* filename)
{
MXFFile* mxfFile = NULL;
if (!mxf_disk_file_open_modify(filename, &mxfFile))
{
mxf_log_error("Failed to open modify '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
return 0;
}
/* TEST */
CHK_OFAIL(do_write(mxfFile));
mxf_file_close(&mxfFile);
CHK_OFAIL(test_read(filename));
return 1;
fail:
mxf_file_close(&mxfFile);
return 0;
}
int main(int argv, const char* argc[])
{
FILE* dv50File = NULL;
MXFFile* mxfFile = NULL;
int result;
int cmdlnIndex = 1;
int test = 0;
if (argv < 3 || argv > 4)
{
usage(argc[0]);
return 1;
}
if (argv == 4)
{
if (strcmp(argc[cmdlnIndex], "--test") != 0)
{
usage(argc[0]);
return 1;
}
test = 1;
cmdlnIndex++;
}
if ((dv50File = fopen(argc[cmdlnIndex], "rb")) == NULL)
{
fprintf(stderr, "Failed to open %s for reading\n", argc[1]);
return 1;
}
cmdlnIndex++;
if (!mxf_disk_file_open_new(argc[cmdlnIndex], &mxfFile))
{
fprintf(stderr, "Failed to open %s for writing\n", argc[2]);
fclose(dv50File);
return 1;
}
cmdlnIndex++;
if (!write_dv50(dv50File, mxfFile, test))
{
result = 1;
}
else
{
result = 0;
}
fclose(dv50File);
mxf_file_close(&mxfFile);
return result;
}
int archive_mxf_is_metadata_only(const char* filename)
{
MXFPageFile* mxfPageFile = NULL;
MXFFile* mxfFile = NULL;
mxfKey key;
uint8_t llen;
uint64_t len;
MXFPartition* headerPartition = NULL;
int result;
/* 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 header partition pack */
if (!mxf_read_header_pp_kl_with_runin(mxfFile, &key, &llen, &len) ||
!mxf_read_partition(mxfFile, &key, &headerPartition))
{
return 0;
}
/* check whether there is an essence container label */
result = (mxf_get_list_length(&headerPartition->essenceContainers) == 0);
mxf_free_partition(&headerPartition);
mxf_file_close(&mxfFile);
return result;
fail:
mxf_free_partition(&headerPartition);
mxf_file_close(&mxfFile);
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;
}
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_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 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 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;
}
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;
}
int test_create_and_write(const char *filename)
{
MXFFile *mxfFile = NULL;
uint8_t runin[RUNIN_LEN];
MXFFilePartitions partitions;
MXFPartition *headerPartition = NULL;
MXFPartition *bodyPartition1 = NULL;
MXFPartition *bodyPartition2 = NULL;
MXFPartition *footerPartition = NULL;
if (!mxf_disk_file_open_new(filename, &mxfFile))
{
mxf_log_error("Failed to create '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
return 0;
}
mxf_initialise_file_partitions(&partitions);
/* TEST */
/* write 8 bytes of runin */
memset(runin, 0, RUNIN_LEN);
CHK_OFAIL(mxf_file_write(mxfFile, runin, RUNIN_LEN) == RUNIN_LEN);
/* write the header pp */
CHK_OFAIL(mxf_append_new_partition(&partitions, &headerPartition));
headerPartition->key = MXF_PP_K(ClosedComplete, Header);
headerPartition->indexSID = 1;
CHK_OFAIL(mxf_append_partition_esscont_label(headerPartition, &MXF_EC_L(SD_Unc_625_50i_422_135_FrameWrapped)));
CHK_OFAIL(mxf_append_partition_esscont_label(headerPartition, &MXF_EC_L(BWFFrameWrapped)));
CHK_OFAIL(mxf_write_partition(mxfFile, headerPartition));
/* write empty header metadata */
CHK_OFAIL(mxf_mark_header_start(mxfFile, headerPartition));
CHK_OFAIL(mxf_allocate_space(mxfFile, 1024));
CHK_OFAIL(mxf_mark_header_end(mxfFile, headerPartition));
/* write the body pp 1 */
CHK_OFAIL(mxf_append_new_from_partition(&partitions, headerPartition, &bodyPartition1));
bodyPartition1->key = MXF_PP_K(ClosedComplete, Body);
bodyPartition1->bodySID = 2;
CHK_OFAIL(mxf_write_partition(mxfFile, bodyPartition1));
/* write the body pp 2, with KAG 256 */
CHK_OFAIL(mxf_append_new_from_partition(&partitions, headerPartition, &bodyPartition2));
bodyPartition2->key = MXF_PP_K(ClosedComplete, Body);
bodyPartition2->bodySID = 3;
bodyPartition2->kagSize = 256;
CHK_OFAIL(mxf_write_partition(mxfFile, bodyPartition2));
CHK_OFAIL(mxf_fill_to_kag(mxfFile, bodyPartition2));
/* write the footer pp */
CHK_OFAIL(mxf_append_new_from_partition(&partitions, headerPartition, &footerPartition));
footerPartition->key = MXF_PP_K(ClosedComplete, Footer);
footerPartition->indexSID = 1;
CHK_OFAIL(mxf_write_partition(mxfFile, footerPartition));
/* write RIP */
CHK_OFAIL(mxf_write_rip(mxfFile, &partitions));
/* update the partitions */
CHK_OFAIL(mxf_update_partitions(mxfFile, &partitions));
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
return 1;
fail:
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
return 0;
}
int test_read(const char *filename)
{
MXFFile *mxfFile = NULL;
MXFFilePartitions partitions;
MXFPartition *headerPartition = NULL;
mxfKey key;
uint8_t llen;
uint64_t len;
int i;
int k;
MXFIndexTableSegment *indexSegment = NULL;
MXFDeltaEntry *deltaEntry;
MXFIndexEntry *indexEntry;
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);
/* read header pp */
CHK_OFAIL(mxf_read_header_pp_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_read_partition(mxfFile, &key, len, &headerPartition));
CHK_OFAIL(mxf_append_partition(&partitions, headerPartition));
/* TEST */
/* read index table segment */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_index_table_segment(&key));
CHK_OFAIL(mxf_read_index_table_segment(mxfFile, len, &indexSegment));
CHK_OFAIL(indexSegment->indexEditRate.numerator == 25 && indexSegment->indexEditRate.denominator == 1);
CHK_OFAIL(indexSegment->indexStartPosition == 0);
CHK_OFAIL(indexSegment->indexDuration == 0x64);
CHK_OFAIL(indexSegment->editUnitByteCount == 0x100);
CHK_OFAIL(indexSegment->indexSID == 1);
CHK_OFAIL(indexSegment->bodySID == 2);
CHK_OFAIL(indexSegment->sliceCount == 0);
CHK_OFAIL(indexSegment->posTableCount == 0);
CHK_OFAIL(indexSegment->extStartOffset == 0);
CHK_OFAIL(indexSegment->vbeByteCount == 0);
CHK_OFAIL(indexSegment->singleIndexLocation == MXF_OPT_BOOL_NOT_PRESENT);
CHK_OFAIL(indexSegment->singleEssenceLocation == MXF_OPT_BOOL_NOT_PRESENT);
CHK_OFAIL(indexSegment->forwardIndexDirection == MXF_OPT_BOOL_NOT_PRESENT);
CHK_OFAIL(indexSegment->deltaEntryArray != 0);
CHK_OFAIL(indexSegment->indexEntryArray == 0);
deltaEntry = indexSegment->deltaEntryArray;
for (i = 0; i < 4; i++)
{
CHK_OFAIL(deltaEntry != 0);
CHK_OFAIL(deltaEntry->posTableIndex == i);
CHK_OFAIL(deltaEntry->slice == i);
CHK_OFAIL((int)deltaEntry->elementData == i);
deltaEntry = deltaEntry->next;
}
mxf_free_index_table_segment(&indexSegment);
/* read index table segment */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_index_table_segment(&key));
CHK_OFAIL(mxf_read_index_table_segment(mxfFile, len, &indexSegment));
CHK_OFAIL(indexSegment->indexEditRate.numerator == 25 && indexSegment->indexEditRate.denominator == 1);
CHK_OFAIL(indexSegment->indexStartPosition == 0);
CHK_OFAIL(indexSegment->indexDuration == 0x0a);
CHK_OFAIL(indexSegment->editUnitByteCount == 0);
CHK_OFAIL(indexSegment->indexSID == 1);
CHK_OFAIL(indexSegment->bodySID == 2);
CHK_OFAIL(indexSegment->sliceCount == 2);
CHK_OFAIL(indexSegment->posTableCount == 2);
CHK_OFAIL(indexSegment->extStartOffset == 0);
CHK_OFAIL(indexSegment->vbeByteCount == 1);
CHK_OFAIL(indexSegment->singleIndexLocation == MXF_OPT_BOOL_NOT_PRESENT);
CHK_OFAIL(indexSegment->singleEssenceLocation == MXF_OPT_BOOL_TRUE);
CHK_OFAIL(indexSegment->forwardIndexDirection == MXF_OPT_BOOL_FALSE);
CHK_OFAIL(indexSegment->deltaEntryArray == 0);
CHK_OFAIL(indexSegment->indexEntryArray != 0);
indexEntry = indexSegment->indexEntryArray;
for (i = 0; i < indexSegment->indexDuration; i++)
{
CHK_OFAIL(indexEntry != 0);
CHK_OFAIL(indexEntry->temporalOffset == i);
CHK_OFAIL(indexEntry->keyFrameOffset == i);
CHK_OFAIL(indexEntry->flags == i);
CHK_OFAIL((int)indexEntry->streamOffset == i);
for (k = 0; k < indexSegment->sliceCount; k++)
{
CHK_OFAIL((int)indexEntry->sliceOffset[k] == i);
}
for (k = 0; k < indexSegment->posTableCount; k++)
{
CHK_OFAIL(indexEntry->posTable[k].numerator == i);
CHK_OFAIL(indexEntry->posTable[k].denominator == i + 1);
}
indexEntry = indexEntry->next;
}
mxf_free_index_table_segment(&indexSegment);
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
return 1;
fail:
mxf_free_index_table_segment(&indexSegment);
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
return 0;
}
int test_create_and_write(const char *filename)
{
MXFFile *mxfFile = NULL;
MXFFilePartitions partitions;
MXFPartition *headerPartition = NULL;
MXFIndexTableSegment *indexSegment = NULL;
uint32_t sliceOffset[2];
mxfRational posTable[2];
const mxfRational editRate = {25, 1};
int i;
int k;
if (!mxf_disk_file_open_new(filename, &mxfFile))
{
mxf_log_error("Failed to create '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
return 0;
}
mxf_initialise_file_partitions(&partitions);
/* TEST */
/* write the header pp */
CHK_OFAIL(mxf_append_new_partition(&partitions, &headerPartition));
headerPartition->key = MXF_PP_K(ClosedComplete, Header);
headerPartition->kagSize = 256;
CHK_OFAIL(mxf_write_partition(mxfFile, headerPartition));
/* write index table segment */
CHK_OFAIL(mxf_mark_index_start(mxfFile, headerPartition));
CHK_OFAIL(mxf_create_index_table_segment(&indexSegment));
mxf_generate_uuid(&indexSegment->instanceUID);
indexSegment->indexEditRate = editRate;
indexSegment->indexDuration = 0x64;
indexSegment->editUnitByteCount = 0x100;
indexSegment->indexSID = 1;
indexSegment->bodySID = 2;
for (i = 0; i < 4; i++)
{
CHK_OFAIL(mxf_default_add_delta_entry(NULL, 0, indexSegment, i, i, i));
}
CHK_OFAIL(mxf_write_index_table_segment(mxfFile, indexSegment));
CHK_OFAIL(mxf_fill_to_kag(mxfFile, headerPartition));
CHK_OFAIL(mxf_mark_index_end(mxfFile, headerPartition));
mxf_free_index_table_segment(&indexSegment);
/* write index table segment */
CHK_OFAIL(mxf_mark_index_start(mxfFile, headerPartition));
CHK_OFAIL(mxf_create_index_table_segment(&indexSegment));
mxf_generate_uuid(&indexSegment->instanceUID);
indexSegment->indexEditRate = editRate;
indexSegment->indexDuration = 0x0a;
indexSegment->editUnitByteCount = 0;
indexSegment->indexSID = 1;
indexSegment->bodySID = 2;
indexSegment->sliceCount = 2;
indexSegment->posTableCount = 2;
indexSegment->vbeByteCount = 1;
indexSegment->singleEssenceLocation = MXF_OPT_BOOL_TRUE;
indexSegment->forwardIndexDirection = MXF_OPT_BOOL_FALSE;
for (i = 0; i < indexSegment->indexDuration; i++)
{
for (k = 0; k < indexSegment->sliceCount; k++)
{
sliceOffset[k] = i;
}
for (k = 0; k < indexSegment->posTableCount; k++)
{
posTable[k].numerator = i;
posTable[k].denominator = i + 1;
}
CHK_OFAIL(mxf_default_add_index_entry(NULL, 0, indexSegment, i, i, i, i,
sliceOffset, posTable));
}
CHK_OFAIL(mxf_write_index_table_segment(mxfFile, indexSegment));
CHK_OFAIL(mxf_fill_to_kag(mxfFile, headerPartition));
CHK_OFAIL(mxf_mark_index_end(mxfFile, headerPartition));
/* update the partitions */
CHK_OFAIL(mxf_update_partitions(mxfFile, &partitions));
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
mxf_free_index_table_segment(&indexSegment);
return 1;
fail:
mxf_file_close(&mxfFile);
mxf_clear_file_partitions(&partitions);
mxf_free_index_table_segment(&indexSegment);
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 test_create_and_write(const char *filename)
{
MXFFile *mxfFile = NULL;
MXFFilePartitions partitions;
MXFPartition *headerPartition = NULL;
MXFPartition *bodyPartition1 = NULL;
MXFPartition *bodyPartition2 = NULL;
MXFPartition *footerPartition = NULL;
MXFEssenceElement *essenceElement = NULL;
uint8_t essenceData[1024];
memset(essenceData, 0, 1024);
if (!mxf_disk_file_open_new(filename, &mxfFile))
{
mxf_log_error("Failed to create '%s'" LOG_LOC_FORMAT, filename, LOG_LOC_PARAMS);
return 0;
}
mxf_initialise_file_partitions(&partitions);
/* TEST */
/* write the header pp */
CHK_OFAIL(mxf_append_new_partition(&partitions, &headerPartition));
headerPartition->key = MXF_PP_K(ClosedComplete, Header);
headerPartition->bodySID = 1;
CHK_OFAIL(mxf_append_partition_esscont_label(headerPartition, &MXF_EC_L(BWFFrameWrapped)));
CHK_OFAIL(mxf_append_partition_esscont_label(headerPartition, &MXF_EC_L(BWFClipWrapped)));
CHK_OFAIL(mxf_write_partition(mxfFile, headerPartition));
/* write essence element directly */
CHK_OFAIL(mxf_write_fixed_kl(mxfFile, &g_bwfFrameWrappedEEKey, 4, 256));
CHK_OFAIL(mxf_file_write(mxfFile, essenceData, 256));
/* write the body pp 1 */
CHK_OFAIL(mxf_append_new_from_partition(&partitions, headerPartition, &bodyPartition1));
bodyPartition1->key = MXF_PP_K(ClosedComplete, Body);
bodyPartition1->bodySID = 2;
CHK_OFAIL(mxf_write_partition(mxfFile, bodyPartition1));
/* write using MXFEssenceElement with known length */
CHK_OFAIL(mxf_open_essence_element_write(mxfFile, &g_bwfClipWrappedEEKey, 8, 1024, &essenceElement));
CHK_OFAIL(mxf_write_essence_element_data(mxfFile, essenceElement, essenceData, 1024));
mxf_close_essence_element(&essenceElement);
/* write the body pp 2 */
CHK_OFAIL(mxf_append_new_from_partition(&partitions, headerPartition, &bodyPartition2));
bodyPartition2->key = MXF_PP_K(ClosedComplete, Body);
bodyPartition2->bodySID = 3;
CHK_OFAIL(mxf_write_partition(mxfFile, bodyPartition2));
/* write using MXFEssenceElement with uknown length */
CHK_OFAIL(mxf_open_essence_element_write(mxfFile, &g_bwfClipWrappedEEKey, 8, 0, &essenceElement));
CHK_OFAIL(mxf_write_essence_element_data(mxfFile, essenceElement, essenceData, 256));
CHK_OFAIL(mxf_write_essence_element_data(mxfFile, essenceElement, essenceData, 512));
CHK_OFAIL(mxf_write_essence_element_data(mxfFile, essenceElement, essenceData, 256));
CHK_ORET(mxf_finalize_essence_element_write(mxfFile, essenceElement));
mxf_close_essence_element(&essenceElement);
/* write the footer pp */
CHK_OFAIL(mxf_append_new_from_partition(&partitions, headerPartition, &footerPartition));
footerPartition->key = MXF_PP_K(ClosedComplete, Footer);
CHK_OFAIL(mxf_write_partition(mxfFile, footerPartition));
/* update the partitions */
CHK_OFAIL(mxf_update_partitions(mxfFile, &partitions));
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 test1(const char* mxfFilename, MXFTimecode* startTimecode, int sourceTimecodeCount, const char* outFilename)
{
MXFReader* input;
MXFClip* clip;
int64_t frameCount;
int64_t frameNumber;
MXFReaderListenerData data;
MXFReaderListener listener;
MXFFile* stdinMXFFile = NULL;
MXFTimecode playoutTimecode;
int i;
MXFTimecode sourceTimecode;
int type;
int count;
int result;
uint32_t archiveCRC32;
memset(&data, 0, sizeof(MXFReaderListenerData));
listener.data = &data;
listener.accept_frame = accept_frame;
listener.allocate_buffer = allocate_buffer;
listener.deallocate_buffer = deallocate_buffer;
listener.receive_frame = receive_frame;
if (strcmp("-", mxfFilename) != 0)
{
if (!open_mxf_reader(mxfFilename, &input))
{
fprintf(stderr, "Failed to open MXF reader\n");
return 0;
}
}
else
{
if (!mxf_stdin_wrap_read(&stdinMXFFile))
{
fprintf(stderr, "Failed to open standard input MXF file\n");
return 0;
}
if (!init_mxf_reader(&stdinMXFFile, &input))
{
mxf_file_close(&stdinMXFFile);
fprintf(stderr, "Failed to open MXF reader using standard input\n");
return 0;
}
}
listener.data->input = input;
if ((data.outFile = fopen(outFilename, "wb")) == NULL)
{
fprintf(stderr, "Failed to open output data file\n");
return 0;
}
clip = get_mxf_clip(input);
printf("Clip frame rate = %d/%d fps\n", clip->frameRate.numerator, clip->frameRate.denominator);
printf("Clip duration = %"PFi64" frames\n", clip->duration);
if (startTimecode->hour != INVALID_TIMECODE_HOUR)
{
if (sourceTimecodeCount < 0)
{
if (!position_at_playout_timecode(input, startTimecode))
{
fprintf(stderr, "Failed to position files at start playout timecode\n");
return 0;
}
}
else
{
if (!position_at_source_timecode(input, startTimecode, SYSTEM_ITEM_TC_ARRAY_TIMECODE,
sourceTimecodeCount))
{
fprintf(stderr, "Failed to position files at start source timecode\n");
return 0;
}
}
}
frameCount = 0;
while (read_next_frame(input, &listener) == 1)
{
frameNumber = get_frame_number(input);
printf("frame = %"PFi64"\n", frameNumber);
get_playout_timecode(input, &playoutTimecode);
printf("playout timecode = ");
print_timecode(&playoutTimecode);
printf("\n");
for (i = 0; i < get_num_source_timecodes(input); i++)
{
if ((result = get_source_timecode(input, i, &sourceTimecode, &type, &count)) == 1)
{
printf("source timecode (type = %d, count = %d) = ", type, count);
print_timecode(&sourceTimecode);
printf("\n");
}
else if (result == -1)
{
printf("source timecode (type = %d, count = %d) unavailable", type, count);
printf("\n");
}
}
for (i = 0; i < get_num_archive_crc32(input); i++)
{
if (get_archive_crc32(input, i, &archiveCRC32))
{
printf("crc32 %d = 0x%08x\n", i, archiveCRC32);
}
else
{
printf("Failed to get archive crc-32\n");
}
}
frameCount++;
}
if (clip->duration != -1 && frameCount != clip->duration)
{
fprintf(stderr, "1) Frame count %"PFi64" != duration %"PFi64"\n", frameCount, clip->duration);
return 0;
}
close_mxf_reader(&input);
fclose(data.outFile);
if (data.buffer != NULL)
{
free(data.buffer);
}
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;
}
static int test3(const char* mxfFilename, const char* outFilename)
{
MXFReader* input;
int64_t frameCount;
MXFClip* clip;
MXFReaderListenerData data;
MXFReaderListener listener;
int64_t frameNumber;
MXFFile* stdinMXFFile = NULL;
MXFTimecode playoutTimecode;
int i;
MXFTimecode sourceTimecode;
int type;
int count;
int result;
memset(&data, 0, sizeof(MXFReaderListenerData));
listener.data = &data;
listener.accept_frame = accept_frame;
listener.allocate_buffer = allocate_buffer;
listener.deallocate_buffer = deallocate_buffer;
listener.receive_frame = receive_frame;
if (strcmp("-", mxfFilename) != 0)
{
if (!open_mxf_reader(mxfFilename, &input))
{
fprintf(stderr, "Failed to open MXF reader\n");
return 0;
}
}
else
{
if (!mxf_stdin_wrap_read(&stdinMXFFile))
{
fprintf(stderr, "Failed to open standard input MXF file\n");
return 0;
}
if (!init_mxf_reader(&stdinMXFFile, &input))
{
mxf_file_close(&stdinMXFFile);
fprintf(stderr, "Failed to open MXF reader using standard input\n");
return 0;
}
}
listener.data->input = input;
if ((data.outFile = fopen(outFilename, "wb")) == NULL)
{
fprintf(stderr, "Failed to open output data file\n");
return 0;
}
clip = get_mxf_clip(input);
if (!position_at_frame(input, 10))
{
fprintf(stderr, "Failed to position at frame 10\n");
return 0;
}
frameCount = 10;
while (read_next_frame(input, &listener) == 1)
{
frameNumber = get_frame_number(input);
printf("frame = %"PFi64"\n", frameNumber);
get_playout_timecode(input, &playoutTimecode);
printf("playout timecode = ");
print_timecode(&playoutTimecode);
printf("\n");
for (i = 0; i < get_num_source_timecodes(input); i++)
{
if ((result = get_source_timecode(input, i, &sourceTimecode, &type, &count)) == 1)
{
printf("source timecode (type = %d, count = %d) = ", type, count);
print_timecode(&sourceTimecode);
printf("\n");
}
else if (result == -1)
{
printf("source timecode (type = %d, count = %d) unavailable", type, count);
printf("\n");
}
}
frameCount++;
}
if (clip->duration != -1 && frameCount != clip->duration)
{
fprintf(stderr, "2) Frame count %"PFi64" != duration %"PFi64"\n", frameCount, clip->duration);
return 0;
}
if (!position_at_frame(input, 0))
{
fprintf(stderr, "Failed to position at frame 0\n");
return 0;
}
frameCount = 0;
while (read_next_frame(input, &listener) == 1)
{
frameNumber = get_frame_number(input);
printf("frame = %"PFi64"\n", frameNumber);
get_playout_timecode(input, &playoutTimecode);
printf("playout timecode = ");
print_timecode(&playoutTimecode);
printf("\n");
for (i = 0; i < get_num_source_timecodes(input); i++)
{
if ((result = get_source_timecode(input, i, &sourceTimecode, &type, &count)) == 1)
{
printf("source timecode (type = %d, count = %d) = ", type, count);
print_timecode(&sourceTimecode);
printf("\n");
}
else if (result == -1)
{
printf("source timecode (type = %d, count = %d) unavailable", type, count);
printf("\n");
}
}
frameCount++;
}
if (clip->duration != -1 && frameCount != clip->duration)
{
fprintf(stderr, "3) Frame count %"PFi64" != duration %"PFi64"\n", frameCount, clip->duration);
return 0;
}
if (!position_at_frame(input, 5))
{
fprintf(stderr, "Failed to position at frame 5\n");
return 0;
}
frameCount = 0;
while (read_next_frame(input, &listener) == 1)
{
frameNumber = get_frame_number(input);
printf("frame = %"PFi64"\n", frameNumber);
get_playout_timecode(input, &playoutTimecode);
printf("playout timecode = ");
print_timecode(&playoutTimecode);
printf("\n");
for (i = 0; i < get_num_source_timecodes(input); i++)
{
if ((result = get_source_timecode(input, i, &sourceTimecode, &type, &count)) == 1)
{
printf("source timecode (type = %d, count = %d) = ", type, count);
print_timecode(&sourceTimecode);
printf("\n");
}
else if (result == -1)
{
printf("source timecode (type = %d, count = %d) unavailable", type, count);
printf("\n");
}
}
frameCount++;
}
if (clip->duration != -1 && frameCount + 5 != clip->duration)
{
fprintf(stderr, "4) Frame count %"PFi64" != duration %"PFi64"\n", frameCount + 5, clip->duration);
return 0;
}
close_mxf_reader(&input);
fclose(data.outFile);
if (data.buffer != NULL)
{
free(data.buffer);
}
return 1;
}
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 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;
}
