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 "audio_info.h"
19 #include "native_avcodec_audiodecoder.h"
20 #include "native_avcodec_audioencoder.h"
21 #include "native_avcodec_base.h"
22 #include "native_avformat.h"
23 #include "ADecEncNdkSample.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 ActsAudioDecEncNdkTest : 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 ActsAudioDecEncNdkTest::SetUpTestCase() {}
TearDownTestCase()40 void ActsAudioDecEncNdkTest::TearDownTestCase() {}
SetUp()41 void ActsAudioDecEncNdkTest::SetUp() {}
TearDown()42 void ActsAudioDecEncNdkTest::TearDown() {}
43
44 uint32_t ES_AAC_48000_32_1[] = {
45 283, 336, 291, 405, 438, 411, 215, 215, 313, 270, 342, 641, 554, 545, 545, 546, 541,
46 540, 542, 552, 537, 533, 498, 472, 445, 430, 445, 427, 414, 386, 413, 370, 380, 401,
47 393, 369, 391, 367, 395, 396, 396, 385, 391, 384, 395, 392, 386, 388, 384, 379, 376,
48 381, 375, 373, 349, 391, 357, 384, 395, 384, 380, 386, 372, 386, 383, 378, 385, 385,
49 384, 342, 390, 379, 387, 386, 393, 397, 362, 393, 394, 391, 383, 385, 377, 379, 381,
50 369, 375, 379, 346, 382, 356, 361, 366, 394, 393, 385, 362, 406, 399, 384, 377, 385};
51
52 constexpr uint32_t ES_AAC_48000_32_1_Length = sizeof(ES_AAC_48000_32_1) / sizeof(uint32_t);
53 const string MIME_TYPE_AAC = "audio/mp4a-latm";
54 const string DECODER_AAC = "avdec_aac";
55 const string ENCODER_AAC = "avenc_aac";
56 constexpr uint32_t DEFAULT_SAMPLE_RATE = 44100;
57 constexpr uint32_t DEFAULT_CHANNELS = 2;
58 const char* READPATH = "/data/media/AAC_48000_32_1.aac";
59
CheckDecDesc(map<string,int> InDesc,OH_AVFormat * OutDesc)60 bool CheckDecDesc(map<string, int> InDesc, OH_AVFormat* OutDesc)
61 {
62 int32_t out ;
63 for (const auto& t: InDesc) {
64 bool res = OH_AVFormat_GetIntValue(OutDesc, t.first.c_str(), &out);
65 cout << "key: " << t.first << "; out: " << out <<endl;
66 if (!res) {
67 cout << "OH_AVFormat_GetIntValue Fail. key:" << t.first << endl;
68 return false;
69 }
70 if (out != t.second) {
71 cout << "OH_AVFormat_GetIntValue error. key: " << t.first
72 << "; expect: "<< t.second
73 << ", actual: "<< out << endl;
74 return false;
75 }
76 out = 0;
77 }
78 return true;
79 }
80
SetFormat(struct OH_AVFormat * format,map<string,int> mediaDescription)81 bool SetFormat(struct OH_AVFormat *format, map<string, int> mediaDescription)
82 {
83 const char *key;
84 for (const auto& t: mediaDescription) {
85 key = t.first.c_str();
86 if (not OH_AVFormat_SetIntValue(format, key, t.second)) {
87 cout << "OH_AV_FormatPutIntValue Fail. format key: " << t.first
88 << ", value: "<< t.second << endl;
89 return false;
90 }
91 }
92 return true;
93 }
94 }
95
96 /**
97 * @tc.number : SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0100
98 * @tc.name : stop at end of stream
99 * @tc.desc : Basic function test
100 */
101 HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0100, TestSize.Level1)
102 {
103 ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
104
105 map<string, int> AudioParam = {
106 {OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS},
107 {OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE},
108 {OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE},
109 };
110 OH_AVFormat *AudioFormat = OH_AVFormat_Create();
111 ASSERT_NE(nullptr, AudioFormat);
112 ASSERT_EQ(true, SetFormat(AudioFormat, AudioParam));
113 OH_AVFormat_SetStringValue(AudioFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
114
115 struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByName(DECODER_AAC);
116 ASSERT_NE(nullptr, audDec);
117 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
118 OH_AVFormat *OutDescDec = OH_AudioDecoder_GetOutputDescription(audDec);
119 ASSERT_NE(nullptr, OutDescDec);
120 ASSERT_EQ(true, CheckDecDesc(AudioParam, OutDescDec));
121 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
122
123 struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByName(ENCODER_AAC);
124 ASSERT_NE(nullptr, audEnc);
125 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
126 OH_AVFormat *OutDescEnc = OH_AudioEncoder_GetOutputDescription(audEnc);
127 ASSERT_NE(nullptr, OutDescEnc);
128 ASSERT_EQ(true, CheckDecDesc(AudioParam, OutDescEnc));
129 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
130
131 aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
132 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out1.aac");
133 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
134 ASSERT_EQ(AV_ERR_OK, aDecEncSample->SetParameterEnc(AudioFormat));
135 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
136 ASSERT_EQ(AV_ERR_OK, aDecEncSample->SetParameterDec(AudioFormat));
137
138 while (!aDecEncSample->GetEncEosState()) {};
139 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopDec());
140 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopEnc());
141 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
142 audDec = nullptr;
143 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseEnc());
144 audEnc = nullptr;
145 OH_AVFormat_Destroy(AudioFormat);
146 AudioFormat = nullptr;
147 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
148 }
149
150 /**
151 * @tc.number : SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0200
152 * @tc.name : reset at end of stream
153 * @tc.desc : Basic function test
154 */
155 HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0200, TestSize.Level1)
156 {
157 ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
158
159 struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
160 ASSERT_NE(nullptr, audDec);
161 OH_AVFormat *AudioFormat = OH_AVFormat_Create();
162 ASSERT_NE(nullptr, AudioFormat);
163 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
164 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
165 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
166 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_TRACK_TYPE, MEDIA_TYPE_AUD);
167
168 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
169 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
170
171 struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
172 ASSERT_NE(nullptr, audEnc);
173 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
174 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
175 aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
176 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out2.aac");
177
178 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
179 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
180 while (!aDecEncSample->GetEncEosState()) {};
181 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ResetEnc());
182 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ResetDec());
183 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
184 audDec = nullptr;
185 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseEnc());
186 audEnc = nullptr;
187 OH_AVFormat_Destroy(AudioFormat);
188 AudioFormat = nullptr;
189 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
190 }
191
192 /**
193 * @tc.number : SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0300
194 * @tc.name : release at end of stream
195 * @tc.desc : Basic function test
196 */
197 HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0300, TestSize.Level1)
198 {
199 ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
200
201 struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
202 ASSERT_NE(nullptr, audDec);
203 OH_AVFormat *AudioFormat = OH_AVFormat_Create();
204 ASSERT_NE(nullptr, AudioFormat);
205 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
206 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
207 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
208 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_PROFILE, AAC_PROFILE_LC);
209
210 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
211 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
212
213 struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
214 ASSERT_NE(nullptr, audEnc);
215 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
216 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
217 aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
218 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out3.aac");
219
220 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
221 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
222 while (!aDecEncSample->GetEncEosState()) {};
223 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
224 audDec = nullptr;
225 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseEnc());
226 audEnc = nullptr;
227 OH_AVFormat_Destroy(AudioFormat);
228 AudioFormat = nullptr;
229 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
230 }
231
232 /**
233 * @tc.number : SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0400
234 * @tc.name : flush at running
235 * @tc.desc : Basic function test
236 */
237 HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0400, TestSize.Level1)
238 {
239 ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
240
241 struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
242 ASSERT_NE(nullptr, audDec);
243 OH_AVFormat *AudioFormat = OH_AVFormat_Create();
244 ASSERT_NE(nullptr, AudioFormat);
245 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
246 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
247 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
248 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
249 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
250
251 struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
252 ASSERT_NE(nullptr, audEnc);
253 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
254 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
255 aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
256 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out4.aac");
257 aDecEncSample->SetEosState(false);
258
259 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
260 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
261 while (aDecEncSample->GetFrameCount() < 50) {};
262 ASSERT_EQ(AV_ERR_OK, aDecEncSample->FlushDec());
263 ASSERT_EQ(AV_ERR_OK, aDecEncSample->FlushEnc());
264 aDecEncSample->ReRead();
265 aDecEncSample->ResetDecParam();
266 aDecEncSample->ResetEncParam();
267 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out4_2.aac");
268 aDecEncSample->SetEosState(true);
269 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
270 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
271
272 while (!aDecEncSample->GetEncEosState()) {};
273 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
274 audDec = nullptr;
275 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseEnc());
276 audEnc = nullptr;
277 OH_AVFormat_Destroy(AudioFormat);
278 AudioFormat = nullptr;
279 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
280 }
281
282 /**
283 * @tc.number : SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0500
284 * @tc.name : flush decoder at eos
285 * @tc.desc : Basic function test
286 */
287 HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0500, TestSize.Level1)
288 {
289 ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
290
291 struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
292 ASSERT_NE(nullptr, audDec);
293 OH_AVFormat *AudioFormat = OH_AVFormat_Create();
294 ASSERT_NE(nullptr, AudioFormat);
295 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
296 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
297 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
298 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
299 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
300
301 struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
302 ASSERT_NE(nullptr, audEnc);
303 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
304 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
305 aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
306 aDecEncSample->SetEosState(false);
307 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out5.aac");
308
309 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
310 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
311 while (!aDecEncSample->GetDecEosState()) {};
312 cout << "aDecEncSample->GetDecEosState() is " << aDecEncSample->GetDecEosState() << endl;
313 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
314 ASSERT_EQ(AV_ERR_OK, aDecEncSample->FlushDec());
315 ASSERT_EQ(AV_ERR_OK, aDecEncSample->FlushEnc());
316 aDecEncSample->ReRead();
317 aDecEncSample->ResetDecParam();
318 aDecEncSample->ResetEncParam();
319 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out5_2.aac");
320 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
321 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
322 aDecEncSample->SetEosState(true);
323
324 while (!aDecEncSample->GetEncEosState()) {};
325 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
326 audDec = nullptr;
327 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseEnc());
328 audEnc = nullptr;
329 OH_AVFormat_Destroy(AudioFormat);
330 AudioFormat = nullptr;
331 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
332 }
333
334
335 /**
336 * @tc.number : SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0600
337 * @tc.name : stop at running and restart to eos
338 * @tc.desc : Basic function test
339 */
340 HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0600, TestSize.Level1)
341 {
342 ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
343
344 struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
345 ASSERT_NE(nullptr, audDec);
346 OH_AVFormat *AudioFormat = OH_AVFormat_Create();
347 ASSERT_NE(nullptr, AudioFormat);
348 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
349 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
350 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
351 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
352 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
353
354 struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
355 ASSERT_NE(nullptr, audEnc);
356 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
357 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
358 aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
359 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out6.aac");
360 aDecEncSample->SetEosState(false);
361
362 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
363 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
364 while (aDecEncSample->GetFrameCount() < 50) {};
365 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopDec());
366 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopEnc());
367 aDecEncSample->ReRead();
368 aDecEncSample->ResetDecParam();
369 aDecEncSample->ResetEncParam();
370 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out6_2.aac");
371 aDecEncSample->SetEosState(true);
372 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
373 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
374 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
375
376 while (!aDecEncSample->GetEncEosState()) {};
377 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
378 audDec = nullptr;
379 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseEnc());
380 audEnc = nullptr;
381 OH_AVFormat_Destroy(AudioFormat);
382 AudioFormat = nullptr;
383 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
384 }
385
386
387 /**
388 * @tc.number : SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0700
389 * @tc.name : stop dec at eos and restart to eos
390 * @tc.desc : Basic function test
391 */
392 HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_0700, TestSize.Level1)
393 {
394 ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
395
396 struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
397 ASSERT_NE(nullptr, audDec);
398 OH_AVFormat *AudioFormat = OH_AVFormat_Create();
399 ASSERT_NE(nullptr, AudioFormat);
400 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
401 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
402 OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
403 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
404 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
405
406 struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
407 ASSERT_NE(nullptr, audEnc);
408 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
409 ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
410 aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
411 aDecEncSample->SetEosState(false);
412 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out7.aac");
413
414 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
415 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
416 while (!aDecEncSample->GetDecEosState()) {};
417 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopDec());
418 ASSERT_EQ(AV_ERR_OK, aDecEncSample->FlushEnc());
419 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
420
421 aDecEncSample->ReRead();
422 aDecEncSample->ResetDecParam();
423 aDecEncSample->ResetEncParam();
424 aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out7_2.aac");
425 aDecEncSample->SetEosState(true);
426 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
427 ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
428
429 while (!aDecEncSample->GetEncEosState()) {};
430 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
431 audDec = nullptr;
432 ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseEnc());
433 audEnc = nullptr;
434 OH_AVFormat_Destroy(AudioFormat);
435 AudioFormat = nullptr;
436 ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
437 }