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