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