1 /*
2 * Copyright (c) 2022 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 <string>
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videodecoder.h"
19 #include "native_avcodec_videoencoder.h"
20 #include "native_avcodec_base.h"
21 #include "native_avformat.h"
22 #include "VDecEncNdkSample.h"
23 #include "syscap_ndk.h"
24 #include "native_avcapability.h"
25 namespace {
26 OH_AVCapability *cap_avc = nullptr;
27 bool g_capAvcResult = false;
28 OH_AVCapability *cap_mpeg4 = nullptr;
29 bool g_capM4Result = false;
30 } // namespace
31
32 using namespace std;
33 using namespace testing::ext;
34 using namespace OHOS;
35 using namespace OHOS::Media;
36
37 namespace {
38 class ActsVideoDecEncNdkTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 };
45
SetUpTestCase()46 void ActsVideoDecEncNdkTest::SetUpTestCase() {
47 cap_avc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
48 if (cap_avc) {
49 g_capAvcResult = true;
50 }
51 cap_mpeg4 = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, true, HARDWARE);
52 if (cap_mpeg4) {
53 g_capM4Result = true;
54 }
55 }
TearDownTestCase()56 void ActsVideoDecEncNdkTest::TearDownTestCase() {}
SetUp()57 void ActsVideoDecEncNdkTest::SetUp() {}
TearDown()58 void ActsVideoDecEncNdkTest::TearDown() {}
59 const string MIME_TYPE_AVC = "video/avc";
60 const string MIME_TYPE_MPEG4 = "video/mp4v-es";
61 constexpr uint32_t DEFAULT_WIDTH = 320;
62 constexpr uint32_t DEFAULT_HEIGHT = 240;
63 constexpr uint32_t DEFAULT_PIXELFORMAT = 2;
64 constexpr double DEFAULT_FRAMERATE = 60;
65 const char* READPATH = "/data/media/out_320_240_10s.h264";
66
CheckDecDesc(map<string,int> InDesc,OH_AVFormat * OutDesc)67 bool CheckDecDesc(map<string, int> InDesc, OH_AVFormat* OutDesc)
68 {
69 int32_t out ;
70 for (const auto& t: InDesc) {
71 bool res = OH_AVFormat_GetIntValue(OutDesc, t.first.c_str(), &out);
72 cout << "key: " << t.first << "; out: " << out <<endl;
73 if (!res) {
74 cout << "OH_AVFormat_GetIntValue Fail. key:" << t.first << endl;
75 return false;
76 }
77 if (out != t.second) {
78 cout << "OH_AVFormat_GetIntValue error. key: " << t.first
79 << "; expect: "<< t.second
80 << ", actual: "<< out << endl;
81 return false;
82 }
83 out = 0;
84 }
85
86 double dout;
87 bool res = OH_AVFormat_GetDoubleValue(OutDesc, OH_MD_KEY_FRAME_RATE, &dout);
88 if (!res || abs(dout - DEFAULT_FRAMERATE) > 1e-6) {
89 cout << "OH_AVFormat_GetDoubleValue error. key: " << OH_MD_KEY_FRAME_RATE << endl;
90 }
91 return true;
92 }
93
SetFormat(struct OH_AVFormat * format,map<string,int> mediaDescription)94 bool SetFormat(struct OH_AVFormat *format, map<string, int> mediaDescription)
95 {
96 const char *key;
97 for (const auto& t: mediaDescription) {
98 key = t.first.c_str();
99 if (not OH_AVFormat_SetIntValue(format, key, t.second)) {
100 cout << "OH_AV_FormatPutIntValue Fail. format key: " << t.first
101 << ", value: "<< t.second << endl;
102 return false;
103 }
104 }
105 return true;
106 }
107
createFormat()108 struct OH_AVFormat* createFormat()
109 {
110 OH_AVFormat *DefaultFormat = OH_AVFormat_Create();
111 OH_AVFormat_SetIntValue(DefaultFormat, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
112 OH_AVFormat_SetIntValue(DefaultFormat, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
113 OH_AVFormat_SetIntValue(DefaultFormat, OH_MD_KEY_PIXEL_FORMAT, DEFAULT_PIXELFORMAT);
114 OH_AVFormat_SetDoubleValue(DefaultFormat, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAMERATE);
115 OH_AVFormat_SetStringValue(DefaultFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_AVC);
116 return DefaultFormat;
117 }
118
CanUseVideoCodec()119 bool CanUseVideoCodec()
120 {
121 return canIUse("SystemCapability.Multimedia.Media.CodecBase") &&
122 canIUse("SystemCapability.Multimedia.Media.VideoDecoder") &&
123 canIUse("SystemCapability.Multimedia.Media.VideoEncoder");
124 }
125 }
126
127 /**
128 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0100
129 * @tc.name : stop at end of stream
130 * @tc.desc : Basic function test
131 */
132 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0100, TestSize.Level1)
133 {
134 if (!CanUseVideoCodec() || !g_capAvcResult || !g_capM4Result) {
135 cout << "codec not support, ignore SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0100 ignore" <<endl;
136 return;
137 }
138 VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
139 struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
140 ASSERT_NE(nullptr, videoDec);
141
142 struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_MPEG4);
143 videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
144 ASSERT_NE(nullptr, videoEnc);
145 vDecEncSample->SetReadPath(READPATH);
146 vDecEncSample->SetSavePath("/data/media/video_001.h264");
147
148 OH_AVFormat *VideoFormat = OH_AVFormat_Create();
149 ASSERT_NE(nullptr, VideoFormat);
150 map<string, int> VideoParam = {
151 {OH_MD_KEY_WIDTH, DEFAULT_WIDTH},
152 {OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT},
153 {OH_MD_KEY_PIXEL_FORMAT, DEFAULT_PIXELFORMAT},
154 };
155 ASSERT_EQ(true, SetFormat(VideoFormat, VideoParam));
156 OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_TRACK_TYPE, MEDIA_TYPE_VID);
157 OH_AVFormat_SetDoubleValue(VideoFormat, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAMERATE);
158
159 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
160 OH_AVFormat *OutDescDec = OH_VideoDecoder_GetOutputDescription(videoDec);
161 ASSERT_NE(nullptr, OutDescDec);
162 ASSERT_EQ(true, CheckDecDesc(VideoParam, OutDescDec));
163
164 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
165 OH_AVFormat *OutDescEnc = OH_VideoEncoder_GetOutputDescription(videoEnc);
166 ASSERT_NE(nullptr, OutDescEnc);
167
168 ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
169 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
170 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
171 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
172 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
173 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
174
175 while (!vDecEncSample->GetEncEosState()) {};
176 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopDec());
177 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopEnc());
178 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseEnc());
179 videoEnc = nullptr;
180 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseDec());
181 videoDec = nullptr;
182 OH_AVFormat_Destroy(VideoFormat);
183 VideoFormat = nullptr;
184 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
185 }
186
187 /**
188 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0200
189 * @tc.name : reset at end of stream
190 * @tc.desc : Basic function test
191 */
192 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0200, TestSize.Level1)
193 {
194 if (!CanUseVideoCodec() || !g_capAvcResult) {
195 cout << "codec not support, ignore SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0200 ignore" <<endl;
196 return;
197 }
198 VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
199
200 struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
201 ASSERT_NE(nullptr, videoDec);
202 struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
203 ASSERT_NE(nullptr, videoEnc);
204 vDecEncSample->SetReadPath(READPATH);
205 vDecEncSample->SetSavePath("/data/media/video_002.h264");
206
207 OH_AVFormat *VideoFormat = createFormat();
208 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
209 OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR);
210 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
211 ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
212 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
213 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
214 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
215 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
216 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetParameterEnc(VideoFormat));
217 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
218 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetParameterDec(VideoFormat));
219
220 while (!vDecEncSample->GetEncEosState()) {};
221 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ResetDec());
222 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ResetEnc());
223 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseEnc());
224 videoEnc = nullptr;
225 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseDec());
226 videoDec = nullptr;
227 OH_AVFormat_Destroy(VideoFormat);
228 VideoFormat = nullptr;
229 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
230 }
231
232 /**
233 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0300
234 * @tc.name : release at end of stream
235 * @tc.desc : Basic function test
236 */
237 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0300, TestSize.Level1)
238 {
239 if (!CanUseVideoCodec() || !g_capAvcResult) {
240 cout << "codec not support, ignore SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0300 ignore" <<endl;
241 return;
242 }
243 VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
244
245 struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
246 ASSERT_NE(nullptr, videoDec);
247 struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
248 ASSERT_NE(nullptr, videoEnc);
249 vDecEncSample->SetReadPath(READPATH);
250 vDecEncSample->SetSavePath("/data/media/video_003.h264");
251
252 OH_AVFormat *VideoFormat = createFormat();
253 OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_PROFILE, AVC_PROFILE_BASELINE);
254
255 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
256 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
257 ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
258 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
259 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
260 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
261 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
262 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
263
264 while (!vDecEncSample->GetEncEosState()) {};
265 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseEnc());
266 videoEnc = nullptr;
267 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseDec());
268 videoDec = nullptr;
269 OH_AVFormat_Destroy(VideoFormat);
270 VideoFormat = nullptr;
271 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
272 }
273
274 /**
275 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0400
276 * @tc.name : flush at running
277 * @tc.desc : Basic function test
278 */
279 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0400, TestSize.Level1)
280 {
281 if (!CanUseVideoCodec() || !g_capAvcResult) {
282 cout << "codec not support, ignore SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0400 ignore" <<endl;
283 return;
284 }
285 VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
286
287 struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
288 ASSERT_NE(nullptr, videoDec);
289 struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
290 ASSERT_NE(nullptr, videoEnc);
291 vDecEncSample->SetReadPath(READPATH);
292 vDecEncSample->SetEosState(false);
293 vDecEncSample->SetSavePath("/data/media/video_004.h264");
294
295 OH_AVFormat *VideoFormat = createFormat();
296 OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_PROFILE, AVC_PROFILE_HIGH);
297
298 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
299 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
300 ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
301 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
302 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
303 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
304 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
305 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
306
307 while (vDecEncSample->GetFrameCount() < 100) {};
308 ASSERT_EQ(AV_ERR_OK, vDecEncSample->FlushDec());
309 ASSERT_EQ(AV_ERR_OK, vDecEncSample->FlushEnc());
310 vDecEncSample->ReRead();
311 vDecEncSample->ResetDecParam();
312 vDecEncSample->ResetEncParam();
313 vDecEncSample->SetEosState(true);
314 vDecEncSample->SetSavePath("/data/media/video_004_2.h264");
315
316 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
317 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
318
319 while (!vDecEncSample->GetEncEosState()) {};
320 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseEnc());
321 videoEnc = nullptr;
322 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseDec());
323 videoDec = nullptr;
324 OH_AVFormat_Destroy(VideoFormat);
325 VideoFormat = nullptr;
326 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
327 }
328
329
330 /**
331 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0500
332 * @tc.name : flush dec at eos and restart
333 * @tc.desc : Basic function test
334 */
335 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0500, TestSize.Level1)
336 {
337 if (!CanUseVideoCodec() || !g_capAvcResult) {
338 cout << "codec not support, ignore SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0500 ignore" <<endl;
339 return;
340 }
341 VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
342
343 struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
344 ASSERT_NE(nullptr, videoDec);
345 struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
346 ASSERT_NE(nullptr, videoEnc);
347 vDecEncSample->SetReadPath(READPATH);
348 vDecEncSample->SetEosState(false);
349 vDecEncSample->SetSavePath("/data/media/video_005.h264");
350
351 OH_AVFormat *VideoFormat = createFormat();
352 OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN);
353
354 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
355 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
356 ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
357 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
358 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
359 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
360 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
361 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
362
363 while (!vDecEncSample->GetDecEosState()) {};
364 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
365 ASSERT_EQ(AV_ERR_OK, vDecEncSample->FlushDec());
366 ASSERT_EQ(AV_ERR_OK, vDecEncSample->FlushEnc());
367 vDecEncSample->ReRead();
368 vDecEncSample->ResetDecParam();
369 vDecEncSample->ResetEncParam();
370 vDecEncSample->SetSavePath("/data/media/video_005_2.h264");
371 vDecEncSample->SetEosState(true);
372 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
373 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
374 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
375
376 while (!vDecEncSample->GetEncEosState()) {};
377 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseEnc());
378 videoEnc = nullptr;
379 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseDec());
380 videoDec = nullptr;
381 OH_AVFormat_Destroy(VideoFormat);
382 VideoFormat = nullptr;
383 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
384 }
385
386
387 /**
388 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0600
389 * @tc.name : stop at running and restart to eos
390 * @tc.desc : Basic function test
391 */
392 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0600, TestSize.Level1)
393 {
394 if (!CanUseVideoCodec() || !g_capAvcResult) {
395 cout << "codec not support, ignore SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0600 ignore" <<endl;
396 return;
397 }
398 VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
399
400 struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
401 ASSERT_NE(nullptr, videoDec);
402 struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
403 ASSERT_NE(nullptr, videoEnc);
404 vDecEncSample->SetReadPath(READPATH);
405 vDecEncSample->SetEosState(false);
406 vDecEncSample->SetSavePath("/data/media/video_006.h264");
407
408 OH_AVFormat *VideoFormat = createFormat();
409 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
410 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
411 ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
412 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
413 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
414 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
415 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
416 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
417
418 while (vDecEncSample->GetFrameCount() < 100) {};
419 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopDec());
420 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopEnc());
421 vDecEncSample->ReRead();
422 vDecEncSample->ResetDecParam();
423 vDecEncSample->ResetEncParam();
424 vDecEncSample->SetEosState(true);
425 vDecEncSample->SetSavePath("/data/media/video_006_2.h264");
426 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
427 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
428
429 while (!vDecEncSample->GetEncEosState()) {};
430 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopDec());
431 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopEnc());
432 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseEnc());
433 videoEnc = nullptr;
434 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseDec());
435 videoDec = nullptr;
436 OH_AVFormat_Destroy(VideoFormat);
437 VideoFormat = nullptr;
438 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
439 }
440
441
442 /**
443 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0700
444 * @tc.name : stop dec at eos and restart to eos
445 * @tc.desc : Basic function test
446 */
447 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0700, TestSize.Level1)
448 {
449 if (!CanUseVideoCodec() || !g_capAvcResult) {
450 cout << "codec not support, ignore SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0700 ignore" <<endl;
451 return;
452 }
453 VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
454
455 struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
456 ASSERT_NE(nullptr, videoDec);
457 struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
458 ASSERT_NE(nullptr, videoEnc);
459 vDecEncSample->SetReadPath(READPATH);
460 vDecEncSample->SetEosState(false);
461 vDecEncSample->SetSavePath("/data/media/video_007.h264");
462
463 OH_AVFormat *VideoFormat = createFormat();
464 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
465 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
466 ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
467 ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
468 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
469 ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
470 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
471 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
472
473 while (!vDecEncSample->GetDecEosState()) {};
474 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopDec());
475 ASSERT_EQ(AV_ERR_OK, vDecEncSample->FlushEnc());
476 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
477 vDecEncSample->ReRead();
478 vDecEncSample->ResetDecParam();
479 vDecEncSample->ResetEncParam();
480 vDecEncSample->SetSavePath("/data/media/video_007_2.h264");
481 vDecEncSample->SetEosState(true);
482 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
483 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
484
485 while (!vDecEncSample->GetEncEosState()) {};
486 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopDec());
487 ASSERT_EQ(AV_ERR_OK, vDecEncSample->StopEnc());
488 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseEnc());
489 videoEnc = nullptr;
490 ASSERT_EQ(AV_ERR_OK, vDecEncSample->ReleaseDec());
491 videoDec = nullptr;
492 OH_AVFormat_Destroy(VideoFormat);
493 VideoFormat = nullptr;
494 ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
495 }