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