1
2 /*
3 * Copyright (C) 2024 Huawei Device Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include <iostream>
17 #include <cstdio>
18 #include <string>
19
20 #include "gtest/gtest.h"
21 #include "avcodec_common.h"
22 #include "meta/format.h"
23 #include "avcodec_video_encoder.h"
24 #include "videoenc_inner_sample.h"
25 #include "native_avcapability.h"
26 #include "avcodec_info.h"
27 #include "avcodec_list.h"
28
29 using namespace std;
30 using namespace OHOS;
31 using namespace OHOS::MediaAVCodec;
32 using namespace testing::ext;
33
34 namespace {
35 class HwEncInnerFuncBTest : public testing::Test {
36 public:
37 // SetUpTestCase: Called before all test cases
38 static void SetUpTestCase(void);
39 // TearDownTestCase: Called after all test case
40 static void TearDownTestCase(void);
41 // SetUp: Called before each test cases
42 void SetUp() override;
43 // TearDown: Called after each test cases
44 void TearDown() override;
45 };
46
47 std::string g_codecMimeHevc = "video/hevc";
48 std::string g_codecNameHevc = "";
49
50
SetUpTestCase()51 void HwEncInnerFuncBTest::SetUpTestCase()
52 {
53 OH_AVCapability *capHevc = OH_AVCodec_GetCapabilityByCategory(g_codecMimeHevc.c_str(), true, HARDWARE);
54 const char *tmpCodecNameHevc = OH_AVCapability_GetName(capHevc);
55 g_codecNameHevc = tmpCodecNameHevc;
56 cout << "g_codecNameHevc: " << g_codecNameHevc << endl;
57 }
58
TearDownTestCase()59 void HwEncInnerFuncBTest::TearDownTestCase() {}
SetUp()60 void HwEncInnerFuncBTest::SetUp() {}
TearDown()61 void HwEncInnerFuncBTest::TearDown() {}
62 } // namespace
63
64 namespace {
IsEncoderBitrateModeSupported(CapabilityData * capData,VideoEncodeBitrateMode bitrateMode)65 bool IsEncoderBitrateModeSupported(CapabilityData *capData, VideoEncodeBitrateMode bitrateMode)
66 {
67 if (!AVCodecInfo::isEncoder(capData->codecType)) {
68 return false;
69 }
70 std::shared_ptr<VideoCaps> codecInfo = std::make_shared<VideoCaps>(capData);
71 const auto &bitrateModeVec = codecInfo->GetSupportedBitrateMode();
72 return find(bitrateModeVec.begin(), bitrateModeVec.end(), bitrateMode) != bitrateModeVec.end();
73 }
74
75 /**
76 * @tc.number : VIDEO_ENCODE_INNER_REPEAT_FUNC_0100
77 * @tc.name : config bframe
78 * @tc.desc : function test
79 */
80 HWTEST_F(HwEncInnerFuncBTest, VIDEO_HW_ENCODE_INNER_B_FUNC_001, TestSize.Level0)
81 {
82 Format format;
83 std::shared_ptr<AVCodecList> codecCapability = AVCodecListFactory::CreateAVCodecList();
84 CapabilityData *capabilityData = nullptr;
85 capabilityData = codecCapability->GetCapability(g_codecMimeHevc, true, AVCodecCategory::AVCODEC_HARDWARE);
86 std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
87 bool retBsupport = codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
88 if (!retBsupport) {
89 return;
90 }
91 auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
92 vEncInnerSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
93 vEncInnerSample->DEFAULT_WIDTH = 1280;
94 vEncInnerSample->DEFAULT_HEIGHT = 720;
95 vEncInnerSample->DEFAULT_BITRATE_MODE = CBR;
96 vEncInnerSample->MODE_ENABLE = true;
97 vEncInnerSample->GOPMODE_ENABLE = true;
98 vEncInnerSample->B_ENABLE = true;
99 vEncInnerSample->DEFAULT_BFRAME = 1;
100 vEncInnerSample->DEFAULT_GOP_MODE = 1;
101 vEncInnerSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_B_FUNC_001.h265";
102 int32_t bframe = codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_B_FRAME, format);
103 ASSERT_EQ(bframe, AV_ERR_OK);
104 int32_t value = 0;
105 format.GetIntValue(Media::Tag::VIDEO_ENCODER_MAX_B_FRAME, value);
106 ASSERT_GT(value, 0);
107 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->CreateByName(g_codecNameHevc));
108 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->SetCallback());
109 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->ConfigureVideoEncoderSqr());
110 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->StartVideoEncoder());
111 vEncInnerSample->WaitForEOS();
112 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->errCount);
113 }
114
115 /**
116 * @tc.number : VIDEO_ENCODE_INNER_REPEAT_FUNC_002
117 * @tc.name : config bframe
118 * @tc.desc : function test
119 */
120 HWTEST_F(HwEncInnerFuncBTest, VIDEO_HW_ENCODE_INNER_B_FUNC_002, TestSize.Level0)
121 {
122 Format format;
123 std::shared_ptr<AVCodecList> codecCapability = AVCodecListFactory::CreateAVCodecList();
124 CapabilityData *capabilityData = nullptr;
125 capabilityData = codecCapability->GetCapability(g_codecMimeHevc, true, AVCodecCategory::AVCODEC_HARDWARE);
126 std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
127 bool retBsupport = codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
128 if (!retBsupport) {
129 return;
130 }
131 auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
132 vEncInnerSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
133 vEncInnerSample->DEFAULT_WIDTH = 1280;
134 vEncInnerSample->DEFAULT_HEIGHT = 720;
135 vEncInnerSample->DEFAULT_BITRATE_MODE = CBR;
136 vEncInnerSample->MODE_ENABLE = true;
137 vEncInnerSample->B_ENABLE = true;
138 vEncInnerSample->DEFAULT_BFRAME = 1;
139 vEncInnerSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_B_FUNC_002.h265";
140 int32_t bframe = codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_B_FRAME, format);
141 ASSERT_EQ(bframe, AV_ERR_OK);
142 int32_t value = 0;
143 format.GetIntValue(Media::Tag::VIDEO_ENCODER_MAX_B_FRAME, value);
144 ASSERT_GT(value, 0);
145 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->CreateByName(g_codecNameHevc));
146 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->SetCallback());
147 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->ConfigureVideoEncoderSqr());
148 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->StartVideoEncoder());
149 vEncInnerSample->WaitForEOS();
150 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->errCount);
151 }
152
153 /**
154 * @tc.number : VIDEO_HW_ENCODE_INNER_SQR_FUNC_001
155 * @tc.name : setparemeter sqrfactor and max bitrate
156 * @tc.desc : function test
157 */
158 HWTEST_F(HwEncInnerFuncBTest, VIDEO_HW_ENCODE_INNER_SQR_FUNC_001, TestSize.Level0)
159 {
160 Format format;
161 std::shared_ptr<AVCodecList> codecCapability = AVCodecListFactory::CreateAVCodecList();
162 CapabilityData *capabilityData = nullptr;
163 capabilityData = codecCapability->GetCapability(g_codecMimeHevc, true, AVCodecCategory::AVCODEC_HARDWARE);
164 bool sqrSupport = IsEncoderBitrateModeSupported(capabilityData, SQR);
165 if (!sqrSupport) {
166 return;
167 }
168 auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
169 vEncInnerSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
170 vEncInnerSample->DEFAULT_WIDTH = 1280;
171 vEncInnerSample->DEFAULT_HEIGHT = 720;
172 vEncInnerSample->DEFAULT_BITRATE_MODE = SQR;
173 vEncInnerSample->surfaceInput = true;
174 vEncInnerSample->FACTOR_ENABLE = true;
175 vEncInnerSample->MAXBITE_ENABLE = true;
176 vEncInnerSample->MODE_ENABLE = true;
177 vEncInnerSample->enableParameter = true;
178 vEncInnerSample->MAXBITE_ENABLE_RUN = true;
179 vEncInnerSample->FACTOR_ENABLE_RUN = true;
180 vEncInnerSample->DEFAULT_MAX_BITERATE = 100000000;
181 vEncInnerSample->DEFAULT_SQR_FACTOR = 32;
182 vEncInnerSample->DEFAULT_MAX_BITERATE_RUN = 1000000;
183 vEncInnerSample->DEFAULT_SQR_FACTOR_RUN = 51;
184 vEncInnerSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_SQR_FUNC_001.h265";
185 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->CreateByName(g_codecNameHevc));
186 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->SetCallback());
187 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->ConfigureVideoEncoderSqr());
188 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->StartVideoEncoder());
189 vEncInnerSample->WaitForEOS();
190 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->errCount);
191 }
192
193 /**
194 * @tc.number : VIDEO_HW_ENCODE_INNER_SQR_FUNC_002
195 * @tc.name : setparemeter sqrfactor and max bitrate
196 * @tc.desc : function test
197 */
198 HWTEST_F(HwEncInnerFuncBTest, VIDEO_HW_ENCODE_INNER_SQR_FUNC_002, TestSize.Level0)
199 {
200 Format format;
201 std::shared_ptr<AVCodecList> codecCapability = AVCodecListFactory::CreateAVCodecList();
202 CapabilityData *capabilityData = nullptr;
203 capabilityData = codecCapability->GetCapability(g_codecMimeHevc, true, AVCodecCategory::AVCODEC_HARDWARE);
204 bool sqrSupport = IsEncoderBitrateModeSupported(capabilityData, SQR);
205 if (!sqrSupport) {
206 return;
207 }
208 auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
209 vEncInnerSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
210 vEncInnerSample->DEFAULT_WIDTH = 1280;
211 vEncInnerSample->DEFAULT_HEIGHT = 720;
212 vEncInnerSample->DEFAULT_BITRATE_MODE = SQR;
213 vEncInnerSample->FACTOR_ENABLE = true;
214 vEncInnerSample->MAXBITE_ENABLE = true;
215 vEncInnerSample->MODE_ENABLE = true;
216 vEncInnerSample->enableParameter = true;
217 vEncInnerSample->MAXBITE_ENABLE_RUN = true;
218 vEncInnerSample->FACTOR_ENABLE_RUN = true;
219 vEncInnerSample->DEFAULT_MAX_BITERATE = 6000000;
220 vEncInnerSample->DEFAULT_SQR_FACTOR = 32;
221 vEncInnerSample->DEFAULT_MAX_BITERATE_RUN = 100000000;
222 vEncInnerSample->DEFAULT_SQR_FACTOR_RUN = 1;
223 vEncInnerSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_SQR_FUNC_002.h265";
224 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->CreateByName(g_codecNameHevc));
225 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->SetCallback());
226 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->ConfigureVideoEncoderSqr());
227 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->StartVideoEncoder());
228 vEncInnerSample->WaitForEOS();
229 ASSERT_EQ(AV_ERR_OK, vEncInnerSample->errCount);
230 }
231 } // namespace