1 /*
2 * Copyright (C) 2024 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 <iostream>
17 #include <unistd.h>
18 #include <chrono>
19 #include "avcodec_codec_name.h"
20 #include "avcodec_common.h"
21 #include "avcodec_errors.h"
22 #include "demo_log.h"
23 #include "avcodec_mime_type.h"
24 #include "media_description.h"
25 #include "native_avcodec_base.h"
26 #include "native_avformat.h"
27 #include "securec.h"
28 #include "audiodecoderdemo.h"
29
30 using namespace OHOS;
31 using namespace OHOS::MediaAVCodec;
32 using namespace OHOS::MediaAVCodec::AudioDemoAuto;
33 using namespace std;
34
35 namespace OHOS {
36 namespace MediaAVCodec {
37 namespace AudioDemoAuto {
38 constexpr uint32_t CHANNEL_COUNT = 2;
39 constexpr uint32_t CHANNEL_COUNT1 = 1;
40 constexpr uint32_t SAMPLE_RATE = 44100;
41 constexpr uint32_t DEFAULT_AAC_TYPE = 1;
42 constexpr uint32_t AMRWB_SAMPLE_RATE = 16000;
43 constexpr uint32_t AMRNB_SAMPLE_RATE = 8000;
44
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)45 void OnError(OH_AVCodec* codec, int32_t errorCode, void* userData)
46 {
47 (void)codec;
48 (void)errorCode;
49 (void)userData;
50 }
51
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)52 void OnOutputFormatChanged(OH_AVCodec* codec, OH_AVFormat* format, void* userData)
53 {
54 (void)codec;
55 (void)format;
56 (void)userData;
57 cout << "OnOutputFormatChanged received" << endl;
58 }
59
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,void * userData)60 void OnInputBufferAvailable(OH_AVCodec* codec, uint32_t index, OH_AVMemory* data, void* userData)
61 {
62 (void)codec;
63 ADecSignal* signal = static_cast<ADecSignal*>(userData);
64 unique_lock<mutex> lock(signal->inMutex_);
65 signal->inQueue_.push(index);
66 signal->inBufferQueue_.push(data);
67 signal->inCond_.notify_all();
68 }
69
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,OH_AVCodecBufferAttr * attr,void * userData)70 void OnOutputBufferAvailable(OH_AVCodec* codec, uint32_t index, OH_AVMemory* data, OH_AVCodecBufferAttr* attr,
71 void* userData)
72 {
73 (void)codec;
74 ADecSignal* signal = static_cast<ADecSignal*>(userData);
75 unique_lock<mutex> lock(signal->outMutex_);
76 signal->outQueue_.push(index);
77 signal->outBufferQueue_.push(data);
78 if (attr) {
79 signal->attrQueue_.push(*attr);
80 } else {
81 cout << "OnOutputBufferAvailable, attr is nullptr!" << endl;
82 }
83 signal->outCond_.notify_all();
84 }
85 }
86 }
87 }
88
CreateByMime(const char * mime)89 OH_AVCodec* ADecDemoAuto::CreateByMime(const char* mime)
90 {
91 return OH_AudioDecoder_CreateByMime(mime);
92 }
93
CreateByName(const char * name)94 OH_AVCodec* ADecDemoAuto::CreateByName(const char* name)
95 {
96 return OH_AudioDecoder_CreateByName(name);
97 }
98
Destroy(OH_AVCodec * codec)99 OH_AVErrCode ADecDemoAuto::Destroy(OH_AVCodec* codec)
100 {
101 if (format_ != nullptr) {
102 OH_AVFormat_Destroy(format_);
103 format_ = nullptr;
104 }
105 OH_AVErrCode ret = OH_AudioDecoder_Destroy(codec);
106 ClearQueue();
107 return ret;
108 }
109
SetCallback(OH_AVCodec * codec)110 OH_AVErrCode ADecDemoAuto::SetCallback(OH_AVCodec* codec)
111 {
112 cb_ = { &OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable };
113 return OH_AudioDecoder_SetCallback(codec, cb_, signal_);
114 }
115
Prepare(OH_AVCodec * codec)116 OH_AVErrCode ADecDemoAuto::Prepare(OH_AVCodec* codec)
117 {
118 return OH_AudioDecoder_Prepare(codec);
119 }
120
Start(OH_AVCodec * codec)121 OH_AVErrCode ADecDemoAuto::Start(OH_AVCodec* codec)
122 {
123 return OH_AudioDecoder_Start(codec);
124 }
125
Stop(OH_AVCodec * codec)126 OH_AVErrCode ADecDemoAuto::Stop(OH_AVCodec* codec)
127 {
128 OH_AVErrCode ret = OH_AudioDecoder_Stop(codec);
129 ClearQueue();
130 return ret;
131 }
132
Flush(OH_AVCodec * codec)133 OH_AVErrCode ADecDemoAuto::Flush(OH_AVCodec* codec)
134 {
135 OH_AVErrCode ret = OH_AudioDecoder_Flush(codec);
136 ClearQueue();
137 return ret;
138 }
139
Reset(OH_AVCodec * codec)140 OH_AVErrCode ADecDemoAuto::Reset(OH_AVCodec* codec)
141 {
142 return OH_AudioDecoder_Reset(codec);
143 }
144
GetOutputDescription(OH_AVCodec * codec)145 OH_AVFormat* ADecDemoAuto::GetOutputDescription(OH_AVCodec* codec)
146 {
147 return OH_AudioDecoder_GetOutputDescription(codec);
148 }
149
PushInputData(OH_AVCodec * codec,uint32_t index,int32_t size,int32_t offset)150 OH_AVErrCode ADecDemoAuto::PushInputData(OH_AVCodec* codec, uint32_t index, int32_t size, int32_t offset)
151 {
152 OH_AVCodecBufferAttr info;
153 info.size = size;
154 info.offset = offset;
155 info.pts = 0;
156 info.flags = AVCODEC_BUFFER_FLAGS_NONE;
157
158 return OH_AudioDecoder_PushInputData(codec, index, info);
159 }
160
PushInputDataEOS(OH_AVCodec * codec,uint32_t index)161 OH_AVErrCode ADecDemoAuto::PushInputDataEOS(OH_AVCodec* codec, uint32_t index)
162 {
163 OH_AVCodecBufferAttr info;
164 info.size = 0;
165 info.offset = 0;
166 info.pts = 0;
167 info.flags = AVCODEC_BUFFER_FLAGS_EOS;
168
169 return OH_AudioDecoder_PushInputData(codec, index, info);
170 }
171
FreeOutputData(OH_AVCodec * codec,uint32_t index)172 OH_AVErrCode ADecDemoAuto::FreeOutputData(OH_AVCodec* codec, uint32_t index)
173 {
174 return OH_AudioDecoder_FreeOutputData(codec, index);
175 }
176
IsValid(OH_AVCodec * codec,bool * isValid)177 OH_AVErrCode ADecDemoAuto::IsValid(OH_AVCodec* codec, bool* isValid)
178 {
179 return OH_AudioDecoder_IsValid(codec, isValid);
180 }
181
GetInputIndex()182 uint32_t ADecDemoAuto::GetInputIndex()
183 {
184 int32_t sleepTime = 0;
185 uint32_t index;
186 int32_t condTime = 5;
187 while (signal_->inQueue_.empty() && sleepTime < condTime) {
188 sleep(1);
189 sleepTime++;
190 }
191 if (sleepTime >= condTime) {
192 return 0;
193 } else {
194 index = signal_->inQueue_.front();
195 signal_->inQueue_.pop();
196 }
197 return index;
198 }
199
GetOutputIndex()200 uint32_t ADecDemoAuto::GetOutputIndex()
201 {
202 int32_t sleepTime = 0;
203 uint32_t index;
204 int32_t condTime = 5;
205 while (signal_->outQueue_.empty() && sleepTime < condTime) {
206 sleep(1);
207 sleepTime++;
208 }
209 if (sleepTime >= condTime) {
210 return 0;
211 } else {
212 index = signal_->outQueue_.front();
213 signal_->outQueue_.pop();
214 }
215 return index;
216 }
217
ClearQueue()218 void ADecDemoAuto::ClearQueue()
219 {
220 while (!signal_->inQueue_.empty()) {
221 signal_->inQueue_.pop();
222 }
223 while (!signal_->outQueue_.empty()) {
224 signal_->outQueue_.pop();
225 }
226 while (!signal_->inBufferQueue_.empty()) {
227 signal_->inBufferQueue_.pop();
228 }
229 while (!signal_->outBufferQueue_.empty()) {
230 signal_->outBufferQueue_.pop();
231 }
232 while (!signal_->attrQueue_.empty()) {
233 signal_->attrQueue_.pop();
234 }
235 }
236
InitFile(string inputFile)237 bool ADecDemoAuto::InitFile(string inputFile)
238 {
239 if (inputFile.find("aac") != std::string::npos) {
240 audioType_ = TYPE_AAC;
241 } else if (inputFile.find("flac") != std::string::npos) {
242 audioType_ = TYPE_FLAC;
243 } else if (inputFile.find("mp3") != std::string::npos) {
244 audioType_ = TYPE_MP3;
245 } else if (inputFile.find("vorbis") != std::string::npos) {
246 audioType_ = TYPE_VORBIS;
247 } else if (inputFile.find("amrnb") != std::string::npos) {
248 audioType_ = TYPE_AMRNB;
249 } else if (inputFile.find("amrwb") != std::string::npos) {
250 audioType_ = TYPE_AMRWB;
251 } else if (inputFile.find("opus") != std::string::npos) {
252 audioType_ = TYPE_OPUS;
253 } else if (inputFile.find("g711mu") != std::string::npos) {
254 audioType_ = TYPE_G711MU;
255 } else {
256 audioType_ = TYPE_AAC;
257 }
258 return true;
259 }
260
InitFormat(OH_AVFormat * format)261 bool ADecDemoAuto::InitFormat(OH_AVFormat *format)
262 {
263 int32_t channelCount = CHANNEL_COUNT;
264 int32_t sampleRate = SAMPLE_RATE;
265 if (audioType_ == TYPE_AAC) {
266 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AAC_IS_ADTS.data(),
267 DEFAULT_AAC_TYPE);
268 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
269 OH_BitsPerSample::SAMPLE_S16LE);
270 } else if (audioType_ == TYPE_AMRNB || audioType_ == TYPE_G711MU || audioType_ == TYPE_OPUS) {
271 channelCount = CHANNEL_COUNT1;
272 sampleRate = AMRNB_SAMPLE_RATE;
273 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
274 OH_BitsPerSample::SAMPLE_S16LE);
275 } else if (audioType_ == TYPE_AMRWB) {
276 channelCount = CHANNEL_COUNT1;
277 sampleRate = AMRWB_SAMPLE_RATE;
278 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
279 OH_BitsPerSample::SAMPLE_S16LE);
280 }
281 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
282 OH_BitsPerSample::SAMPLE_S16LE);
283 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), channelCount);
284 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), sampleRate);
285 DEMO_CHECK_AND_RETURN_RET_LOG(Configure(format) == AVCS_ERR_OK, false,
286 "Fatal: Configure fail");
287 return true;
288 }
289
ADecDemoAuto()290 ADecDemoAuto::ADecDemoAuto() : audioDec_(nullptr), signal_(nullptr), audioType_(TYPE_AAC)
291 {
292 signal_ = new ADecSignal();
293 DEMO_CHECK_AND_RETURN_LOG(signal_ != nullptr, "Fatal: No memory");
294 }
295
~ADecDemoAuto()296 ADecDemoAuto::~ADecDemoAuto()
297 {
298 if (signal_) {
299 delete signal_;
300 signal_ = nullptr;
301 }
302 }
303
CreateDec()304 int32_t ADecDemoAuto::CreateDec()
305 {
306 if (audioType_ == TYPE_AAC) {
307 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_AAC_NAME).data());
308 } else if (audioType_ == TYPE_FLAC) {
309 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_FLAC_NAME).data());
310 } else if (audioType_ == TYPE_MP3) {
311 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_MP3_NAME).data());
312 } else if (audioType_ == TYPE_VORBIS) {
313 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME).data());
314 } else if (audioType_ == TYPE_AMRNB) {
315 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_AMRNB_NAME).data());
316 } else if (audioType_ == TYPE_AMRWB) {
317 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_AMRWB_NAME).data());
318 } else if (audioType_ == TYPE_OPUS) {
319 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_OPUS_NAME).data());
320 } else if (audioType_ == TYPE_G711MU) {
321 audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_G711MU_NAME).data());
322 } else {
323 return AVCS_ERR_INVALID_VAL;
324 }
325 DEMO_CHECK_AND_RETURN_RET_LOG(audioDec_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: CreateByName fail");
326
327 cb_ = { &OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable };
328 int32_t ret = OH_AudioDecoder_SetCallback(audioDec_, cb_, signal_);
329 DEMO_CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCS_ERR_UNKNOWN, "Fatal: SetCallback fail");
330
331 return AVCS_ERR_OK;
332 }
333
CreateDecByMime()334 int32_t ADecDemoAuto::CreateDecByMime()
335 {
336 if (audioType_ == TYPE_AAC) {
337 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC).data());
338 } else if (audioType_ == TYPE_FLAC) {
339 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC).data());
340 } else if (audioType_ == TYPE_MP3) {
341 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG).data());
342 } else if (audioType_ == TYPE_VORBIS) {
343 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS).data());
344 } else if (audioType_ == TYPE_AMRNB) {
345 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB).data());
346 } else if (audioType_ == TYPE_AMRWB) {
347 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB).data());
348 } else if (audioType_ == TYPE_OPUS) {
349 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS).data());
350 } else if (audioType_ == TYPE_G711MU) {
351 audioDec_ = OH_AudioDecoder_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU).data());
352 } else {
353 return AVCS_ERR_INVALID_VAL;
354 }
355 DEMO_CHECK_AND_RETURN_RET_LOG(audioDec_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: CreateByName fail");
356 return AVCS_ERR_OK;
357 }
358
Configure(OH_AVFormat * format)359 int32_t ADecDemoAuto::Configure(OH_AVFormat* format)
360 {
361 return OH_AudioDecoder_Configure(audioDec_, format);
362 }
363
Start()364 int32_t ADecDemoAuto::Start()
365 {
366 isRunning_.store(true);
367
368 inputLoop_ = make_unique<thread>(&ADecDemoAuto::InputFunc, this);
369 DEMO_CHECK_AND_RETURN_RET_LOG(inputLoop_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
370
371 outputLoop_ = make_unique<thread>(&ADecDemoAuto::OutputFunc, this);
372 DEMO_CHECK_AND_RETURN_RET_LOG(outputLoop_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
373
374 return OH_AudioDecoder_Start(audioDec_);
375 }
376
Stop()377 int32_t ADecDemoAuto::Stop()
378 {
379 isRunning_.store(false);
380 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
381 {
382 unique_lock<mutex> lock(signal_->inMutex_);
383 signal_->inCond_.notify_all();
384 }
385 inputLoop_->join();
386 inputLoop_ = nullptr;
387 while (!signal_->inQueue_.empty()) {
388 signal_->inQueue_.pop();
389 }
390 while (!signal_->inBufferQueue_.empty()) {
391 signal_->inBufferQueue_.pop();
392 }
393 }
394
395 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
396 {
397 unique_lock<mutex> lock(signal_->outMutex_);
398 signal_->outCond_.notify_all();
399 }
400 outputLoop_->join();
401 outputLoop_ = nullptr;
402 while (!signal_->outQueue_.empty()) {
403 signal_->outQueue_.pop();
404 }
405 while (!signal_->attrQueue_.empty()) {
406 signal_->attrQueue_.pop();
407 }
408 while (!signal_->outBufferQueue_.empty()) {
409 signal_->outBufferQueue_.pop();
410 }
411 }
412 return OH_AudioDecoder_Stop(audioDec_);
413 }
414
Flush()415 int32_t ADecDemoAuto::Flush()
416 {
417 isRunning_.store(false);
418 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
419 {
420 unique_lock<mutex> lock(signal_->inMutex_);
421 signal_->inCond_.notify_all();
422 }
423 inputLoop_->join();
424 inputLoop_ = nullptr;
425 while (!signal_->inQueue_.empty()) {
426 signal_->inQueue_.pop();
427 }
428 while (!signal_->inBufferQueue_.empty()) {
429 signal_->inBufferQueue_.pop();
430 }
431 std::cout << "clear input buffer!\n";
432 }
433
434 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
435 {
436 unique_lock<mutex> lock(signal_->outMutex_);
437 signal_->outCond_.notify_all();
438 }
439 outputLoop_->join();
440 outputLoop_ = nullptr;
441 while (!signal_->outQueue_.empty()) {
442 signal_->outQueue_.pop();
443 }
444 while (!signal_->attrQueue_.empty()) {
445 signal_->attrQueue_.pop();
446 }
447 while (!signal_->outBufferQueue_.empty()) {
448 signal_->outBufferQueue_.pop();
449 }
450 std::cout << "clear output buffer!\n";
451 }
452 return OH_AudioDecoder_Flush(audioDec_);
453 }
454
Reset()455 int32_t ADecDemoAuto::Reset()
456 {
457 return OH_AudioDecoder_Reset(audioDec_);
458 }
459
Release()460 int32_t ADecDemoAuto::Release()
461 {
462 return OH_AudioDecoder_Destroy(audioDec_);
463 }
464
HandleInputEOS(const uint32_t index)465 void ADecDemoAuto::HandleInputEOS(const uint32_t index)
466 {
467 OH_AVCodecBufferAttr info;
468 info.size = 0;
469 info.offset = 0;
470 info.pts = 0;
471 info.flags = AVCODEC_BUFFER_FLAGS_EOS;
472 OH_AudioDecoder_PushInputData(audioDec_, index, info);
473 signal_->inBufferQueue_.pop();
474 signal_->inQueue_.pop();
475 }
476
HandleNormalInput(const uint32_t & index,const int64_t pts,const size_t size)477 int32_t ADecDemoAuto::HandleNormalInput(const uint32_t& index, const int64_t pts, const size_t size)
478 {
479 OH_AVCodecBufferAttr info;
480 info.size = size;
481 info.offset = 0;
482 info.pts = pts;
483
484 int32_t ret = AVCS_ERR_OK;
485 if (isFirstFrame_) {
486 info.flags = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
487 ret = OH_AudioDecoder_PushInputData(audioDec_, index, info);
488 isFirstFrame_ = false;
489 } else {
490 info.flags = AVCODEC_BUFFER_FLAGS_NONE;
491 ret = OH_AudioDecoder_PushInputData(audioDec_, index, info);
492 }
493 signal_->inQueue_.pop();
494 signal_->inBufferQueue_.pop();
495 frameCount_++;
496 return ret;
497 }
498
InputFunc()499 void ADecDemoAuto::InputFunc()
500 {
501 size_t frameBytes = 1152;
502 if (audioType_ == TYPE_OPUS) {
503 size_t opussize = 320;
504 frameBytes = opussize;
505 } else if (audioType_ == TYPE_G711MU) {
506 size_t gmusize = 320;
507 frameBytes = gmusize;
508 } else if (audioType_ == TYPE_AAC) {
509 size_t aacsize = 1024;
510 frameBytes = aacsize;
511 }
512 size_t currentSize = inputdatasize < frameBytes ? inputdatasize : frameBytes;
513 int64_t pts = 0;
514 while (isRunning_.load()) {
515 unique_lock<mutex> lock(signal_->inMutex_);
516 signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
517
518 if (!isRunning_.load()) {
519 break;
520 }
521
522 uint32_t index = signal_->inQueue_.front();
523 auto buffer = signal_->inBufferQueue_.front();
524 DEMO_CHECK_AND_BREAK_LOG(buffer != nullptr, "Fatal: GetInputBuffer fail");
525
526 if (isFirstFrame_ == false || currentSize <= 0) {
527 HandleInputEOS(index);
528 std::cout << "end buffer\n";
529 isRunning_.store(false);
530 break;
531 }
532
533 strncpy_s((char *)OH_AVMemory_GetAddr(buffer), currentSize, inputdata.c_str(), currentSize);
534 int32_t ret = HandleNormalInput(index, pts, currentSize);
535 if (ret != AVCS_ERR_OK) {
536 cout << "Fatal, exit" << endl;
537 isRunning_.store(false);
538 break;
539 }
540 }
541 signal_->startCond_.notify_all();
542 }
543
OutputFunc()544 void ADecDemoAuto::OutputFunc()
545 {
546 while (isRunning_.load()) {
547 unique_lock<mutex> lock(signal_->outMutex_);
548 signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
549 if (!isRunning_.load()) {
550 cout << "wait to stop, exit" << endl;
551 break;
552 }
553 uint32_t index = signal_->outQueue_.front();
554 OH_AVCodecBufferAttr attr = signal_->attrQueue_.front();
555 if (attr.flags == AVCODEC_BUFFER_FLAGS_EOS) {
556 cout << "decode eos" << endl;
557 isRunning_.store(false);
558 signal_->startCond_.notify_all();
559 }
560 signal_->outBufferQueue_.pop();
561 signal_->attrQueue_.pop();
562 signal_->outQueue_.pop();
563 if (OH_AudioDecoder_FreeOutputData(audioDec_, index) != AV_ERR_OK) {
564 cout << "Fatal: FreeOutputData fail" << endl;
565 break;
566 }
567 }
568 signal_->startCond_.notify_all();
569 }
570
RunCase(const uint8_t * data,size_t size)571 bool ADecDemoAuto::RunCase(const uint8_t *data, size_t size)
572 {
573 std::string codecdata(reinterpret_cast<const char*>(data), size);
574 inputdata = codecdata;
575 inputdatasize = size;
576 DEMO_CHECK_AND_RETURN_RET_LOG(CreateDec() == AVCS_ERR_OK, false, "Fatal: CreateDec fail");
577
578 OH_AVFormat* format = OH_AVFormat_Create();
579 auto res = InitFormat(format);
580 if (res == false) {
581 return false;
582 }
583 DEMO_CHECK_AND_RETURN_RET_LOG(Start() == AVCS_ERR_OK, false, "Fatal: Start fail");
584 auto start = chrono::steady_clock::now();
585
586 unique_lock<mutex> lock(signal_->startMutex_);
587 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
588
589 auto end = chrono::steady_clock::now();
590 std::cout << "Encode finished, time = " << std::chrono::duration_cast<chrono::milliseconds>(end - start).count()
591 << " ms" << std::endl;
592 DEMO_CHECK_AND_RETURN_RET_LOG(Stop() == AVCS_ERR_OK, false, "Fatal: Stop fail");
593 DEMO_CHECK_AND_RETURN_RET_LOG(Release() == AVCS_ERR_OK, false, "Fatal: Release fail");
594 if (format != nullptr) {
595 OH_AVFormat_Destroy(format);
596 format = nullptr;
597 }
598 sleep(1);
599 return true;
600 }