自学教程：C++ CHK_ORET函数代码示例

static int get_or_create_set_item(MXFHeaderMetadata* headerMetadata, MXFMetadataSet* set,    const mxfKey* itemKey, MXFMetadataItem** item){    MXFMetadataItem* resultItem = NULL;    mxfLocalTag tag;    MXFItemDef* itemDef = NULL;        /* check if item already exists */    if (!mxf_get_item(set, itemKey, &resultItem))    {        /* check if item registered in primer */        if (!mxf_get_item_tag(headerMetadata->primerPack, itemKey, &tag))        {            /* register item in primer */            CHK_ORET(mxf_find_item_def(headerMetadata->dataModel, itemKey, &itemDef));            CHK_ORET(mxf_register_primer_entry(headerMetadata->primerPack, (const mxfUID*)itemKey,                 itemDef->localTag, &tag));        }        /* create new item */        CHK_ORET(mxf_create_item(set, itemKey, tag, &resultItem));    }        *item = resultItem;    return 1;    }

int x11c_initialise(X11Common* x11Common, int reviewDuration, OnScreenDisplay* osd, X11WindowInfo* windowInfo){    memset(x11Common, 0, sizeof(x11Common));    x11Common->reviewDuration = reviewDuration;    x11Common->osd = osd;    x11Common->progressBarInput.data = x11Common;    x11Common->progressBarInput.set_listener = x11c_set_pbar_listener;    x11Common->progressBarInput.unset_listener = x11c_unset_pbar_listener;    x11Common->progressBarInput.close = x11c_close_pbar;    x11Common->keyboardInput.data = x11Common;    x11Common->keyboardInput.set_listener = x11c_set_keyboard_listener;    x11Common->keyboardInput.unset_listener = x11c_unset_keyboard_listener;    x11Common->keyboardInput.close = x11c_close_keyboard;    x11Common->mouseInput.data = x11Common;    x11Common->mouseInput.set_listener = x11c_set_mouse_listener;    x11Common->mouseInput.unset_listener = x11c_unset_mouse_listener;    x11Common->mouseInput.close = x11c_close_mouse;    if (windowInfo)    {        x11Common->windowInfo = *windowInfo;    }    CHK_ORET(XInitThreads() != 0);        CHK_ORET(init_mutex(&x11Common->eventMutex));    CHK_ORET(create_joinable_thread(&x11Common->processEventThreadId, process_event_thread, x11Common));    return 1;}

int mxf_write_rip(MXFFile *mxfFile, MXFFilePartitions *partitions){    uint32_t numPartitions;    uint64_t len;    uint8_t llen;    MXFListIterator iter;    numPartitions = (uint32_t)mxf_get_list_length(partitions);    len = (4 + 8) * numPartitions + 4;    CHK_ORET(mxf_write_k(mxfFile, &g_RandomIndexPack_key));    CHK_ORET((llen = mxf_write_l(mxfFile, len)) != 0);    mxf_initialise_list_iter(&iter, partitions);    while (mxf_next_list_iter_element(&iter))    {        MXFPartition *partition = (MXFPartition*)mxf_get_iter_element(&iter);        CHK_ORET(mxf_write_uint32(mxfFile, partition->bodySID));        CHK_ORET(mxf_write_uint64(mxfFile, partition->thisPartition));    }    CHK_ORET(mxf_write_uint32(mxfFile, (uint32_t)(16 + llen + len)));    return 1;}

static int mxf_read_l(FILE* mxfFile, uint8_t* llen, uint64_t* len){    int i;    int c;    uint64_t length;    uint8_t llength;        CHK_ORET((c = fgetc(mxfFile)) != EOF);     length = 0;    llength = 1;    if (c < 0x80)     {        length = c;    }    else     {        int bytesToRead = c & 0x7f;        CHK_ORET(bytesToRead <= 8);         for (i = 0; i < bytesToRead; i++)         {            CHK_ORET((c = fgetc(mxfFile)) != EOF);             length = length << 8;            length = length | c;        }        llength += bytesToRead;    }        *llen = llength;    *len = length;        return 1;}

int mxf_read_item_tl(MXFFile* mxfFile, mxfLocalTag* itemTag, uint16_t* itemLen){    CHK_ORET(mxf_read_local_tag(mxfFile, itemTag));    CHK_ORET(mxf_read_uint16(mxfFile, itemLen));        return 1;}

int mxf_write_header_metadata(MXFFile* mxfFile, MXFHeaderMetadata* headerMetadata){    CHK_ORET(mxf_write_header_primer_pack(mxfFile, headerMetadata));    CHK_ORET(mxf_write_header_sets(mxfFile, headerMetadata));        return 1;}

int mxf_fill_to_position(MXFFile *mxfFile, uint64_t position){    int64_t filePos;    uint64_t fillSize;    uint8_t llen;    CHK_ORET((filePos = mxf_file_tell(mxfFile)) >= 0);    if ((uint64_t)filePos == position)    {        return 1;    }    CHK_ORET(((uint64_t)filePos <= position - mxf_get_min_llen(mxfFile) + mxfKey_extlen));    CHK_ORET(mxf_write_k(mxfFile, &g_KLVFill_key));    fillSize = position - filePos - mxfKey_extlen;    llen = mxf_get_llen(mxfFile, fillSize);    assert(fillSize >= llen);    fillSize -= llen;    CHK_ORET(mxf_write_l(mxfFile, fillSize));    CHK_ORET(mxf_write_zeros(mxfFile, fillSize));    return 1;}

int mxf_read_header_pp_kl_with_runin(MXFFile *mxfFile, mxfKey *key, uint8_t *llen, uint64_t *len){    mxfKey tkey = MXF_PP_KEY(0x01, 0x00, 0x00);    uint8_t tllen;    uint64_t tlen;    uint8_t keyCompareByte = 0;    uint32_t runinCheckCount = 0;    int byte;    /* the run-in shall not contain the first 11 bytes of the partition pack label and so       read until the first 11 bytes are found or max run-in exceeded */    while (runinCheckCount <= MAX_RUNIN_LEN && keyCompareByte < 11) {        CHK_ORET((byte = mxf_file_getc(mxfFile)) != EOF);        if (byte == ((uint8_t*)(&tkey))[keyCompareByte]) {            keyCompareByte++;        } else {            runinCheckCount += keyCompareByte + 1;            keyCompareByte = 0;        }    }    CHK_ORET(runinCheckCount <= MAX_RUNIN_LEN);    CHK_ORET(mxf_file_read(mxfFile, &tkey.octet11, 5) == 5);    CHK_ORET(mxf_is_header_partition_pack(&tkey));    CHK_ORET(mxf_read_l(mxfFile, &tllen, &tlen));    mxf_set_runin_len(mxfFile, (uint16_t)runinCheckCount);    *key = tkey;    *llen = tllen;    *len = tlen;    return 1;}

static int mxf_read_kl(FILE* mxfFile, mxfKey* key, uint8_t* llen, uint64_t *len){    CHK_ORET(mxf_read_k(mxfFile, key));     CHK_ORET(mxf_read_l(mxfFile, llen, len));        return 1; }

int mxf_register_set_items(MXFHeaderMetadata* headerMetadata, const mxfKey* key){    MXFSetDef* setDef;    MXFItemDef* itemDef;    MXFListIterator iter;    mxfLocalTag tag;        CHK_ORET(mxf_find_set_def(headerMetadata->dataModel, key, &setDef));        /* go though the set def and parents and register the items */    while (setDef != NULL)    {        mxf_initialise_list_iter(&iter, &setDef->itemDefs);        while (mxf_next_list_iter_element(&iter))        {            itemDef = (MXFItemDef*)mxf_get_iter_element(&iter);                        CHK_ORET(mxf_register_primer_entry(headerMetadata->primerPack, (const mxfUID*)&itemDef->key,                 itemDef->localTag, &tag));        }                setDef = setDef->parentSetDef;    }        return 1;}

int mxf_write_item(MXFFile* mxfFile, MXFMetadataItem* item){    CHK_ORET(mxf_write_local_tag(mxfFile, item->tag));    CHK_ORET(mxf_write_uint16(mxfFile, item->length));    CHK_ORET(mxf_file_write(mxfFile, item->value, item->length) == item->length);    item->isPersistent = 1;        return 1;}

int mxf_allocate_space_to_kag(MXFFile *mxfFile, MXFPartition *partition, uint32_t size){    int64_t filePos;    uint64_t relativeFilePos;    int64_t fillSize;    uint8_t llen;    assert(partition->kagSize > 0);    if (size == 0 && partition->kagSize == 1)    {        return 1;    }    CHK_ORET((filePos = mxf_file_tell(mxfFile)) >= 0);    CHK_ORET((uint64_t)filePos > partition->thisPartition);    relativeFilePos = filePos + size - partition->thisPartition;    if (size != 0 || (relativeFilePos % partition->kagSize) != 0)    {        CHK_ORET(mxf_write_k(mxfFile, &g_KLVFill_key));        fillSize = (int64_t)size - mxfKey_extlen;        if (partition->kagSize > 1)        {            fillSize += partition->kagSize - relativeFilePos % partition->kagSize;        }        if (fillSize >= 0)        {            llen = mxf_get_llen(mxfFile, fillSize);        }        else        {            llen = 0;        }        while (fillSize - llen < 0)        {            fillSize += partition->kagSize;            if (fillSize >= 0)            {                llen = mxf_get_llen(mxfFile, fillSize);            }            else            {                llen = 0;            }        }        fillSize -= llen;        CHK_ORET(mxf_write_l(mxfFile, fillSize));        CHK_ORET(mxf_write_zeros(mxfFile, fillSize));    }    return 1;}

int mxf_avid_add_typedef_record_member(MXFMetadataSet* typeDefSet, const mxfUTF16Char* name, const mxfUL* typeId){    uint8_t* elementValue;    CHK_ORET(append_name_to_string_array(typeDefSet, &MXF_ITEM_K(TypeDefinitionRecord, MemberNames), name));            CHK_ORET(mxf_grow_array_item(typeDefSet, &MXF_ITEM_K(TypeDefinitionRecord, MemberTypes), mxfUL_extlen, 1, &elementValue));    mxf_set_ul(typeId, elementValue);    return 1;}

int mxf_avid_create_typedef_enum(MXFMetadataSet* metaDictSet, const mxfUL* id, const mxfUTF16Char* name, const mxfUTF16Char* description, const mxfUL* typeId, MXFMetadataSet** typeDefSet){    MXFMetadataSet* newSet = NULL;        CHK_ORET(mxf_avid_create_typedef(metaDictSet, &MXF_SET_K(TypeDefinitionEnumeration), id, name, description, &newSet));    CHK_ORET(mxf_set_ul_item(newSet, &MXF_ITEM_K(TypeDefinitionEnumeration, Type), typeId));        *typeDefSet = newSet;    return 1;}

int xml_writer_character_data(XMLWriter* writer, const char* data){    if (writer->previousWrite == ELEMENT_START || writer->previousWrite == ATTRIBUTE)    {        CHK_ORET(fprintf(writer->file, ">") > 0);    }    CHK_ORET(fprintf(writer->file, "%s", data) > 0);    writer->previousWrite = CHARACTER_DATA;    return 1;}

int mxf_avid_add_typedef_extenum_element(MXFMetadataSet* typeDefSet, const mxfUTF16Char* name, const mxfUL* value){    uint8_t* elementValue;    CHK_ORET(append_name_to_string_array(typeDefSet, &MXF_ITEM_K(TypeDefinitionExtendibleEnumeration, Names), name));            CHK_ORET(mxf_grow_array_item(typeDefSet, &MXF_ITEM_K(TypeDefinitionExtendibleEnumeration, Values), mxfUL_extlen, 1, &elementValue));    mxf_set_ul(value, elementValue);    return 1;}

static int op1a_position_at_frame(MXFReader *reader, int64_t frameNumber){    MXFFile *mxfFile = reader->mxfFile;    EssenceReader *essenceReader = reader->essenceReader;    EssenceReaderData *data = essenceReader->data;    CHK_ORET(mxf_file_is_seekable(mxfFile));    CHK_ORET(set_position(mxfFile, data->index, frameNumber));    return 1;}

int mxf_avid_set_metadef_items(MXFMetadataSet* set, const mxfUL* id, const mxfUTF16Char* name, const mxfUTF16Char* description){    CHK_ORET(mxf_set_ul_item(set, &MXF_ITEM_K(MetaDefinition, Identification), id));    CHK_ORET(name != NULL);    CHK_ORET(mxf_set_utf16string_item(set, &MXF_ITEM_K(MetaDefinition, Name), name));    if (description != NULL)    {        CHK_ORET(mxf_set_utf16string_item(set, &MXF_ITEM_K(MetaDefinition, Description), description));    }        return 1;}

static int write_indent(XMLWriter* writer){    int i;        CHK_ORET(fprintf(writer->file, "/r/n") > 0);    for (i = 0; i < writer->indent; i++)    {        CHK_ORET(fprintf(writer->file, "  ") > 0);    }        return 1;}

int mxf_avid_create_typedef_vararray(MXFMetadataSet* metaDictSet, const mxfUL* id, const mxfUTF16Char* name, const mxfUTF16Char* description, const mxfUL* elementTypeId, MXFMetadataSet** typeDefSet){    MXFMetadataSet* newSet = NULL;        CHK_ORET(mxf_avid_create_typedef(metaDictSet, &MXF_SET_K(TypeDefinitionVariableArray), id, name, description, &newSet));        CHK_ORET(mxf_set_ul_item(newSet, &MXF_ITEM_K(TypeDefinitionVariableArray, ElementType), elementTypeId));    *typeDefSet = newSet;    return 1;}

int mxf_avid_create_typedef_weakref(MXFMetadataSet* metaDictSet, const mxfUL* id, const mxfUTF16Char* name, const mxfUTF16Char* description, const mxfUL* referencedTypeId, MXFMetadataSet** typeDefSet){    MXFMetadataSet* newSet = NULL;    CHK_ORET(mxf_avid_create_typedef(metaDictSet, &MXF_SET_K(TypeDefinitionWeakObjectReference), id, name, description, &newSet));        CHK_ORET(mxf_set_ul_item(newSet, &MXF_ITEM_K(TypeDefinitionWeakObjectReference, ReferencedType), referencedTypeId));            *typeDefSet = newSet;    return 1;}

int mxf_register_item(MXFHeaderMetadata* headerMetadata, const mxfKey* key){    mxfLocalTag tag;    MXFItemDef* itemDef;        /* register item in primer */    CHK_ORET(mxf_find_item_def(headerMetadata->dataModel, key, &itemDef));    CHK_ORET(mxf_register_primer_entry(headerMetadata->primerPack, (const mxfUID*)key,         itemDef->localTag, &tag));        return 1;}

int mxf_mark_index_end(MXFFile *mxfFile, MXFPartition *partition){    int64_t filePos;    CHK_ORET(partition->indexMarkInPos >= 0);    CHK_ORET((filePos = mxf_file_tell(mxfFile)) >= 0);    CHK_ORET(filePos >= partition->indexMarkInPos);    partition->indexByteCount = filePos - partition->indexMarkInPos;    partition->indexMarkInPos = -1;    return 1;}

int mxf_avid_create_typedef(MXFMetadataSet* metaDictSet, const mxfKey* setId, const mxfUL* id, const mxfUTF16Char* name, const mxfUTF16Char* description, MXFMetadataSet** typeDefSet){    MXFMetadataSet* newSet = NULL;        CHK_ORET(mxf_create_set(metaDictSet->headerMetadata, setId, &newSet));    CHK_ORET(mxf_add_array_item_strongref(metaDictSet, &MXF_ITEM_K(MetaDictionary, TypeDefinitions), newSet));        CHK_ORET(mxf_avid_set_metadef_items(newSet, id, name, description));            *typeDefSet = newSet;    return 1;}

int mxf_avid_create_typedef_integer(MXFMetadataSet* metaDictSet, const mxfUL* id, const mxfUTF16Char* name, const mxfUTF16Char* description, uint8_t size, mxfBoolean isSigned, MXFMetadataSet** typeDefSet){    MXFMetadataSet* newSet = NULL;        CHK_ORET(mxf_avid_create_typedef(metaDictSet, &MXF_SET_K(TypeDefinitionInteger), id, name, description, &newSet));    CHK_ORET(mxf_set_uint8_item(newSet, &MXF_ITEM_K(TypeDefinitionInteger, Size), size));    CHK_ORET(mxf_set_boolean_item(newSet, &MXF_ITEM_K(TypeDefinitionInteger, IsSigned), isSigned));            *typeDefSet = newSet;    return 1;}

int xml_writer_element_start(XMLWriter* writer, const char* name){    if (writer->previousWrite == ELEMENT_START || writer->previousWrite == ATTRIBUTE)    {        CHK_ORET(fprintf(writer->file, ">") > 0);    }        write_indent(writer);    CHK_ORET(fprintf(writer->file, "<%s", name) > 0);        writer->indent++;    writer->previousWrite = ELEMENT_START;    return 1;}

int mxf_read_partition(MXFFile *mxfFile, const mxfKey *key, uint64_t len, MXFPartition **partition){    MXFPartition *newPartition;    uint32_t numLabels;    uint32_t labelLen;    mxfUL label;    uint64_t expectedLen;    uint32_t i;    CHK_ORET(len >= 88 && len <= INT64_MAX);    CHK_ORET(mxf_create_partition(&newPartition));    newPartition->key = *key;    CHK_OFAIL(mxf_read_uint16(mxfFile, &newPartition->majorVersion));    CHK_OFAIL(mxf_read_uint16(mxfFile, &newPartition->minorVersion));    CHK_OFAIL(mxf_read_uint32(mxfFile, &newPartition->kagSize));    CHK_OFAIL(mxf_read_uint64(mxfFile, &newPartition->thisPartition));    CHK_OFAIL(mxf_read_uint64(mxfFile, &newPartition->previousPartition));    CHK_OFAIL(mxf_read_uint64(mxfFile, &newPartition->footerPartition));    CHK_OFAIL(mxf_read_uint64(mxfFile, &newPartition->headerByteCount));    CHK_OFAIL(mxf_read_uint64(mxfFile, &newPartition->indexByteCount));    CHK_OFAIL(mxf_read_uint32(mxfFile, &newPartition->indexSID));    CHK_OFAIL(mxf_read_uint64(mxfFile, &newPartition->bodyOffset));    CHK_OFAIL(mxf_read_uint32(mxfFile, &newPartition->bodySID));    CHK_OFAIL(mxf_read_ul(mxfFile, &newPartition->operationalPattern));    CHK_OFAIL(mxf_read_batch_header(mxfFile, &numLabels, &labelLen));    CHK_OFAIL(numLabels == 0 || labelLen == 16);    expectedLen = 88 + (uint64_t)numLabels * labelLen;    CHK_OFAIL(len >= expectedLen);    for (i = 0; i < numLabels; i++)    {        CHK_OFAIL(mxf_read_ul(mxfFile, &label));        CHK_OFAIL(mxf_append_partition_esscont_label(newPartition, &label));    }    if (len > expectedLen) {        mxf_log_warn("Partition pack len %" PRIu64 " is larger than expected len %" PRIu64 "/n",                     len, expectedLen);        CHK_OFAIL(mxf_file_seek(mxfFile, (int64_t)(len - expectedLen), SEEK_CUR));    }    *partition = newPartition;    return 1;fail:    mxf_free_partition(&newPartition);    return 0;}

int mxf_finalize_essence_element_write(MXFFile *mxfFile, MXFEssenceElement *essenceElement){    int64_t filePos;    assert(essenceElement != NULL);    CHK_ORET((filePos = mxf_file_tell(mxfFile)) >= 0);    CHK_ORET(mxf_file_seek(mxfFile, essenceElement->startFilePos + 16, SEEK_SET));    CHK_ORET(mxf_write_fixed_l(mxfFile, essenceElement->llen, essenceElement->totalLen));    CHK_ORET(mxf_file_seek(mxfFile, filePos, SEEK_SET));    return 1;}

static int add_item(MXFMetadataSet* set, MXFMetadataItem* item){    MXFMetadataItem* removedItem;        /* if item already attached to set, then removed it first */    if (item->set != NULL)    {        CHK_ORET(mxf_remove_item(item->set, &item->key, &removedItem));    }        CHK_ORET(mxf_append_list_element(&set->items, (void*)item));    item->set = set;        return 1;}

int mxf_read_header_pp_kl(MXFFile *mxfFile, mxfKey *key, uint8_t *llen, uint64_t *len){    mxfKey tkey;    uint8_t tllen;    uint64_t tlen;    CHK_ORET(mxf_read_k(mxfFile, &tkey));    CHK_ORET(mxf_is_header_partition_pack(&tkey));    CHK_ORET(mxf_read_l(mxfFile, &tllen, &tlen));    *key = tkey;    *llen = tllen;    *len = tlen;    return 1;}