1 /*
2 * Copyright (c) 2025 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 #include "av_codec_adapter.h"
16 #include "camera_log.h"
17
18 namespace OHOS {
19 namespace CameraStandard {
AVCodecAdapter()20 AVCodecAdapter::AVCodecAdapter()
21 {
22 MEDIA_DEBUG_LOG("AVCodecAdapter constructor");
23 }
24
~AVCodecAdapter()25 AVCodecAdapter::~AVCodecAdapter()
26 {
27 MEDIA_DEBUG_LOG("AVCodecAdapter destructor");
28 }
29
CreateAVMuxer(int32_t fd,OutputFormat format)30 int32_t AVCodecAdapter::CreateAVMuxer(int32_t fd, OutputFormat format)
31 {
32 MEDIA_DEBUG_LOG("CreateAVMuxer start");
33 muxer_ = AVMuxerFactory::CreateAVMuxer(fd, format);
34 CHECK_RETURN_RET_ELOG(muxer_ == nullptr, AV_ERR_FAILED, "CreateAVMuxer failed");
35 return AV_ERR_OK;
36 }
37
CreateAVCodecVideoEncoder(const std::string & codecMime)38 int32_t AVCodecAdapter::CreateAVCodecVideoEncoder(const std::string &codecMime)
39 {
40 MEDIA_DEBUG_LOG("CreateAVCodecVideoEncoder start");
41 videoEncoder_ = VideoEncoderFactory::CreateByMime(codecMime);
42 CHECK_RETURN_RET_ELOG(
43 videoEncoder_ == nullptr, AV_ERR_FAILED, "CreateAVCodecVideoEncoder failed");
44 MEDIA_DEBUG_LOG("CreateAVCodecVideoEncoder success");
45 return AV_ERR_OK;
46 }
47
AVMuxerSetParameter(const std::shared_ptr<Meta> & param)48 int32_t AVCodecAdapter::AVMuxerSetParameter(const std::shared_ptr<Meta> ¶m)
49 {
50 MEDIA_DEBUG_LOG("AVMuxerSetParameter start");
51 CHECK_RETURN_RET_ELOG(muxer_ == nullptr, AV_ERR_INVALID_VAL, "muxer_ is not created");
52 CHECK_RETURN_RET_ELOG(param == nullptr, AV_ERR_INVALID_VAL, "input param is nullptr!");
53 int32_t ret = muxer_->SetParameter(param);
54 CHECK_RETURN_RET_ELOG(ret != AV_ERR_OK, AV_ERR_FAILED, "AVMuxerSetParameter failed, ret: %{public}d", ret);
55 MEDIA_DEBUG_LOG("AVMuxerSetParameter end");
56 return ret;
57 }
58
AVMuxerSetUserMeta(const std::shared_ptr<Meta> & userMeta)59 int32_t AVCodecAdapter::AVMuxerSetUserMeta(const std::shared_ptr<Meta> &userMeta)
60 {
61 MEDIA_DEBUG_LOG("AVMuxerSetUserMeta start");
62 CHECK_RETURN_RET_ELOG(muxer_ == nullptr, AV_ERR_INVALID_VAL, "muxer_ is not created");
63 CHECK_RETURN_RET_ELOG(userMeta == nullptr, AV_ERR_INVALID_VAL, "input userMeta is nullptr!");
64 int32_t ret = muxer_->SetUserMeta(userMeta);
65 CHECK_RETURN_RET_ELOG(ret != AV_ERR_OK, AV_ERR_FAILED, "AVMuxerSetUserMeta failed, ret: %{public}d", ret);
66 MEDIA_DEBUG_LOG("AVMuxerSetUserMeta end");
67 return ret;
68 }
69
AVMuxerAddTrack(int32_t & trackIndex,const std::shared_ptr<Meta> & trackDesc)70 int32_t AVCodecAdapter::AVMuxerAddTrack(int32_t &trackIndex, const std::shared_ptr<Meta> &trackDesc)
71 {
72 MEDIA_DEBUG_LOG("AVMuxerAddTrack start");
73 CHECK_RETURN_RET_ELOG(muxer_ == nullptr, AV_ERR_INVALID_VAL, "muxer_ is not created");
74 CHECK_RETURN_RET_ELOG(trackDesc == nullptr, AV_ERR_INVALID_VAL, "input trackDesc is nullptr!");
75 int32_t ret = muxer_->AddTrack(trackIndex, trackDesc);
76 CHECK_RETURN_RET_ELOG(ret != AV_ERR_OK, AV_ERR_FAILED, "AVMuxerAddTrack failed, ret: %{public}d", ret);
77 MEDIA_DEBUG_LOG("AVMuxerAddTrack end");
78 return ret;
79 }
80
AVMuxerStart()81 int32_t AVCodecAdapter::AVMuxerStart()
82 {
83 MEDIA_DEBUG_LOG("AVMuxerStart start");
84 CHECK_RETURN_RET_ELOG(muxer_ == nullptr, AV_ERR_INVALID_VAL, "muxer_ is not created");
85 int32_t ret = muxer_->Start();
86 CHECK_RETURN_RET_ELOG(ret != AV_ERR_OK, AV_ERR_FAILED, "AVMuxerStart failed, ret: %{public}d", ret);
87 MEDIA_DEBUG_LOG("AVMuxerStart end");
88 return ret;
89 }
90
AVMuxerWriteSample(uint32_t trackIndex,const std::shared_ptr<AVBuffer> & sample)91 int32_t AVCodecAdapter::AVMuxerWriteSample(uint32_t trackIndex, const std::shared_ptr<AVBuffer> &sample)
92 {
93 MEDIA_DEBUG_LOG("AVMuxerWriteSampleBuffer start");
94 CHECK_RETURN_RET_ELOG(muxer_ == nullptr, AV_ERR_INVALID_VAL, "muxer_ is not created");
95 CHECK_RETURN_RET_ELOG(sample == nullptr, AV_ERR_INVALID_VAL, "input sample is nullptr!");
96 int32_t ret = muxer_->WriteSample(trackIndex, sample);
97 CHECK_RETURN_RET_ELOG(
98 ret != AV_ERR_OK, AV_ERR_FAILED, "AVMuxerWriteSampleBuffer failed, ret: %{public}d", ret);
99 MEDIA_DEBUG_LOG("AVMuxerWriteSampleBuffer end");
100 return ret;
101 }
102
AVMuxerStop()103 int32_t AVCodecAdapter::AVMuxerStop()
104 {
105 MEDIA_DEBUG_LOG("AVMuxerStop start");
106 CHECK_RETURN_RET_ELOG(muxer_ == nullptr, AV_ERR_INVALID_VAL, "muxer_ is not created");
107 int32_t ret = muxer_->Stop();
108 CHECK_RETURN_RET_ELOG(ret != AV_ERR_OK, AV_ERR_FAILED, "AVMuxerStop failed, ret: %{public}d", ret);
109 MEDIA_DEBUG_LOG("AVMuxerStop end");
110 return ret;
111 }
112
AVCodecVideoEncoderPrepare()113 int32_t AVCodecAdapter::AVCodecVideoEncoderPrepare()
114 {
115 MEDIA_DEBUG_LOG("AVCodecVideoEncoderPrepare start");
116 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
117 int32_t ret = videoEncoder_->Prepare();
118 CHECK_RETURN_RET_ELOG(
119 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderPrepare failed, ret: %{public}d", ret);
120 MEDIA_DEBUG_LOG("AVCodecVideoEncoderPrepare end");
121 return ret;
122 }
123
AVCodecVideoEncoderStart()124 int32_t AVCodecAdapter::AVCodecVideoEncoderStart()
125 {
126 MEDIA_DEBUG_LOG("AVCodecVideoEncoderStart start");
127 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
128 int32_t ret = videoEncoder_->Start();
129 CHECK_RETURN_RET_ELOG(
130 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderStart failed, ret: %{public}d", ret);
131 MEDIA_DEBUG_LOG("AVCodecVideoEncoderStart end");
132 return ret;
133 }
134
AVCodecVideoEncoderStop()135 int32_t AVCodecAdapter::AVCodecVideoEncoderStop()
136 {
137 MEDIA_DEBUG_LOG("AVCodecVideoEncoderStop start");
138 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
139 int32_t ret = videoEncoder_->Stop();
140 CHECK_RETURN_RET_ELOG(
141 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderStop failed, ret: %{public}d", ret);
142 MEDIA_DEBUG_LOG("AVCodecVideoEncoderStop end");
143 return ret;
144 }
145
AVCodecVideoEncoderRelease()146 int32_t AVCodecAdapter::AVCodecVideoEncoderRelease()
147 {
148 MEDIA_DEBUG_LOG("AVCodecVideoEncoderRelease start");
149 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
150 int32_t ret = videoEncoder_->Release();
151 CHECK_RETURN_RET_ELOG(
152 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderRelease failed, ret: %{public}d", ret);
153 videoEncoder_ = nullptr;
154 MEDIA_DEBUG_LOG("AVCodecVideoEncoderRelease end");
155 return ret;
156 }
157
IsVideoEncoderExisted()158 bool AVCodecAdapter::IsVideoEncoderExisted()
159 {
160 MEDIA_DEBUG_LOG("IsVideoEncoderExisted start");
161 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, false, "videoEncoder_ is not created");
162 return true;
163 }
164
CreateInputSurface()165 sptr<Surface> AVCodecAdapter::CreateInputSurface()
166 {
167 MEDIA_DEBUG_LOG("CreateInputSurface start");
168 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, nullptr, "videoEncoder_ is not created");
169 sptr<Surface> surface = videoEncoder_->CreateInputSurface();
170 CHECK_RETURN_RET_ELOG(surface == nullptr, nullptr, "CreateInputSurface failed");
171 MEDIA_DEBUG_LOG("CreateInputSurface end");
172 return surface;
173 }
174
QueueInputBuffer(uint32_t index)175 int32_t AVCodecAdapter::QueueInputBuffer(uint32_t index)
176 {
177 MEDIA_DEBUG_LOG("QueueInputBuffer start");
178 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
179 int32_t ret = videoEncoder_->QueueInputBuffer(index);
180 CHECK_RETURN_RET_ELOG(ret != AV_ERR_OK, AV_ERR_FAILED, "QueueInputBuffer failed, ret: %{public}d", ret);
181 MEDIA_DEBUG_LOG("QueueInputBuffer end");
182 return ret;
183 }
184
AVCodecVideoEncoderNotifyEos()185 int32_t AVCodecAdapter::AVCodecVideoEncoderNotifyEos()
186 {
187 MEDIA_DEBUG_LOG("AVCodecVideoEncoderNotifyEos start");
188 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
189 int32_t ret = videoEncoder_->NotifyEos();
190 CHECK_RETURN_RET_ELOG(
191 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderNotifyEos failed, ret: %{public}d", ret);
192 MEDIA_DEBUG_LOG("AVCodecVideoEncoderNotifyEos end");
193 return ret;
194 }
195
ReleaseOutputBuffer(uint32_t index)196 int32_t AVCodecAdapter::ReleaseOutputBuffer(uint32_t index)
197 {
198 MEDIA_DEBUG_LOG("ReleaseOutputBuffer start");
199 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
200 int32_t ret = videoEncoder_->ReleaseOutputBuffer(index);
201 CHECK_RETURN_RET_ELOG(ret != AV_ERR_OK, AV_ERR_FAILED, "ReleaseOutputBuffer failed, ret: %{public}d", ret);
202 MEDIA_DEBUG_LOG("ReleaseOutputBuffer end");
203 return ret;
204 }
205
AVCodecVideoEncoderSetParameter(const Format & format)206 int32_t AVCodecAdapter::AVCodecVideoEncoderSetParameter(const Format &format)
207 {
208 MEDIA_DEBUG_LOG("AVCodecVideoEncoderSetParameter start");
209 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
210 int32_t ret = videoEncoder_->SetParameter(format);
211 CHECK_RETURN_RET_ELOG(
212 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderSetParameter failed, ret: %{public}d", ret);
213 MEDIA_DEBUG_LOG("AVCodecVideoEncoderSetParameter end");
214 return ret;
215 }
216
AVCodecVideoEncoderSetCallback(const std::shared_ptr<MediaCodecCallback> & callback)217 int32_t AVCodecAdapter::AVCodecVideoEncoderSetCallback(const std::shared_ptr<MediaCodecCallback> &callback)
218 {
219 MEDIA_DEBUG_LOG("AVCodecVideoEncoderSetCallback start");
220 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
221 CHECK_RETURN_RET_ELOG(callback == nullptr, AV_ERR_INVALID_VAL, "input callback is nullptr!");
222 int32_t ret = videoEncoder_->SetCallback(callback);
223 CHECK_RETURN_RET_ELOG(
224 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderSetCallback failed, ret: %{public}d", ret);
225 MEDIA_DEBUG_LOG("AVCodecVideoEncoderSetCallback end");
226 return ret;
227 }
228
AVCodecVideoEncoderConfigure(const Format & format)229 int32_t AVCodecAdapter::AVCodecVideoEncoderConfigure(const Format &format)
230 {
231 MEDIA_DEBUG_LOG("AVCodecVideoEncoderConfigure start");
232 CHECK_RETURN_RET_ELOG(videoEncoder_ == nullptr, AV_ERR_INVALID_VAL, "videoEncoder_ is not created");
233 int32_t ret = videoEncoder_->Configure(format);
234 CHECK_RETURN_RET_ELOG(
235 ret != AV_ERR_OK, AV_ERR_FAILED, "AVCodecVideoEncoderConfigure failed, ret: %{public}d", ret);
236 MEDIA_DEBUG_LOG("AVCodecVideoEncoderConfigure end");
237 return ret;
238 }
239
CreateAVSource(int32_t fd,int64_t offset,int64_t size)240 void AVCodecAdapter::CreateAVSource(int32_t fd, int64_t offset, int64_t size)
241 {
242 MEDIA_DEBUG_LOG("CreateAVSource start");
243 source_ = AVSourceFactory::CreateWithFD(fd, offset, size);
244 CHECK_RETURN_ELOG(source_ == nullptr,
245 "CreateAVSource failed for fd: %{public}d, offset: %{public}" PRId64 ", size: %{public}" PRId64,
246 fd, offset, size);
247 MEDIA_DEBUG_LOG("CreateAVSource end");
248 }
249
AVSourceGetSourceFormat(Format & format)250 int32_t AVCodecAdapter::AVSourceGetSourceFormat(Format &format)
251 {
252 MEDIA_DEBUG_LOG("AVSourceGetSourceFormat start");
253 CHECK_RETURN_RET_ELOG(source_ == nullptr, AV_ERR_INVALID_VAL, "source_ is not created");
254 int32_t ret = source_->GetSourceFormat(format);
255 CHECK_RETURN_RET_ELOG(
256 ret != AV_ERR_OK, AV_ERR_FAILED, "AVSourceGetSourceFormat failed, ret: %{public}d", ret);
257 MEDIA_DEBUG_LOG("AVSourceGetSourceFormat end");
258 return ret;
259 }
260
AVSourceGetUserMeta(Format & format)261 int32_t AVCodecAdapter::AVSourceGetUserMeta(Format &format)
262 {
263 MEDIA_DEBUG_LOG("AVSourceGetUserMeta start");
264 CHECK_RETURN_RET_ELOG(source_ == nullptr, AV_ERR_INVALID_VAL, "source_ is not created");
265 int32_t ret = source_->GetUserMeta(format);
266 CHECK_RETURN_RET_ELOG(
267 ret != AV_ERR_OK, AV_ERR_FAILED, "AVSourceGetUserMeta failed, ret: %{public}d", ret);
268 MEDIA_DEBUG_LOG("AVSourceGetUserMeta end");
269 return ret;
270 }
271
AVSourceGetTrackFormat(Format & format,uint32_t trackIndex)272 int32_t AVCodecAdapter::AVSourceGetTrackFormat(Format &format, uint32_t trackIndex)
273 {
274 MEDIA_DEBUG_LOG("AVSourceGetTrackFormat start");
275 CHECK_RETURN_RET_ELOG(source_ == nullptr, AV_ERR_INVALID_VAL, "source_ is not created");
276 int32_t ret = source_->GetTrackFormat(format, trackIndex);
277 CHECK_RETURN_RET_ELOG(
278 ret != AV_ERR_OK, AV_ERR_FAILED, "AVSourceGetTrackFormat failed, ret: %{public}d", ret);
279 MEDIA_DEBUG_LOG("AVSourceGetTrackFormat end");
280 return ret;
281 }
282
CreateAVDemuxer(std::shared_ptr<AVSource> source)283 void AVCodecAdapter::CreateAVDemuxer(std::shared_ptr<AVSource> source)
284 {
285 MEDIA_DEBUG_LOG("CreateAVDemuxer start");
286 CHECK_RETURN_ELOG(source == nullptr, "source is nullptr");
287 demuxer_ = AVDemuxerFactory::CreateWithSource(source);
288 CHECK_RETURN_ELOG(demuxer_ == nullptr, "CreateAVDemuxer failed");
289 MEDIA_DEBUG_LOG("CreateAVDemuxer end");
290 }
291
ReadSampleBuffer(uint32_t trackIndex,std::shared_ptr<AVBuffer> sample)292 int32_t AVCodecAdapter::ReadSampleBuffer(uint32_t trackIndex, std::shared_ptr<AVBuffer> sample)
293 {
294 MEDIA_DEBUG_LOG("ReadSampleBuffer start");
295 CHECK_RETURN_RET_ELOG(demuxer_ == nullptr, AV_ERR_INVALID_VAL, "demuxer_ is not created");
296 CHECK_RETURN_RET_ELOG(sample == nullptr, AV_ERR_INVALID_VAL, "input sample is nullptr!");
297 int32_t ret = demuxer_->ReadSampleBuffer(trackIndex, sample);
298 CHECK_RETURN_RET_ELOG(
299 ret != AV_ERR_OK, AV_ERR_FAILED, "ReadSampleBuffer failed, ret: %{public}d", ret);
300 MEDIA_DEBUG_LOG("ReadSampleBuffer end");
301 return ret;
302 }
303
AVDemuxerSeekToTime(int64_t millisecond,SeekMode mode)304 int32_t AVCodecAdapter::AVDemuxerSeekToTime(int64_t millisecond, SeekMode mode)
305 {
306 MEDIA_DEBUG_LOG("AVDemuxerSeekToTime start");
307 CHECK_RETURN_RET_ELOG(demuxer_ == nullptr, AV_ERR_INVALID_VAL, "demuxer_ is not created");
308 int32_t ret = demuxer_->SeekToTime(millisecond, mode);
309 CHECK_RETURN_RET_ELOG(
310 ret != AV_ERR_OK, AV_ERR_FAILED, "AVDemuxerSeekToTime failed, ret: %{public}d", ret);
311 MEDIA_DEBUG_LOG("AVDemuxerSeekToTime end");
312 return ret;
313 }
314
AVDemuxerSelectTrackByID(uint32_t trackIndex)315 int32_t AVCodecAdapter::AVDemuxerSelectTrackByID(uint32_t trackIndex)
316 {
317 MEDIA_DEBUG_LOG("AVDemuxerSelectTrackByID start");
318 CHECK_RETURN_RET_ELOG(demuxer_ == nullptr, AV_ERR_INVALID_VAL, "demuxer_ is not created");
319 int32_t ret = demuxer_->SelectTrackByID(trackIndex);
320 CHECK_RETURN_RET_ELOG(
321 ret != AV_ERR_OK, AV_ERR_FAILED, "AVDemuxerSelectTrackByID failed, ret: %{public}d", ret);
322 MEDIA_DEBUG_LOG("AVDemuxerSelectTrackByID end");
323 return ret;
324 }
325
createAVCodecIntf()326 extern "C" AVCodecIntf *createAVCodecIntf()
327 {
328 return new AVCodecAdapter();
329 }
330 } // namespace CameraStandard
331 } // namespace OHOS