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