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 "avcodec_audio_avbuffer_lbvc_encoder_inner_demo.h"
17 #include <unistd.h>
18 #include <string>
19 #include <string_view>
20 #include <iostream>
21 #include <unistd.h>
22 #include <chrono>
23 #include "securec.h"
24 #include "demo_log.h"
25 #include "meta/audio_types.h"
26 #include "inner_api/native/avcodec_audio_codec.h"
27 #include "avcodec_errors.h"
28 
29 using namespace OHOS::Media;
30 using namespace OHOS::MediaAVCodec;
31 using namespace OHOS::MediaAVCodec::InnerAudioEncoderLbvcDemo;
32 
33 namespace {
34 constexpr std::string_view INPUT_FILE_PATH = "/data/test/media/lbvc_1c_16000hz_6k.pcm";
35 constexpr std::string_view OUTPUT_PCM_FILE_PATH = "/data/test/media/lbvc_1c_16000hz_6k.dat";
36 
37 constexpr int32_t INPUT_FRAME_BYTES = 160 * 4;
38 constexpr int32_t TIME_OUT_MS = 8;
39 
40 typedef enum OH_AVCodecBufferFlags {
41     AVCODEC_BUFFER_FLAGS_NONE = 0,
42     /* Indicates that the Buffer is an End-of-Stream frame */
43     AVCODEC_BUFFER_FLAGS_EOS = 1 << 0,
44     /* Indicates that the Buffer contains keyframes */
45     AVCODEC_BUFFER_FLAGS_SYNC_FRAME = 1 << 1,
46     /* Indicates that the data contained in the Buffer is only part of a frame */
47     AVCODEC_BUFFER_FLAGS_INCOMPLETE_FRAME = 1 << 2,
48     /* Indicates that the Buffer contains Codec-Specific-Data */
49     AVCODEC_BUFFER_FLAGS_CODEC_DATA = 1 << 3,
50 } OH_AVCodecBufferFlags;
51 } // namespace
52 
GetFileSize(const std::string & filePath)53 static int32_t GetFileSize(const std::string &filePath)
54 {
55     std::ifstream file(filePath, std::ios::binary | std::ios::ate);
56     if (!file) {
57         std::cerr << "Failed to open file:" << filePath << std::endl;
58         return -1;
59     }
60 
61     std::streampos fileSize = file.tellg(); // 获取文件大小
62     file.close();
63 
64     return (int32_t)fileSize;
65 }
66 
AudioCodecConsumerListener(AudioEncInnerAvBufferLbvcDemo * demo)67 AudioCodecConsumerListener::AudioCodecConsumerListener(AudioEncInnerAvBufferLbvcDemo *demo)
68 {
69     demo_ = demo;
70 }
71 
OnBufferAvailable()72 void AudioCodecConsumerListener::OnBufferAvailable()
73 {
74     demo_->OutputFunc();
75 }
76 
RunCase()77 void AudioEncInnerAvBufferLbvcDemo::RunCase()
78 {
79     innerBufferQueue_ = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "InnerDemo");  // 4
80 
81     audiocodec_ = AudioCodecFactory::CreateByName("OH.Media.Codec.Encoder.Audio.LBVC");
82     if (audiocodec_ == nullptr) {
83         std::cout << "codec == nullptr" << std::endl;
84         return;
85     }
86     auto meta = std::make_shared<Media::Meta>();
87     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(1);    // CHANNEL_COUNT is 1
88     meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
89     meta->Set<Tag::AUDIO_SAMPLE_RATE>(16000);    // SAMPLE_RATE is 16000
90     meta->Set<Tag::MEDIA_BITRATE>(6000);    // BITRATE is 6000
91     audiocodec_->Configure(meta);
92 
93     audiocodec_->SetOutputBufferQueue(innerBufferQueue_->GetProducer());
94     audiocodec_->Prepare();
95 
96     implConsumer_ = innerBufferQueue_->GetConsumer();
97     sptr<Media::IConsumerListener> comsumerListener = new AudioCodecConsumerListener(this);
98     implConsumer_->SetBufferAvailableListener(comsumerListener);
99     mediaCodecProducer_ = audiocodec_->GetInputBufferQueue();
100 
101     audiocodec_->Start();
102     isRunning_.store(true);
103 
104     fileSize_ = GetFileSize(INPUT_FILE_PATH.data());
105     inputFile_ = std::make_unique<std::ifstream>(INPUT_FILE_PATH, std::ios::binary);
106     outputFile_ = std::make_unique<std::ofstream>(OUTPUT_PCM_FILE_PATH, std::ios::binary);
107     InputFunc();
108     inputFile_->close();
109     outputFile_->close();
110     audiocodec_->Stop();
111     audiocodec_->Release();
112     return;
113 }
114 
GetInputBufferSize()115 int32_t AudioEncInnerAvBufferLbvcDemo::GetInputBufferSize()
116 {
117     int32_t capacity = 0;
118     DEMO_CHECK_AND_RETURN_RET_LOG(audiocodec_ != nullptr, capacity, "audiocodec_ is nullptr");
119     std::shared_ptr<Media::Meta> bufferConfig = std::make_shared<Media::Meta>();
120     DEMO_CHECK_AND_RETURN_RET_LOG(bufferConfig != nullptr, capacity, "bufferConfig is nullptr");
121     int32_t ret = audiocodec_->GetOutputFormat(bufferConfig);
122     DEMO_CHECK_AND_RETURN_RET_LOG(ret == AVCodecServiceErrCode::AVCS_ERR_OK, capacity, "GetOutputFormat fail");
123     DEMO_CHECK_AND_RETURN_RET_LOG(bufferConfig->Get<Media::Tag::AUDIO_MAX_INPUT_SIZE>(capacity),
124         capacity, "get max input buffer size fail");
125     return capacity;
126 }
127 
InputFunc()128 void AudioEncInnerAvBufferLbvcDemo::InputFunc()
129 {
130     DEMO_CHECK_AND_RETURN_LOG(inputFile_ != nullptr && inputFile_->is_open(), "Fatal: open file fail");
131     int32_t sumReadSize = 0;
132     Media::Status ret;
133     Media::AVBufferConfig avBufferConfig;
134     avBufferConfig.size = GetInputBufferSize();
135     while (isRunning_) {
136         std::shared_ptr<AVBuffer> inputBuffer = nullptr;
137         DEMO_CHECK_AND_BREAK_LOG(mediaCodecProducer_ != nullptr, "mediaCodecProducer_ is nullptr");
138         ret = mediaCodecProducer_->RequestBuffer(inputBuffer, avBufferConfig, TIME_OUT_MS);
139         if (ret != Media::Status::OK) {
140             std::cout << "produceInputBuffer RequestBuffer fail,ret=" << (int32_t)ret << std::endl;
141             break;
142         }
143         DEMO_CHECK_AND_BREAK_LOG(inputBuffer != nullptr, "buffer is nullptr");
144         if (!inputFile_->eof()) {
145             inputFile_->read(reinterpret_cast<char *>(inputBuffer->memory_->GetAddr()), INPUT_FRAME_BYTES);
146             inputBuffer->memory_->SetSize(INPUT_FRAME_BYTES);
147             sumReadSize += INPUT_FRAME_BYTES;
148         } else {
149             inputBuffer->memory_->SetSize(1);
150             inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
151             mediaCodecProducer_->PushBuffer(inputBuffer, true);
152             std::cout << "end buffer\n";
153             break;
154         }
155 
156         if (isFirstFrame_) {
157             inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
158             mediaCodecProducer_->PushBuffer(inputBuffer, true);
159             isFirstFrame_ = false;
160         } else {
161             inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
162             mediaCodecProducer_->PushBuffer(inputBuffer, true);
163         }
164 
165         std::cout << "InputFunc, INPUT_FRAME_BYTES:" << INPUT_FRAME_BYTES << " flag:" << inputBuffer->flag_
166                   << " sumReadSize:" << sumReadSize << " fileSize_:" << fileSize_
167                   << " process:" << 100 * sumReadSize / fileSize_ << "%" << std::endl;   // 100
168     }
169 }
170 
OutputFunc()171 void AudioEncInnerAvBufferLbvcDemo::OutputFunc()
172 {
173     bufferConsumerAvailableCount_++;
174     Media::Status ret = Media::Status::OK;
175     int64_t size = 0;
176     int64_t pts = 0;
177     while (isRunning_ && (bufferConsumerAvailableCount_ > 0)) {
178         std::cout << "/**********ImplConsumerOutputBuffer while**********/" << std::endl;
179         std::shared_ptr<AVBuffer> outputBuffer;
180         ret = implConsumer_->AcquireBuffer(outputBuffer);
181         if (ret != Media::Status::OK) {
182             std::cout << "Consumer AcquireBuffer fail,ret=" << (int32_t)ret << std::endl;
183             break;
184         }
185         if (outputBuffer == nullptr) {
186             std::cout << "OutputFunc OH_AVBuffer is nullptr" << std::endl;
187             continue;
188         }
189 
190         size = outputBuffer->memory_->GetSize();
191         outputFile_->write(reinterpret_cast<char *>(&size), sizeof(int64_t));
192         outputFile_->write(reinterpret_cast<char *>(&pts), sizeof(int64_t));
193         outputFile_->write(reinterpret_cast<char *>(outputBuffer->memory_->GetAddr()),
194                            outputBuffer->memory_->GetSize());
195         if (outputBuffer->flag_ == AVCODEC_BUFFER_FLAGS_EOS || outputBuffer->memory_->GetSize() == 0) {
196             std::cout << "out eos" << std::endl;
197             isRunning_.store(false);
198         }
199         implConsumer_->ReleaseBuffer(outputBuffer);
200         bufferConsumerAvailableCount_--;
201     }
202 }