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