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