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_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     if (audioType_ == AudioBufferFormatType::TYPE_OPUS) {
416         size_t opussize = 960;
417         frameBytes = opussize;
418     } else if (audioType_ == AudioBufferFormatType::TYPE_G711MU) {
419         size_t gmusize = 320;
420         frameBytes = gmusize;
421     } else if (audioType_ == AudioBufferFormatType::TYPE_LBVC) {
422         size_t lbvcsize = 640;
423         frameBytes = lbvcsize;
424     } else if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
425         size_t aacsize = 1024;
426         frameBytes = aacsize;
427     }
428     size_t currentSize = inputdatasize < frameBytes ? inputdatasize : frameBytes;
429     while (isRunning_.load()) {
430         unique_lock<mutex> lock(signal_->inMutex_);
431         signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
432         if (!isRunning_.load()) {
433             break;
434         }
435         uint32_t index = signal_->inQueue_.front();
436         auto buffer = signal_->inBufferQueue_.front();
437         DEMO_CHECK_AND_BREAK_LOG(buffer != nullptr, "Fatal: GetInputBuffer fail");
438         int ret;
439         strncpy_s(reinterpret_cast<char*>(OH_AVBuffer_GetAddr(buffer)), currentSize, inputdata.c_str(), currentSize);
440         buffer->buffer_->memory_->SetSize(currentSize);
441         if (isFirstFrame_) {
442             buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
443             ret = OH_AudioCodec_PushInputBuffer(audioDec_, index);
444             isFirstFrame_ = false;
445         } else {
446             buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
447             ret = OH_AudioCodec_PushInputBuffer(audioDec_, index);
448             isRunning_.store(false);
449             break;
450         }
451         signal_->inQueue_.pop();
452         signal_->inBufferQueue_.pop();
453         frameCount_++;
454         if (ret != AVCS_ERR_OK) {
455             isRunning_.store(false);
456             break;
457         }
458     }
459     signal_->startCond_.notify_all();
460 }
461 
OutputFunc()462 void ADecBufferDemo::OutputFunc()
463 {
464     while (isRunning_.load()) {
465         unique_lock<mutex> lock(signal_->outMutex_);
466         signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
467         if (!isRunning_.load()) {
468             cout << "wait to stop, exit" << endl;
469             break;
470         }
471 
472         uint32_t index = signal_->outQueue_.front();
473         OH_AVBuffer *data = signal_->outBufferQueue_.front();
474         cout << "OutputFunc index:" << index << endl;
475         if (data == nullptr) {
476             cout << "OutputFunc OH_AVBuffer is nullptr" << endl;
477             continue;
478         }
479         if (data != nullptr &&
480             (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS || data->buffer_->memory_->GetSize() == 0)) {
481             cout << "decode eos" << endl;
482             isRunning_.store(false);
483             signal_->startCond_.notify_all();
484         }
485         signal_->outBufferQueue_.pop();
486         signal_->outQueue_.pop();
487         if (OH_AudioCodec_FreeOutputBuffer(audioDec_, index) != AV_ERR_OK) {
488             cout << "Fatal: FreeOutputData fail" << endl;
489             break;
490         }
491         if (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) {
492             cout << "decode eos" << endl;
493             isRunning_.store(false);
494             signal_->startCond_.notify_all();
495         }
496     }
497     signal_->startCond_.notify_all();
498 }
499 
SetCallback(OH_AVCodec * codec)500 OH_AVErrCode ADecBufferDemo::SetCallback(OH_AVCodec* codec)
501 {
502     cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
503     return OH_AudioCodec_RegisterCallback(codec, cb_, signal_);
504 }
505 
CreateByMime(const char * mime)506 OH_AVCodec* ADecBufferDemo::CreateByMime(const char* mime)
507 {
508     if (mime != nullptr) {
509         if (strcmp(mime, "audio/mp4a-latm") == 0) {
510             audioType_ = AudioBufferFormatType::TYPE_AAC;
511         } else if (strcmp(mime, "audio/flac") == 0) {
512             audioType_ = AudioBufferFormatType::TYPE_FLAC;
513         } else if (strcmp(mime, "audio/x-ape") == 0) {
514             audioType_ = AudioBufferFormatType::TYPE_APE;
515         } else if (strcmp(mime, OH_AVCODEC_MIMETYPE_AUDIO_LBVC) == 0) {
516             audioType_ = AudioBufferFormatType::TYPE_LBVC;
517         } else {
518             audioType_ = AudioBufferFormatType::TYPE_VIVID;
519         }
520     }
521     return OH_AudioCodec_CreateByMime(mime, false);
522 }
523 
CreateByName(const char * name)524 OH_AVCodec* ADecBufferDemo::CreateByName(const char* name)
525 {
526     return OH_AudioCodec_CreateByName(name);
527 }
528 
Destroy(OH_AVCodec * codec)529 OH_AVErrCode ADecBufferDemo::Destroy(OH_AVCodec* codec)
530 {
531     OH_AVErrCode ret = OH_AudioCodec_Destroy(codec);
532     return ret;
533 }
534 
IsValid(OH_AVCodec * codec,bool * isValid)535 OH_AVErrCode ADecBufferDemo::IsValid(OH_AVCodec* codec, bool* isValid)
536 {
537     return OH_AudioCodec_IsValid(codec, isValid);
538 }
539 
Prepare(OH_AVCodec * codec)540 OH_AVErrCode ADecBufferDemo::Prepare(OH_AVCodec* codec)
541 {
542     return OH_AudioCodec_Prepare(codec);
543 }
544 
Start(OH_AVCodec * codec)545 OH_AVErrCode ADecBufferDemo::Start(OH_AVCodec* codec)
546 {
547     return OH_AudioCodec_Start(codec);
548 }
549 
Stop(OH_AVCodec * codec)550 OH_AVErrCode ADecBufferDemo::Stop(OH_AVCodec* codec)
551 {
552     OH_AVErrCode ret = OH_AudioCodec_Stop(codec);
553     return ret;
554 }
555 
Flush(OH_AVCodec * codec)556 OH_AVErrCode ADecBufferDemo::Flush(OH_AVCodec* codec)
557 {
558     OH_AVErrCode ret = OH_AudioCodec_Flush(codec);
559     return ret;
560 }
561 
Reset(OH_AVCodec * codec)562 OH_AVErrCode ADecBufferDemo::Reset(OH_AVCodec* codec)
563 {
564     return OH_AudioCodec_Reset(codec);
565 }
566 
GetOutputDescription(OH_AVCodec * codec)567 OH_AVFormat* ADecBufferDemo::GetOutputDescription(OH_AVCodec* codec)
568 {
569     return OH_AudioCodec_GetOutputDescription(codec);
570 }
571 
FreeOutputData(OH_AVCodec * codec,uint32_t index)572 OH_AVErrCode ADecBufferDemo::FreeOutputData(OH_AVCodec* codec, uint32_t index)
573 {
574     return OH_AudioCodec_FreeOutputBuffer(codec, index);
575 }
576 
PushInputData(OH_AVCodec * codec,uint32_t index)577 OH_AVErrCode ADecBufferDemo::PushInputData(OH_AVCodec* codec, uint32_t index)
578 {
579     OH_AVCodecBufferAttr info;
580     if (!eosFlag) {
581         if (!signal_->inBufferQueue_.empty()) {
582             int32_t size = 100;
583             unique_lock<mutex> lock(signal_->inMutex_);
584             auto buffer = signal_->inBufferQueue_.front();
585             info.size = size;
586             info.pts = 0;
587             info.flags = AVCODEC_BUFFER_FLAGS_NONE;
588             OH_AVErrCode ret = OH_AVBuffer_SetBufferAttr(buffer, &info);
589             std::cout <<"info.size:" << info.size <<"   ADecBufferDemo::PushInputData : = "<< (int32_t)ret<<std::endl;
590             if (ret != AV_ERR_OK) {
591                 return ret;
592             }
593         }
594     }
595     return OH_AudioCodec_PushInputBuffer(codec, index);
596 }
597 
GetInputIndex()598 uint32_t ADecBufferDemo::GetInputIndex()
599 {
600     int32_t sleepTime = 0;
601     int32_t condTime = 5;
602     uint32_t index;
603     while (signal_->inQueue_.empty() && sleepTime < condTime) {
604         sleep(1);
605         sleepTime++;
606     }
607     if (sleepTime >= condTime) {
608         return 0;
609     } else {
610         index = signal_->inQueue_.front();
611         signal_->inQueue_.pop();
612     }
613     return index;
614 }
615 
GetOutputIndex()616 uint32_t ADecBufferDemo::GetOutputIndex()
617 {
618     int32_t sleepTime = 0;
619     int32_t condTime = 5;
620     uint32_t index;
621     while (signal_->outQueue_.empty() && sleepTime < condTime) {
622         sleep(1);
623         sleepTime++;
624     }
625     if (sleepTime >= condTime) {
626         return 0;
627     } else {
628         index = signal_->outQueue_.front();
629         signal_->outQueue_.pop();
630     }
631     return index;
632 }
633 
PushInputDataEOS(OH_AVCodec * codec,uint32_t index)634 OH_AVErrCode ADecBufferDemo::PushInputDataEOS(OH_AVCodec* codec, uint32_t index)
635 {
636     OH_AVCodecBufferAttr info;
637     info.size = 0;
638     info.offset = 0;
639     info.pts = 0;
640     info.flags = AVCODEC_BUFFER_FLAGS_EOS;
641     eosFlag = true;
642     if (!signal_->inBufferQueue_.empty()) {
643         auto buffer = signal_->inBufferQueue_.front();
644         OH_AVBuffer_SetBufferAttr(buffer, &info);
645     }
646     return OH_AudioCodec_PushInputBuffer(codec, index);
647 }
648 
Configure(OH_AVCodec * codec,OH_AVFormat * format,int32_t channel,int32_t sampleRate)649 OH_AVErrCode ADecBufferDemo::Configure(OH_AVCodec* codec, OH_AVFormat* format, int32_t channel, int32_t sampleRate)
650 {
651     if (format == nullptr) {
652         std::cout<<" Configure format nullptr"<< std::endl;
653         return OH_AudioCodec_Configure(codec, format);
654     }
655     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, channel);
656     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, sampleRate);
657     if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
658         OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
659     } else if (audioType_ == AudioBufferFormatType::TYPE_FLAC) {
660     }
661     std::cout<<" Configure format :"<< format << std::endl;
662     if (format == nullptr) {
663         std::cout<<" Configure format end is nullptr"<< std::endl;
664     }
665     OH_AVErrCode ret = OH_AudioCodec_Configure(codec, format);
666     return ret;
667 }
668 
SetParameter(OH_AVCodec * codec,OH_AVFormat * format,int32_t channel,int32_t sampleRate)669 OH_AVErrCode ADecBufferDemo::SetParameter(OH_AVCodec* codec, OH_AVFormat* format, int32_t channel, int32_t sampleRate)
670 {
671     if (format == nullptr) {
672         std::cout<<" SetParameter format nullptr"<< std::endl;
673         return OH_AudioCodec_SetParameter(codec, format);
674     }
675     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, channel);
676     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, sampleRate);
677     if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
678         OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
679     } else if (audioType_ == AudioBufferFormatType::TYPE_FLAC) {
680     }
681     std::cout<<" SetParameter format :"<< format << std::endl;
682     if (format == nullptr) {
683         std::cout<<" SetParameter format end is nullptr"<< std::endl;
684     }
685     OH_AVErrCode ret = OH_AudioCodec_SetParameter(codec, format);
686     return ret;
687 }