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 /**
182  * @tc.name: EncoderCallbackImpl_NormalTest_001.
183  * @tc.desc: test of EncoderCallbackImpl::OnError() OnOutputFormatChanged() OnInputBufferAvailable()
184  * @tc.type: FUNC.
185  * @tc.require:
186  */
187 HWTEST_F(EncoderCallbackImplTest, EncoderCallbackImpl_NormalTest_001, TestSize.Level1)
188 {
189     std::shared_ptr<CodecCallbackAdapter> cb = nullptr;
190     std::shared_ptr<EncoderCallbackImpl> callbackImpl = std::make_shared<EncoderCallbackImpl>(cb);
191     const int32_t errorcode = 0;
192     const AVCodecErrorType errorType = AVCODEC_ERROR_EXTEND_START;
193     callbackImpl->OnError(errorType, errorcode);
194     Media::Format fomat;
195     callbackImpl->OnOutputFormatChanged(fomat);
196     uint32_t index = 1;
197     std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
198     callbackImpl->OnInputBufferAvailable(index, buffer);
199     AVCodecBufferInfo info;
200     callbackImpl->OnOutputBufferAvailable(1, info, AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS, nullptr);
201 }
202 
203 class MediaCodecEncoderAdapterImplTest : public testing::Test {
204 protected:
205     void SetUp() override;
206     std::shared_ptr<CodecConfigParaAdapterMock> config_ = nullptr;
207     std::shared_ptr<MediaCodecEncoderAdapterImpl> mediaCodecEncoderAdapterImpl = nullptr;
208 };
209 
SetUp()210 void MediaCodecEncoderAdapterImplTest::SetUp()
211 {
212     constexpr int32_t testWidth = 640;
213     constexpr int32_t testHeight = 360;
214     constexpr int32_t testBitRate = 300000;
215     constexpr int32_t testFrameRate = 15;
216 
217     EXPECT_EQ(mediaCodecEncoderAdapterImpl, nullptr);
218     mediaCodecEncoderAdapterImpl = std::make_unique<MediaCodecEncoderAdapterImpl>();
219     EXPECT_NE(mediaCodecEncoderAdapterImpl, nullptr);
220     EXPECT_EQ(mediaCodecEncoderAdapterImpl->encoder_, nullptr);
221     EXPECT_EQ(config_, nullptr);
222     config_ = std::make_shared<CodecConfigParaAdapterMock>();
223     EXPECT_NE(config_, nullptr);
224     config_->width = testWidth;
225     config_->height = testHeight;
226     config_->bitRate = testBitRate;
227     config_->frameRate = testFrameRate;
228 }
229 
230 /**
231  * @tc.name: MediaCodecEncoderAdapterImpl_CreateVideoEncoderByName_001.
232  * @tc.desc: test of MediaCodecEncoderAdapterImpl::CreateVideoEncoderByName() CreateVideoEncoderByName()
233  * @tc.type: FUNC.
234  * @tc.require:
235  */
236 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_CreateVideoEncoderByName_001, TestSize.Level1)
237 {
238     const std::string mimetype_ = "testmimeType";
239     EXPECT_EQ(mediaCodecEncoderAdapterImpl->CreateVideoCodecByMime(mimetype_), CodecCodeAdapter::ERROR);
240     const std::string name_ = "testname";
241     EXPECT_EQ(mediaCodecEncoderAdapterImpl->CreateVideoCodecByName(name_), CodecCodeAdapter::ERROR);
242 }
243 
244 /**
245  * @tc.name: MediaCodecEncoderAdapterImpl_InvalidValueTest_002.
246  * @tc.desc: test of InvalidValueScene in MediaCodecEncoderAdapterImpl
247  * @tc.type: FUNC.
248  * @tc.require:
249  */
250 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_InvalidValueTest_002, TestSize.Level1)
251 {
252     uint32_t index = 0;
253     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(config_), CodecCodeAdapter::ERROR);
254     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::ERROR);
255     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Start(), CodecCodeAdapter::ERROR);
256     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Stop(), CodecCodeAdapter::ERROR);
257     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Reset(), CodecCodeAdapter::ERROR);
258     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Release(), CodecCodeAdapter::ERROR);
259     EXPECT_EQ(mediaCodecEncoderAdapterImpl->ReleaseOutputBuffer(index, true), CodecCodeAdapter::ERROR);
260     EXPECT_EQ(mediaCodecEncoderAdapterImpl->RequestKeyFrameSoon(), CodecCodeAdapter::ERROR);
261     std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
262     EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
263     std::shared_ptr<ProducerSurfaceAdapter> surface = mediaCodecEncoderAdapterImpl->CreateInputSurface();
264     EXPECT_EQ(surface, nullptr);
265 }
266 
267 /**
268  * @tc.name: MediaCodecEncoderAdapterImpl_NormalTest_003.
269  * @tc.desc: test of NormalScene in MediaCodecEncoderAdapterImpl
270  * @tc.type: FUNC.
271  * @tc.require:
272  */
273 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_NormalTest_003, TestSize.Level1)
274 {
275     mediaCodecEncoderAdapterImpl->encoder_ = std::make_shared<MediaAVCodec::AVCodecVideoEncoderImpl>();
276     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(config_), CodecCodeAdapter::ERROR);
277     std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
278     EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
279     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::ERROR);
280 }
281 
282 /**
283  * @tc.name: MediaCodecEncoderAdapterImpl_SetCallbackDec_004.
284  * @tc.desc: test of MediaCodecEncoderAdapterImpl::SetCodecCallback
285  * @tc.type: FUNC.
286  * @tc.require:
287  */
288 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_SetCodecCallback_004, TestSize.Level1)
289 {
290     std::shared_ptr<CodecCallbackAdapter> callback = nullptr;
291     EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
292     callback = std::make_shared<EncoderCallbackAdapterMock>();
293     EXPECT_EQ(mediaCodecEncoderAdapterImpl->SetCodecCallback(callback), CodecCodeAdapter::ERROR);
294 }
295 
296 /**
297  * @tc.name: MediaCodecEncoderAdapterImpl_GetTypeOrFlag_005.
298  * @tc.desc: test of MediaCodecEncoderAdapterImpl::GetErrorType() GetBufferFlag()
299  * @tc.type: FUNC.
300  * @tc.require:
301  */
302 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_GetTypeOrFlag_005, TestSize.Level1)
303 {
304     EXPECT_EQ(
305         mediaCodecEncoderAdapterImpl->GetErrorType(OHOS::MediaAVCodec::AVCodecErrorType::AVCODEC_ERROR_EXTEND_START),
306         ErrorType::CODEC_ERROR_EXTEND_START);
307     EXPECT_EQ(
308         mediaCodecEncoderAdapterImpl->GetBufferFlag(OHOS::MediaAVCodec::AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS),
309         BufferFlag::CODEC_BUFFER_FLAG_EOS);
310     AVCodecErrorType testAVCodecErrorType = static_cast<AVCodecErrorType>(100);
311     EXPECT_EQ(mediaCodecEncoderAdapterImpl->GetErrorType(testAVCodecErrorType), ErrorType::CODEC_ERROR_INTERNAL);
312     AVCodecBufferFlag testAVCodecBufferFlag = static_cast<AVCodecBufferFlag>(100);
313     EXPECT_EQ(mediaCodecEncoderAdapterImpl->GetBufferFlag(testAVCodecBufferFlag), BufferFlag::CODEC_BUFFER_FLAG_NONE);
314 }
315 
316 /**
317  * @tc.name: MediaCodecEncoderAdapterImpl_OnError_006.
318  * @tc.desc: test of MediaCodecEncoderAdapterImpl::GetErrorType() GetBufferFlag()
319  * @tc.type: FUNC.
320  * @tc.require:
321  */
322 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_OnError_006, TestSize.Level1)
323 {
324     std::shared_ptr<CodecCallbackAdapter> cb = nullptr;
325     std::shared_ptr<EncoderCallbackImpl> callbackImpl = std::make_shared<EncoderCallbackImpl>(cb);
326     EXPECT_NE(callbackImpl, nullptr);
327     std::shared_ptr<CodecCallbackAdapter> callback = std::make_shared<EncoderCallbackAdapterMock>();
328     EXPECT_NE(callback, nullptr);
329     callbackImpl->cb_ = callback;
330     callbackImpl->OnError(OHOS::MediaAVCodec::AVCodecErrorType::AVCODEC_ERROR_EXTEND_START, 1);
331     MediaAVCodec::Format fomat;
332     callbackImpl->OnOutputFormatChanged(fomat);
333     callbackImpl->OnInputBufferAvailable(1, nullptr);
334     std::shared_ptr<Media::AVSharedMemory> memory = std::make_shared<Media::AVSharedMemoryBase>(1, 1.0, "test");
335     callbackImpl->OnInputBufferAvailable(1, memory);
336     AVCodecBufferInfo info;
337     callbackImpl->OnOutputBufferAvailable(1, info, AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS, memory);
338 }
339 
340 /**
341  * @tc.name: MediaCodecEncoderAdapterImpl_GetList_001.
342  * @tc.desc: test of MediaCodecListAdapterImpl::GetCodecCapability()
343  * @tc.type: FUNC.
344  * @tc.require:
345  */
346 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_GetList_001, TestSize.Level1)
347 {
348     MediaCodecListAdapterImpl& codecListImpl = MediaCodecListAdapterImpl::GetInstance();
349 
350     std::shared_ptr<CapabilityDataAdapter> capaData = codecListImpl.GetCodecCapability("test", true);
351     EXPECT_NE(capaData, nullptr);
352     EXPECT_EQ(capaData->GetMaxWidth(), 0);
353 
354     capaData = codecListImpl.GetCodecCapability("video/avc", true);
355     EXPECT_NE(capaData, nullptr);
356     EXPECT_NE(capaData->GetMaxWidth(), 0);
357 }
358 
359 /**
360  * @tc.name: MediaCodecEncoderAdapterImpl_Surface_001.
361  * @tc.desc: test of ProducerSurfaceAdapterImpl::RequestBuffer()、FlushBuffer()
362  * @tc.type: FUNC.
363  * @tc.require:
364  */
365 HWTEST_F(MediaCodecEncoderAdapterImplTest, MediaCodecEncoderAdapterImpl_Surface_001, TestSize.Level1)
366 {
367     const std::string mimetype = "video/avc";
368     EXPECT_EQ(mediaCodecEncoderAdapterImpl->CreateVideoCodecByMime(mimetype), CodecCodeAdapter::OK);
369     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Configure(config_), CodecCodeAdapter::OK);
370     std::shared_ptr<ProducerSurfaceAdapter> surfaceAdapter =
371         mediaCodecEncoderAdapterImpl->CreateInputSurface();
372     ASSERT_NE(surfaceAdapter, nullptr);
373     int32_t fence = -1;
374     auto configAdapter = std::make_shared<BufferRequestConfigAdapterMock>();
375     EXPECT_NE(configAdapter, nullptr);
376     std::shared_ptr<SurfaceBufferAdapter> SurfaceBufferAdapter =
377         surfaceAdapter->RequestBuffer(fence, configAdapter);
378     EXPECT_NE(SurfaceBufferAdapter, nullptr);
379 
380     auto fulshConfigAdapter = std::make_shared<BufferFlushConfigAdapterMock>();
381     EXPECT_NE(fulshConfigAdapter, nullptr);
382     int32_t ret = surfaceAdapter->FlushBuffer(SurfaceBufferAdapter, fence, fulshConfigAdapter);
383     EXPECT_NE(ret, 0);
384 
385     uint32_t index = 0;
386     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Prepare(), CodecCodeAdapter::OK);
387     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Start(), CodecCodeAdapter::OK);
388     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Stop(), CodecCodeAdapter::OK);
389     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Reset(), CodecCodeAdapter::OK);
390     EXPECT_EQ(mediaCodecEncoderAdapterImpl->Release(), CodecCodeAdapter::OK);
391     EXPECT_EQ(mediaCodecEncoderAdapterImpl->ReleaseOutputBuffer(index, true), CodecCodeAdapter::ERROR);
392     EXPECT_EQ(mediaCodecEncoderAdapterImpl->RequestKeyFrameSoon(), CodecCodeAdapter::ERROR);
393 }
394 } // namespace OHOS::NWeb
395