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 std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
256 EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
257 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::ERROR);
258 }
259
260 /**
261 * @tc.name: MediaCodecEncoderAdapterImpl_SetCallbackDec_004.
262 * @tc.desc: test of MediaCodecEncoderAdapterImpl::SetCodecCallback
263 * @tc.type: FUNC.
264 * @tc.require:
265 */
266 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_SetCodecCallback_004, TestSize.Level1)
267 {
268 std::shared_ptr<CodecCallbackAdapter> callback = nullptr;
269 EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
270 callback = std::make_shared<EncoderCallbackAdapterMock>();
271 EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
272 }
273
274 /**
275 * @tc.name: MediaCodecEncoderAdapterImpl_GetTypeOrFlag_005.
276 * @tc.desc: test of MediaCodecEncoderAdapterImpl::GetErrorType() GetBufferFlag()
277 * @tc.type: FUNC.
278 * @tc.require:
279 */
280 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_GetTypeOrFlag_005, TestSize.Level1)
281 {
282 EXPECT_EQ(
283 mediaCodecEncoderAdapterImpl->GetErrorType(OHOS::MediaAVCodec::AVCodecErrorType::AVCODEC_ERROR_EXTEND_START),
284 ErrorType::CODEC_ERROR_EXTEND_START);
285 EXPECT_EQ(
286 mediaCodecEncoderAdapterImpl->GetBufferFlag(OHOS::MediaAVCodec::AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS),
287 BufferFlag::CODEC_BUFFER_FLAG_EOS);
288 AVCodecErrorType testAVCodecErrorType = static_cast<AVCodecErrorType>(100);
289 EXPECT_EQ(mediaCodecEncoderAdapterImpl->GetErrorType(testAVCodecErrorType), ErrorType::CODEC_ERROR_INTERNAL);
290 AVCodecBufferFlag testAVCodecBufferFlag = static_cast<AVCodecBufferFlag>(100);
291 EXPECT_EQ(mediaCodecEncoderAdapterImpl->GetBufferFlag(testAVCodecBufferFlag), BufferFlag::CODEC_BUFFER_FLAG_NONE);
292 }
293
294 /**
295 * @tc.name: MediaCodecEncoderAdapterImpl_OnError_006.
296 * @tc.desc: test of MediaCodecEncoderAdapterImpl::GetErrorType() GetBufferFlag()
297 * @tc.type: FUNC.
298 * @tc.require:
299 */
300 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_OnError_006, TestSize.Level1)
301 {
302 std::shared_ptr<CodecCallbackAdapter> cb = nullptr;
303 std::shared_ptr<EncoderCallbackImpl> callbackImpl = std::make_shared<EncoderCallbackImpl>(cb);
304 EXPECT_NE(callbackImpl, nullptr);
305 std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
306 EXPECT_NE(callback, nullptr);
307 callbackImpl->cb_ = callback;
308 callbackImpl->OnError(OHOS::MediaAVCodec::AVCodecErrorType::AVCODEC_ERROR_EXTEND_START, 1);
309 MediaAVCodec::Format fomat;
310 callbackImpl->OnOutputFormatChanged(fomat);
311 callbackImpl->OnInputBufferAvailable(1, nullptr);
312 std::shared_ptr<Media::AVSharedMemory> memory = std::make_shared<Media::AVSharedMemoryBase>(1, 1.0, "test");
313 callbackImpl->OnInputBufferAvailable(1, memory);
314 AVCodecBufferInfo info;
315 callbackImpl->OnOutputBufferAvailable(1, info, AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS, memory);
316 }
317
318 /**
319 * @tc.name: MediaCodecEncoderAdapterImpl_GetList_001.
320 * @tc.desc: test of MediaCodecListAdapterImpl::GetCodecCapability()
321 * @tc.type: FUNC.
322 * @tc.require:
323 */
324 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_GetList_001, TestSize.Level1)
325 {
326 MediaCodecListAdapterImpl& codecListImpl = MediaCodecListAdapterImpl::GetInstance();
327
328 std::shared_ptr<CapabilityDataAdapter> capaData = codecListImpl.GetCodecCapability("test", true);
329 EXPECT_NE(capaData, nullptr);
330 EXPECT_EQ(capaData->GetMaxWidth(), 0);
331
332 capaData = codecListImpl.GetCodecCapability("video/avc", true);
333 EXPECT_NE(capaData, nullptr);
334 EXPECT_NE(capaData->GetMaxWidth(), 0);
335 }
336
337 /**
338 * @tc.name: MediaCodecEncoderAdapterImpl_Surface_001.
339 * @tc.desc: test of ProducerSurfaceAdapterImpl::RequestBuffer()、FlushBuffer()
340 * @tc.type: FUNC.
341 * @tc.require:
342 */
343 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_Surface_001, TestSize.Level1)
344 {
345 const std::string mimetype = "video/avc";
346 EXPECT_EQ(mediaCodecEncoderAdapterImpl->CreateVideoCodecByMime(mimetype), CodecCodeAdapter::OK);
347 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(config_), CodecCodeAdapter::OK);
348 std::shared_ptr<ProducerSurfaceAdapter> surfaceAdapter =
349 mediaCodecEncoderAdapterImpl->CreateInputSurface();
350 ASSERT_NE(surfaceAdapter, nullptr);
351 int32_t fence = -1;
352 auto configAdapter = std::make_shared<BufferRequestConfigAdapterMock>();
353 EXPECT_NE(configAdapter, nullptr);
354 std::shared_ptr<SurfaceBufferAdapter> SurfaceBufferAdapter =
355 surfaceAdapter->RequestBuffer(fence, configAdapter);
356 EXPECT_NE(SurfaceBufferAdapter, nullptr);
357
358 auto fulshConfigAdapter = std::make_shared<BufferFlushConfigAdapterMock>();
359 EXPECT_NE(fulshConfigAdapter, nullptr);
360 int32_t ret = surfaceAdapter->FlushBuffer(SurfaceBufferAdapter, fence, fulshConfigAdapter);
361 EXPECT_NE(ret, 0);
362
363 uint32_t index = 0;
364 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::OK);
365 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Start(), CodecCodeAdapter::OK);
366 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Stop(), CodecCodeAdapter::OK);
367 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Reset(), CodecCodeAdapter::OK);
368 EXPECT_EQ(mediaCodecEncoderAdapterImpl->Release(), CodecCodeAdapter::OK);
369 EXPECT_EQ(mediaCodecEncoderAdapterImpl->ReleaseOutputBuffer(index, true), CodecCodeAdapter::ERROR);
370 EXPECT_EQ(mediaCodecEncoderAdapterImpl->RequestKeyFrameSoon(), CodecCodeAdapter::ERROR);
371 }
372 } // namespace OHOS::NWeb
373