1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "icodec.h" 17 #include <gtest/gtest.h> 18 #include <osal_mem.h> 19 #include <unistd.h> 20 #include "codec_callback_stub.h" 21 22 using namespace std; 23 using namespace testing::ext; 24 25 namespace { 26 constexpr const char *TEST_SERVICE_NAME = "codec_hdi_service"; 27 ICodecCallback *g_callback = nullptr; 28 29 class CodecObjCTest : public testing::Test { 30 public: SetUpTestCase()31 static void SetUpTestCase(){} TearDownTestCase()32 static void TearDownTestCase(){} SetUp()33 void SetUp(){} TearDown()34 void TearDown(){} 35 }; 36 37 HWTEST_F(CodecObjCTest, CodecObjCTest_001, TestSize.Level0) 38 { 39 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 40 ASSERT_TRUE(codecObj != nullptr); 41 42 int32_t ec = codecObj->CodecInit(codecObj); 43 44 ASSERT_EQ(ec, HDF_SUCCESS); 45 46 HdiCodecRelease(codecObj); 47 } 48 49 HWTEST_F(CodecObjCTest, CodecObjCTest_002, TestSize.Level0) 50 { 51 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 52 ASSERT_TRUE(codecObj != nullptr); 53 54 int32_t ec = codecObj->CodecDeinit(codecObj); 55 56 ASSERT_EQ(ec, HDF_SUCCESS); 57 58 HdiCodecRelease(codecObj); 59 } 60 61 HWTEST_F(CodecObjCTest, CodecObjCTest_003, TestSize.Level0) 62 { 63 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 64 ASSERT_TRUE(codecObj != nullptr); 65 66 uint32_t index = 2; 67 CodecCapbility cap; 68 69 int32_t ec = codecObj->CodecEnumerateCapbility(codecObj, index, &cap); 70 71 ASSERT_EQ(ec, HDF_SUCCESS); 72 73 HdiCodecRelease(codecObj); 74 } 75 76 HWTEST_F(CodecObjCTest, CodecObjCTest_004, TestSize.Level0) 77 { 78 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 79 ASSERT_TRUE(codecObj != nullptr); 80 81 uint32_t flags = 1; 82 AvCodecMime mime = MEDIA_MIMETYPE_VIDEO_AVC; 83 CodecType type = AUDIO_DECODER; 84 CodecCapbility cap; 85 86 int32_t ec = codecObj->CodecGetCapbility(codecObj, mime, type, flags, &cap); 87 88 ASSERT_EQ(ec, HDF_SUCCESS); 89 ASSERT_EQ(cap.mime, MEDIA_MIMETYPE_VIDEO_AVC); 90 ASSERT_EQ(cap.type, AUDIO_DECODER); 91 ASSERT_EQ(cap.whAlignment.widthAlginment, 10); 92 ASSERT_EQ(cap.supportLevels.actualLen, 3); 93 94 HdiCodecRelease(codecObj); 95 } 96 97 HWTEST_F(CodecObjCTest, CodecObjCTest_005, TestSize.Level0) 98 { 99 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 100 ASSERT_TRUE(codecObj != nullptr); 101 int num = 10; 102 const char* name = "codec.avc.hardware.decoder"; 103 Param params; 104 params.key = KEY_CODEC_TYPE; 105 params.val = (void *)# 106 params.size = 20; 107 int len = 3; 108 uint32_t handle = 5; 109 110 int32_t ec = codecObj->CodecCreate(codecObj, name, ¶ms, len, (CODEC_HANDLETYPE *)&handle); 111 112 ASSERT_EQ(ec, HDF_SUCCESS); 113 ASSERT_EQ(params.key, KEY_CODEC_TYPE); 114 ASSERT_EQ(params.size, 20); 115 ASSERT_EQ(len, 3); 116 117 HdiCodecRelease(codecObj); 118 } 119 120 HWTEST_F(CodecObjCTest, CodecObjCTest_006, TestSize.Level0) 121 { 122 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 123 ASSERT_TRUE(codecObj != nullptr); 124 125 uint32_t handle = 5; 126 127 int32_t ec = codecObj->CodecDestroy(codecObj, (CODEC_HANDLETYPE *)&handle); 128 129 ASSERT_EQ(ec, HDF_SUCCESS); 130 131 HdiCodecRelease(codecObj); 132 } 133 134 HWTEST_F(CodecObjCTest, CodecObjCTest_007, TestSize.Level0) 135 { 136 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 137 ASSERT_TRUE(codecObj != nullptr); 138 139 uint32_t handle = 5; 140 DirectionType type = OUTPUT_TYPE; 141 BufferMode mode = EXTERNAL; 142 143 int32_t ec = codecObj->CodecSetPortMode(codecObj, (CODEC_HANDLETYPE *)&handle, type, mode); 144 145 ASSERT_EQ(ec, HDF_SUCCESS); 146 ASSERT_EQ(type, OUTPUT_TYPE); 147 ASSERT_EQ(mode, EXTERNAL); 148 149 HdiCodecRelease(codecObj); 150 } 151 152 HWTEST_F(CodecObjCTest, CodecObjCTest_008, TestSize.Level0) 153 { 154 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 155 ASSERT_TRUE(codecObj != nullptr); 156 157 uint32_t handle = 5; 158 Param params; 159 params.key = KEY_CODEC_TYPE; 160 params.val = 0; 161 params.size = 20; 162 163 int paramCnt = 3; 164 165 int32_t ec = codecObj->CodecSetParameter(codecObj, (CODEC_HANDLETYPE *)&handle, ¶ms, paramCnt); 166 167 ASSERT_EQ(ec, HDF_SUCCESS); 168 ASSERT_EQ(params.key, KEY_CODEC_TYPE); 169 ASSERT_EQ(params.size, 20); 170 ASSERT_EQ(paramCnt, 3); 171 172 HdiCodecRelease(codecObj); 173 } 174 175 HWTEST_F(CodecObjCTest, CodecObjCTest_009, TestSize.Level0) 176 { 177 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 178 ASSERT_TRUE(codecObj != nullptr); 179 180 uint32_t handle = 5; 181 int paramCnt = 3; 182 Param *params; 183 params = (Param *)OsalMemAlloc(sizeof(Param)*paramCnt); 184 ASSERT_TRUE(params != nullptr); 185 params->key = KEY_CODEC_TYPE; 186 params->val = 0; 187 params->size = 20; 188 189 int32_t ec = codecObj->CodecGetParameter(codecObj, (CODEC_HANDLETYPE *)&handle, params, paramCnt); 190 191 ASSERT_EQ(ec, HDF_SUCCESS); 192 OsalMemFree(params); 193 HdiCodecRelease(codecObj); 194 } 195 196 HWTEST_F(CodecObjCTest, CodecObjCTest_010, TestSize.Level0) 197 { 198 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 199 ASSERT_TRUE(codecObj != nullptr); 200 201 uint32_t handle = 5; 202 203 int32_t ec = codecObj->CodecStart(codecObj, (CODEC_HANDLETYPE *)&handle); 204 205 ASSERT_EQ(ec, HDF_SUCCESS); 206 207 HdiCodecRelease(codecObj); 208 } 209 210 HWTEST_F(CodecObjCTest, CodecObjCTest_011, TestSize.Level0) 211 { 212 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 213 ASSERT_TRUE(codecObj != nullptr); 214 215 uint32_t handle = 5; 216 217 int32_t ec = codecObj->CodecStop(codecObj, (CODEC_HANDLETYPE *)&handle); 218 219 ASSERT_EQ(ec, HDF_SUCCESS); 220 221 HdiCodecRelease(codecObj); 222 } 223 224 HWTEST_F(CodecObjCTest, CodecObjCTest_012, TestSize.Level0) 225 { 226 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 227 ASSERT_TRUE(codecObj != nullptr); 228 229 uint32_t handle = 5; 230 DirectionType directType = OUTPUT_TYPE; 231 232 int32_t ec = codecObj->CodecFlush(codecObj, (CODEC_HANDLETYPE *)&handle, directType); 233 234 ASSERT_EQ(ec, HDF_SUCCESS); 235 ASSERT_EQ(directType, OUTPUT_TYPE); 236 237 HdiCodecRelease(codecObj); 238 } 239 240 HWTEST_F(CodecObjCTest, CodecObjCTest_013, TestSize.Level0) 241 { 242 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 243 ASSERT_TRUE(codecObj != nullptr); 244 245 uint32_t handle = 5; 246 InputInfo inputData = {0}; 247 inputData.bufferCnt = 1; 248 inputData.buffers = (CodecBufferInfo *)OsalMemAlloc(sizeof(CodecBufferInfo) * inputData.bufferCnt); 249 inputData.buffers->type = BUFFER_TYPE_FD; 250 inputData.buffers->fd = 2; 251 inputData.buffers->offset = 3; 252 inputData.buffers->length = 4; 253 inputData.buffers->size = 5; 254 inputData.pts = 0; 255 inputData.flag = STREAM_FLAG_CODEC_SPECIFIC_INF; 256 uint32_t timeoutMs = 10; 257 258 int32_t ec = codecObj->CodecQueueInput(codecObj, (CODEC_HANDLETYPE *)&handle, &inputData, timeoutMs); 259 ASSERT_EQ(ec, HDF_SUCCESS); 260 ASSERT_EQ(inputData.pts, 0); 261 ASSERT_EQ(inputData.flag, STREAM_FLAG_CODEC_SPECIFIC_INF); 262 ASSERT_EQ(ec, HDF_SUCCESS); 263 OsalMemFree(inputData.buffers); 264 HdiCodecRelease(codecObj); 265 } 266 267 HWTEST_F(CodecObjCTest, CodecObjCTest_014, TestSize.Level0) 268 { 269 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 270 ASSERT_TRUE(codecObj != nullptr); 271 272 uint32_t handle = 5; 273 uint32_t timeoutMs = 10; 274 InputInfo inputData = {0}; 275 inputData.bufferCnt = 1; 276 inputData.buffers = (CodecBufferInfo *)OsalMemAlloc(sizeof(CodecBufferInfo) * (inputData.bufferCnt)); 277 ASSERT_TRUE(inputData.buffers != nullptr); 278 int32_t ec = codecObj->CodecDequeInput(codecObj, (CODEC_HANDLETYPE *)&handle, timeoutMs, &inputData); 279 280 ASSERT_EQ(ec, HDF_SUCCESS); 281 ASSERT_EQ((int)timeoutMs, 10); 282 OsalMemFree(inputData.buffers); 283 HdiCodecRelease(codecObj); 284 } 285 286 HWTEST_F(CodecObjCTest, CodecObjCTest_015, TestSize.Level0) 287 { 288 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 289 ASSERT_TRUE(codecObj != nullptr); 290 291 uint32_t handle = 5; 292 OutputInfo outInfo = {0}; 293 outInfo.bufferCnt = 1; 294 outInfo.buffers = (CodecBufferInfo *)OsalMemAlloc(sizeof(CodecBufferInfo) * (outInfo.bufferCnt)); 295 outInfo.buffers->type = BUFFER_TYPE_FD; 296 outInfo.buffers->fd = 1; 297 outInfo.buffers->offset = 2; 298 outInfo.buffers->length = 3; 299 outInfo.buffers->size = 4; 300 outInfo.timeStamp = 0; 301 outInfo.sequence = 1; 302 outInfo.flag = STREAM_FLAG_CODEC_SPECIFIC_INF; 303 outInfo.type = AUDIO_DECODER; 304 outInfo.vendorPrivate = 0; 305 uint32_t timeoutMs = 10; 306 int releaseFenceFd = 3; 307 308 int32_t ec = codecObj->CodecQueueOutput(codecObj, (CODEC_HANDLETYPE *)&handle, &outInfo, timeoutMs, releaseFenceFd); 309 310 ASSERT_EQ(ec, HDF_SUCCESS); 311 ASSERT_EQ((int)timeoutMs, 10); 312 ASSERT_EQ(releaseFenceFd, 3); 313 OsalMemFree(outInfo.buffers); 314 HdiCodecRelease(codecObj); 315 } 316 317 HWTEST_F(CodecObjCTest, CodecObjCTest_016, TestSize.Level0) 318 { 319 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 320 ASSERT_TRUE(codecObj != nullptr); 321 322 uint32_t handle = 5; 323 uint32_t timeoutMs = 10; 324 int acquireFd; 325 OutputInfo outInfo = {0}; 326 outInfo.bufferCnt = 1; 327 outInfo.buffers = (CodecBufferInfo *)OsalMemAlloc(sizeof(CodecBufferInfo) * (outInfo.bufferCnt)); 328 ASSERT_TRUE(outInfo.buffers != nullptr); 329 int32_t ec = codecObj->CodecDequeueOutput(codecObj, (CODEC_HANDLETYPE *)&handle, timeoutMs, &acquireFd, &outInfo); 330 331 ASSERT_EQ(ec, HDF_SUCCESS); 332 ASSERT_EQ((int)timeoutMs, 10); 333 OsalMemFree(outInfo.buffers); 334 HdiCodecRelease(codecObj); 335 } 336 337 HWTEST_F(CodecObjCTest, CodecObjCTest_017, TestSize.Level0) 338 { 339 struct ICodec *codecObj = HdiCodecGet(TEST_SERVICE_NAME); 340 ASSERT_TRUE(codecObj != nullptr); 341 342 uint32_t handle = 5; 343 UINTPTR instance = 0; 344 g_callback = CodecCallbackStubObtain(); 345 ASSERT_TRUE(g_callback != nullptr); 346 347 int32_t ec = codecObj->CodecSetCallback(codecObj, (CODEC_HANDLETYPE *)&handle, g_callback, instance); 348 349 ASSERT_EQ(ec, HDF_SUCCESS); 350 HdiCodecRelease(codecObj); 351 } 352 }