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 opussize = 320;
382 size_t frameBytes = opussize;
383 while (isRunning_.load()) {
384 unique_lock<mutex> lock(signal_->inMutex_);
385 signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
386 if (!isRunning_.load()) {
387 break;
388 }
389 uint32_t index = signal_->inQueue_.front();
390 auto buffer = signal_->inBufferQueue_.front();
391 DEMO_CHECK_AND_BREAK_LOG(buffer != nullptr, "Fatal: GetInputBuffer fail");
392 size_t currentSize = inputdatasize < frameBytes ? inputdatasize : frameBytes;
393 if (currentSize == 0) {
394 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
395 OH_AudioCodec_PushInputBuffer(audioEnc_, index);
396 break;
397 }
398 std::string currentStr = inputdata.substr(inputOffset, currentSize);
399 int ret;
400 strncpy_s(reinterpret_cast<char*>(OH_AVBuffer_GetAddr(buffer)), currentSize, currentStr.c_str(), currentSize);
401 buffer->buffer_->memory_->SetSize(currentSize);
402 if (isFirstFrame_) {
403 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
404 ret = OH_AudioCodec_PushInputBuffer(audioEnc_, index);
405 isFirstFrame_ = false;
406 } else {
407 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
408 ret = OH_AudioCodec_PushInputBuffer(audioEnc_, index);
409 }
410 signal_->inQueue_.pop();
411 signal_->inBufferQueue_.pop();
412 inputdatasize -= currentSize;
413 inputOffset += currentSize;
414 frameCount_++;
415 if (ret != AVCS_ERR_OK) {
416 isRunning_.store(false);
417 break;
418 }
419 }
420 signal_->outCond_.notify_all();
421 }
422
OutputFunc()423 void AudioBufferAacEncDemo::OutputFunc()
424 {
425 while (isRunning_.load()) {
426 unique_lock<mutex> lock(signal_->outMutex_);
427 signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
428
429 if (!isRunning_.load()) {
430 cout << "wait to stop, exit" << endl;
431 break;
432 }
433
434 uint32_t index = signal_->outQueue_.front();
435 OH_AVBuffer *avBuffer = signal_->outBufferQueue_.front();
436 if (avBuffer == nullptr) {
437 cout << "OutputFunc OH_AVBuffer is nullptr" << endl;
438 continue;
439 }
440 std::cout << "OutputFunc index:" << index << endl;
441 if (avBuffer != nullptr &&
442 (avBuffer->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS || avBuffer->buffer_->memory_->GetSize() == 0)) {
443 cout << "encode eos" << endl;
444 isRunning_.store(false);
445 signal_->startCond_.notify_all();
446 }
447
448 signal_->outBufferQueue_.pop();
449 signal_->outQueue_.pop();
450 if (OH_AudioCodec_FreeOutputBuffer(audioEnc_, index) != AV_ERR_OK) {
451 cout << "Fatal: FreeOutputData fail" << endl;
452 break;
453 }
454 }
455 signal_->startCond_.notify_all();
456 cout << "stop, exit" << endl;
457 }
458
CreateByMime(const char * mime)459 OH_AVCodec *AudioBufferAacEncDemo::CreateByMime(const char *mime)
460 {
461 if (mime != nullptr) {
462 if (strcmp(mime, "audio/mp4a-latm") == 0) {
463 audioType_ = AudioBufferFormatType::TYPE_AAC;
464 cout << "creat, aac" << endl;
465 } else if (strcmp(mime, "audio/flac") == 0) {
466 audioType_ = AudioBufferFormatType::TYPE_FLAC;
467 cout << "creat, flac" << endl;
468 } else if (strcmp(mime, "audio/lbvc") == 0) {
469 audioType_ = AudioBufferFormatType::TYPE_LBVC;
470 cout << "creat, LBVC" << endl;
471 } else {
472 audioType_ = AudioBufferFormatType::TYPE_G711MU;
473 }
474 }
475
476 return OH_AudioCodec_CreateByMime(mime, true);
477 }
478
CreateByName(const char * name)479 OH_AVCodec *AudioBufferAacEncDemo::CreateByName(const char *name)
480 {
481 return OH_AudioCodec_CreateByName(name);
482 }
483
Destroy(OH_AVCodec * codec)484 OH_AVErrCode AudioBufferAacEncDemo::Destroy(OH_AVCodec *codec)
485 {
486 OH_AVErrCode ret = OH_AudioCodec_Destroy(codec);
487 ClearQueue();
488 return ret;
489 }
490
SetCallback(OH_AVCodec * codec)491 OH_AVErrCode AudioBufferAacEncDemo::SetCallback(OH_AVCodec *codec)
492 {
493 if (codec == nullptr) {
494 cout << "SetCallback, codec null" << endl;
495 }
496 if (signal_ == nullptr) {
497 cout << "SetCallback, signal_ null" << endl;
498 }
499 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
500 return OH_AudioCodec_RegisterCallback(codec, cb_, signal_);
501 }
502
Prepare(OH_AVCodec * codec)503 OH_AVErrCode AudioBufferAacEncDemo::Prepare(OH_AVCodec *codec)
504 {
505 return OH_AudioCodec_Prepare(codec);
506 }
507
Start(OH_AVCodec * codec)508 OH_AVErrCode AudioBufferAacEncDemo::Start(OH_AVCodec *codec)
509 {
510 return OH_AudioCodec_Start(codec);
511 }
512
Stop(OH_AVCodec * codec)513 OH_AVErrCode AudioBufferAacEncDemo::Stop(OH_AVCodec *codec)
514 {
515 OH_AVErrCode ret = OH_AudioCodec_Stop(codec);
516 ClearQueue();
517 return ret;
518 }
519
Flush(OH_AVCodec * codec)520 OH_AVErrCode AudioBufferAacEncDemo::Flush(OH_AVCodec *codec)
521 {
522 OH_AVErrCode ret = OH_AudioCodec_Flush(codec);
523 ClearQueue();
524 return ret;
525 }
526
Reset(OH_AVCodec * codec)527 OH_AVErrCode AudioBufferAacEncDemo::Reset(OH_AVCodec *codec)
528 {
529 return OH_AudioCodec_Reset(codec);
530 }
531
GetOutputDescription(OH_AVCodec * codec)532 OH_AVFormat *AudioBufferAacEncDemo::GetOutputDescription(OH_AVCodec *codec)
533 {
534 return OH_AudioCodec_GetOutputDescription(codec);
535 }
536
PushInputData(OH_AVCodec * codec,uint32_t index)537 OH_AVErrCode AudioBufferAacEncDemo::PushInputData(OH_AVCodec *codec, uint32_t index)
538 {
539 OH_AVCodecBufferAttr info;
540 if (!signal_->inBufferQueue_.empty()) {
541 unique_lock<mutex> lock(signal_->inMutex_);
542 auto buffer = signal_->inBufferQueue_.front();
543 OH_AVBuffer_GetBufferAttr(buffer, &info);
544 info.size = 100; // size 100
545 OH_AVErrCode ret = OH_AVBuffer_SetBufferAttr(buffer, &info);
546 if (ret != AV_ERR_OK) {
547 return ret;
548 }
549 signal_->inBufferQueue_.pop();
550 }
551 return OH_AudioCodec_PushInputBuffer(codec, index);
552 }
553
PushInputDataEOS(OH_AVCodec * codec,uint32_t index)554 OH_AVErrCode AudioBufferAacEncDemo::PushInputDataEOS(OH_AVCodec *codec, uint32_t index)
555 {
556 OH_AVCodecBufferAttr info;
557 info.size = 0;
558 info.offset = 0;
559 info.pts = 0;
560 info.flags = AVCODEC_BUFFER_FLAGS_EOS;
561 if (!signal_->inBufferQueue_.empty()) {
562 unique_lock<mutex> lock(signal_->inMutex_);
563 auto buffer = signal_->inBufferQueue_.front();
564 OH_AVBuffer_SetBufferAttr(buffer, &info);
565 signal_->inBufferQueue_.pop();
566 }
567 return OH_AudioCodec_PushInputBuffer(codec, index);
568 }
569
FreeOutputData(OH_AVCodec * codec,uint32_t index)570 OH_AVErrCode AudioBufferAacEncDemo::FreeOutputData(OH_AVCodec *codec, uint32_t index)
571 {
572 return OH_AudioCodec_FreeOutputBuffer(codec, index);
573 }
574
IsValid(OH_AVCodec * codec,bool * isValid)575 OH_AVErrCode AudioBufferAacEncDemo::IsValid(OH_AVCodec *codec, bool *isValid)
576 {
577 return OH_AudioCodec_IsValid(codec, isValid);
578 }
579
GetInputIndex()580 uint32_t AudioBufferAacEncDemo::GetInputIndex()
581 {
582 uint32_t sleeptime = 0;
583 uint32_t index;
584 uint32_t timeout = 5;
585 while (signal_->inQueue_.empty() && sleeptime < timeout) {
586 sleep(1);
587 sleeptime++;
588 }
589 if (sleeptime >= timeout) {
590 return 0;
591 } else {
592 index = signal_->inQueue_.front();
593 signal_->inQueue_.pop();
594 }
595 return index;
596 }
597
GetOutputIndex()598 uint32_t AudioBufferAacEncDemo::GetOutputIndex()
599 {
600 uint32_t sleeptime = 0;
601 uint32_t index;
602 uint32_t timeout = 5;
603 while (signal_->outQueue_.empty() && sleeptime < timeout) {
604 sleep(1);
605 sleeptime++;
606 }
607 if (sleeptime >= timeout) {
608 return 0;
609 } else {
610 index = signal_->outQueue_.front();
611 signal_->outQueue_.pop();
612 }
613 return index;
614 }
615
ClearQueue()616 void AudioBufferAacEncDemo::ClearQueue()
617 {
618 while (!signal_->inQueue_.empty()) {
619 signal_->inQueue_.pop();
620 }
621
622 while (!signal_->outQueue_.empty()) {
623 signal_->outQueue_.pop();
624 }
625
626 while (!signal_->inBufferQueue_.empty()) {
627 signal_->inBufferQueue_.pop();
628 }
629
630 while (!signal_->outBufferQueue_.empty()) {
631 signal_->outBufferQueue_.pop();
632 }
633 }