1 /*
2 * Copyright (c) 2024 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 "gtest/gtest.h"
17 #define private public
18 #include "avcodec_list.h"
19 #include "avcodec_video_encoder_impl.h"
20 #include "media_codec_encoder_adapter_impl.h"
21 #include "media_codec_list_adapter_impl.h"
22 #undef private
23 #include "avsharedmemory.h"
24 #include "avsharedmemorybase.h"
25
26 using testing::ext::TestSize;
27 using namespace OHOS::MediaAVCodec;
28
29 namespace OHOS::NWeb {
30 namespace {
31 const int32_t DEFAULT_WIDTH = 1396;
32 const int32_t DEFAULT_HEIGHT = 1396;
33 }
34 class EncoderCallbackImplTest : public testing::Test {};
35
36 class EncoderCallbackAdapterMock : public CodecCallbackAdapter {
37 public:
38 EncoderCallbackAdapterMock() = default;
39
40 ~EncoderCallbackAdapterMock() override = default;
41
OnError(ErrorType errorType,int32_t errorCode)42 void OnError(ErrorType errorType, int32_t errorCode) override {}
43
OnStreamChanged(const std::shared_ptr<CodecFormatAdapter> formatApadter_)44 void OnStreamChanged(const std::shared_ptr<CodecFormatAdapter> formatApadter_) override {}
45
OnNeedInputData(uint32_t index,std::shared_ptr<OhosBufferAdapter> buffer)46 void OnNeedInputData(uint32_t index, std::shared_ptr<OhosBufferAdapter> buffer) override {}
47
OnNeedOutputData(uint32_t index,std::shared_ptr<BufferInfoAdapter> info,BufferFlag flag,std::shared_ptr<OhosBufferAdapter> buffer)48 void OnNeedOutputData(uint32_t index, std::shared_ptr<BufferInfoAdapter> info, BufferFlag flag,
49 std::shared_ptr<OhosBufferAdapter> buffer) override
50 {}
51 };
52
53 class ProducerSurfaceAdapterMock : public ProducerSurfaceAdapter {
54 public:
55 ProducerSurfaceAdapterMock() = default;
56
57 virtual ~ProducerSurfaceAdapterMock() = default;
58
RequestBuffer(int32_t & fence,std::shared_ptr<BufferRequestConfigAdapter> configAdapter)59 std::shared_ptr<SurfaceBufferAdapter> RequestBuffer(
60 int32_t& fence, std::shared_ptr<BufferRequestConfigAdapter> configAdapter) override
61 {
62 return nullptr;
63 };
64
FlushBuffer(std::shared_ptr<SurfaceBufferAdapter> bufferAdapter,int32_t fence,std::shared_ptr<BufferFlushConfigAdapter> flushConfigAdapter)65 int32_t FlushBuffer(std::shared_ptr<SurfaceBufferAdapter> bufferAdapter, int32_t fence,
66 std::shared_ptr<BufferFlushConfigAdapter> flushConfigAdapter) override
67 {
68 return 0;
69 };
70 };
71
72 class CodecConfigParaAdapterMock : public CodecConfigParaAdapter {
73 public:
74 CodecConfigParaAdapterMock() = default;
75
GetWidth()76 int32_t GetWidth() override
77 {
78 return width;
79 }
80
GetHeight()81 int32_t GetHeight() override
82 {
83 return height;
84 }
85
GetBitRate()86 int64_t GetBitRate() override
87 {
88 return bitRate;
89 }
90
GetFrameRate()91 double GetFrameRate() override
92 {
93 return frameRate;
94 }
95
96 int32_t width;
97 int32_t height;
98 int64_t bitRate;
99 double frameRate;
100 };
101
102 class BufferRequestConfigAdapterMock : public BufferRequestConfigAdapter {
103 public:
104 BufferRequestConfigAdapterMock() = default;
105
106 ~BufferRequestConfigAdapterMock() override = default;
107
GetWidth()108 int32_t GetWidth() override
109 {
110 return DEFAULT_WIDTH;
111 }
112
GetHeight()113 int32_t GetHeight() override
114 {
115 return DEFAULT_HEIGHT;
116 }
117
GetStrideAlignment()118 int32_t GetStrideAlignment() override
119 {
120 return 1;
121 }
122
GetFormat()123 int32_t GetFormat() override
124 {
125 return 1;
126 }
127
GetUsage()128 uint64_t GetUsage() override
129 {
130 return 1;
131 }
132
GetTimeout()133 int32_t GetTimeout() override
134 {
135 return 1;
136 }
137
GetColorGamut()138 ColorGamutAdapter GetColorGamut() override
139 {
140 return ColorGamutAdapter::STANDARD_BT601;
141 }
142
GetTransformType()143 TransformTypeAdapter GetTransformType() override
144 {
145 return TransformTypeAdapter::ROTATE_90;
146 }
147 };
148
149 class BufferFlushConfigAdapterMock : public BufferFlushConfigAdapter {
150 public:
151 BufferFlushConfigAdapterMock() = default;
152
153 ~BufferFlushConfigAdapterMock() override = default;
154
GetX()155 int32_t GetX() override
156 {
157 return 1;
158 }
159
GetY()160 int32_t GetY() override
161 {
162 return 1;
163 }
164
GetW()165 int32_t GetW() override
166 {
167 return DEFAULT_WIDTH;
168 }
169
GetH()170 int32_t GetH() override
171 {
172 return DEFAULT_HEIGHT;
173 }
174
GetTimestamp()175 int64_t GetTimestamp() override
176 {
177 return 1;
178 }
179 };
180
181 class MediaCodecEncoderAdapterImplTest : public testing::Test {
182 protected:
183 void SetUp() override;
184 std::shared_ptr<CodecConfigParaAdapterMock> config_ = nullptr;
185 std::shared_ptr<MediaCodecEncoderAdapterImpl> mediaCodecEncoderAdapterImpl = nullptr;
186 };
187
SetUp()188 void MediaCodecEncoderAdapterImplTest::SetUp()
189 {
190 constexpr int32_t testWidth = 640;
191 constexpr int32_t testHeight = 360;
192 constexpr int32_t testBitRate = 300000;
193 constexpr int32_t testFrameRate = 15;
194
195 EXPECT_EQ(mediaCodecEncoderAdapterImpl, nullptr);
196 mediaCodecEncoderAdapterImpl = std::make_unique<MediaCodecEncoderAdapterImpl>();
197 EXPECT_NE(mediaCodecEncoderAdapterImpl, nullptr);
198 EXPECT_EQ(mediaCodecEncoderAdapterImpl->encoder_, nullptr);
199 EXPECT_EQ(config_, nullptr);
200 config_ = std::make_shared<CodecConfigParaAdapterMock>();
201 EXPECT_NE(config_, nullptr);
202 config_->width = testWidth;
203 config_->height = testHeight;
204 config_->bitRate = testBitRate;
205 config_->frameRate = testFrameRate;
206 }
207
208 /**
209 * @tc.name: MediaCodecEncoderAdapterImpl_CreateVideoEncoderByName_001.
210 * @tc.desc: test of MediaCodecEncoderAdapterImpl::CreateVideoEncoderByName() CreateVideoEncoderByName()
211 * @tc.type: FUNC.
212 * @tc.require:
213 */
214 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_CreateVideoEncoderByName_001, TestSize.Level1)
215 {
216 const std::string mimetype_ = "testmimeType";
217 EXPECT_EQ(mediaCodecEncoderAdapterImpl->CreateVideoCodecByMime(mimetype_), CodecCodeAdapter::ERROR);
218 const std::string name_ = "testname";
219 EXPECT_EQ(mediaCodecEncoderAdapterImpl->CreateVideoCodecByName(name_), CodecCodeAdapter::ERROR);
220 }
221
222 /**
223 * @tc.name: MediaCodecEncoderAdapterImpl_InvalidValueTest_002.
224 * @tc.desc: test of InvalidValueScene in MediaCodecEncoderAdapterImpl
225 * @tc.type: FUNC.
226 * @tc.require:
227 */
228 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_InvalidValueTest_002, TestSize.Level1)
229 {
230 uint32_t index = 0;
231 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(config_), CodecCodeAdapter::ERROR);
232 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::ERROR);
233 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Start(), CodecCodeAdapter::ERROR);
234 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Stop(), CodecCodeAdapter::ERROR);
235 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Reset(), CodecCodeAdapter::ERROR);
236 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Release(), CodecCodeAdapter::ERROR);
237 EXPECT_EQ(mediaCodecEncoderAdapterImpl->ReleaseOutputBuffer(index, true), CodecCodeAdapter::ERROR);
238 EXPECT_EQ(mediaCodecEncoderAdapterImpl->RequestKeyFrameSoon(), CodecCodeAdapter::ERROR);
239 std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
240 EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
241 std::shared_ptr<ProducerSurfaceAdapter> surface = mediaCodecEncoderAdapterImpl->CreateInputSurface();
242 EXPECT_EQ(surface, nullptr);
243 }
244
245 /**
246 * @tc.name: MediaCodecEncoderAdapterImpl_NormalTest_003.
247 * @tc.desc: test of NormalScene in MediaCodecEncoderAdapterImpl
248 * @tc.type: FUNC.
249 * @tc.require:
250 */
251 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_NormalTest_003, TestSize.Level1)
252 {
253 mediaCodecEncoderAdapterImpl->encoder_ = std::make_shared<MediaAVCodec::AVCodecVideoEncoderImpl>();
254 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(config_), CodecCodeAdapter::ERROR);
255 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(nullptr), CodecCodeAdapter::ERROR);
256 std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
257 EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
258 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::ERROR);
259 }
260
261 /**
262 * @tc.name: MediaCodecEncoderAdapterImpl_SetCallbackDec_004.
263 * @tc.desc: test of MediaCodecEncoderAdapterImpl::SetCodecCallback
264 * @tc.type: FUNC.
265 * @tc.require:
266 */
267 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_SetCodecCallback_004, TestSize.Level1)
268 {
269 std::shared_ptr<CodecCallbackAdapter> callback = nullptr;
270 EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
271 callback = std::make_shared<EncoderCallbackAdapterMock>();
272 EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
273 }
274
275 /**
276 * @tc.name: MediaCodecEncoderAdapterImpl_GetTypeOrFlag_005.
277 * @tc.desc: test of MediaCodecEncoderAdapterImpl::GetErrorType() GetBufferFlag()
278 * @tc.type: FUNC.
279 * @tc.require:
280 */
281 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_GetTypeOrFlag_005, TestSize.Level1)
282 {
283 EXPECT_EQ(
284 mediaCodecEncoderAdapterImpl->GetErrorType(OHOS::MediaAVCodec::AVCodecErrorType::AVCODEC_ERROR_EXTEND_START),
285 ErrorType::CODEC_ERROR_EXTEND_START);
286 EXPECT_EQ(
287 mediaCodecEncoderAdapterImpl->GetBufferFlag(OHOS::MediaAVCodec::AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS),
288 BufferFlag::CODEC_BUFFER_FLAG_EOS);
289 AVCodecErrorType testAVCodecErrorType = static_cast<AVCodecErrorType>(100);
290 EXPECT_EQ(mediaCodecEncoderAdapterImpl->GetErrorType(testAVCodecErrorType), ErrorType::CODEC_ERROR_INTERNAL);
291 AVCodecBufferFlag testAVCodecBufferFlag = static_cast<AVCodecBufferFlag>(100);
292 EXPECT_EQ(mediaCodecEncoderAdapterImpl->GetBufferFlag(testAVCodecBufferFlag), BufferFlag::CODEC_BUFFER_FLAG_NONE);
293 }
294
295 /**
296 * @tc.name: MediaCodecEncoderAdapterImpl_OnError_006.
297 * @tc.desc: test of MediaCodecEncoderAdapterImpl::GetErrorType() GetBufferFlag()
298 * @tc.type: FUNC.
299 * @tc.require:
300 */
301 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_OnError_006, TestSize.Level1)
302 {
303 std::shared_ptr<CodecCallbackAdapter> cb = nullptr;
304 std::shared_ptr<EncoderCallbackImpl> callbackImpl = std::make_shared<EncoderCallbackImpl>(cb);
305 EXPECT_NE(callbackImpl, nullptr);
306 std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
307 EXPECT_NE(callback, nullptr);
308 callbackImpl->cb_ = callback;
309 callbackImpl->OnError(OHOS::MediaAVCodec::AVCodecErrorType::AVCODEC_ERROR_EXTEND_START, 1);
310 MediaAVCodec::Format fomat;
311 callbackImpl->OnOutputFormatChanged(fomat);
312 callbackImpl->OnInputBufferAvailable(1, nullptr);
313 std::shared_ptr<Media::AVSharedMemory> memory = std::make_shared<Media::AVSharedMemoryBase>(1, 1.0, "test");
314 callbackImpl->OnInputBufferAvailable(1, memory);
315 AVCodecBufferInfo info;
316 callbackImpl->OnOutputBufferAvailable(1, info, AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS, memory);
317
318 callbackImpl->cb_ = nullptr;
319 callbackImpl->OnError(OHOS::MediaAVCodec::AVCodecErrorType::AVCODEC_ERROR_EXTEND_START, 1);
320 callbackImpl->OnOutputFormatChanged(fomat);
321 callbackImpl->OnInputBufferAvailable(1, nullptr);
322 callbackImpl->OnInputBufferAvailable(1, memory);
323 callbackImpl->OnOutputBufferAvailable(1, info, AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS, memory);
324 }
325
326 /**
327 * @tc.name: MediaCodecEncoderAdapterImpl_GetList_001.
328 * @tc.desc: test of MediaCodecListAdapterImpl::GetCodecCapability()
329 * @tc.type: FUNC.
330 * @tc.require:
331 */
332 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_GetList_001, TestSize.Level1)
333 {
334 MediaCodecListAdapterImpl& codecListImpl = MediaCodecListAdapterImpl::GetInstance();
335
336 std::shared_ptr<CapabilityDataAdapter> capaData = codecListImpl.GetCodecCapability("test", true);
337 EXPECT_NE(capaData, nullptr);
338 EXPECT_EQ(capaData->GetMaxWidth(), 0);
339
340 capaData = codecListImpl.GetCodecCapability("video/avc", true);
341 EXPECT_NE(capaData, nullptr);
342 EXPECT_NE(capaData->GetMaxWidth(), 0);
343 }
344
345 /**
346 * @tc.name: MediaCodecEncoderAdapterImpl_Surface_001.
347 * @tc.desc: test of ProducerSurfaceAdapterImpl::RequestBuffer()、FlushBuffer()
348 * @tc.type: FUNC.
349 * @tc.require:
350 */
351 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_Surface_001, TestSize.Level1)
352 {
353 const std::string mimetype = "video/avc";
354 EXPECT_EQ(mediaCodecEncoderAdapterImpl->CreateVideoCodecByMime(mimetype), CodecCodeAdapter::OK);
355 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(config_), CodecCodeAdapter::OK);
356 std::shared_ptr<ProducerSurfaceAdapter> surfaceAdapter =
357 mediaCodecEncoderAdapterImpl->CreateInputSurface();
358 ASSERT_NE(surfaceAdapter, nullptr);
359 int32_t fence = -1;
360 auto configAdapter = std::make_shared<BufferRequestConfigAdapterMock>();
361 EXPECT_NE(configAdapter, nullptr);
362 std::shared_ptr<SurfaceBufferAdapter> SurfaceBufferAdapter =
363 surfaceAdapter->RequestBuffer(fence, configAdapter);
364 EXPECT_NE(SurfaceBufferAdapter, nullptr);
365
366 auto fulshConfigAdapter = std::make_shared<BufferFlushConfigAdapterMock>();
367 EXPECT_NE(fulshConfigAdapter, nullptr);
368 int32_t ret = surfaceAdapter->FlushBuffer(SurfaceBufferAdapter, fence, fulshConfigAdapter);
369 EXPECT_NE(ret, 0);
370
371 uint32_t index = 0;
372 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::OK);
373 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Start(), CodecCodeAdapter::OK);
374 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Stop(), CodecCodeAdapter::OK);
375 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Reset(), CodecCodeAdapter::OK);
376 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Release(), CodecCodeAdapter::OK);
377 EXPECT_EQ(mediaCodecEncoderAdapterImpl->ReleaseOutputBuffer(index, true), CodecCodeAdapter::ERROR);
378 EXPECT_EQ(mediaCodecEncoderAdapterImpl->RequestKeyFrameSoon(), CodecCodeAdapter::ERROR);
379 }
380 } // namespace OHOS::NWeb
381