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 <iostream>
17 #include <unistd.h>
18 #include <chrono>
19 #include "securec.h"
20 #include "avcodec_common.h"
21 #include "avcodec_errors.h"
22 #include "media_description.h"
23 #include "native_avformat.h"
24 #include "demo_log.h"
25 #include "avcodec_codec_name.h"
26 #include "native_avmemory.h"
27 #include "native_avbuffer.h"
28 #include "ffmpeg_converter.h"
29 #include "audio_encoder_demo.h"
30
31 using namespace OHOS;
32 using namespace OHOS::MediaAVCodec;
33 using namespace OHOS::MediaAVCodec::AudioAacEncDemo;
34 using namespace std;
35 namespace {
36 constexpr uint32_t CHANNEL_COUNT_1 = 1;
37 constexpr uint32_t CHANNEL_COUNT = 2;
38 constexpr uint32_t BIT_RATE_6000 = 6000;
39 constexpr uint32_t BIT_RATE_6700 = 6700;
40 constexpr uint32_t BIT_RATE_8850 = 8850;
41 constexpr uint32_t BIT_RATE_64000 = 64000;
42 constexpr uint32_t BIT_RATE_96000 = 96000;
43 constexpr uint32_t SAMPLE_RATE_8000 = 8000;
44 constexpr uint32_t SAMPLE_RATE_16000 = 16000;
45 constexpr uint32_t SAMPLE_RATE = 44100;
46 constexpr int32_t SAMPLE_FORMAT_S16 = AudioSampleFormat::SAMPLE_S16LE;
47 constexpr int32_t SAMPLE_FORMAT_S32 = AudioSampleFormat::SAMPLE_S32LE;
48 constexpr int32_t BIT_PER_CODE_COUNT = 16;
49 constexpr int32_t COMPLEXITY_COUNT = 10;
50 constexpr int32_t CHANNEL_1 = 1;
51 constexpr int32_t CHANNEL_2 = 2;
52 constexpr int32_t CHANNEL_3 = 3;
53 constexpr int32_t CHANNEL_4 = 4;
54 constexpr int32_t CHANNEL_5 = 5;
55 constexpr int32_t CHANNEL_6 = 6;
56 constexpr int32_t CHANNEL_7 = 7;
57 constexpr int32_t CHANNEL_8 = 8;
58 } // namespace
59
60
GetChannelLayout(int32_t channel)61 static uint64_t GetChannelLayout(int32_t channel)
62 {
63 switch (channel) {
64 case CHANNEL_1:
65 return MONO;
66 case CHANNEL_2:
67 return STEREO;
68 case CHANNEL_3:
69 return CH_2POINT1;
70 case CHANNEL_4:
71 return CH_3POINT1;
72 case CHANNEL_5:
73 return CH_4POINT1;
74 case CHANNEL_6:
75 return CH_5POINT1;
76 case CHANNEL_7:
77 return CH_6POINT1;
78 case CHANNEL_8:
79 return CH_7POINT1;
80 default:
81 return UNKNOWN_CHANNEL_LAYOUT;
82 }
83 }
84
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)85 static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
86 {
87 (void)codec;
88 (void)errorCode;
89 (void)userData;
90 }
91
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)92 static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
93 {
94 (void)codec;
95 (void)format;
96 (void)userData;
97 cout << "OnOutputFormatChanged received" << endl;
98 }
99
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * buffer,void * userData)100 static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *buffer, void *userData)
101 {
102 (void)codec;
103 AEncSignal *signal = static_cast<AEncSignal *>(userData);
104 unique_lock<mutex> lock(signal->inMutex_);
105 signal->inQueue_.push(index);
106 signal->inBufferQueue_.push(buffer);
107 signal->inCond_.notify_all();
108 }
109
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * buffer,void * userData)110 static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *buffer, void *userData)
111 {
112 (void)codec;
113 AEncSignal *signal = static_cast<AEncSignal *>(userData);
114 unique_lock<mutex> lock(signal->outMutex_);
115 signal->outQueue_.push(index);
116 signal->outBufferQueue_.push(buffer);
117 if (buffer) {
118 cout << "OnOutputBufferAvailable received, index:" << index << ", size:" << buffer->buffer_->memory_->GetSize()
119 << ", flags:" << buffer->buffer_->flag_ << ", pts: " << buffer->buffer_->pts_ << endl;
120 }
121 signal->outCond_.notify_all();
122 }
123
InitFile(const std::string & inputFile)124 bool AudioBufferAacEncDemo::InitFile(const std::string& inputFile)
125 {
126 if (inputFile.find("mp4") != std::string::npos || inputFile.find("m4a") != std::string::npos ||
127 inputFile.find("vivid") != std::string::npos) {
128 audioType_ = AudioBufferFormatType::TYPE_VIVID;
129 } else if (inputFile.find("opus") != std::string::npos) {
130 audioType_ = AudioBufferFormatType::TYPE_OPUS;
131 } else if (inputFile.find("g711") != std::string::npos) {
132 audioType_ = AudioBufferFormatType::TYPE_G711MU;
133 } else if (inputFile.find("lbvc") != std::string::npos) {
134 audioType_ = AudioBufferFormatType::TYPE_LBVC;
135 } else if (inputFile.find("flac") != std::string::npos) {
136 audioType_ = AudioBufferFormatType::TYPE_FLAC;
137 } else if (inputFile.find("amrnb") != std::string::npos) {
138 audioType_ = AudioBufferFormatType::TYPE_AMRNB;
139 } else if (inputFile.find("amrwb") != std::string::npos) {
140 audioType_ = AudioBufferFormatType::TYPE_AMRWB;
141 } else if (inputFile.find("mp3") != std::string::npos) {
142 audioType_ = AudioBufferFormatType::TYPE_MP3;
143 } else {
144 audioType_ = AudioBufferFormatType::TYPE_AAC;
145 }
146
147 return true;
148 }
149
RunCase(const uint8_t * data,size_t size)150 bool AudioBufferAacEncDemo::RunCase(const uint8_t *data, size_t size)
151 {
152 std::string codecdata(reinterpret_cast<const char *>(data), size);
153 inputdata = codecdata;
154 inputdatasize = size;
155 DEMO_CHECK_AND_RETURN_RET_LOG(CreateEnc() == AVCS_ERR_OK, false, "Fatal: CreateEnc fail");
156 OH_AVFormat *format = OH_AVFormat_Create();
157 Setformat(format);
158 DEMO_CHECK_AND_RETURN_RET_LOG(Configure(format) == AVCS_ERR_OK, false, "Fatal: Configure fail");
159 DEMO_CHECK_AND_RETURN_RET_LOG(Start() == AVCS_ERR_OK, false, "Fatal: Start fail");
160 {
161 unique_lock<mutex> lock(signal_->startMutex_);
162 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
163 }
164 DEMO_CHECK_AND_RETURN_RET_LOG(Stop() == AVCS_ERR_OK, false, "Fatal: Stop fail");
165 DEMO_CHECK_AND_RETURN_RET_LOG(Release() == AVCS_ERR_OK, false, "Fatal: Release fail");
166 OH_AVFormat_Destroy(format);
167 sleep(1);
168 return true;
169 }
170
Setformat(OH_AVFormat * format)171 void AudioBufferAacEncDemo::Setformat(OH_AVFormat *format)
172 {
173 int32_t channelCount = CHANNEL_COUNT_1;
174 int32_t sampleRate = SAMPLE_RATE;
175 long bitrate = BIT_RATE_64000;
176 uint64_t channelLayout;
177 int32_t sampleFormat = SAMPLE_FORMAT_S16;
178 if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
179 channelCount = CHANNEL_COUNT;
180 sampleRate = SAMPLE_RATE;
181 bitrate = BIT_RATE_96000;
182 sampleFormat = SAMPLE_FORMAT_S32;
183 } else if (audioType_ == AudioBufferFormatType::TYPE_OPUS) {
184 sampleRate = SAMPLE_RATE_8000;
185 bitrate = BIT_RATE_64000;
186 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BIT_PER_CODE_COUNT);
187 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLEXITY_COUNT);
188 } else if (audioType_ == AudioBufferFormatType::TYPE_G711MU) {
189 sampleRate = SAMPLE_RATE_8000;
190 bitrate = BIT_RATE_64000;
191 } else if (audioType_ == AudioBufferFormatType::TYPE_LBVC) {
192 sampleRate = SAMPLE_RATE_16000; //采样率16000
193 bitrate = BIT_RATE_6000; // 码率 6000
194 } else if (audioType_ == AudioBufferFormatType::TYPE_FLAC) {
195 channelCount = CHANNEL_COUNT_1;
196 sampleRate = SAMPLE_RATE;
197 bitrate = BIT_RATE_64000;
198 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
199 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRNB) {
200 sampleRate = SAMPLE_RATE_8000;
201 bitrate = BIT_RATE_6700;
202 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRWB) {
203 sampleRate = SAMPLE_RATE_16000;
204 bitrate = BIT_RATE_8850;
205 } else if (audioType_ == AudioBufferFormatType::TYPE_MP3) {
206 sampleRate = SAMPLE_RATE;
207 bitrate = BIT_RATE_64000;
208 }
209 channelLayout = GetChannelLayout(channelCount);
210 OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, channelLayout);
211 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), channelCount);
212 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), sampleRate);
213 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), bitrate);
214 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), sampleFormat);
215 return;
216 }
217
AudioBufferAacEncDemo()218 AudioBufferAacEncDemo::AudioBufferAacEncDemo() : isRunning_(false), audioEnc_(nullptr), signal_(nullptr), frameCount_(0)
219 {
220 signal_ = new AEncSignal();
221 DEMO_CHECK_AND_RETURN_LOG(signal_ != nullptr, "Fatal: No memory");
222 }
223
~AudioBufferAacEncDemo()224 AudioBufferAacEncDemo::~AudioBufferAacEncDemo()
225 {
226 if (signal_) {
227 delete signal_;
228 signal_ = nullptr;
229 }
230 }
231
CreateEnc()232 int32_t AudioBufferAacEncDemo::CreateEnc()
233 {
234 if (audioType_ == AudioBufferFormatType::TYPE_AAC) {
235 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).data());
236 cout << "CreateEnc aac!" << endl;
237 } else if (audioType_ == AudioBufferFormatType::TYPE_FLAC) {
238 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_FLAC_NAME).data());
239 cout << "CreateEnc flac!" << endl;
240 } else if (audioType_ == AudioBufferFormatType::TYPE_OPUS) {
241 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_OPUS_NAME).data());
242 cout << "CreateEnc opus!" << endl;
243 } else if (audioType_ == AudioBufferFormatType::TYPE_G711MU) {
244 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_G711MU_NAME).data());
245 cout << "CreateEnc g711!" << endl;
246 } else if (audioType_ == AudioBufferFormatType::TYPE_LBVC) {
247 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_LBVC_NAME).data());
248 cout << "CreateEnc lbvc!" << endl;
249 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRNB) {
250 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AMRNB_NAME).data());
251 cout << "CreateEnc amrnb!" << endl;
252 } else if (audioType_ == AudioBufferFormatType::TYPE_AMRWB) {
253 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AMRWB_NAME).data());
254 cout << "CreateEnc amrwb!" << endl;
255 } else if (audioType_ == AudioBufferFormatType::TYPE_MP3) {
256 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_MP3_NAME).data());
257 cout << "CreateEnc mp3!" << endl;
258 } else {
259 return AVCS_ERR_INVALID_VAL;
260 }
261 DEMO_CHECK_AND_RETURN_RET_LOG(audioEnc_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: CreateByName fail");
262 if (signal_ == nullptr) {
263 signal_ = new AEncSignal();
264 DEMO_CHECK_AND_RETURN_RET_LOG(signal_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
265 }
266 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
267 int32_t ret = OH_AudioCodec_RegisterCallback(audioEnc_, cb_, signal_);
268 DEMO_CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCS_ERR_UNKNOWN, "Fatal: SetCallback fail");
269
270 return AVCS_ERR_OK;
271 }
272
Configure(OH_AVFormat * format)273 int32_t AudioBufferAacEncDemo::Configure(OH_AVFormat *format)
274 {
275 int32_t ret = OH_AudioCodec_Configure(audioEnc_, format);
276 return ret;
277 }
278
Start()279 int32_t AudioBufferAacEncDemo::Start()
280 {
281 isRunning_.store(true);
282
283 inputLoop_ = make_unique<thread>(&AudioBufferAacEncDemo::InputFunc, this);
284 DEMO_CHECK_AND_RETURN_RET_LOG(inputLoop_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
285
286 outputLoop_ = make_unique<thread>(&AudioBufferAacEncDemo::OutputFunc, this);
287 DEMO_CHECK_AND_RETURN_RET_LOG(outputLoop_ != nullptr, AVCS_ERR_UNKNOWN, "Fatal: No memory");
288 return OH_AudioCodec_Start(audioEnc_);
289 }
290
Stop()291 int32_t AudioBufferAacEncDemo::Stop()
292 {
293 isRunning_.store(false);
294
295 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
296 {
297 unique_lock<mutex> lock(signal_->inMutex_);
298 signal_->inCond_.notify_all();
299 }
300 inputLoop_->join();
301 inputLoop_ = nullptr;
302 while (!signal_->inQueue_.empty()) {
303 signal_->inQueue_.pop();
304 }
305 while (!signal_->inBufferQueue_.empty()) {
306 signal_->inBufferQueue_.pop();
307 }
308 }
309
310 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
311 {
312 unique_lock<mutex> lock(signal_->outMutex_);
313 signal_->outCond_.notify_all();
314 }
315 outputLoop_->join();
316 outputLoop_ = nullptr;
317 while (!signal_->outQueue_.empty()) {
318 signal_->outQueue_.pop();
319 }
320 while (!signal_->outBufferQueue_.empty()) {
321 signal_->outBufferQueue_.pop();
322 }
323 }
324
325 return OH_AudioCodec_Stop(audioEnc_);
326 }
327
Flush()328 int32_t AudioBufferAacEncDemo::Flush()
329 {
330 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
331 {
332 unique_lock<mutex> lock(signal_->inMutex_);
333 signal_->inCond_.notify_all();
334 }
335 inputLoop_->join();
336 inputLoop_ = nullptr;
337 while (!signal_->inQueue_.empty()) {
338 signal_->inQueue_.pop();
339 }
340 while (!signal_->inBufferQueue_.empty()) {
341 signal_->inBufferQueue_.pop();
342 }
343 }
344
345 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
346 {
347 unique_lock<mutex> lock(signal_->outMutex_);
348 signal_->outCond_.notify_all();
349 }
350 outputLoop_->join();
351 outputLoop_ = nullptr;
352 while (!signal_->outQueue_.empty()) {
353 signal_->outQueue_.pop();
354 }
355 while (!signal_->outBufferQueue_.empty()) {
356 signal_->outBufferQueue_.pop();
357 }
358 }
359 return OH_AudioCodec_Flush(audioEnc_);
360 }
361
Reset()362 int32_t AudioBufferAacEncDemo::Reset()
363 {
364 return OH_AudioCodec_Reset(audioEnc_);
365 }
366
Release()367 int32_t AudioBufferAacEncDemo::Release()
368 {
369 return OH_AudioCodec_Destroy(audioEnc_);
370 }
371
HandleEOS(const uint32_t & index)372 void AudioBufferAacEncDemo::HandleEOS(const uint32_t &index)
373 {
374 OH_AudioCodec_PushInputBuffer(audioEnc_, index);
375 signal_->inQueue_.pop();
376 signal_->inBufferQueue_.pop();
377 }
378
InputFunc()379 void AudioBufferAacEncDemo::InputFunc()
380 {
381 size_t frameBytes = 320; // 320
382 while (isRunning_.load()) {
383 unique_lock<mutex> lock(signal_->inMutex_);
384 signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
385 if (!isRunning_.load()) {
386 break;
387 }
388 uint32_t index = signal_->inQueue_.front();
389 auto buffer = signal_->inBufferQueue_.front();
390 DEMO_CHECK_AND_BREAK_LOG(buffer != nullptr, "Fatal: GetInputBuffer fail");
391 size_t currentSize = inputdatasize < frameBytes ? inputdatasize : frameBytes;
392 if (currentSize == 0) {
393 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
394 OH_AudioCodec_PushInputBuffer(audioEnc_, index);
395 break;
396 }
397 std::string currentStr = inputdata.substr(inputOffset, currentSize);
398 int ret;
399 strncpy_s(reinterpret_cast<char*>(OH_AVBuffer_GetAddr(buffer)), currentSize, currentStr.c_str(), currentSize);
400 buffer->buffer_->memory_->SetSize(currentSize);
401 if (isFirstFrame_) {
402 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
403 ret = OH_AudioCodec_PushInputBuffer(audioEnc_, index);
404 isFirstFrame_ = false;
405 } else {
406 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
407 ret = OH_AudioCodec_PushInputBuffer(audioEnc_, index);
408 }
409 signal_->inQueue_.pop();
410 signal_->inBufferQueue_.pop();
411 inputdatasize -= currentSize;
412 inputOffset += currentSize;
413 frameCount_++;
414 if (ret != AVCS_ERR_OK) {
415 isRunning_.store(false);
416 break;
417 }
418 }
419 signal_->outCond_.notify_all();
420 }
421
OutputFunc()422 void AudioBufferAacEncDemo::OutputFunc()
423 {
424 while (isRunning_.load()) {
425 unique_lock<mutex> lock(signal_->outMutex_);
426 signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
427
428 if (!isRunning_.load()) {
429 cout << "wait to stop, exit" << endl;
430 break;
431 }
432
433 uint32_t index = signal_->outQueue_.front();
434 OH_AVBuffer *avBuffer = signal_->outBufferQueue_.front();
435 if (avBuffer == nullptr) {
436 cout << "OutputFunc OH_AVBuffer is nullptr" << endl;
437 continue;
438 }
439 std::cout << "OutputFunc index:" << index << endl;
440 if (avBuffer != nullptr &&
441 (avBuffer->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS || avBuffer->buffer_->memory_->GetSize() == 0)) {
442 cout << "encode eos" << endl;
443 isRunning_.store(false);
444 signal_->startCond_.notify_all();
445 }
446
447 signal_->outBufferQueue_.pop();
448 signal_->outQueue_.pop();
449 if (OH_AudioCodec_FreeOutputBuffer(audioEnc_, index) != AV_ERR_OK) {
450 cout << "Fatal: FreeOutputData fail" << endl;
451 break;
452 }
453 }
454 signal_->startCond_.notify_all();
455 cout << "stop, exit" << endl;
456 }
457
CreateByMime(const char * mime)458 OH_AVCodec *AudioBufferAacEncDemo::CreateByMime(const char *mime)
459 {
460 if (mime != nullptr) {
461 if (strcmp(mime, "audio/mp4a-latm") == 0) {
462 audioType_ = AudioBufferFormatType::TYPE_AAC;
463 cout << "creat, aac" << endl;
464 } else if (strcmp(mime, "audio/flac") == 0) {
465 audioType_ = AudioBufferFormatType::TYPE_FLAC;
466 cout << "creat, flac" << endl;
467 } else if (strcmp(mime, "audio/lbvc") == 0) {
468 audioType_ = AudioBufferFormatType::TYPE_LBVC;
469 cout << "creat, LBVC" << endl;
470 } else {
471 audioType_ = AudioBufferFormatType::TYPE_G711MU;
472 }
473 }
474
475 return OH_AudioCodec_CreateByMime(mime, true);
476 }
477
CreateByName(const char * name)478 OH_AVCodec *AudioBufferAacEncDemo::CreateByName(const char *name)
479 {
480 return OH_AudioCodec_CreateByName(name);
481 }
482
Destroy(OH_AVCodec * codec)483 OH_AVErrCode AudioBufferAacEncDemo::Destroy(OH_AVCodec *codec)
484 {
485 OH_AVErrCode ret = OH_AudioCodec_Destroy(codec);
486 ClearQueue();
487 return ret;
488 }
489
SetCallback(OH_AVCodec * codec)490 OH_AVErrCode AudioBufferAacEncDemo::SetCallback(OH_AVCodec *codec)
491 {
492 if (codec == nullptr) {
493 cout << "SetCallback, codec null" << endl;
494 }
495 if (signal_ == nullptr) {
496 cout << "SetCallback, signal_ null" << endl;
497 }
498 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
499 return OH_AudioCodec_RegisterCallback(codec, cb_, signal_);
500 }
501
Prepare(OH_AVCodec * codec)502 OH_AVErrCode AudioBufferAacEncDemo::Prepare(OH_AVCodec *codec)
503 {
504 return OH_AudioCodec_Prepare(codec);
505 }
506
Start(OH_AVCodec * codec)507 OH_AVErrCode AudioBufferAacEncDemo::Start(OH_AVCodec *codec)
508 {
509 return OH_AudioCodec_Start(codec);
510 }
511
Stop(OH_AVCodec * codec)512 OH_AVErrCode AudioBufferAacEncDemo::Stop(OH_AVCodec *codec)
513 {
514 OH_AVErrCode ret = OH_AudioCodec_Stop(codec);
515 ClearQueue();
516 return ret;
517 }
518
Flush(OH_AVCodec * codec)519 OH_AVErrCode AudioBufferAacEncDemo::Flush(OH_AVCodec *codec)
520 {
521 OH_AVErrCode ret = OH_AudioCodec_Flush(codec);
522 ClearQueue();
523 return ret;
524 }
525
Reset(OH_AVCodec * codec)526 OH_AVErrCode AudioBufferAacEncDemo::Reset(OH_AVCodec *codec)
527 {
528 return OH_AudioCodec_Reset(codec);
529 }
530
GetOutputDescription(OH_AVCodec * codec)531 OH_AVFormat *AudioBufferAacEncDemo::GetOutputDescription(OH_AVCodec *codec)
532 {
533 return OH_AudioCodec_GetOutputDescription(codec);
534 }
535
PushInputData(OH_AVCodec * codec,uint32_t index)536 OH_AVErrCode AudioBufferAacEncDemo::PushInputData(OH_AVCodec *codec, uint32_t index)
537 {
538 OH_AVCodecBufferAttr info;
539 if (!signal_->inBufferQueue_.empty()) {
540 unique_lock<mutex> lock(signal_->inMutex_);
541 auto buffer = signal_->inBufferQueue_.front();
542 OH_AVBuffer_GetBufferAttr(buffer, &info);
543 info.size = 100; // size 100
544 OH_AVErrCode ret = OH_AVBuffer_SetBufferAttr(buffer, &info);
545 if (ret != AV_ERR_OK) {
546 return ret;
547 }
548 signal_->inBufferQueue_.pop();
549 }
550 return OH_AudioCodec_PushInputBuffer(codec, index);
551 }
552
PushInputDataEOS(OH_AVCodec * codec,uint32_t index)553 OH_AVErrCode AudioBufferAacEncDemo::PushInputDataEOS(OH_AVCodec *codec, uint32_t index)
554 {
555 OH_AVCodecBufferAttr info;
556 info.size = 0;
557 info.offset = 0;
558 info.pts = 0;
559 info.flags = AVCODEC_BUFFER_FLAGS_EOS;
560 if (!signal_->inBufferQueue_.empty()) {
561 unique_lock<mutex> lock(signal_->inMutex_);
562 auto buffer = signal_->inBufferQueue_.front();
563 OH_AVBuffer_SetBufferAttr(buffer, &info);
564 signal_->inBufferQueue_.pop();
565 }
566 return OH_AudioCodec_PushInputBuffer(codec, index);
567 }
568
FreeOutputData(OH_AVCodec * codec,uint32_t index)569 OH_AVErrCode AudioBufferAacEncDemo::FreeOutputData(OH_AVCodec *codec, uint32_t index)
570 {
571 return OH_AudioCodec_FreeOutputBuffer(codec, index);
572 }
573
IsValid(OH_AVCodec * codec,bool * isValid)574 OH_AVErrCode AudioBufferAacEncDemo::IsValid(OH_AVCodec *codec, bool *isValid)
575 {
576 return OH_AudioCodec_IsValid(codec, isValid);
577 }
578
GetInputIndex()579 uint32_t AudioBufferAacEncDemo::GetInputIndex()
580 {
581 uint32_t sleeptime = 0;
582 uint32_t index;
583 uint32_t timeout = 5;
584 while (signal_->inQueue_.empty() && sleeptime < timeout) {
585 sleep(1);
586 sleeptime++;
587 }
588 if (sleeptime >= timeout) {
589 return 0;
590 } else {
591 index = signal_->inQueue_.front();
592 signal_->inQueue_.pop();
593 }
594 return index;
595 }
596
GetOutputIndex()597 uint32_t AudioBufferAacEncDemo::GetOutputIndex()
598 {
599 uint32_t sleeptime = 0;
600 uint32_t index;
601 uint32_t timeout = 5;
602 while (signal_->outQueue_.empty() && sleeptime < timeout) {
603 sleep(1);
604 sleeptime++;
605 }
606 if (sleeptime >= timeout) {
607 return 0;
608 } else {
609 index = signal_->outQueue_.front();
610 signal_->outQueue_.pop();
611 }
612 return index;
613 }
614
ClearQueue()615 void AudioBufferAacEncDemo::ClearQueue()
616 {
617 while (!signal_->inQueue_.empty()) {
618 signal_->inQueue_.pop();
619 }
620
621 while (!signal_->outQueue_.empty()) {
622 signal_->outQueue_.pop();
623 }
624
625 while (!signal_->inBufferQueue_.empty()) {
626 signal_->inBufferQueue_.pop();
627 }
628
629 while (!signal_->outBufferQueue_.empty()) {
630 signal_->outBufferQueue_.pop();
631 }
632 }