OSCL_EXPORT_REF PvmiKvpType GetTypeFromKeyString(PvmiKeyType aKeyString)
{
    if (aKeyString == NULL)
    {
        return PVMI_KVPTYPE_UNKNOWN;
    }

    // Determine the type
    char* paramstr = NULL;
    OSCL_StackString<24> typestr;
    OSCL_StackString<10> basestr(PVMI_KVPTYPE_STRING_CONSTCHAR);

    // value
    typestr = basestr;
    typestr += PVMI_KVPTYPE_VALUE_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, typestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPTYPE_VALUE;
    }

    // pointer
    typestr = basestr;
    typestr += PVMI_KVPTYPE_POINTER_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, typestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPTYPE_POINTER;
    }

    // aggregate
    typestr = basestr;
    typestr += PVMI_KVPTYPE_AGGREGATE_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, typestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPTYPE_AGGREGATE;
    }

    return PVMI_KVPTYPE_UNKNOWN;
}
OSCL_EXPORT_REF PvmiKvpAttr GetAttrTypeFromKeyString(PvmiKeyType aKeyString)
{
    if (aKeyString == NULL)
    {
        return PVMI_KVPATTR_UNKNOWN;
    }

    // Determine the attribute type
    char* paramstr = NULL;
    OSCL_StackString<16> attrstr;
    OSCL_StackString<8> basestr(PVMI_KVPATTR_STRING_CONSTCHAR);

    // cap
    attrstr = basestr;
    attrstr += PVMI_KVPATTR_CAP_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, attrstr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPATTR_CAP;
    }
    // def
    attrstr = basestr;
    attrstr += PVMI_KVPATTR_DEF_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, attrstr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPATTR_DEF;
    }
    // cur
    attrstr = basestr;
    attrstr += PVMI_KVPATTR_CUR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, attrstr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPATTR_CUR;
    }

    return PVMI_KVPATTR_UNKNOWN;
}
OSCL_EXPORT_REF PvmiKvpValueType GetValTypeFromKeyString(PvmiKeyType aKeyString)
{
    if (aKeyString == NULL)
    {
        return PVMI_KVPVALTYPE_UNKNOWN;
    }

    // Determine the valtype
    char* paramstr = NULL;
    OSCL_StackString<64> valtypestr;
    OSCL_StackString<10> basestr(PVMI_KVPVALTYPE_STRING_CONSTCHAR);

    // bool
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_BOOL_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_BOOL;
    }
    // float
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_FLOAT_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_FLOAT;
    }
    // double
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_DOUBLE_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_DOUBLE;
    }
    // uint8
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_UINT8_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_UINT8;
    }
    // int32
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_INT32_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_INT32;
    }
    // uint32
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_UINT32_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_UINT32;
    }
    // int64
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_INT64_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_INT32;
    }
    // uint64
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_UINT64_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_UINT32;
    }
    // wchar*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_WCHARPTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_WCHARPTR;
    }
    // char*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_CHARPTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_CHARPTR;
    }
    // uint8*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_UINT8PTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_UINT8PTR;
    }
    // int32*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_INT32PTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_INT32PTR;
    }
    // uint32*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_UINT32PTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_UINT32PTR;
    }
    // int64*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_INT64PTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_INT64PTR;
    }
    // uint64*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_UINT64PTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_UINT64PTR;
    }
    // float*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_FLOATPTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_FLOATPTR;
    }
    // double*
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_DOUBLEPTR_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_DOUBLEPTR;
    }
    // ksv
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_KSV_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_KSV;
    }
    // pKvp
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_PKVP_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_PKVP;
    }
    // ppKvp
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_PPKVP_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_PPKVP;
    }
    // range_float
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_RANGE_FLOAT_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_RANGE_FLOAT;
    }
    // range_double
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_RANGE_DOUBLE_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_RANGE_DOUBLE;
    }
    // range_uint8
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_RANGE_UINT8_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_RANGE_UINT8;
    }
    // range_int32
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_RANGE_INT32_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_RANGE_INT32;
    }
    // range_uint32
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_RANGE_UINT32_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_RANGE_UINT32;
    }
    // range_int64
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_RANGE_INT64_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_RANGE_INT64;
    }
    // range_uint64
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_RANGE_UINT64_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_RANGE_UINT64;
    }
    // bitarray32
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_BITARRAY32_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_BITARRAY32;
    }
    // bitarray64
    valtypestr = basestr;
    valtypestr += PVMI_KVPVALTYPE_BITARRAY64_STRING_CONSTCHAR;
    if (pv_mime_string_parse_param(aKeyString, valtypestr.get_str(), paramstr) > 0)
    {
        return PVMI_KVPVALTYPE_BITARRAY64;
    }

    return PVMI_KVPVALTYPE_UNKNOWN;
}
PVMFStatus PVMp4FFComposerNode::VerifyAndSetConfigParameter(PvmiKvp& aParameter, bool aSetParam)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMp4FFComposerNode::VerifyAndSetConfigParameter() In"));

    // Determine the valtype
    PvmiKvpValueType keyvaltype = GetValTypeFromKeyString(aParameter.key);
    if (PVMI_KVPVALTYPE_UNKNOWN == keyvaltype)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMp4FFComposerNode::VerifyAndSetConfigParameter() Valtype in key string unknown"));
        return PVMFErrNotSupported;// key is not supported here
    }

    // Retrieve the fourth component from the key string
    char* compstr = NULL;
    pv_mime_string_extract_type(3, aParameter.key, compstr);

    int32 mp4comp4ind;
    for (mp4comp4ind = 0; mp4comp4ind < MP4COMPOSERNODECONFIG_BASE_NUMKEYS; ++mp4comp4ind)
    {
        // Go through each component string at 4th level
        if (pv_mime_strcmp(compstr, (char*)(MP4ComposerNodeConfig_BaseKeys[mp4comp4ind].iString)) >= 0)
        {
            // Break out of the for loop
            break;
        }
    }

    if (MP4COMPOSERNODECONFIG_BASE_NUMKEYS <= mp4comp4ind)
    {
        // Match couldn't be found or non-leaf node specified
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMp4FFComposerNode::VerifyAndSetConfigParameter() Unsupported key or non-leaf node"));
        return PVMFErrNotSupported;
    }

    // Verify the valtype
    if (keyvaltype != MP4ComposerNodeConfig_BaseKeys[mp4comp4ind].iValueType)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMp4FFComposerNode::VerifyAndSetConfigParameter() Valtype does not match for key"));
        return PVMFErrNotSupported;
    }

    switch (mp4comp4ind)
    {
        case PRESENTATION_TIMESCALE: // "presentation-timescale"
            // Change the parameter
            if (aSetParam)
            {
                iPresentationTimescale = aParameter.value.uint32_value;
            }
            break;

        case PV_CACHE_SIZE: // "pv-cache-size"
            // change the parameter
            if (aSetParam)
            {
                // set any parameter here
                iCacheSize = aParameter.value.uint32_value ;
            }
            break;
#ifdef _TEST_AE_ERROR_HANDLING
        case ERROR_START_ADDMEMFRAG:
            // change the parameter
            if (aSetParam)
            {
                // set any parameter here
                iErrorHandlingAddMemFrag = aParameter.value.bool_value ;
            }
            break;
        case ERROR_START_ADDTRACK:
            // change the parameter
            if (aSetParam)
            {
                // set any parameter here
                iErrorHandlingAddTrack = aParameter.value.bool_value ;
            }
            break;
        case ERROR_ADDTRACK: //error in AddTrack()
            if (aSetParam)
            {
                //char* paramstr = NULL;
                char* val_key = aParameter.value.pChar_value;
                if (pv_mime_strcmp(val_key, "PVMF_MIME_H264_VIDEO_MP4") == 0)
                {
                    iErrorAddTrack = PVMF_MIME_H264_VIDEO_MP4;
                }
                if (pv_mime_strcmp(val_key, "PVMF_MIME_3GPP_TIMEDTEXT") == 0)
                {
                    iErrorAddTrack = PVMF_MIME_3GPP_TIMEDTEXT;
                }
                if (pv_mime_strcmp(val_key, "PVMF_MIME_M4V") == 0)
                {
                    iErrorAddTrack = PVMF_MIME_M4V;
                }
                if (pv_mime_strcmp(val_key, "PVMF_MIME_H2631998") == 0)
                {
                    iErrorAddTrack = PVMF_MIME_H2631998;
                }
                if (pv_mime_strcmp(val_key, "PVMF_MIME_H2632000") == 0)
                {
                    iErrorAddTrack = PVMF_MIME_H2632000;
                }
                if (pv_mime_strcmp(val_key, "PVMF_MIME_AMR_IETF") == 0)
                {
                    iErrorAddTrack = PVMF_MIME_AMR_IETF;
                }
                if (pv_mime_strcmp(val_key, "PVMF_MIME_AMRWB_IETF") == 0)
                {
                    iErrorAddTrack = PVMF_MIME_AMRWB_IETF;
                }

            }
            break;
        case ERROR_NODE_CMD:
            if (aSetParam)
            {
                iErrorNodeCmd = aParameter.value.uint32_value;
            }
            break;
        case ERROR_CREATE_COMPOSER:
            if (aSetParam)
            {
                iErrorCreateComposer = aParameter.value.bool_value ;
            }
            break;
        case ERROR_RENDERTOFILE:
            if (aSetParam)
            {
                iErrorRenderToFile = aParameter.value.bool_value ;
            }
            break;
        case ERROR_ADD_SAMPLE:
            if (aSetParam)
            {
                char* paramstr = NULL;
                OSCL_HeapString<OsclMemAllocator> mode1 = "mode=filesize";
                OSCL_HeapString<OsclMemAllocator> mode2 = "mode=duration";

                if (pv_mime_string_parse_param(aParameter.key, mode1.get_str(), paramstr) > 0)
                {
                    iFileSize = aParameter.value.uint32_value;
                    iErrorAddSample = 1;
                }
                else if (pv_mime_string_parse_param(aParameter.key, mode2.get_str(), paramstr) > 0)
                {
                    iFileDuration = aParameter.value.uint32_value;
                    iErrorAddSample = 2;
                }

            }
            break;
        case ERROR_DATAPATH_STALL:
            if (aSetParam)
            {
                iErrorDataPathStall = aParameter.value.uint32_value;
            }
            break;
#endif
        default:
            OSCL_ASSERT(0);
    }

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMp4FFComposerNode::VerifyAndSetConfigParameter() Out"));
    return PVMFSuccess;
}