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 "audio_decoder_vivid_demo.h"
17 #include <iostream>
18 #include <fstream>
19 #include <unistd.h>
20 #include <sys/stat.h>
21 #include <chrono>
22 #include <fcntl.h>
23 #include "avcodec_codec_name.h"
24 #include "avcodec_common.h"
25 #include "avcodec_errors.h"
26 #include "demo_log.h"
27 #include "media_description.h"
28 #include "native_avcodec_base.h"
29 #include "native_avformat.h"
30 #include "native_avbuffer.h"
31 #include "native_avmemory.h"
32 #include "securec.h"
33
34 using namespace OHOS;
35 using namespace OHOS::MediaAVCodec;
36 using namespace OHOS::MediaAVCodec::AudioBufferDemo;
37
38 using namespace std;
39 namespace {
40 constexpr uint32_t CHANNEL_COUNT = 2;
41 constexpr uint32_t SAMPLE_RATE = 44100;
42 constexpr uint32_t DEFAULT_AAC_TYPE = 1;
43 constexpr uint32_t AMRWB_SAMPLE_RATE = 16000;
44 constexpr uint32_t AMRNB_SAMPLE_RATE = 8000;
45 constexpr string_view INPUT_VORBIS_FILE_PATH = "/data/test/media/vorbis_2c_44100hz_320k.dat";
46 } // namespace
47
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)48 static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
49 {
50 (void)codec;
51 (void)errorCode;
52 (void)userData;
53 }
54
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)55 static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
56 {
57 (void)codec;
58 (void)format;
59 (void)userData;
60 cout << "OnOutputFormatChanged received" << endl;
61 }
62
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * data,void * userData)63 static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
64 {
65 (void)codec;
66 ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
67 unique_lock<mutex> lock(signal->inMutex_);
68 signal->inQueue_.push(index);
69 signal->inBufferQueue_.push(data);
70 signal->inCond_.notify_all();
71 }
72
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * data,void * userData)73 static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
74 {
75 (void)codec;
76 ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
77 unique_lock<mutex> lock(signal->outMutex_);
78 signal->outQueue_.push(index);
79 signal->outBufferQueue_.push(data);
80 signal->outCond_.notify_all();
81 }
82
SplitStringFully(const string & str,const string & separator)83 vector<string> SplitStringFully(const string& str, const string& separator)
84 {
85 vector<string> dest;
86 string substring;
87 string::size_type start = 0;
88 string::size_type index = str.find_first_of(separator, start);
89
90 while (index != string::npos) {
91 substring = str.substr(start, index - start);
92 dest.push_back(substring);
93 start = str.find_first_not_of(separator, index);
94 if (start == string::npos) {
95 return dest;
96 }
97 index = str.find_first_of(separator, start);
98 }
99 substring = str.substr(start);
100 dest.push_back(substring);
101
102 return dest;
103 }
104
StringReplace(std::string & strBig,const std::string & strsrc,const std::string & strdst)105 void StringReplace(std::string& strBig, const std::string& strsrc, const std::string& strdst)
106 {
107 std::string::size_type pos = 0;
108 std::string::size_type srclen = strsrc.size();
109 std::string::size_type dstlen = strdst.size();
110
111 while ((pos = strBig.find(strsrc, pos)) != std::string::npos) {
112 strBig.replace(pos, srclen, strdst);
113 pos += dstlen;
114 }
115 }
116
RunCase(const uint8_t * data,size_t size)117 bool ADecBufferDemo::RunCase(const uint8_t *data, size_t size)
118 {
119 std::string codecdata(reinterpret_cast<const char *>(data), size);
120 inputdata = codecdata;
121 inputdatasize = size;
122 DEMO_CHECK_AND_RETURN_RET_LOG(CreateDec() == AVCS_ERR_OK, false, "Fatal: CreateDec fail");
123
124 OH_AVFormat *format = OH_AVFormat_Create();
125 auto res = InitFormat(format);
126 if (res == false) {
127 return false;
128 }
129 DEMO_CHECK_AND_RETURN_RET_LOG(Start() == AVCS_ERR_OK, false, "Fatal: Start fail");
130 auto start = chrono::steady_clock::now();
131 unique_lock<mutex> lock(signal_->startMutex_);
132 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
133 auto end = chrono::steady_clock::now();
134 std::cout << "decode finished, time = " << std::chrono::duration_cast<chrono::milliseconds>(end - start).count()
135 << " ms" << std::endl;
136 DEMO_CHECK_AND_RETURN_RET_LOG(Stop() == AVCS_ERR_OK, false, "Fatal: Stop fail");
137 DEMO_CHECK_AND_RETURN_RET_LOG(Release() == AVCS_ERR_OK, false, "Fatal: Release fail");
138 OH_AVFormat_Destroy(format);
139 sleep(1);
140 return true;
141 }
142
ConfigVorbisExtraData(OH_AVFormat * format)143 bool ADecBufferDemo::ConfigVorbisExtraData(OH_AVFormat *format)
144 {
145 std::ifstream inputFile(INPUT_VORBIS_FILE_PATH, std::ios::binary);
146 int64_t extradataSize;
147 DEMO_CHECK_AND_RETURN_RET_LOG(inputFile.is_open(), false, "Fatal: file is not open");
148 inputFile.read(reinterpret_cast<char *>(&extradataSize), sizeof(int64_t));
149 DEMO_CHECK_AND_RETURN_RET_LOG(inputFile.gcount() == sizeof(int64_t), false,
150 "Fatal: read extradataSize bytes error");
151 if (extradataSize < 0) {
152 return false;
153 }
154 char buffer[extradataSize];
155 inputFile.read(buffer, extradataSize);
156 DEMO_CHECK_AND_RETURN_RET_LOG(inputFile.gcount() == extradataSize, false, "Fatal: read extradata bytes error");
157 OH_AVFormat_SetBuffer(format, MediaDescriptionKey::MD_KEY_CODEC_CONFIG.data(), reinterpret_cast<uint8_t *>(buffer),
158 extradataSize);
159 inputFile.close();
160 return true;
161 }
162
InitFormat(OH_AVFormat * format)163 bool ADecBufferDemo::InitFormat(OH_AVFormat *format)
164 {
165 int32_t channelCount = CHANNEL_COUNT;
166 int32_t sampleRate = SAMPLE_RATE;
167 if (audioType_ != AudioBufferFormatType::TYPE_OPUS) {
168 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
169 OH_BitsPerSample::SAMPLE_S16LE);
170 }
171 if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
172 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AAC_IS_ADTS.data(), DEFAULT_AAC_TYPE);
173 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRNB || audioType_ == AudioBufferFormatType::TYPE_G711MU) {
174 channelCount = 1;
175 sampleRate = AMRNB_SAMPLE_RATE;
176 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRWB || audioType_ == AudioBufferFormatType::TYPE_LBVC) {
177 channelCount = 1;
178 sampleRate = AMRWB_SAMPLE_RATE;
179 } else if (audioType_ == AudioBufferFormatType::TYPE_OPUS) {
180 int32_t channelCounttmp = 1;
181 int32_t sampleRatetmp = 8000;
182 channelCount = channelCounttmp;
183 sampleRate = sampleRatetmp;
184 } else if (audioType_ == AudioBufferFormatType::TYPE_MP3) {
185 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
186 OH_BitsPerSample::SAMPLE_S16LE);
187 }
188 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), channelCount);
189 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), sampleRate);
190 if (audioType_ == AudioBufferFormatType::TYPE_VORBIS) {
191 if (ConfigVorbisExtraData(format)) {
192 DEMO_CHECK_AND_RETURN_RET_LOG(Configure(format) == AVCS_ERR_OK, false, "Fatal: Configure fail");
193 }
194 } else if (audioType_ == AudioBufferFormatType::TYPE_VIVID) {
195 DEMO_CHECK_AND_RETURN_RET_LOG(Configure(format) == AVCS_ERR_OK, false,
196 "Fatal: TYPE_VIVID Configure fail");
197 } else if (audioType_ == AudioBufferFormatType::TYPE_APE) {
198 DEMO_CHECK_AND_RETURN_RET_LOG(Configure(format) == AVCS_ERR_OK, false,
199 "Fatal: TYPE_APE Configure fail");
200 } else {
201 DEMO_CHECK_AND_RETURN_RET_LOG(Configure(format) == AVCS_ERR_OK, false,
202 "Fatal: Configure fail");
203 }
204 return true;
205 }
206
InitFile(const std::string & inputFile)207 bool ADecBufferDemo::InitFile(const std::string& inputFile)
208 {
209 if (inputFile.find("mp4") != std::string::npos || inputFile.find("m4a") != std::string::npos ||
210 inputFile.find("vivid") != std::string::npos || inputFile.find("ts") != std::string::npos) {
211 audioType_ = AudioBufferFormatType::TYPE_VIVID;
212 } else if (inputFile.find("aac") != std::string::npos) {
213 audioType_ = AudioBufferFormatType::TYPE_AAC;
214 } else if (inputFile.find("flac") != std::string::npos) {
215 audioType_ = AudioBufferFormatType::TYPE_FLAC;
216 } else if (inputFile.find("mp3") != std::string::npos) {
217 audioType_ = AudioBufferFormatType::TYPE_MP3;
218 } else if (inputFile.find("vorbis") != std::string::npos) {
219 audioType_ = AudioBufferFormatType::TYPE_VORBIS;
220 } else if (inputFile.find("amrnb") != std::string::npos) {
221 audioType_ = AudioBufferFormatType::TYPE_AMRNB;
222 } else if (inputFile.find("amrwb") != std::string::npos) {
223 audioType_ = AudioBufferFormatType::TYPE_AMRWB;
224 } else if (inputFile.find("opus") != std::string::npos) {
225 audioType_ = AudioBufferFormatType::TYPE_OPUS;
226 } else if (inputFile.find("g711mu") != std::string::npos) {
227 audioType_ = AudioBufferFormatType::TYPE_G711MU;
228 } else if (inputFile.find("ape") != std::string::npos) {
229 audioType_ = AudioBufferFormatType::TYPE_APE;
230 } else if (inputFile.find("lbvc") != std::string::npos) {
231 audioType_ = AudioBufferFormatType::TYPE_LBVC;
232 } else {
233 audioType_ = AudioBufferFormatType::TYPE_AAC;
234 }
235 return true;
236 }
237
ADecBufferDemo()238 ADecBufferDemo::ADecBufferDemo() : audioDec_(nullptr), signal_(nullptr), audioType_(AudioBufferFormatType::TYPE_AAC)
239 {
240 signal_ = new ADecBufferSignal();
241 DEMO_CHECK_AND_RETURN_LOG(signal_ != nullptr, "Fatal: No memory");
242 }
243
~ADecBufferDemo()244 ADecBufferDemo::~ADecBufferDemo()
245 {
246 if (signal_) {
247 delete signal_;
248 signal_ = nullptr;
249 }
250 }
251
CreateDec()252 int32_t ADecBufferDemo::CreateDec()
253 {
254 if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
255 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_AAC_NAME).data());
256 std::cout << "CreateDec TYPE_AAC!" << endl;
257 } else if (audioType_ == AudioBufferFormatType::TYPE_FLAC) {
258 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_FLAC_NAME).data());
259 std::cout << "CreateDec TYPE_FLAC!" << endl;
260 } else if (audioType_ == AudioBufferFormatType::TYPE_MP3) {
261 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_MP3_NAME).data());
262 std::cout << "CreateDec TYPE_MP3!" << endl;
263 } else if (audioType_ == AudioBufferFormatType::TYPE_VORBIS) {
264 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME).data());
265 std::cout << "CreateDec TYPE_VORBIS!" << endl;
266 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRNB) {
267 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_AMRNB_NAME).data());
268 std::cout << "CreateDec TYPE_AMRNB!" << endl;
269 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRWB) {
270 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_AMRWB_NAME).data());
271 std::cout << "CreateDec TYPE_AMRWB!" << endl;
272 } else if (audioType_ == AudioBufferFormatType::TYPE_VIVID) {
273 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VIVID_NAME).data());
274 std::cout << "CreateDec TYPE_VIVID!" << endl;
275 } else if (audioType_ == AudioBufferFormatType::TYPE_OPUS) {
276 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_OPUS_NAME).data());
277 std::cout << "CreateDec TYPE_OPUS!" << endl;
278 } else if (audioType_ == AudioBufferFormatType::TYPE_G711MU) {
279 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_G711MU_NAME).data());
280 std::cout << "CreateDec TYPE_G711MU!" << endl;
281 } else if (audioType_ == AudioBufferFormatType::TYPE_APE) {
282 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_APE_NAME).data());
283 std::cout << "CreateDec TYPE_APE!" << endl;
284 } else if (audioType_ == AudioBufferFormatType::TYPE_LBVC) {
285 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_LBVC_NAME).data());
286 std::cout << "CreateDec TYPE_LBVC!" << endl;
287 } else {
288 return AVCS_ERR_INVALID_VAL;
289 }
290 DEMO_CHECK_AND_RETURN_RET_LOG(audioDec_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: CreateByName fail");
291 if (audioDec_ == nullptr) {
292 return AVCS_ERR_UNKNOWN;
293 }
294 if (signal_ == nullptr) {
295 signal_ = new ADecBufferSignal();
296 DEMO_CHECK_AND_RETURN_RET_LOG(signal_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
297 }
298 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
299 int32_t ret = OH_AudioCodec_RegisterCallback(audioDec_, cb_, signal_);
300 DEMO_CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCS_ERR_UNKNOWN, "Fatal: SetCallback fail");
301 return AVCS_ERR_OK;
302 }
303
Configure(OH_AVFormat * format)304 int32_t ADecBufferDemo::Configure(OH_AVFormat *format)
305 {
306 return OH_AudioCodec_Configure(audioDec_, format);
307 }
308
Start()309 int32_t ADecBufferDemo::Start()
310 {
311 isRunning_.store(true);
312
313 inputLoop_ = make_unique<thread>(&ADecBufferDemo::InputFunc, this);
314 DEMO_CHECK_AND_RETURN_RET_LOG(inputLoop_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
315
316 outputLoop_ = make_unique<thread>(&ADecBufferDemo::OutputFunc, this);
317 DEMO_CHECK_AND_RETURN_RET_LOG(outputLoop_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
318
319 return OH_AudioCodec_Start(audioDec_);
320 }
321
Stop()322 int32_t ADecBufferDemo::Stop()
323 {
324 isRunning_.store(false);
325 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
326 {
327 unique_lock<mutex> lock(signal_->inMutex_);
328 signal_->inCond_.notify_all();
329 }
330 inputLoop_->join();
331 inputLoop_ = nullptr;
332 while (!signal_->inQueue_.empty()) {
333 signal_->inQueue_.pop();
334 }
335 while (!signal_->inBufferQueue_.empty()) {
336 signal_->inBufferQueue_.pop();
337 }
338 }
339
340 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
341 {
342 unique_lock<mutex> lock(signal_->outMutex_);
343 signal_->outCond_.notify_all();
344 }
345 outputLoop_->join();
346 outputLoop_ = nullptr;
347 while (!signal_->outQueue_.empty()) {
348 signal_->outQueue_.pop();
349 }
350 while (!signal_->outBufferQueue_.empty()) {
351 signal_->outBufferQueue_.pop();
352 }
353 }
354 std::cout << "start stop!\n";
355 return OH_AudioCodec_Stop(audioDec_);
356 }
357
Flush()358 int32_t ADecBufferDemo::Flush()
359 {
360 isRunning_.store(false);
361 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
362 {
363 unique_lock<mutex> lock(signal_->inMutex_);
364 signal_->inCond_.notify_all();
365 }
366 inputLoop_->join();
367 inputLoop_ = nullptr;
368 while (!signal_->inQueue_.empty()) {
369 signal_->inQueue_.pop();
370 }
371 while (!signal_->inBufferQueue_.empty()) {
372 signal_->inBufferQueue_.pop();
373 }
374 std::cout << "clear input buffer!\n";
375 }
376
377 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
378 {
379 unique_lock<mutex> lock(signal_->outMutex_);
380 signal_->outCond_.notify_all();
381 }
382 outputLoop_->join();
383 outputLoop_ = nullptr;
384 while (!signal_->outQueue_.empty()) {
385 signal_->outQueue_.pop();
386 }
387 while (!signal_->outBufferQueue_.empty()) {
388 signal_->outBufferQueue_.pop();
389 }
390 std::cout << "clear output buffer!\n";
391 }
392 return OH_AudioCodec_Flush(audioDec_);
393 }
394
Reset()395 int32_t ADecBufferDemo::Reset()
396 {
397 return OH_AudioCodec_Reset(audioDec_);
398 }
399
Release()400 int32_t ADecBufferDemo::Release()
401 {
402 return OH_AudioCodec_Destroy(audioDec_);
403 }
404
HandleInputEOS(const uint32_t index)405 void ADecBufferDemo::HandleInputEOS(const uint32_t index)
406 {
407 OH_AudioCodec_PushInputBuffer(audioDec_, index);
408 signal_->inBufferQueue_.pop();
409 signal_->inQueue_.pop();
410 }
411
InputFunc()412 void ADecBufferDemo::InputFunc()
413 {
414 size_t frameBytes = 1152;
415 while (isRunning_.load()) {
416 unique_lock<mutex> lock(signal_->inMutex_);
417 signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
418 if (!isRunning_.load()) {
419 break;
420 }
421 uint32_t index = signal_->inQueue_.front();
422 auto buffer = signal_->inBufferQueue_.front();
423 DEMO_CHECK_AND_BREAK_LOG(buffer != nullptr, "Fatal: GetInputBuffer fail");
424 size_t currentSize = inputdatasize < frameBytes ? inputdatasize : frameBytes;
425 if (currentSize == 0) {
426 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
427 OH_AudioCodec_PushInputBuffer(audioDec_, index);
428 break;
429 }
430 std::string currentStr = inputdata.substr(inputOffset, currentSize);
431 int ret;
432 strncpy_s(reinterpret_cast<char*>(OH_AVBuffer_GetAddr(buffer)), currentSize, currentStr.c_str(), currentSize);
433 buffer->buffer_->memory_->SetSize(currentSize);
434 if (isFirstFrame_) {
435 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
436 ret = OH_AudioCodec_PushInputBuffer(audioDec_, index);
437 isFirstFrame_ = false;
438 } else {
439 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
440 ret = OH_AudioCodec_PushInputBuffer(audioDec_, index);
441 }
442 signal_->inQueue_.pop();
443 signal_->inBufferQueue_.pop();
444 inputdatasize -= currentSize;
445 inputOffset += currentSize;
446 frameCount_++;
447 if (ret != AVCS_ERR_OK) {
448 isRunning_.store(false);
449 break;
450 }
451 }
452 signal_->startCond_.notify_all();
453 }
454
OutputFunc()455 void ADecBufferDemo::OutputFunc()
456 {
457 while (isRunning_.load()) {
458 unique_lock<mutex> lock(signal_->outMutex_);
459 signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
460 if (!isRunning_.load()) {
461 cout << "wait to stop, exit" << endl;
462 break;
463 }
464
465 uint32_t index = signal_->outQueue_.front();
466 OH_AVBuffer *data = signal_->outBufferQueue_.front();
467 cout << "OutputFunc index:" << index << endl;
468 if (data == nullptr) {
469 cout << "OutputFunc OH_AVBuffer is nullptr" << endl;
470 continue;
471 }
472 if (data != nullptr &&
473 (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS || data->buffer_->memory_->GetSize() == 0)) {
474 cout << "decode eos" << endl;
475 isRunning_.store(false);
476 signal_->startCond_.notify_all();
477 }
478 signal_->outBufferQueue_.pop();
479 signal_->outQueue_.pop();
480 if (OH_AudioCodec_FreeOutputBuffer(audioDec_, index) != AV_ERR_OK) {
481 cout << "Fatal: FreeOutputData fail" << endl;
482 break;
483 }
484 if (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) {
485 cout << "decode eos" << endl;
486 isRunning_.store(false);
487 signal_->startCond_.notify_all();
488 }
489 }
490 signal_->startCond_.notify_all();
491 }
492
SetCallback(OH_AVCodec * codec)493 OH_AVErrCode ADecBufferDemo::SetCallback(OH_AVCodec* codec)
494 {
495 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
496 return OH_AudioCodec_RegisterCallback(codec, cb_, signal_);
497 }
498
CreateByMime(const char * mime)499 OH_AVCodec* ADecBufferDemo::CreateByMime(const char* mime)
500 {
501 if (mime != nullptr) {
502 if (strcmp(mime, "audio/mp4a-latm") == 0) {
503 audioType_ = AudioBufferFormatType::TYPE_AAC;
504 } else if (strcmp(mime, "audio/flac") == 0) {
505 audioType_ = AudioBufferFormatType::TYPE_FLAC;
506 } else if (strcmp(mime, "audio/x-ape") == 0) {
507 audioType_ = AudioBufferFormatType::TYPE_APE;
508 } else if (strcmp(mime, OH_AVCODEC_MIMETYPE_AUDIO_LBVC) == 0) {
509 audioType_ = AudioBufferFormatType::TYPE_LBVC;
510 } else {
511 audioType_ = AudioBufferFormatType::TYPE_VIVID;
512 }
513 }
514 return OH_AudioCodec_CreateByMime(mime, false);
515 }
516
CreateByName(const char * name)517 OH_AVCodec* ADecBufferDemo::CreateByName(const char* name)
518 {
519 return OH_AudioCodec_CreateByName(name);
520 }
521
Destroy(OH_AVCodec * codec)522 OH_AVErrCode ADecBufferDemo::Destroy(OH_AVCodec* codec)
523 {
524 OH_AVErrCode ret = OH_AudioCodec_Destroy(codec);
525 return ret;
526 }
527
IsValid(OH_AVCodec * codec,bool * isValid)528 OH_AVErrCode ADecBufferDemo::IsValid(OH_AVCodec* codec, bool* isValid)
529 {
530 return OH_AudioCodec_IsValid(codec, isValid);
531 }
532
Prepare(OH_AVCodec * codec)533 OH_AVErrCode ADecBufferDemo::Prepare(OH_AVCodec* codec)
534 {
535 return OH_AudioCodec_Prepare(codec);
536 }
537
Start(OH_AVCodec * codec)538 OH_AVErrCode ADecBufferDemo::Start(OH_AVCodec* codec)
539 {
540 return OH_AudioCodec_Start(codec);
541 }
542
Stop(OH_AVCodec * codec)543 OH_AVErrCode ADecBufferDemo::Stop(OH_AVCodec* codec)
544 {
545 OH_AVErrCode ret = OH_AudioCodec_Stop(codec);
546 return ret;
547 }
548
Flush(OH_AVCodec * codec)549 OH_AVErrCode ADecBufferDemo::Flush(OH_AVCodec* codec)
550 {
551 OH_AVErrCode ret = OH_AudioCodec_Flush(codec);
552 return ret;
553 }
554
Reset(OH_AVCodec * codec)555 OH_AVErrCode ADecBufferDemo::Reset(OH_AVCodec* codec)
556 {
557 return OH_AudioCodec_Reset(codec);
558 }
559
GetOutputDescription(OH_AVCodec * codec)560 OH_AVFormat* ADecBufferDemo::GetOutputDescription(OH_AVCodec* codec)
561 {
562 return OH_AudioCodec_GetOutputDescription(codec);
563 }
564
FreeOutputData(OH_AVCodec * codec,uint32_t index)565 OH_AVErrCode ADecBufferDemo::FreeOutputData(OH_AVCodec* codec, uint32_t index)
566 {
567 return OH_AudioCodec_FreeOutputBuffer(codec, index);
568 }
569
PushInputData(OH_AVCodec * codec,uint32_t index)570 OH_AVErrCode ADecBufferDemo::PushInputData(OH_AVCodec* codec, uint32_t index)
571 {
572 OH_AVCodecBufferAttr info;
573 if (!eosFlag) {
574 if (!signal_->inBufferQueue_.empty()) {
575 int32_t size = 100;
576 unique_lock<mutex> lock(signal_->inMutex_);
577 auto buffer = signal_->inBufferQueue_.front();
578 info.size = size;
579 info.pts = 0;
580 info.flags = AVCODEC_BUFFER_FLAGS_NONE;
581 OH_AVErrCode ret = OH_AVBuffer_SetBufferAttr(buffer, &info);
582 std::cout <<"info.size:" << info.size <<" ADecBufferDemo::PushInputData : = "<< (int32_t)ret<<std::endl;
583 if (ret != AV_ERR_OK) {
584 return ret;
585 }
586 }
587 }
588 return OH_AudioCodec_PushInputBuffer(codec, index);
589 }
590
GetInputIndex()591 uint32_t ADecBufferDemo::GetInputIndex()
592 {
593 int32_t sleepTime = 0;
594 int32_t condTime = 5;
595 uint32_t index;
596 while (signal_->inQueue_.empty() && sleepTime < condTime) {
597 sleep(1);
598 sleepTime++;
599 }
600 if (sleepTime >= condTime) {
601 return 0;
602 } else {
603 index = signal_->inQueue_.front();
604 signal_->inQueue_.pop();
605 }
606 return index;
607 }
608
GetOutputIndex()609 uint32_t ADecBufferDemo::GetOutputIndex()
610 {
611 int32_t sleepTime = 0;
612 int32_t condTime = 5;
613 uint32_t index;
614 while (signal_->outQueue_.empty() && sleepTime < condTime) {
615 sleep(1);
616 sleepTime++;
617 }
618 if (sleepTime >= condTime) {
619 return 0;
620 } else {
621 index = signal_->outQueue_.front();
622 signal_->outQueue_.pop();
623 }
624 return index;
625 }
626
PushInputDataEOS(OH_AVCodec * codec,uint32_t index)627 OH_AVErrCode ADecBufferDemo::PushInputDataEOS(OH_AVCodec* codec, uint32_t index)
628 {
629 OH_AVCodecBufferAttr info;
630 info.size = 0;
631 info.offset = 0;
632 info.pts = 0;
633 info.flags = AVCODEC_BUFFER_FLAGS_EOS;
634 eosFlag = true;
635 if (!signal_->inBufferQueue_.empty()) {
636 auto buffer = signal_->inBufferQueue_.front();
637 OH_AVBuffer_SetBufferAttr(buffer, &info);
638 }
639 return OH_AudioCodec_PushInputBuffer(codec, index);
640 }
641
Configure(OH_AVCodec * codec,OH_AVFormat * format,int32_t channel,int32_t sampleRate)642 OH_AVErrCode ADecBufferDemo::Configure(OH_AVCodec* codec, OH_AVFormat* format, int32_t channel, int32_t sampleRate)
643 {
644 if (format == nullptr) {
645 std::cout<<" Configure format nullptr"<< std::endl;
646 return OH_AudioCodec_Configure(codec, format);
647 }
648 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, channel);
649 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, sampleRate);
650 if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
651 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
652 } else if (audioType_ == AudioBufferFormatType::TYPE_FLAC) {
653 }
654 std::cout<<" Configure format :"<< format << std::endl;
655 if (format == nullptr) {
656 std::cout<<" Configure format end is nullptr"<< std::endl;
657 }
658 OH_AVErrCode ret = OH_AudioCodec_Configure(codec, format);
659 return ret;
660 }
661
SetParameter(OH_AVCodec * codec,OH_AVFormat * format,int32_t channel,int32_t sampleRate)662 OH_AVErrCode ADecBufferDemo::SetParameter(OH_AVCodec* codec, OH_AVFormat* format, int32_t channel, int32_t sampleRate)
663 {
664 if (format == nullptr) {
665 std::cout<<" SetParameter format nullptr"<< std::endl;
666 return OH_AudioCodec_SetParameter(codec, format);
667 }
668 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, channel);
669 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, sampleRate);
670 if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
671 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
672 } else if (audioType_ == AudioBufferFormatType::TYPE_FLAC) {
673 }
674 std::cout<<" SetParameter format :"<< format << std::endl;
675 if (format == nullptr) {
676 std::cout<<" SetParameter format end is nullptr"<< std::endl;
677 }
678 OH_AVErrCode ret = OH_AudioCodec_SetParameter(codec, format);
679 return ret;
680 }