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 #include <string>
16 #include <limits>
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "videoenc_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24 namespace {
25 OH_AVCodec *venc_ = NULL;
26 OH_AVCapability *cap = nullptr;
27 OH_AVCapability *cap_hevc = nullptr;
28 constexpr uint32_t CODEC_NAME_SIZE = 128;
29 constexpr uint32_t DEFAULT_BITRATE = 1000000;
30 char g_codecName[CODEC_NAME_SIZE] = {};
31 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
32 const char *INP_DIR_720 = "/data/test/media/1280_720_nv.yuv";
33 constexpr uint32_t DEFAULT_WIDTH = 1280;
34 constexpr uint32_t DEFAULT_HEIGHT = 720;
35 } // namespace
36 namespace OHOS {
37 namespace Media {
38 class HwEncGetParamNdkTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 void InputFunc();
45 void OutputFunc();
46 void Release();
47 int32_t Stop();
48 };
49 } // namespace Media
50 } // namespace OHOS
51
52 using namespace std;
53 using namespace OHOS;
54 using namespace OHOS::Media;
55 using namespace testing::ext;
56
SetUpTestCase()57 void HwEncGetParamNdkTest::SetUpTestCase()
58 {
59 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
60 const char *tmpCodecName = OH_AVCapability_GetName(cap);
61 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
62 cout << "memcpy failed" << endl;
63 cout << "codecname: " << g_codecName << endl;
64 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
65 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
66 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
67 cout << "memcpy failed" << endl;
68 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
69 }
TearDownTestCase()70 void HwEncGetParamNdkTest::TearDownTestCase() {}
SetUp()71 void HwEncGetParamNdkTest::SetUp() {}
TearDown()72 void HwEncGetParamNdkTest::TearDown()
73 {
74 if (venc_ != NULL) {
75 OH_VideoEncoder_Destroy(venc_);
76 venc_ = nullptr;
77 }
78 }
79 namespace {
80 /**
81 * @tc.number : VIDEO_ENCODE_MSE_QP_0100
82 * @tc.name : encode Avbuffer h265 buffer,get QP and MSE
83 * @tc.desc : function test
84 */
85 HWTEST_F(HwEncGetParamNdkTest, VIDEO_ENCODE_MSE_QP_0100, TestSize.Level0)
86 {
87 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
88 if (cap) {
89 auto vEncSample = make_unique<VEncAPI11Sample>();
90 vEncSample->INP_DIR = INP_DIR_720;
91 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
92 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
93 vEncSample->DEFAULT_FRAME_RATE = 30;
94 vEncSample->DEFAULT_BITRATE = DEFAULT_BITRATE;
95 vEncSample->getQpMse = true;
96 vEncSample->SURF_INPUT = false;
97 vEncSample->OUT_DIR = "/data/test/media/qp_mse_0100.h265";
98 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
99 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
100 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
101 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
102 vEncSample->WaitForEOS();
103 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
104 }
105 else {
106 return;
107 }
108 }
109
110 /**
111 * @tc.number : VIDEO_ENCODE_MSE_QP_0200
112 * @tc.name : encode Avbuffer h265 surf,get QP and MSE
113 * @tc.desc : function test
114 */
115 HWTEST_F(HwEncGetParamNdkTest, VIDEO_ENCODE_MSE_QP_0200, TestSize.Level0)
116 {
117 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
118 if (cap) {
119 auto vEncSample = make_unique<VEncAPI11Sample>();
120 vEncSample->INP_DIR = INP_DIR_720;
121 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
122 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
123 vEncSample->DEFAULT_FRAME_RATE = 30;
124 vEncSample->DEFAULT_BITRATE = DEFAULT_BITRATE;
125 vEncSample->getQpMse = true;
126 vEncSample->SURF_INPUT = true;
127 vEncSample->OUT_DIR = "/data/test/media/qp_mse_0200.h265";
128 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
129 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
130 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
131 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
132 vEncSample->WaitForEOS();
133 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
134 } else {
135 return;
136 }
137 }
138
139 /**
140 * @tc.number : VIDEO_ENCODE_MSE_QP_0300
141 * @tc.name : encode Avbuffer h264 buffer,get QP and MSE
142 * @tc.desc : function test
143 */
144 HWTEST_F(HwEncGetParamNdkTest, VIDEO_ENCODE_MSE_QP_0300, TestSize.Level0)
145 {
146 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
147 if (cap) {
148 auto vEncSample = make_unique<VEncAPI11Sample>();
149 vEncSample->INP_DIR = INP_DIR_720;
150 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
151 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
152 vEncSample->DEFAULT_FRAME_RATE = 30;
153 vEncSample->DEFAULT_BITRATE = DEFAULT_BITRATE;
154 vEncSample->getQpMse = true;
155 vEncSample->SURF_INPUT = false;
156 vEncSample->OUT_DIR = "/data/test/media/qp_mse_0300.h265";
157 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
158 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
159 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
160 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
161 vEncSample->WaitForEOS();
162 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
163 } else {
164 return;
165 }
166 }
167
168 /**
169 * @tc.number : VIDEO_ENCODE_MSE_QP_0400
170 * @tc.name : encode Avbuffer h264 surf,get QP and MSE
171 * @tc.desc : function test
172 */
173 HWTEST_F(HwEncGetParamNdkTest, VIDEO_ENCODE_MSE_QP_0400, TestSize.Level0)
174 {
175 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
176 if (cap) {
177 auto vEncSample = make_unique<VEncAPI11Sample>();
178 vEncSample->INP_DIR = INP_DIR_720;
179 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
180 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
181 vEncSample->DEFAULT_FRAME_RATE = 30;
182 vEncSample->DEFAULT_BITRATE = DEFAULT_BITRATE;
183 vEncSample->getQpMse = true;
184 vEncSample->SURF_INPUT = true;
185 vEncSample->OUT_DIR = "/data/test/media/qp_mse_0400.h265";
186 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
187 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
188 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
189 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
190 vEncSample->WaitForEOS();
191 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
192 } else {
193 return;
194 }
195 }
196
197 /**
198 * @tc.number : VIDEO_ENCODE_REPEAT_0100
199 * @tc.name : set frame after 0
200 * @tc.desc : function test
201 */
202 HWTEST_F(HwEncGetParamNdkTest, VIDEO_ENCODE_REPEAT_0100, TestSize.Level0)
203 {
204 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
205 if (cap != nullptr) {
206 auto vEncSample = make_unique<VEncAPI11Sample>();
207 vEncSample->INP_DIR = INP_DIR_720;
208 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
209 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
210 vEncSample->DEFAULT_BITRATE_MODE = CBR;
211 vEncSample->SURF_INPUT = true;
212 vEncSample->enableRepeat = true;
213 vEncSample->setMaxCount = true;
214 vEncSample->DEFAULT_FRAME_AFTER = 0;
215 vEncSample->DEFAULT_MAX_COUNT = -1;
216 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
217 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
218 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
219 }
220 }
221 }