From a696317b9fef490045d9f2896988bf988b6a2767 Mon Sep 17 00:00:00 2001 From: zhangguorong Date: Fri, 29 Jul 2022 17:55:45 +0800 Subject: [PATCH] feat: optimize oem interface return value, GetParameter can return all setup data Signed-off-by: zhangguorong --- .../codec_instance/include/codec_instance.h | 8 +- .../v1.0/codec_instance/src/codec_instance.c | 47 +++++---- .../codec_service_stub/codec_service.c | 56 ++++++----- .../codec_service_stub/codec_stub.c | 18 ++-- codec/test/demo/v1.0/codec_decode_test_ipc.c | 8 +- codec/test/demo/v1.0/codec_encode_test_ipc.c | 98 +++++++++++++++---- .../unittest/hdi_v1.0/codec_proxy_test.cpp | 2 +- 7 files changed, 160 insertions(+), 77 deletions(-) diff --git a/codec/hal/v1.0/codec_instance/include/codec_instance.h b/codec/hal/v1.0/codec_instance/include/codec_instance.h index a20384a079..6a05b59390 100644 --- a/codec/hal/v1.0/codec_instance/include/codec_instance.h +++ b/codec/hal/v1.0/codec_instance/include/codec_instance.h @@ -63,10 +63,10 @@ struct CodecInstance { }; struct CodecInstance* GetCodecInstance(void); -void InitCodecInstance(struct CodecInstance *instance); -void RunCodecInstance(struct CodecInstance *instance); -void StopCodecInstance(struct CodecInstance *instance); -void DestroyCodecInstance(struct CodecInstance *instance); +int32_t InitCodecInstance(struct CodecInstance *instance); +int32_t RunCodecInstance(struct CodecInstance *instance); +int32_t StopCodecInstance(struct CodecInstance *instance); +int32_t DestroyCodecInstance(struct CodecInstance *instance); void AddInputShm(struct CodecInstance *instance, const CodecBufferInfo *bufferInfo, int32_t bufferId); void AddOutputShm(struct CodecInstance *instance, const CodecBufferInfo *bufferInfo, int32_t bufferId); ShareMemory* GetInputShm(struct CodecInstance *instance, int32_t id); diff --git a/codec/hal/v1.0/codec_instance/src/codec_instance.c b/codec/hal/v1.0/codec_instance/src/codec_instance.c index 62e437b651..624d726b3e 100644 --- a/codec/hal/v1.0/codec_instance/src/codec_instance.c +++ b/codec/hal/v1.0/codec_instance/src/codec_instance.c @@ -25,18 +25,18 @@ #define CODEC_BUFFER_MANAGER_LIB_NAME "libcodec_buffer_manager.z.so" #define BUFFER_COUNT 1 -static void InitCodecOemIf(struct CodecInstance *instance) +static int32_t InitCodecOemIf(struct CodecInstance *instance) { if (instance == NULL || instance->codecOemIface == NULL) { HDF_LOGE("%{public}s: Invalid param!", __func__); - return; + return HDF_FAILURE; } void *libHandle = dlopen(CODEC_OEM_INTERFACE_LIB_NAME, RTLD_NOW); if (libHandle == NULL) { HDF_LOGE("%{public}s: lib %{public}s dlopen failed, error code[%{public}s]", __func__, CODEC_OEM_INTERFACE_LIB_NAME, dlerror()); - return; + return HDF_FAILURE; } struct CodecOemIf *iface = instance->codecOemIface; @@ -55,20 +55,21 @@ static void InitCodecOemIf(struct CodecInstance *instance) iface->CodecEncodeHeader = (CodecEncodeHeaderType)dlsym(libHandle, "CodecEncodeHeader"); instance->oemLibHandle = libHandle; + return HDF_SUCCESS; } -static void InitBufferManagerIf(struct CodecInstance *instance) +static int32_t InitBufferManagerIf(struct CodecInstance *instance) { if (instance == NULL || instance->bufferManagerIface == NULL) { HDF_LOGE("%{public}s: Invalid param!", __func__); - return; + return HDF_FAILURE; } void *libHandle = dlopen(CODEC_BUFFER_MANAGER_LIB_NAME, RTLD_NOW); if (libHandle == NULL) { HDF_LOGE("%{public}s: lib %{public}s dlopen failed, error code[%{public}s]", __func__, CODEC_BUFFER_MANAGER_LIB_NAME, dlerror()); - return; + return HDF_FAILURE; } struct BufferManagerIf *iface = instance->bufferManagerIface; @@ -80,9 +81,11 @@ static void InitBufferManagerIf(struct CodecInstance *instance) } else { HDF_LOGE("%{public}s: lib %{public}s dlsym failed, error code[%{public}s]", __func__, CODEC_BUFFER_MANAGER_LIB_NAME, dlerror()); + return HDF_FAILURE; } instance->bufferManagerLibHandle = libHandle; + return HDF_SUCCESS; } static int32_t WaitForBufferData(struct CodecInstance *instance, CodecBuffer *outputData) @@ -173,32 +176,36 @@ struct CodecInstance* GetCodecInstance(void) return instance; } -void InitCodecInstance(struct CodecInstance *instance) +int32_t InitCodecInstance(struct CodecInstance *instance) { if (instance == NULL) { HDF_LOGE("%{public}s: Invalid param!", __func__); - return; + return HDF_FAILURE; } instance->codecOemIface = (struct CodecOemIf *)OsalMemCalloc(sizeof(struct CodecOemIf)); if (instance->codecOemIface == NULL) { HDF_LOGE("%{public}s: codecOemIface mem alloc failed", __func__); - return; + return HDF_FAILURE; + } + int32_t ret = InitCodecOemIf(instance); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: InitCodecOemIf failed", __func__); + return HDF_FAILURE; } - InitCodecOemIf(instance); instance->bufferManagerIface = (struct BufferManagerIf *)OsalMemAlloc(sizeof(struct BufferManagerIf)); if (instance->bufferManagerIface == NULL) { HDF_LOGE("%{public}s: bufferManagerIface mem alloc failed", __func__); - return; + return HDF_FAILURE; } - InitBufferManagerIf(instance); + return InitBufferManagerIf(instance); } -void RunCodecInstance(struct CodecInstance *instance) +int32_t RunCodecInstance(struct CodecInstance *instance) { if (instance == NULL) { HDF_LOGE("%{public}s: Invalid param!", __func__); - return; + return HDF_FAILURE; } pthread_attr_t attr; @@ -209,23 +216,26 @@ void RunCodecInstance(struct CodecInstance *instance) int32_t ret = pthread_create(&instance->task, NULL, CodecTaskThread, instance); if (ret != 0) { HDF_LOGE("%{public}s: run codec task thread failed!", __func__); + return HDF_FAILURE; } + return HDF_SUCCESS; } -void StopCodecInstance(struct CodecInstance *instance) +int32_t StopCodecInstance(struct CodecInstance *instance) { if (instance == NULL) { HDF_LOGE("%{public}s: Invalid param!", __func__); - return; + return HDF_FAILURE; } instance->codecStatus = CODEC_STATUS_STOPED; + return HDF_SUCCESS; } -void DestroyCodecInstance(struct CodecInstance *instance) +int32_t DestroyCodecInstance(struct CodecInstance *instance) { if (instance == NULL) { HDF_LOGE("%{public}s: Invalid param!", __func__); - return; + return HDF_FAILURE; } instance->codecStatus = CODEC_STATUS_STOPED; @@ -245,6 +255,7 @@ void DestroyCodecInstance(struct CodecInstance *instance) if (instance->bufferManagerIface != NULL) { OsalMemFree(instance->bufferManagerIface); } + return HDF_SUCCESS; } void AddInputShm(struct CodecInstance *instance, const CodecBufferInfo *bufferInfo, int32_t bufferId) diff --git a/codec/hdi_service/codec_service_stub/codec_service.c b/codec/hdi_service/codec_service_stub/codec_service.c index 176d3c9efb..6a3a476c92 100644 --- a/codec/hdi_service/codec_service_stub/codec_service.c +++ b/codec/hdi_service/codec_service_stub/codec_service.c @@ -51,6 +51,7 @@ static int32_t DefaultCbInputBufferAvailable(UINTPTR userData, CodecBuffer *inBu } inputInfo->buffer[0].buf = (intptr_t)GetFdById(g_codecInstance, inBuf->bufferId); inputInfo->buffer[0].type = BUFFER_TYPE_FD; + inputInfo->buffer[0].length = 0; g_codecInstance->bufferManagerWrapper->PutUsedInputDataBuffer(g_codecInstance->bufferManagerWrapper, inputInfo); return HDF_SUCCESS; } @@ -87,14 +88,21 @@ static int32_t DefaultCbOutputBufferAvailable(UINTPTR userData, CodecBuffer *out int32_t CodecInit() { g_codecInstance = GetCodecInstance(); - InitCodecInstance(g_codecInstance); + if (g_codecInstance == NULL) { + HDF_LOGE("%{public}s: g_codecInstance is NULL!", __func__); + return HDF_FAILURE; + } + int32_t ret = InitCodecInstance(g_codecInstance); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: InitCodecInstance failed!", __func__); + return ret; + } - if (g_codecInstance == NULL || g_codecInstance->codecOemIface == NULL) { - HDF_LOGE("%{public}s: g_codecInstance or oemIface is NULL!", __func__); + if (g_codecInstance->codecOemIface == NULL) { + HDF_LOGE("%{public}s: oemIface is NULL!", __func__); return HDF_FAILURE; } - g_codecInstance->codecOemIface->CodecInit(); - return HDF_SUCCESS; + return g_codecInstance->codecOemIface->CodecInit(); } int32_t CodecDeinit() @@ -104,7 +112,11 @@ int32_t CodecDeinit() return HDF_FAILURE; } g_codecInstance->codecOemIface->CodecDeinit(); - DestroyCodecInstance(g_codecInstance); + int32_t ret = DestroyCodecInstance(g_codecInstance); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: CodecDeinit failed!", __func__); + return ret; + } g_codecInstance = NULL; return HDF_SUCCESS; } @@ -171,7 +183,10 @@ int32_t CodecCreate(const char* name, CODEC_HANDLETYPE *handle) HDF_LOGE("%{public}s: g_codecInstance or oemIface is NULL!", __func__); return HDF_FAILURE; } - g_codecInstance->codecOemIface->CodecCreate(name, handle); + int32_t ret = g_codecInstance->codecOemIface->CodecCreate(name, handle); + if (ret != HDF_SUCCESS) { + return ret; + } g_codecInstance->handle = *handle; HDF_LOGI("%{public}s codec created", __func__); return HDF_SUCCESS; @@ -183,8 +198,7 @@ int32_t CodecDestroy(CODEC_HANDLETYPE handle) HDF_LOGE("%{public}s: g_codecInstance or oemIface is NULL!", __func__); return HDF_FAILURE; } - g_codecInstance->codecOemIface->CodecDestroy(handle); - return HDF_SUCCESS; + return g_codecInstance->codecOemIface->CodecDestroy(handle); } int32_t CodecSetPortMode(CODEC_HANDLETYPE handle, DirectionType direct, AllocateBufferMode mode, BufferType type) @@ -214,8 +228,7 @@ int32_t CodecSetParameter(CODEC_HANDLETYPE handle, const Param *params, int32_t g_codecInstance->codecType = codecType; } } - g_codecInstance->codecOemIface->CodecSetParameter(handle, params, paramCnt); - return HDF_SUCCESS; + return g_codecInstance->codecOemIface->CodecSetParameter(handle, params, paramCnt); } int32_t CodecGetParameter(CODEC_HANDLETYPE handle, Param *params, int32_t paramCnt) @@ -228,8 +241,7 @@ int32_t CodecGetParameter(CODEC_HANDLETYPE handle, Param *params, int32_t paramC HDF_LOGE("%{public}s: params empty!", __func__); return HDF_FAILURE; } - g_codecInstance->codecOemIface->CodecGetParameter(handle, params, paramCnt); - return HDF_SUCCESS; + return g_codecInstance->codecOemIface->CodecGetParameter(handle, params, paramCnt); } int32_t CodecStart(CODEC_HANDLETYPE handle) @@ -244,8 +256,7 @@ int32_t CodecStart(CODEC_HANDLETYPE handle) g_codecInstance->defaultCb.OutputBufferAvailable = DefaultCbOutputBufferAvailable; g_codecInstance->codecOemIface->CodecSetCallback(handle, &(g_codecInstance->defaultCb), 0); } - RunCodecInstance(g_codecInstance); - return HDF_SUCCESS; + return RunCodecInstance(g_codecInstance); } int32_t CodecStop(CODEC_HANDLETYPE handle) @@ -254,8 +265,7 @@ int32_t CodecStop(CODEC_HANDLETYPE handle) HDF_LOGE("%{public}s: g_codecInstance is NULL!", __func__); return HDF_FAILURE; } - StopCodecInstance(g_codecInstance); - return HDF_SUCCESS; + return StopCodecInstance(g_codecInstance); } int32_t CodecFlush(CODEC_HANDLETYPE handle, DirectionType directType) @@ -264,8 +274,7 @@ int32_t CodecFlush(CODEC_HANDLETYPE handle, DirectionType directType) HDF_LOGE("%{public}s: g_codecInstance or oemIface is NULL!", __func__); return HDF_FAILURE; } - g_codecInstance->codecOemIface->CodecFlush(handle, directType); - return HDF_SUCCESS; + return g_codecInstance->codecOemIface->CodecFlush(handle, directType); } int32_t CodecQueueInput(CODEC_HANDLETYPE handle, const CodecBuffer *inputData, uint32_t timeoutMs, int releaseFenceFd) @@ -343,6 +352,7 @@ int32_t CodecQueueOutput(CODEC_HANDLETYPE handle, CodecBuffer *outInfo, uint32_t } else if (g_codecInstance->codecStatus == CODEC_STATUS_STARTED) { CodecBuffer *info = GetOutputInfo(g_codecInstance, outInfo->bufferId); CopyCodecBuffer(info, outInfo); + info->buffer[0].length = 0; g_codecInstance->bufferManagerWrapper->PutUsedOutputDataBuffer(g_codecInstance->bufferManagerWrapper, info); return HDF_SUCCESS; } else if (g_codecInstance->codecStatus == CODEC_STATUS_STOPED) { @@ -377,7 +387,9 @@ int32_t CodecSetCallback(CODEC_HANDLETYPE handle, const CodecCallback *cb, UINTP HDF_LOGE("%{public}s: g_codecInstance or oemIface is NULL!", __func__); return HDF_FAILURE; } - g_codecInstance->codecOemIface->CodecSetCallback(handle, cb, instance); - g_codecInstance->hasCallback = true; - return HDF_SUCCESS; + int32_t ret = g_codecInstance->codecOemIface->CodecSetCallback(handle, cb, instance); + if (ret == HDF_SUCCESS) { + g_codecInstance->hasCallback = true; + } + return ret; } diff --git a/codec/hdi_service/codec_service_stub/codec_stub.c b/codec/hdi_service/codec_service_stub/codec_stub.c index 1ef78b1f5e..c51d47e78f 100644 --- a/codec/hdi_service/codec_service_stub/codec_stub.c +++ b/codec/hdi_service/codec_service_stub/codec_stub.c @@ -58,7 +58,7 @@ static int32_t SerCodecEnumerateCapability(struct HdfDeviceIoClient *client, str struct HdfSBuf *reply) { uint32_t index; - CodecCapability Capability; + CodecCapability capability; if (!HdfSbufReadUint32(data, &index)) { HDF_LOGE("%{public}s: read index failed!", __func__); @@ -68,16 +68,16 @@ static int32_t SerCodecEnumerateCapability(struct HdfDeviceIoClient *client, str HDF_LOGE("%{public}s: codec capabilities not inited!", __func__); return HDF_FAILURE; } - if (CodecEnumerateCapability(index, &Capability) != HDF_SUCCESS) { + if (CodecEnumerateCapability(index, &capability) != HDF_SUCCESS) { HDF_LOGE("%{public}s: EnumrateCapablity - no more capability to Enumrate!", __func__); return HDF_FAILURE; } - if (Capability.mime == MEDIA_MIMETYPE_INVALID) { + if (capability.mime == MEDIA_MIMETYPE_INVALID) { HDF_LOGE("%{public}s: Capability invalid, discard!", __func__); return HDF_FAILURE; } - if (CodecSerPackCapability(reply, &Capability) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: write Capability to sbuf failed!", __func__); + if (CodecSerPackCapability(reply, &capability) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: write capability to sbuf failed!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -88,7 +88,7 @@ static int32_t SerCodecGetCapability(struct HdfDeviceIoClient *client, struct Hd uint32_t flags; AvCodecMime mime; CodecType type; - CodecCapability Capability; + CodecCapability capability; if (!HdfSbufReadUint32(data, (uint32_t*)&mime)) { HDF_LOGE("%{public}s: read input mime failed!", __func__); @@ -102,12 +102,12 @@ static int32_t SerCodecGetCapability(struct HdfDeviceIoClient *client, struct Hd HDF_LOGE("%{public}s: read input flags failed!", __func__); return HDF_ERR_INVALID_PARAM; } - if (CodecGetCapability(mime, type, flags, &Capability) != HDF_SUCCESS) { + if (CodecGetCapability(mime, type, flags, &capability) != HDF_SUCCESS) { HDF_LOGE("%{public}s: GetCapability - got nothing!", __func__); return HDF_FAILURE; } - if (CodecSerPackCapability(reply, &Capability) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: write Capability to sbuf failed!", __func__); + if (CodecSerPackCapability(reply, &capability) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: write capability to sbuf failed!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; diff --git a/codec/test/demo/v1.0/codec_decode_test_ipc.c b/codec/test/demo/v1.0/codec_decode_test_ipc.c index 21344360b5..1b0226d0d3 100644 --- a/codec/test/demo/v1.0/codec_decode_test_ipc.c +++ b/codec/test/demo/v1.0/codec_decode_test_ipc.c @@ -230,9 +230,9 @@ int32_t SetExtDecParameter(void) paramCnt = 1; memset_s(¶m, sizeof(Param), 0, sizeof(Param)); param.key = (ParamKey)KEY_EXT_SPLIT_PARSE_RK; - int32_t needSplit = 1; + uint32_t needSplit = 1; param.val = &needSplit; - param.size = sizeof(int32_t); + param.size = sizeof(uint32_t); ret = g_codecProxy->CodecSetParameter(g_codecProxy, (CODEC_HANDLETYPE)g_handle, ¶m, paramCnt); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: CodecSetParameter failed", __func__); @@ -280,7 +280,7 @@ int32_t SetDecParameter(void) int32_t needDefault = 1; param.val = &needDefault; param.size = sizeof(int32_t); - ret = g_codecProxy->CodecGetParameter(g_codecProxy, (CODEC_HANDLETYPE)g_handle, ¶m, paramCnt); + ret = g_codecProxy->CodecSetParameter(g_codecProxy, (CODEC_HANDLETYPE)g_handle, ¶m, paramCnt); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: CodecSetParameter failed", __func__); return HDF_FAILURE; @@ -331,7 +331,7 @@ void DecodeLoopHandleInput(MpiDecLoopData *g_data) g_totalSrcSize += readSize; ShareMemory *sm = GetShareMemoryById(inputData->bufferId); memcpy_s(sm->virAddr, readSize, (uint8_t*)readData, readSize); - inputData->buffer[0].capacity = readSize; + inputData->buffer[0].length = readSize; g_codecProxy->CodecQueueInput(g_codecProxy, (CODEC_HANDLETYPE)g_handle, inputData, QUEUE_TIME_OUT, -1); } OsalMemFree(inputData); diff --git a/codec/test/demo/v1.0/codec_encode_test_ipc.c b/codec/test/demo/v1.0/codec_encode_test_ipc.c index e5ec2bdc7e..46c4e7dafa 100644 --- a/codec/test/demo/v1.0/codec_encode_test_ipc.c +++ b/codec/test/demo/v1.0/codec_encode_test_ipc.c @@ -295,7 +295,7 @@ void CalcBpsRange(RKHdiEncodeSetup *encSetup) } } /* setup qp for different codec and rc_mode */ - switch (encSetup->codecType.mimeCodecType) { + switch (encSetup->codecMime.mimeCodecType) { case MPP_VIDEO_CodingAVC: case MPP_VIDEO_CodingHEVC: { SetQpValue(encSetup); @@ -307,9 +307,9 @@ void CalcBpsRange(RKHdiEncodeSetup *encSetup) } } -void SetCodecTypeData(RKHdiCodecTypeSetup *codecTypeSet) +void SetCodecTypeData(RKHdiCodecMimeSetup *codecMimeSet) { - switch (codecTypeSet->mimeCodecType) { + switch (codecMimeSet->mimeCodecType) { case MEDIA_MIMETYPE_VIDEO_AVC: { /* * H.264 profile_idc parameter @@ -317,7 +317,7 @@ void SetCodecTypeData(RKHdiCodecTypeSetup *codecTypeSet) * 77 - Main profile * 100 - High profile */ - codecTypeSet->avcSetup.profile = AVC_SETUP_PROFILE_DEFAULT; + codecMimeSet->avcSetup.profile = AVC_SETUP_PROFILE_DEFAULT; /* * H.264 level_idc parameter * 10 / 11 / 12 / 13 - qcif@15fps / cif@7.5fps / cif@15fps / cif@30fps @@ -326,22 +326,75 @@ void SetCodecTypeData(RKHdiCodecTypeSetup *codecTypeSet) * 40 / 41 / 42 - 1080p@30fps / 1080p@30fps / 1080p@60fps * 50 / 51 / 52 - 4K@30fps */ - codecTypeSet->avcSetup.level = AVC_SETUP_LEVEL_DEFAULT; - codecTypeSet->avcSetup.cabacEn = AVC_SETUP_CABAC_EN_DEFAULT; - codecTypeSet->avcSetup.cabacIdc = AVC_SETUP_CABAC_IDC_DEFAULT; - codecTypeSet->avcSetup.trans8x8 = AVC_SETUP_TRANS_DEFAULT; + codecMimeSet->avcSetup.level = AVC_SETUP_LEVEL_DEFAULT; + codecMimeSet->avcSetup.cabacEn = AVC_SETUP_CABAC_EN_DEFAULT; + codecMimeSet->avcSetup.cabacIdc = AVC_SETUP_CABAC_IDC_DEFAULT; + codecMimeSet->avcSetup.trans8x8 = AVC_SETUP_TRANS_DEFAULT; break; } case MEDIA_MIMETYPE_VIDEO_HEVC: { break; } default: { - HDF_LOGE("%{public}s: unsupport encoder coding type %{public}d", __func__, codecTypeSet->mimeCodecType); + HDF_LOGE("%{public}s: unsupport encoder coding type %{public}d", __func__, codecMimeSet->mimeCodecType); break; } } } +void FreeParams(Param *params, int32_t paramCnt) +{ + if (params == NULL || paramCnt <= 0) { + HDF_LOGE("%{public}s: params is null or invalid count!", __func__); + return; + } + for (int32_t j = 0; j < paramCnt; j++) { + if (params[j].val != NULL && params[j].size > 0) { + OsalMemFree(params[j].val); + params[j].val = NULL; + } + } + OsalMemFree(params); +} + +void CheckEncSetup(Param *setParams, Param *getParams, int32_t paramCnt) +{ + if (setParams == NULL || getParams == NULL || paramCnt <= 0) { + HDF_LOGE("%{public}s: params is null or invalid count!", __func__); + return; + } + for (int32_t i = 0; i < paramCnt; i++) { + if (setParams[i].size != getParams[i].size) { + HDF_LOGE("%{public}s: params size incorrect!", __func__); + return; + } + if (memcmp(setParams[i].val, getParams[i].val, setParams[i].size) != 0) { + HDF_LOGE("%{public}s: params val incorrect! index:%{public}d", __func__, i); + return; + } + } + + HDF_LOGI("%{public}s: get all params correctly!", __func__); +} + +int32_t GetSetupParams(Param *setParams, int32_t paramCnt) +{ + Param *getParams = (Param *)OsalMemCalloc(sizeof(Param) * paramCnt); + + for (int32_t i = 0; i < paramCnt; i++) { + getParams[i].key = setParams[i].key; + } + int32_t ret = g_codecProxy->CodecGetParameter(g_codecProxy, (CODEC_HANDLETYPE)g_handle, getParams, paramCnt); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: CodecGetParameter failed, ret:%{public}d", __func__, ret); + FreeParams(getParams, paramCnt); + return HDF_FAILURE; + } + CheckEncSetup(setParams, getParams, paramCnt); + FreeParams(getParams, paramCnt); + return HDF_SUCCESS; +} + int32_t SetupExtEncParams(Param *params, RKHdiEncodeSetup *encSetup, int32_t count) { Param *param = NULL; @@ -357,16 +410,16 @@ int32_t SetupExtEncParams(Param *params, RKHdiEncodeSetup *encSetup, int32_t cou param = ¶ms[paramCount++]; param->key = KEY_MIMETYPE; - encSetup->codecType.mimeCodecType = MEDIA_MIMETYPE_VIDEO_AVC; - SetCodecTypeData(&encSetup->codecType); - param->val = &(encSetup->codecType); - param->size = sizeof(encSetup->codecType); + encSetup->codecMime.mimeCodecType = MEDIA_MIMETYPE_VIDEO_AVC; + SetCodecTypeData(&encSetup->codecMime); + param->val = &(encSetup->codecMime); + param->size = sizeof(encSetup->codecMime); param = ¶ms[paramCount++]; param->key = KEY_CODEC_TYPE; - CodecType codecType = VIDEO_ENCODER; - param->val = &codecType; - param->size = sizeof(codecType); + encSetup->codecType = VIDEO_ENCODER; + param->val = &encSetup->codecType; + param->size = sizeof(encSetup->codecType); param = ¶ms[paramCount++]; param->key = KEY_VIDEO_RC_MODE; @@ -438,9 +491,16 @@ int32_t SetupEncParams(RKHdiEncodeSetup *encSetup) paramCount = SetupExtEncParams(params, encSetup, paramCount); int32_t ret = g_codecProxy->CodecSetParameter(g_codecProxy, (CODEC_HANDLETYPE)g_handle, params, paramCount); if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: CodecSetParameter KEY_ENC_SETUP_RK failed", __func__); - return HDF_FAILURE; + HDF_LOGE("%{public}s: CodecSetParameter failed, ret:%{public}d", __func__, ret); + return ret; } + + ret = GetSetupParams(params, paramCount - 1); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: GetSetupParams failed", __func__); + return ret; + } + return HDF_SUCCESS; } @@ -471,7 +531,7 @@ void EncodeLoopHandleInput(CodecEnvData *p_data, uint8_t *readData) g_totalSrcSize += readSize; ShareMemory *sm = GetShareMemoryById(inputData->bufferId); memcpy_s(sm->virAddr, readSize, (uint8_t*)readData, readSize); - inputData->buffer[0].capacity = readSize; + inputData->buffer[0].length = readSize; g_codecProxy->CodecQueueInput(g_codecProxy, (CODEC_HANDLETYPE)g_handle, inputData, QUEUE_TIME_OUT, -1); } OsalMemFree(inputData); diff --git a/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp b/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp index 5bb92fc0b4..84b389aec5 100644 --- a/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp +++ b/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp @@ -210,7 +210,7 @@ HWTEST_F(CodecProxyTest, HdfCodecHdiV1GetDefaultCfgTest_008, TestSize.Level1) params->val = nullptr; params->size = 0; - int32_t errorCode = g_codecObj->CodecGetParameter(g_codecObj, g_handle, params, paramCnt); + int32_t errorCode = g_codecObj->CodecSetParameter(g_codecObj, g_handle, params, paramCnt); OsalMemFree(params); ASSERT_EQ(errorCode, HDF_SUCCESS); } -- Gitee