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