Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
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;
}
Ejemplo n.º 5
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;
}
Ejemplo n.º 6
0
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;
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
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;
}