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