1 /*
2 * Copyright (c) 2025 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 #include "avcodec_info.h"
18
19 using namespace testing::ext;
20 using namespace OHOS::MediaAVCodec;
21
22 class AVCodecInfoUnitTest : public testing::Test {
23 public:
24 void SetUp(void);
25 void TearDown(void);
26 CapabilityData *data_;
27 };
28
29 namespace {
30 constexpr int32_t DEFAULT_INSTANCE_CNT = 16;
31 constexpr int32_t DEFAULT_ALIGN_SIZE = 2;
32 constexpr int32_t DEFAULT_BLOCK_SIZE = 16;
33 constexpr int32_t DEFAULT_MIN_SIDE = 2;
34 constexpr int32_t DEFAULT_MAX_SHORT_SIDE = 1088;
35 constexpr int32_t DEFAULT_MAX_LONG_SIDE = 1920;
36 constexpr int32_t DEFAULT_MIN_FRAME_RATE = 1;
37 constexpr int32_t DEFAULT_MAX_FRAME_RATE = 120;
38 constexpr int32_t DEFAULT_MIN_BIT_RATE = 1;
39 constexpr int32_t DEFAULT_MAX_BIT_RATE = 300000000;
40 constexpr int32_t DEFAULT_MIN_BLOCK_PER_FRAME = 1;
41 constexpr int32_t DEFAULT_MAX_BLOCK_PER_FRAME = 8160;
42 constexpr int32_t DEFAULT_MIN_BLOCK_PER_SEC = DEFAULT_MIN_FRAME_RATE * DEFAULT_MIN_BLOCK_PER_FRAME;
43 constexpr int32_t DEFAULT_MAX_BLOCK_PER_SEC = DEFAULT_MAX_FRAME_RATE * DEFAULT_MAX_BLOCK_PER_FRAME;
44 constexpr int32_t DEFAULT_SHORT_SIDE = 1152;
45 constexpr int32_t DEFAULT_LONG_SIDE = 1408;
46 };
47
SetUp(void)48 void AVCodecInfoUnitTest::SetUp(void)
49 {
50 data_ = new CapabilityData();
51 data_->codecName = "unit_test_codec";
52 data_->mimeType = CodecMimeType::VIDEO_AVC;
53 data_->codecType = AVCODEC_TYPE_VIDEO_DECODER;
54 data_->isVendor = false;
55 data_->maxInstance = DEFAULT_INSTANCE_CNT;
56 data_->alignment.width = DEFAULT_ALIGN_SIZE;
57 data_->alignment.height = DEFAULT_ALIGN_SIZE;
58 data_->width = Range(DEFAULT_MIN_SIDE, DEFAULT_MAX_LONG_SIDE);
59 data_->height = Range(DEFAULT_MIN_SIDE, DEFAULT_MAX_SHORT_SIDE);
60 data_->frameRate = Range(DEFAULT_MIN_FRAME_RATE, DEFAULT_MAX_FRAME_RATE);
61 data_->bitrate = Range(DEFAULT_MIN_BIT_RATE, DEFAULT_MAX_BIT_RATE);
62 data_->blockPerFrame = Range(DEFAULT_MIN_BLOCK_PER_FRAME, DEFAULT_MAX_BLOCK_PER_FRAME);
63 data_->blockPerSecond = Range(DEFAULT_MIN_BLOCK_PER_SEC, DEFAULT_MAX_BLOCK_PER_SEC);
64 data_->blockSize.width = DEFAULT_BLOCK_SIZE;
65 data_->blockSize.height = DEFAULT_BLOCK_SIZE;
66 data_->supportSwapWidthHeight = false;
67 data_->pixFormat = {static_cast<int32_t>(VideoPixelFormat::YUVI420),
68 static_cast<int32_t>(VideoPixelFormat::NV12),
69 static_cast<int32_t>(VideoPixelFormat::NV21),
70 static_cast<int32_t>(VideoPixelFormat::RGBA)};
71 }
72
TearDown(void)73 void AVCodecInfoUnitTest::TearDown(void)
74 {
75 delete data_;
76 data_ = nullptr;
77 }
78
79 HWTEST_F(AVCodecInfoUnitTest, NO_SWAP_TEST_001, TestSize.Level3)
80 {
81 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
82 Range widthRange = videoCap->GetVideoWidthRangeForHeight(DEFAULT_LONG_SIDE);
83 printf("widthRange [%d, %d]\n", widthRange.minVal, widthRange.maxVal);
84 ASSERT_FALSE(widthRange.InRange(DEFAULT_SHORT_SIDE));
85 }
86
87 HWTEST_F(AVCodecInfoUnitTest, NO_SWAP_TEST_002, TestSize.Level3)
88 {
89 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
90 Range widthRange = videoCap->GetVideoWidthRangeForHeight(DEFAULT_MAX_SHORT_SIDE);
91 printf("widthRange [%d, %d]\n", widthRange.minVal, widthRange.maxVal);
92 ASSERT_TRUE(widthRange.InRange(DEFAULT_SHORT_SIDE));
93 }
94
95 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_001, TestSize.Level3)
96 {
97 data_->supportSwapWidthHeight = true;
98 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
99 Range range = videoCap->GetVideoWidthRangeForHeight(DEFAULT_LONG_SIDE);
100 printf("range [%d, %d]\n", range.minVal, range.maxVal);
101 ASSERT_FALSE(range.InRange(DEFAULT_SHORT_SIDE));
102 range = videoCap->GetVideoHeightRangeForWidth(DEFAULT_LONG_SIDE);
103 printf("range [%d, %d]\n", range.minVal, range.maxVal);
104 ASSERT_FALSE(range.InRange(DEFAULT_SHORT_SIDE));
105 range = videoCap->GetVideoWidthRangeForHeight(DEFAULT_SHORT_SIDE);
106 printf("range [%d, %d]\n", range.minVal, range.maxVal);
107 ASSERT_FALSE(range.InRange(DEFAULT_LONG_SIDE));
108 range = videoCap->GetVideoHeightRangeForWidth(DEFAULT_SHORT_SIDE);
109 printf("range [%d, %d]\n", range.minVal, range.maxVal);
110 ASSERT_FALSE(range.InRange(DEFAULT_LONG_SIDE));
111 ASSERT_FALSE(videoCap->IsSizeSupported(DEFAULT_SHORT_SIDE, DEFAULT_LONG_SIDE));
112 ASSERT_FALSE(videoCap->IsSizeSupported(DEFAULT_LONG_SIDE, DEFAULT_SHORT_SIDE));
113 }
114
115 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_002, TestSize.Level3)
116 {
117 data_->supportSwapWidthHeight = true;
118 data_->blockPerFrame = Range(1, DEFAULT_MAX_BLOCK_PER_SEC);
119 data_->alignment.width = 1;
120 data_->alignment.height = 1;
121 data_->width = Range(40, DEFAULT_MAX_LONG_SIDE); // 40
122 data_->height = Range(20, DEFAULT_MAX_SHORT_SIDE); // 20
123 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
124 Range range = videoCap->GetVideoWidthRangeForHeight(1000); // 1000
125 printf("range [%d, %d]\n", range.minVal, range.maxVal);
126 ASSERT_EQ(range.minVal, 20); // 20
127 ASSERT_EQ(range.maxVal, DEFAULT_MAX_LONG_SIDE);
128 range = videoCap->GetVideoHeightRangeForWidth(1000); // 1000
129 printf("range [%d, %d]\n", range.minVal, range.maxVal);
130 ASSERT_EQ(range.minVal, 20); // 20
131 ASSERT_EQ(range.maxVal, DEFAULT_MAX_LONG_SIDE);
132 }
133
134 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_003, TestSize.Level3)
135 {
136 data_->supportSwapWidthHeight = true;
137 data_->blockPerFrame = Range(1, DEFAULT_MAX_BLOCK_PER_SEC);
138 data_->alignment.width = 1;
139 data_->alignment.height = 1;
140 data_->width = Range(40, DEFAULT_MAX_LONG_SIDE); // 40
141 data_->height = Range(20, DEFAULT_MAX_SHORT_SIDE); // 20
142 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
143 Range range = videoCap->GetVideoWidthRangeForHeight(24); // 24
144 printf("range [%d, %d]\n", range.minVal, range.maxVal);
145 ASSERT_EQ(range.minVal, 40); // 40
146 ASSERT_EQ(range.maxVal, DEFAULT_MAX_LONG_SIDE);
147 range = videoCap->GetVideoHeightRangeForWidth(24); // 24
148 printf("range [%d, %d]\n", range.minVal, range.maxVal);
149 ASSERT_EQ(range.minVal, 40); // 40
150 ASSERT_EQ(range.maxVal, DEFAULT_MAX_LONG_SIDE);
151 }
152
153 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_004, TestSize.Level3)
154 {
155 data_->supportSwapWidthHeight = true;
156 data_->blockPerFrame = Range(1, DEFAULT_MAX_BLOCK_PER_SEC);
157 data_->alignment.width = 1;
158 data_->alignment.height = 1;
159 data_->width = Range(40, DEFAULT_MAX_LONG_SIDE); // 40
160 data_->height = Range(20, DEFAULT_MAX_SHORT_SIDE); // 20
161 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
162 Range range = videoCap->GetVideoWidthRangeForHeight(1200); // 1200
163 printf("range [%d, %d]\n", range.minVal, range.maxVal);
164 ASSERT_EQ(range.minVal, 20); // 20
165 ASSERT_EQ(range.maxVal, DEFAULT_MAX_SHORT_SIDE);
166 range = videoCap->GetVideoHeightRangeForWidth(1200); // 1200
167 printf("range [%d, %d]\n", range.minVal, range.maxVal);
168 ASSERT_EQ(range.minVal, 20); // 20
169 ASSERT_EQ(range.maxVal, DEFAULT_MAX_SHORT_SIDE);
170 }
171
172 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_005, TestSize.Level3)
173 {
174 data_->supportSwapWidthHeight = true;
175 data_->blockPerFrame = Range(1, DEFAULT_MAX_BLOCK_PER_SEC);
176 data_->alignment.width = 1;
177 data_->alignment.height = 1;
178 data_->width = Range(40, DEFAULT_MAX_LONG_SIDE); // 40
179 data_->height = Range(20, DEFAULT_MAX_SHORT_SIDE); // 20
180 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
181 Range range = videoCap->GetVideoWidthRangeForHeight(2000); // 2000
182 printf("range [%d, %d]\n", range.minVal, range.maxVal);
183 ASSERT_EQ(range.minVal, 0);
184 ASSERT_EQ(range.maxVal, 0);
185 range = videoCap->GetVideoHeightRangeForWidth(2000); // 2000
186 printf("range [%d, %d]\n", range.minVal, range.maxVal);
187 ASSERT_EQ(range.minVal, 0);
188 ASSERT_EQ(range.maxVal, 0);
189 }
190
191 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_006, TestSize.Level3)
192 {
193 data_->supportSwapWidthHeight = true;
194 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
195 Range widthRange = videoCap->GetVideoWidthRangeForHeight(DEFAULT_MAX_LONG_SIDE);
196 printf("widthRange [%d, %d]\n", widthRange.minVal, widthRange.maxVal);
197 ASSERT_FALSE(widthRange.InRange(1200)); // 1200
198 }
199
200 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_007, TestSize.Level3)
201 {
202 data_->supportSwapWidthHeight = true;
203 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
204 Range widthRange = videoCap->GetVideoWidthRangeForHeight(1911); // 1911
205 printf("widthRange [%d, %d]\n", widthRange.minVal, widthRange.maxVal);
206 ASSERT_EQ(widthRange.minVal, 0);
207 ASSERT_EQ(widthRange.maxVal, 0);
208 }
209
210 HWTEST_F(AVCodecInfoUnitTest, SWAP_TEST_008, TestSize.Level3)
211 {
212 data_->supportSwapWidthHeight = true;
213 data_->blockPerFrame = Range(1, DEFAULT_MAX_BLOCK_PER_SEC);
214 data_->alignment.width = 1;
215 data_->alignment.height = 1;
216 data_->width = Range(600, DEFAULT_MAX_LONG_SIDE); // 600
217 data_->height = Range(20, 200); // 20 200
218 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
219 Range range = videoCap->GetVideoWidthRangeForHeight(400); // 400
220 printf("range [%d, %d]\n", range.minVal, range.maxVal);
221 ASSERT_EQ(range.minVal, 0);
222 ASSERT_EQ(range.maxVal, 0);
223 range = videoCap->GetVideoHeightRangeForWidth(400); // 400
224 printf("range [%d, %d]\n", range.minVal, range.maxVal);
225 ASSERT_EQ(range.minVal, 0);
226 ASSERT_EQ(range.maxVal, 0);
227 ASSERT_FALSE(videoCap->IsSizeSupported(400, 100));
228 ASSERT_FALSE(videoCap->IsSizeSupported(100, 400));
229 ASSERT_FALSE(videoCap->IsSizeSupported(400, 800));
230 ASSERT_FALSE(videoCap->IsSizeSupported(800, 400));
231 range = videoCap->GetSupportedHeight();
232 printf("range [%d, %d]\n", range.minVal, range.maxVal);
233 ASSERT_EQ(range.minVal, 20);
234 ASSERT_EQ(range.maxVal, DEFAULT_MAX_LONG_SIDE);
235 }
236
237 HWTEST_F(AVCodecInfoUnitTest, GET_WIDTH_RANGE_TEST_001, TestSize.Level3)
238 {
239 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
240 Range widthRange = videoCap->GetSupportedWidth();
241 printf("widthRange [%d, %d]\n", widthRange.minVal, widthRange.maxVal);
242 ASSERT_EQ(widthRange.minVal, DEFAULT_MIN_SIDE);
243 ASSERT_EQ(widthRange.maxVal, DEFAULT_MAX_LONG_SIDE);
244 }
245
246 HWTEST_F(AVCodecInfoUnitTest, GET_WIDTH_RANGE_TEST_002, TestSize.Level3)
247 {
248 data_->supportSwapWidthHeight = true;
249 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
250 Range widthRange = videoCap->GetSupportedWidth();
251 printf("widthRange [%d, %d]\n", widthRange.minVal, widthRange.maxVal);
252 ASSERT_EQ(widthRange.minVal, DEFAULT_MIN_SIDE);
253 ASSERT_EQ(widthRange.maxVal, DEFAULT_MAX_LONG_SIDE);
254 }
255
256 HWTEST_F(AVCodecInfoUnitTest, GET_HEIGHT_RANGE_TEST_001, TestSize.Level3)
257 {
258 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
259 Range range = videoCap->GetSupportedHeight();
260 printf("range [%d, %d]\n", range.minVal, range.maxVal);
261 ASSERT_EQ(range.minVal, DEFAULT_MIN_SIDE);
262 ASSERT_EQ(range.maxVal, DEFAULT_MAX_SHORT_SIDE);
263 }
264
265 HWTEST_F(AVCodecInfoUnitTest, GET_HEIGHT_RANGE_TEST_002, TestSize.Level3)
266 {
267 data_->supportSwapWidthHeight = true;
268 std::shared_ptr<VideoCaps> videoCap = std::make_shared<VideoCaps>(data_);
269 Range range = videoCap->GetSupportedHeight();
270 printf("range [%d, %d]\n", range.minVal, range.maxVal);
271 ASSERT_EQ(range.minVal, DEFAULT_MIN_SIDE);
272 ASSERT_EQ(range.maxVal, DEFAULT_MAX_LONG_SIDE);
273 }