1 /*
2 * Copyright (C) 2025 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 "gtest/gtest.h"
17 #include "native_averrors.h"
18 #include "videodec_sample.h"
19 #include "videodec_inner_sample.h"
20 #include "native_avcodec_base.h"
21 #include "avcodec_codec_name.h"
22 #include "native_avcapability.h"
23 #include "avcodec_suspend.h"
24 #include <unistd.h>
25 #include "syspara/parameters.h"
26
27 #define MAX_THREAD 16
28
29 using namespace std;
30 using namespace OHOS;
31 using namespace OHOS::Media;
32 using namespace OHOS::MediaAVCodec;
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace Media {
37 class HwdecInnerFuncNdkTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp() override;
42 void TearDown() override;
43 void InputFunc();
44 void OutputFunc();
45 void Release();
46 int32_t Stop();
47
48 protected:
49 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
50 };
51 } // namespace Media
52 } // namespace OHOS
53
54 namespace {
55 static OH_AVCapability *cap = nullptr;
56 static OH_AVCapability *cap_hevc = nullptr;
57 static OH_AVCapability *cap_vvc = nullptr;
58 static string g_codecName = "";
59 static string g_codecNameHEVC = "";
60 static string g_codecNameVVC = "";
61 } // namespace
62
SetUpTestCase()63 void HwdecInnerFuncNdkTest::SetUpTestCase()
64 {
65 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
66 g_codecName = OH_AVCapability_GetName(cap);
67 cout << "codecname: " << g_codecName << endl;
68 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
69 g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
70 cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
71 cap_vvc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
72 g_codecNameVVC = OH_AVCapability_GetName(cap_vvc);
73 cout << "g_codecNameVVC: " << g_codecNameVVC << endl;
74 }
TearDownTestCase()75 void HwdecInnerFuncNdkTest::TearDownTestCase() {}
SetUp()76 void HwdecInnerFuncNdkTest::SetUp() {}
TearDown()77 void HwdecInnerFuncNdkTest::TearDown() {}
78
79 namespace {
80 /**
81 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0010
82 * @tc.name : SuspendFreeze, std::vector<pid_t> &pidList size is 0
83 * @tc.desc : api test
84 */
85 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0010, TestSize.Level2)
86 {
87 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
88 if (recycleMemory) {
89 std::vector<pid_t> pidList = {};
90 ASSERT_EQ(AVCS_ERR_INPUT_DATA_ERROR, AVCodecSuspend::SuspendFreeze(pidList));
91 }
92 }
93
94 /**
95 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0020
96 * @tc.name : SuspendFreeze, pid not exist
97 * @tc.desc : api test
98 */
99 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0020, TestSize.Level2)
100 {
101 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
102 if (recycleMemory) {
103 pid_t pid = -1;
104 std::vector<pid_t> pidList = {pid};
105 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
106 }
107 }
108
109 /**
110 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0030
111 * @tc.name : SuspendActive, std::vector<pid_t> &pidList size is 0
112 * @tc.desc : api test
113 */
114 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0030, TestSize.Level2)
115 {
116 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
117 if (recycleMemory) {
118 std::vector<pid_t> pidList = {};
119 ASSERT_EQ(AVCS_ERR_INPUT_DATA_ERROR, AVCodecSuspend::SuspendActive(pidList));
120 }
121 }
122
123 /**
124 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0040
125 * @tc.name : SuspendActive, pid not exist
126 * @tc.desc : api test
127 */
128 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0040, TestSize.Level2)
129 {
130 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
131 if (recycleMemory) {
132 pid_t pid = -1;
133 std::vector<pid_t> pidList = {pid};
134 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
135 }
136 }
137
138 /**
139 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0050
140 * @tc.name : SuspendActiveAll
141 * @tc.desc : api test
142 */
143 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_API_0050, TestSize.Level0)
144 {
145 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
146 if (recycleMemory) {
147 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
148 }
149 }
150
151 /**
152 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0010
153 * @tc.name : SuspendActive
154 * @tc.desc : function test
155 */
156 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0010, TestSize.Level1)
157 {
158 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
159 if (recycleMemory) {
160 auto vDecSample = make_shared<VDecNdkInnerSample>();
161 vDecSample->INP_DIR = INP_DIR_720_30;
162 vDecSample->DEFAULT_WIDTH = 1280;
163 vDecSample->DEFAULT_HEIGHT = 720;
164 vDecSample->DEFAULT_FRAME_RATE = 30;
165 vDecSample->SF_OUTPUT = false;
166 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
167 pid_t pid = getpid();
168 std::vector<pid_t> pidList = {pid};
169 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
170 vDecSample->WaitForEOS();
171 }
172 }
173
174 /**
175 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0020
176 * @tc.name : SuspendFreeze
177 * @tc.desc : function test
178 */
179 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0020, TestSize.Level2)
180 {
181 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
182 if (recycleMemory) {
183 auto vDecSample = make_shared<VDecNdkInnerSample>();
184 vDecSample->INP_DIR = INP_DIR_720_30;
185 vDecSample->DEFAULT_WIDTH = 1280;
186 vDecSample->DEFAULT_HEIGHT = 720;
187 vDecSample->DEFAULT_FRAME_RATE = 30;
188 vDecSample->SF_OUTPUT = false;
189 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
190 pid_t pid = getpid();
191 std::vector<pid_t> pidList = {pid};
192 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
193 vDecSample->SetRunning();
194 vDecSample->WaitForEOS();
195 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
196 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
197 }
198 }
199
200 /**
201 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0030
202 * @tc.name : SuspendActiveAll
203 * @tc.desc : function test
204 */
205 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0030, TestSize.Level2)
206 {
207 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
208 if (recycleMemory) {
209 auto vDecSample = make_shared<VDecNdkInnerSample>();
210 vDecSample->INP_DIR = INP_DIR_720_30;
211 vDecSample->DEFAULT_WIDTH = 1280;
212 vDecSample->DEFAULT_HEIGHT = 720;
213 vDecSample->DEFAULT_FRAME_RATE = 30;
214 vDecSample->SF_OUTPUT = false;
215 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
216 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
217 vDecSample->WaitForEOS();
218 }
219 }
220
221 /**
222 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0040
223 * @tc.name : SuspendFreeze-SuspendFreeze
224 * @tc.desc : function test
225 */
226 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0040, TestSize.Level2)
227 {
228 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
229 if (recycleMemory) {
230 auto vDecSample = make_shared<VDecNdkInnerSample>();
231 vDecSample->INP_DIR = INP_DIR_720_30;
232 vDecSample->DEFAULT_WIDTH = 1280;
233 vDecSample->DEFAULT_HEIGHT = 720;
234 vDecSample->DEFAULT_FRAME_RATE = 30;
235 vDecSample->SF_OUTPUT = false;
236 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
237 pid_t pid = getpid();
238 std::vector<pid_t> pidList = {pid};
239 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
240 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
241 vDecSample->SetRunning();
242 vDecSample->WaitForEOS();
243 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
244 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
245 }
246 }
247
248 /**
249 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0050
250 * @tc.name : SuspendActive-SuspendActive
251 * @tc.desc : function test
252 */
253 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0050, TestSize.Level2)
254 {
255 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
256 if (recycleMemory) {
257 auto vDecSample = make_shared<VDecNdkInnerSample>();
258 vDecSample->INP_DIR = INP_DIR_720_30;
259 vDecSample->DEFAULT_WIDTH = 1280;
260 vDecSample->DEFAULT_HEIGHT = 720;
261 vDecSample->DEFAULT_FRAME_RATE = 30;
262 vDecSample->SF_OUTPUT = false;
263 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
264 pid_t pid = getpid();
265 std::vector<pid_t> pidList = {pid};
266 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
267 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
268 vDecSample->WaitForEOS();
269 }
270 }
271
272 /**
273 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0060
274 * @tc.name : SuspendActiveAll-SuspendActiveAll
275 * @tc.desc : function test
276 */
277 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0060, TestSize.Level2)
278 {
279 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
280 if (recycleMemory) {
281 auto vDecSample = make_shared<VDecNdkInnerSample>();
282 vDecSample->INP_DIR = INP_DIR_720_30;
283 vDecSample->DEFAULT_WIDTH = 1280;
284 vDecSample->DEFAULT_HEIGHT = 720;
285 vDecSample->DEFAULT_FRAME_RATE = 30;
286 vDecSample->SF_OUTPUT = false;
287 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
288 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
289 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
290 vDecSample->WaitForEOS();
291 }
292 }
293
294 /**
295 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0070
296 * @tc.name : SuspendFreeze-SuspendActive
297 * @tc.desc : function test
298 */
299 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0070, TestSize.Level2)
300 {
301 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
302 if (recycleMemory) {
303 auto vDecSample = make_shared<VDecNdkInnerSample>();
304 vDecSample->INP_DIR = INP_DIR_720_30;
305 vDecSample->DEFAULT_WIDTH = 1280;
306 vDecSample->DEFAULT_HEIGHT = 720;
307 vDecSample->DEFAULT_FRAME_RATE = 30;
308 vDecSample->SF_OUTPUT = false;
309 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
310 pid_t pid = getpid();
311 std::vector<pid_t> pidList = {pid};
312 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
313 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
314 vDecSample->WaitForEOS();
315 }
316 }
317
318 /**
319 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0080
320 * @tc.name : SuspendFreeze-SuspendActiveAll
321 * @tc.desc : function test
322 */
323 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0080, TestSize.Level2)
324 {
325 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
326 if (recycleMemory) {
327 auto vDecSample = make_shared<VDecNdkInnerSample>();
328 vDecSample->INP_DIR = INP_DIR_720_30;
329 vDecSample->DEFAULT_WIDTH = 1280;
330 vDecSample->DEFAULT_HEIGHT = 720;
331 vDecSample->DEFAULT_FRAME_RATE = 30;
332 vDecSample->SF_OUTPUT = false;
333 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
334 pid_t pid = getpid();
335 std::vector<pid_t> pidList = {pid};
336 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
337 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
338 vDecSample->WaitForEOS();
339 }
340 }
341
342 /**
343 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0090
344 * @tc.name : SuspendActive-SuspendFreeze
345 * @tc.desc : function test
346 */
347 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0090, TestSize.Level2)
348 {
349 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
350 if (recycleMemory) {
351 auto vDecSample = make_shared<VDecNdkInnerSample>();
352 vDecSample->INP_DIR = INP_DIR_720_30;
353 vDecSample->DEFAULT_WIDTH = 1280;
354 vDecSample->DEFAULT_HEIGHT = 720;
355 vDecSample->DEFAULT_FRAME_RATE = 30;
356 vDecSample->SF_OUTPUT = false;
357 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
358 pid_t pid = getpid();
359 std::vector<pid_t> pidList = {pid};
360 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
361 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
362 vDecSample->SetRunning();
363 vDecSample->WaitForEOS();
364 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
365 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
366 }
367 }
368
369 /**
370 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0100
371 * @tc.name : SuspendActiveAll-SuspendFreeze
372 * @tc.desc : function test
373 */
374 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0100, TestSize.Level2)
375 {
376 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
377 if (recycleMemory) {
378 auto vDecSample = make_shared<VDecNdkInnerSample>();
379 vDecSample->INP_DIR = INP_DIR_720_30;
380 vDecSample->DEFAULT_WIDTH = 1280;
381 vDecSample->DEFAULT_HEIGHT = 720;
382 vDecSample->DEFAULT_FRAME_RATE = 30;
383 vDecSample->SF_OUTPUT = false;
384 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
385 pid_t pid = getpid();
386 std::vector<pid_t> pidList = {pid};
387 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
388 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
389 vDecSample->SetRunning();
390 vDecSample->WaitForEOS();
391 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
392 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
393 }
394 }
395
396 /**
397 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0110
398 * @tc.name : SuspendFreeze-SuspendActive-SuspendFreeze-SuspendActiveAll
399 * @tc.desc : function test
400 */
401 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0110, TestSize.Level2)
402 {
403 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
404 if (recycleMemory) {
405 auto vDecSample = make_shared<VDecNdkInnerSample>();
406 vDecSample->INP_DIR = INP_DIR_720_30;
407 vDecSample->DEFAULT_WIDTH = 1280;
408 vDecSample->DEFAULT_HEIGHT = 720;
409 vDecSample->DEFAULT_FRAME_RATE = 30;
410 vDecSample->SF_OUTPUT = false;
411 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
412 pid_t pid = getpid();
413 std::vector<pid_t> pidList = {pid};
414 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
415 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
416 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
417 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
418 vDecSample->WaitForEOS();
419 }
420 }
421
422 /**
423 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0120
424 * @tc.name : SuspendFreeze-SuspendActive-SuspendFreeze-SuspendActive
425 * @tc.desc : function test
426 */
427 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0120, TestSize.Level2)
428 {
429 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
430 if (recycleMemory) {
431 auto vDecSample = make_shared<VDecNdkInnerSample>();
432 vDecSample->INP_DIR = INP_DIR_720_30;
433 vDecSample->DEFAULT_WIDTH = 1280;
434 vDecSample->DEFAULT_HEIGHT = 720;
435 vDecSample->DEFAULT_FRAME_RATE = 30;
436 vDecSample->SF_OUTPUT = false;
437 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
438 pid_t pid = getpid();
439 std::vector<pid_t> pidList = {pid};
440 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
441 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
442 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
443 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
444 vDecSample->WaitForEOS();
445 }
446 }
447
448 /**
449 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0130
450 * @tc.name : SuspendFreeze-SuspendActiveAll-SuspendFreeze-SuspendActiveAll
451 * @tc.desc : function test
452 */
453 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0130, TestSize.Level2)
454 {
455 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
456 if (recycleMemory) {
457 auto vDecSample = make_shared<VDecNdkInnerSample>();
458 vDecSample->INP_DIR = INP_DIR_720_30;
459 vDecSample->DEFAULT_WIDTH = 1280;
460 vDecSample->DEFAULT_HEIGHT = 720;
461 vDecSample->DEFAULT_FRAME_RATE = 30;
462 vDecSample->SF_OUTPUT = false;
463 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
464 pid_t pid = getpid();
465 std::vector<pid_t> pidList = {pid};
466 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
467 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
468 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
469 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
470 vDecSample->WaitForEOS();
471 }
472 }
473
474 /**
475 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0140
476 * @tc.name : SuspendActive, flush
477 * @tc.desc : function test
478 */
479 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0140, TestSize.Level2)
480 {
481 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
482 if (recycleMemory) {
483 auto vDecSample = make_shared<VDecNdkInnerSample>();
484 vDecSample->INP_DIR = INP_DIR_720_30;
485 vDecSample->DEFAULT_WIDTH = 1280;
486 vDecSample->DEFAULT_HEIGHT = 720;
487 vDecSample->DEFAULT_FRAME_RATE = 30;
488 vDecSample->SF_OUTPUT = false;
489 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
490 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
491 vDecSample->WaitForEOS();
492 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
493 pid_t pid = getpid();
494 std::vector<pid_t> pidList = {pid};
495 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
496 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
497 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
498 }
499 }
500
501 /**
502 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0150
503 * @tc.name : SuspendFreeze, flush
504 * @tc.desc : function test
505 */
506 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0150, TestSize.Level2)
507 {
508 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
509 if (recycleMemory) {
510 auto vDecSample = make_shared<VDecNdkInnerSample>();
511 vDecSample->INP_DIR = INP_DIR_720_30;
512 vDecSample->DEFAULT_WIDTH = 1280;
513 vDecSample->DEFAULT_HEIGHT = 720;
514 vDecSample->DEFAULT_FRAME_RATE = 30;
515 vDecSample->SF_OUTPUT = false;
516 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
517 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
518 vDecSample->WaitForEOS();
519 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
520 pid_t pid = getpid();
521 std::vector<pid_t> pidList = {pid};
522 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
523 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
524 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
525 }
526 }
527
528 /**
529 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0160
530 * @tc.name : SuspendActiveAll, flush
531 * @tc.desc : function test
532 */
533 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0160, TestSize.Level2)
534 {
535 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
536 if (recycleMemory) {
537 auto vDecSample = make_shared<VDecNdkInnerSample>();
538 vDecSample->INP_DIR = INP_DIR_720_30;
539 vDecSample->DEFAULT_WIDTH = 1280;
540 vDecSample->DEFAULT_HEIGHT = 720;
541 vDecSample->DEFAULT_FRAME_RATE = 30;
542 vDecSample->SF_OUTPUT = false;
543 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
544 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
545 vDecSample->WaitForEOS();
546 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
547 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
548 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
549 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
550 }
551 }
552
553 /**
554 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0170
555 * @tc.name : SuspendFreeze-SuspendFreeze, flush
556 * @tc.desc : function test
557 */
558 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0170, TestSize.Level2)
559 {
560 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
561 if (recycleMemory) {
562 auto vDecSample = make_shared<VDecNdkInnerSample>();
563 vDecSample->INP_DIR = INP_DIR_720_30;
564 vDecSample->DEFAULT_WIDTH = 1280;
565 vDecSample->DEFAULT_HEIGHT = 720;
566 vDecSample->DEFAULT_FRAME_RATE = 30;
567 vDecSample->SF_OUTPUT = false;
568 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
569 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
570 vDecSample->WaitForEOS();
571 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
572 pid_t pid = getpid();
573 std::vector<pid_t> pidList = {pid};
574 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
575 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
576 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
577 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
578 }
579 }
580
581 /**
582 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0180
583 * @tc.name : SuspendActive-SuspendActive, flush
584 * @tc.desc : function test
585 */
586 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0180, TestSize.Level2)
587 {
588 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
589 if (recycleMemory) {
590 auto vDecSample = make_shared<VDecNdkInnerSample>();
591 vDecSample->INP_DIR = INP_DIR_720_30;
592 vDecSample->DEFAULT_WIDTH = 1280;
593 vDecSample->DEFAULT_HEIGHT = 720;
594 vDecSample->DEFAULT_FRAME_RATE = 30;
595 vDecSample->SF_OUTPUT = false;
596 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
597 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
598 vDecSample->WaitForEOS();
599 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
600 pid_t pid = getpid();
601 std::vector<pid_t> pidList = {pid};
602 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
603 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
604 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
605 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
606 }
607 }
608
609 /**
610 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0190
611 * @tc.name : SuspendActiveAll-SuspendActiveAll, flush
612 * @tc.desc : function test
613 */
614 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0190, TestSize.Level2)
615 {
616 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
617 if (recycleMemory) {
618 auto vDecSample = make_shared<VDecNdkInnerSample>();
619 vDecSample->INP_DIR = INP_DIR_720_30;
620 vDecSample->DEFAULT_WIDTH = 1280;
621 vDecSample->DEFAULT_HEIGHT = 720;
622 vDecSample->DEFAULT_FRAME_RATE = 30;
623 vDecSample->SF_OUTPUT = false;
624 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
625 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
626 vDecSample->WaitForEOS();
627 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
628 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
629 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
630 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
631 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
632 }
633 }
634
635 /**
636 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0200
637 * @tc.name : SuspendFreeze-SuspendActive,flush
638 * @tc.desc : function test
639 */
640 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0200, TestSize.Level2)
641 {
642 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
643 if (recycleMemory) {
644 auto vDecSample = make_shared<VDecNdkInnerSample>();
645 vDecSample->INP_DIR = INP_DIR_720_30;
646 vDecSample->DEFAULT_WIDTH = 1280;
647 vDecSample->DEFAULT_HEIGHT = 720;
648 vDecSample->DEFAULT_FRAME_RATE = 30;
649 vDecSample->SF_OUTPUT = false;
650 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
651 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
652 vDecSample->WaitForEOS();
653 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
654 pid_t pid = getpid();
655 std::vector<pid_t> pidList = {pid};
656 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
657 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
658 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
659 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
660 }
661 }
662
663 /**
664 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0210
665 * @tc.name : SuspendFreeze-SuspendActiveAll,flush
666 * @tc.desc : function test
667 */
668 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0210, TestSize.Level2)
669 {
670 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
671 if (recycleMemory) {
672 auto vDecSample = make_shared<VDecNdkInnerSample>();
673 vDecSample->INP_DIR = INP_DIR_720_30;
674 vDecSample->DEFAULT_WIDTH = 1280;
675 vDecSample->DEFAULT_HEIGHT = 720;
676 vDecSample->DEFAULT_FRAME_RATE = 30;
677 vDecSample->SF_OUTPUT = false;
678 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
679 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
680 vDecSample->WaitForEOS();
681 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
682 pid_t pid = getpid();
683 std::vector<pid_t> pidList = {pid};
684 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
685 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
686 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
687 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
688 }
689 }
690
691 /**
692 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0220
693 * @tc.name : SuspendActive-SuspendFreeze,flush
694 * @tc.desc : function test
695 */
696 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0220, TestSize.Level2)
697 {
698 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
699 if (recycleMemory) {
700 auto vDecSample = make_shared<VDecNdkInnerSample>();
701 vDecSample->INP_DIR = INP_DIR_720_30;
702 vDecSample->DEFAULT_WIDTH = 1280;
703 vDecSample->DEFAULT_HEIGHT = 720;
704 vDecSample->DEFAULT_FRAME_RATE = 30;
705 vDecSample->SF_OUTPUT = false;
706 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
707 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
708 vDecSample->WaitForEOS();
709 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
710 pid_t pid = getpid();
711 std::vector<pid_t> pidList = {pid};
712 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
713 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
714 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
715 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
716 }
717 }
718
719 /**
720 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0230
721 * @tc.name : SuspendActiveAll-SuspendFreeze, flush
722 * @tc.desc : function test
723 */
724 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0230, TestSize.Level0)
725 {
726 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
727 if (recycleMemory) {
728 auto vDecSample = make_shared<VDecNdkInnerSample>();
729 vDecSample->INP_DIR = INP_DIR_720_30;
730 vDecSample->DEFAULT_WIDTH = 1280;
731 vDecSample->DEFAULT_HEIGHT = 720;
732 vDecSample->DEFAULT_FRAME_RATE = 30;
733 vDecSample->SF_OUTPUT = false;
734 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
735 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
736 vDecSample->WaitForEOS();
737 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
738 pid_t pid = getpid();
739 std::vector<pid_t> pidList = {pid};
740 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
741 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
742 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
743 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
744 }
745 }
746
747 /**
748 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0240
749 * @tc.name : SuspendFreeze-SuspendActive-SuspendFreeze-SuspendActiveAll, flush
750 * @tc.desc : function test
751 */
752 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0240, TestSize.Level2)
753 {
754 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
755 if (recycleMemory) {
756 auto vDecSample = make_shared<VDecNdkInnerSample>();
757 vDecSample->INP_DIR = INP_DIR_720_30;
758 vDecSample->DEFAULT_WIDTH = 1280;
759 vDecSample->DEFAULT_HEIGHT = 720;
760 vDecSample->DEFAULT_FRAME_RATE = 30;
761 vDecSample->SF_OUTPUT = false;
762 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
763 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
764 vDecSample->WaitForEOS();
765 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
766 pid_t pid = getpid();
767 std::vector<pid_t> pidList = {pid};
768 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
769 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
770 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
771 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
772 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
773 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
774 }
775 }
776
777 /**
778 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0250
779 * @tc.name : SuspendFreeze-SuspendActive-SuspendFreeze-SuspendActive,flush
780 * @tc.desc : function test
781 */
782 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0250, TestSize.Level2)
783 {
784 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
785 if (recycleMemory) {
786 auto vDecSample = make_shared<VDecNdkInnerSample>();
787 vDecSample->INP_DIR = INP_DIR_720_30;
788 vDecSample->DEFAULT_WIDTH = 1280;
789 vDecSample->DEFAULT_HEIGHT = 720;
790 vDecSample->DEFAULT_FRAME_RATE = 30;
791 vDecSample->SF_OUTPUT = false;
792 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
793 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
794 vDecSample->WaitForEOS();
795 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
796 pid_t pid = getpid();
797 std::vector<pid_t> pidList = {pid};
798 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
799 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
800 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
801 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
802 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
803 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
804 }
805 }
806
807 /**
808 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0260
809 * @tc.name : SuspendFreeze-SuspendActiveAll-SuspendFreeze-SuspendActiveAll,flush
810 * @tc.desc : function test
811 */
812 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0260, TestSize.Level2)
813 {
814 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
815 if (recycleMemory) {
816 auto vDecSample = make_shared<VDecNdkInnerSample>();
817 vDecSample->INP_DIR = INP_DIR_720_30;
818 vDecSample->DEFAULT_WIDTH = 1280;
819 vDecSample->DEFAULT_HEIGHT = 720;
820 vDecSample->DEFAULT_FRAME_RATE = 30;
821 vDecSample->SF_OUTPUT = false;
822 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
823 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
824 vDecSample->WaitForEOS();
825 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Flush());
826 pid_t pid = getpid();
827 std::vector<pid_t> pidList = {pid};
828 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
829 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
830 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
831 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
832 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
833 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
834 }
835 }
836
837
838 /**
839 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0270
840 * @tc.name : SuspendActive, eos
841 * @tc.desc : function test
842 */
843 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0270, TestSize.Level2)
844 {
845 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
846 if (recycleMemory) {
847 auto vDecSample = make_shared<VDecNdkInnerSample>();
848 vDecSample->INP_DIR = INP_DIR_720_30;
849 vDecSample->DEFAULT_WIDTH = 1280;
850 vDecSample->DEFAULT_HEIGHT = 720;
851 vDecSample->DEFAULT_FRAME_RATE = 30;
852 vDecSample->SF_OUTPUT = false;
853 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
854 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
855 vDecSample->WaitForEOS();
856 pid_t pid = getpid();
857 std::vector<pid_t> pidList = {pid};
858 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
859 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
860 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
861 }
862 }
863
864 /**
865 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0280
866 * @tc.name : SuspendFreeze, eos
867 * @tc.desc : function test
868 */
869 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0280, TestSize.Level2)
870 {
871 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
872 if (recycleMemory) {
873 auto vDecSample = make_shared<VDecNdkInnerSample>();
874 vDecSample->INP_DIR = INP_DIR_720_30;
875 vDecSample->DEFAULT_WIDTH = 1280;
876 vDecSample->DEFAULT_HEIGHT = 720;
877 vDecSample->DEFAULT_FRAME_RATE = 30;
878 vDecSample->SF_OUTPUT = false;
879 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
880 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
881 vDecSample->WaitForEOS();
882 pid_t pid = getpid();
883 std::vector<pid_t> pidList = {pid};
884 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
885 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
886 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
887 }
888 }
889
890 /**
891 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0290
892 * @tc.name : SuspendActiveAll, eos
893 * @tc.desc : function test
894 */
895 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0290, TestSize.Level2)
896 {
897 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
898 if (recycleMemory) {
899 auto vDecSample = make_shared<VDecNdkInnerSample>();
900 vDecSample->INP_DIR = INP_DIR_720_30;
901 vDecSample->DEFAULT_WIDTH = 1280;
902 vDecSample->DEFAULT_HEIGHT = 720;
903 vDecSample->DEFAULT_FRAME_RATE = 30;
904 vDecSample->SF_OUTPUT = false;
905 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
906 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
907 vDecSample->WaitForEOS();
908 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
909 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
910 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
911 }
912 }
913
914 /**
915 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0300
916 * @tc.name : SuspendFreeze-SuspendFreeze, eos
917 * @tc.desc : function test
918 */
919 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0300, TestSize.Level2)
920 {
921 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
922 if (recycleMemory) {
923 auto vDecSample = make_shared<VDecNdkInnerSample>();
924 vDecSample->INP_DIR = INP_DIR_720_30;
925 vDecSample->DEFAULT_WIDTH = 1280;
926 vDecSample->DEFAULT_HEIGHT = 720;
927 vDecSample->DEFAULT_FRAME_RATE = 30;
928 vDecSample->SF_OUTPUT = false;
929 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
930 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
931 vDecSample->WaitForEOS();
932 pid_t pid = getpid();
933 std::vector<pid_t> pidList = {pid};
934 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
935 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
936 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
937 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
938 }
939 }
940
941 /**
942 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0310
943 * @tc.name : SuspendActive-SuspendActive, eos
944 * @tc.desc : function test
945 */
946 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0310, TestSize.Level2)
947 {
948 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
949 if (recycleMemory) {
950 auto vDecSample = make_shared<VDecNdkInnerSample>();
951 vDecSample->INP_DIR = INP_DIR_720_30;
952 vDecSample->DEFAULT_WIDTH = 1280;
953 vDecSample->DEFAULT_HEIGHT = 720;
954 vDecSample->DEFAULT_FRAME_RATE = 30;
955 vDecSample->SF_OUTPUT = false;
956 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
957 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
958 vDecSample->WaitForEOS();
959 pid_t pid = getpid();
960 std::vector<pid_t> pidList = {pid};
961 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
962 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
963 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
964 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
965 }
966 }
967
968 /**
969 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0320
970 * @tc.name : SuspendActiveAll-SuspendActiveAll, eos
971 * @tc.desc : function test
972 */
973 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0320, TestSize.Level2)
974 {
975 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
976 if (recycleMemory) {
977 auto vDecSample = make_shared<VDecNdkInnerSample>();
978 vDecSample->INP_DIR = INP_DIR_720_30;
979 vDecSample->DEFAULT_WIDTH = 1280;
980 vDecSample->DEFAULT_HEIGHT = 720;
981 vDecSample->DEFAULT_FRAME_RATE = 30;
982 vDecSample->SF_OUTPUT = false;
983 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
984 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
985 vDecSample->WaitForEOS();
986 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
987 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
988 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
989 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
990 }
991 }
992
993 /**
994 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0330
995 * @tc.name : SuspendFreeze-SuspendActive,flush
996 * @tc.desc : function test
997 */
998 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0330, TestSize.Level2)
999 {
1000 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
1001 if (recycleMemory) {
1002 auto vDecSample = make_shared<VDecNdkInnerSample>();
1003 vDecSample->INP_DIR = INP_DIR_720_30;
1004 vDecSample->DEFAULT_WIDTH = 1280;
1005 vDecSample->DEFAULT_HEIGHT = 720;
1006 vDecSample->DEFAULT_FRAME_RATE = 30;
1007 vDecSample->SF_OUTPUT = false;
1008 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1009 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
1010 vDecSample->WaitForEOS();
1011 pid_t pid = getpid();
1012 std::vector<pid_t> pidList = {pid};
1013 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1014 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
1015 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
1016 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
1017 }
1018 }
1019
1020 /**
1021 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0340
1022 * @tc.name : SuspendFreeze-SuspendActiveAll, eos
1023 * @tc.desc : function test
1024 */
1025 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0340, TestSize.Level2)
1026 {
1027 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
1028 if (recycleMemory) {
1029 auto vDecSample = make_shared<VDecNdkInnerSample>();
1030 vDecSample->INP_DIR = INP_DIR_720_30;
1031 vDecSample->DEFAULT_WIDTH = 1280;
1032 vDecSample->DEFAULT_HEIGHT = 720;
1033 vDecSample->DEFAULT_FRAME_RATE = 30;
1034 vDecSample->SF_OUTPUT = false;
1035 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1036 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
1037 vDecSample->WaitForEOS();
1038 pid_t pid = getpid();
1039 std::vector<pid_t> pidList = {pid};
1040 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1041 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
1042 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
1043 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
1044 }
1045 }
1046
1047 /**
1048 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0350
1049 * @tc.name : SuspendActive-SuspendFreeze,eos
1050 * @tc.desc : function test
1051 */
1052 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0350, TestSize.Level1)
1053 {
1054 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
1055 if (recycleMemory) {
1056 auto vDecSample = make_shared<VDecNdkInnerSample>();
1057 vDecSample->INP_DIR = INP_DIR_720_30;
1058 vDecSample->DEFAULT_WIDTH = 1280;
1059 vDecSample->DEFAULT_HEIGHT = 720;
1060 vDecSample->DEFAULT_FRAME_RATE = 30;
1061 vDecSample->SF_OUTPUT = false;
1062 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1063 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
1064 vDecSample->WaitForEOS();
1065 pid_t pid = getpid();
1066 std::vector<pid_t> pidList = {pid};
1067 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
1068 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1069 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
1070 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
1071 }
1072 }
1073
1074 /**
1075 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0360
1076 * @tc.name : SuspendActiveAll-SuspendFreeze, eos
1077 * @tc.desc : function test
1078 */
1079 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0360, TestSize.Level2)
1080 {
1081 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
1082 if (recycleMemory) {
1083 auto vDecSample = make_shared<VDecNdkInnerSample>();
1084 vDecSample->INP_DIR = INP_DIR_720_30;
1085 vDecSample->DEFAULT_WIDTH = 1280;
1086 vDecSample->DEFAULT_HEIGHT = 720;
1087 vDecSample->DEFAULT_FRAME_RATE = 30;
1088 vDecSample->SF_OUTPUT = false;
1089 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1090 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
1091 vDecSample->WaitForEOS();
1092 pid_t pid = getpid();
1093 std::vector<pid_t> pidList = {pid};
1094 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
1095 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1096 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
1097 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
1098 }
1099 }
1100
1101 /**
1102 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0370
1103 * @tc.name : SuspendFreeze-SuspendActive-SuspendFreeze-SuspendActiveAll, eos
1104 * @tc.desc : function test
1105 */
1106 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0370, TestSize.Level0)
1107 {
1108 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
1109 if (recycleMemory) {
1110 auto vDecSample = make_shared<VDecNdkInnerSample>();
1111 vDecSample->INP_DIR = INP_DIR_720_30;
1112 vDecSample->DEFAULT_WIDTH = 1280;
1113 vDecSample->DEFAULT_HEIGHT = 720;
1114 vDecSample->DEFAULT_FRAME_RATE = 30;
1115 vDecSample->SF_OUTPUT = false;
1116 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1117 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
1118 vDecSample->WaitForEOS();
1119 pid_t pid = getpid();
1120 std::vector<pid_t> pidList = {pid};
1121 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1122 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
1123 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1124 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
1125 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
1126 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
1127 }
1128 }
1129
1130 /**
1131 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0380
1132 * @tc.name : SuspendFreeze-SuspendActive-SuspendFreeze-SuspendActive,eos
1133 * @tc.desc : function test
1134 */
1135 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0380, TestSize.Level1)
1136 {
1137 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
1138 if (recycleMemory) {
1139 auto vDecSample = make_shared<VDecNdkInnerSample>();
1140 vDecSample->INP_DIR = INP_DIR_720_30;
1141 vDecSample->DEFAULT_WIDTH = 1280;
1142 vDecSample->DEFAULT_HEIGHT = 720;
1143 vDecSample->DEFAULT_FRAME_RATE = 30;
1144 vDecSample->SF_OUTPUT = false;
1145 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1146 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
1147 vDecSample->WaitForEOS();
1148 pid_t pid = getpid();
1149 std::vector<pid_t> pidList = {pid};
1150 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1151 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
1152 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1153 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActive(pidList));
1154 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
1155 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
1156 }
1157 }
1158
1159 /**
1160 * @tc.number : VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0390
1161 * @tc.name : SuspendFreeze-SuspendActiveAll-SuspendFreeze-SuspendActiveAll,eos
1162 * @tc.desc : function test
1163 */
1164 HWTEST_F(HwdecInnerFuncNdkTest, VIDEO_HWDEC_INNER_RECYCLEMEMORY_FUNC_0390, TestSize.Level2)
1165 {
1166 bool recycleMemory = OHOS::system::GetBoolParameter("resourceschedule.memmgr.dma.reclaimable", false);
1167 if (recycleMemory) {
1168 auto vDecSample = make_shared<VDecNdkInnerSample>();
1169 vDecSample->INP_DIR = INP_DIR_720_30;
1170 vDecSample->DEFAULT_WIDTH = 1280;
1171 vDecSample->DEFAULT_HEIGHT = 720;
1172 vDecSample->DEFAULT_FRAME_RATE = 30;
1173 vDecSample->SF_OUTPUT = false;
1174 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1175 ASSERT_EQ(AVCS_ERR_OK, vDecSample->RunVideoDecoder(g_codecName));
1176 vDecSample->WaitForEOS();
1177 pid_t pid = getpid();
1178 std::vector<pid_t> pidList = {pid};
1179 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1180 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
1181 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendFreeze(pidList));
1182 ASSERT_EQ(AVCS_ERR_OK, AVCodecSuspend::SuspendActiveAll());
1183 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Stop());
1184 ASSERT_EQ(AVCS_ERR_OK, vDecSample->Release());
1185 }
1186 }
1187 } // namespace