1 /*
2 * Copyright (C) 2023 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 <list>
17 #include <mutex>
18 #include <shared_mutex>
19 #include "avcodec_audio_codec.h"
20 #include "avcodec_errors.h"
21 #include "avcodec_log.h"
22 #include "common/native_mfmagic.h"
23 #include "buffer/avsharedmemory.h"
24 #include "native_avcodec_audiocodec.h"
25 #include "native_avcodec_base.h"
26 #include "native_avmagic.h"
27 #include "avcodec_codec_name.h"
28 #include "avcodec_audio_codec_impl.h"
29 #ifdef SUPPORT_DRM
30 #include "native_drm_object.h"
31 #endif
32
33 namespace {
34 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "NativeAudioCodec"};
35 constexpr uint32_t MAX_LENGTH = 255;
36 }
37
38 using namespace OHOS::MediaAVCodec;
39 class NativeAudioCodec;
40
41 struct AudioCodecObject : public OH_AVCodec {
AudioCodecObjectAudioCodecObject42 explicit AudioCodecObject(const std::shared_ptr<AVCodecAudioCodecImpl> &decoder)
43 : OH_AVCodec(AVMagic::AVCODEC_MAGIC_AUDIO_DECODER), audioCodec_(decoder)
44 {
45 }
46 ~AudioCodecObject() = default;
47
48 const std::shared_ptr<AVCodecAudioCodecImpl> audioCodec_;
49 std::list<OHOS::sptr<OH_AVBuffer>> bufferObjList_;
50 std::shared_ptr<NativeAudioCodec> callback_ = nullptr;
51 std::atomic<bool> isFlushing_ = false;
52 std::atomic<bool> isFlushed_ = false;
53 std::atomic<bool> isStop_ = false;
54 std::atomic<bool> isEOS_ = false;
55 std::shared_mutex memoryObjListMutex_;
56 };
57
GetTransData(struct OH_AVCodec * codec,uint32_t index,std::shared_ptr<AVBuffer> buffer)58 OH_AVBuffer *GetTransData(struct OH_AVCodec *codec, uint32_t index, std::shared_ptr<AVBuffer> buffer)
59 {
60 CHECK_AND_RETURN_RET_LOG(codec != nullptr, nullptr, "input codec is nullptr!");
61 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER ||
62 codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_ENCODER, nullptr, "magic error!");
63
64 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
65 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, nullptr, "audioc odec is nullptr!");
66 CHECK_AND_RETURN_RET_LOG(buffer != nullptr, nullptr, "get output buffer is nullptr!");
67
68 std::lock_guard<std::shared_mutex> lock(audioCodecObj->memoryObjListMutex_);
69 for (auto &bufferObj : audioCodecObj->bufferObjList_) {
70 if (bufferObj->IsEqualBuffer(buffer)) {
71 return reinterpret_cast<OH_AVBuffer *>(bufferObj.GetRefPtr());
72 }
73 }
74 OHOS::sptr<OH_AVBuffer> object = new (std::nothrow) OH_AVBuffer(buffer);
75 CHECK_AND_RETURN_RET_LOG(object != nullptr, nullptr, "failed to new OH_AVBuffer");
76 audioCodecObj->bufferObjList_.push_back(object);
77 return reinterpret_cast<OH_AVBuffer *>(object.GetRefPtr());
78 }
79
80 class NativeAudioCodec : public MediaCodecCallback {
81 public:
NativeAudioCodec(OH_AVCodec * codec,struct OH_AVCodecCallback cb,void * userData)82 NativeAudioCodec(OH_AVCodec *codec, struct OH_AVCodecCallback cb, void *userData)
83 : codec_(codec), callback_(cb), userData_(userData)
84 {
85 }
86 virtual ~NativeAudioCodec() = default;
87
OnError(AVCodecErrorType errorType,int32_t errorCode)88 void OnError(AVCodecErrorType errorType, int32_t errorCode) override
89 {
90 std::unique_lock<std::shared_mutex> lock(mutex_);
91 (void)errorType;
92 if (codec_ != nullptr && callback_.onError != nullptr) {
93 int32_t extErr = AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(errorCode));
94 callback_.onError(codec_, extErr, userData_);
95 }
96 }
97
OnOutputFormatChanged(const Format & format)98 void OnOutputFormatChanged(const Format &format) override
99 {
100 std::unique_lock<std::shared_mutex> lock(mutex_);
101 if (codec_ != nullptr && callback_.onStreamChanged != nullptr) {
102 OHOS::sptr<OH_AVFormat> object = new (std::nothrow) OH_AVFormat(format);
103 // The object lifecycle is controlled by the current function stack
104 callback_.onStreamChanged(codec_, reinterpret_cast<OH_AVFormat *>(object.GetRefPtr()), userData_);
105 } else {
106 AVCODEC_LOGE("receive format changed but callback is nullptr");
107 }
108 }
109
OnInputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)110 void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer) override
111 {
112 std::shared_lock<std::shared_mutex> lock(mutex_);
113 if (codec_ != nullptr && callback_.onNeedInputBuffer != nullptr) {
114 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec_);
115 CHECK_AND_RETURN_LOG(audioCodecObj->audioCodec_ != nullptr, "audioCodec_ is nullptr!");
116 if (audioCodecObj->isFlushing_.load() || audioCodecObj->isFlushed_.load() ||
117 audioCodecObj->isStop_.load() || audioCodecObj->isEOS_.load()) {
118 AVCODEC_LOGD("At flush, eos or stop, no buffer available");
119 return;
120 }
121 OH_AVBuffer *data = GetTransData(codec_, index, buffer);
122 callback_.onNeedInputBuffer(codec_, index, data, userData_);
123 }
124 }
125
OnOutputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)126 void OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer) override
127 {
128 std::shared_lock<std::shared_mutex> lock(mutex_);
129 if (codec_ != nullptr && callback_.onNewOutputBuffer != nullptr) {
130 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec_);
131 CHECK_AND_RETURN_LOG(audioCodecObj->audioCodec_ != nullptr, "audioCodec_ is nullptr!");
132 if (audioCodecObj->isFlushing_.load() || audioCodecObj->isFlushed_.load() ||
133 audioCodecObj->isStop_.load()) {
134 AVCODEC_LOGD("At flush or stop, ignore");
135 return;
136 }
137 OH_AVBuffer *data = GetTransData(codec_, index, buffer);
138 callback_.onNewOutputBuffer(codec_, index, data, userData_);
139 }
140 }
141
StopCallback()142 void StopCallback()
143 {
144 std::unique_lock<std::shared_mutex> lock(mutex_);
145 codec_ = nullptr;
146 }
147
148 private:
149 struct OH_AVCodec *codec_;
150 struct OH_AVCodecCallback callback_;
151 void *userData_;
152 std::shared_mutex mutex_;
153 };
154
155 namespace OHOS {
156 namespace MediaAVCodec {
157 #ifdef __cplusplus
158 extern "C" {
159 #endif
160
OH_AudioCodec_CreateByMime(const char * mime,bool isEncoder)161 struct OH_AVCodec *OH_AudioCodec_CreateByMime(const char *mime, bool isEncoder)
162 {
163 CHECK_AND_RETURN_RET_LOG(mime != nullptr, nullptr, "input mime is nullptr!");
164 CHECK_AND_RETURN_RET_LOG(strlen(mime) < MAX_LENGTH, nullptr, "input mime is too long!");
165 std::shared_ptr<AVCodecAudioCodecImpl> audioCodec = std::make_shared<AVCodecAudioCodecImpl>();
166 CHECK_AND_RETURN_RET_LOG(audioCodec != nullptr, nullptr, "failed to AudioCodecFactory::CreateByMime");
167 AVCodecType type = AVCODEC_TYPE_AUDIO_DECODER;
168 if (isEncoder) {
169 type = AVCODEC_TYPE_AUDIO_ENCODER;
170 }
171 int32_t ret = audioCodec->Init(type, true, mime);
172 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, nullptr, "failed to init AVCodecAudioCodecImpl");
173 struct AudioCodecObject *object = new (std::nothrow) AudioCodecObject(audioCodec);
174 CHECK_AND_RETURN_RET_LOG(object != nullptr, nullptr, "failed to new AudioCodecObject");
175
176 return object;
177 }
178
OH_AudioCodec_CreateByName(const char * name)179 struct OH_AVCodec *OH_AudioCodec_CreateByName(const char *name)
180 {
181 CHECK_AND_RETURN_RET_LOG(name != nullptr, nullptr, "input name is nullptr!");
182 CHECK_AND_RETURN_RET_LOG(strlen(name) < MAX_LENGTH, nullptr, "input name is too long!");
183 std::shared_ptr<AVCodecAudioCodecImpl> audioCodec = std::make_shared<AVCodecAudioCodecImpl>();
184 CHECK_AND_RETURN_RET_LOG(audioCodec != nullptr, nullptr, "failed to AudioCodecFactory::CreateByMime");
185 std::string codecMimeName = name;
186 std::string targetName = name;
187 if (targetName.compare(AVCodecCodecName::AUDIO_DECODER_API9_AAC_NAME) == 0) {
188 codecMimeName = AVCodecCodecName::AUDIO_DECODER_AAC_NAME;
189 } else if (targetName.compare(AVCodecCodecName::AUDIO_ENCODER_API9_AAC_NAME) == 0) {
190 codecMimeName = AVCodecCodecName::AUDIO_ENCODER_AAC_NAME;
191 }
192 AVCodecType type = AVCODEC_TYPE_AUDIO_ENCODER;
193 if (codecMimeName.find("Encoder") != codecMimeName.npos) {
194 type = AVCODEC_TYPE_AUDIO_ENCODER;
195 } else {
196 type = AVCODEC_TYPE_AUDIO_DECODER;
197 }
198 int32_t ret = audioCodec->Init(type, false, name);
199 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, nullptr, "failed to init AVCodecAudioCodecImpl");
200 struct AudioCodecObject *object = new(std::nothrow) AudioCodecObject(audioCodec);
201 CHECK_AND_RETURN_RET_LOG(object != nullptr, nullptr, "failed to new AudioCodecObject");
202
203 return object;
204 }
205
OH_AudioCodec_Destroy(struct OH_AVCodec * codec)206 OH_AVErrCode OH_AudioCodec_Destroy(struct OH_AVCodec *codec)
207 {
208 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
209 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
210 AV_ERR_INVALID_VAL, "magic error!");
211
212 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
213 AVCODEC_LOGI("OH_AudioCodec_Destroy enter");
214 if (audioCodecObj != nullptr && audioCodecObj->audioCodec_ != nullptr) {
215 if (audioCodecObj->callback_ != nullptr) {
216 audioCodecObj->callback_->StopCallback();
217 }
218 {
219 std::lock_guard<std::shared_mutex> lock(audioCodecObj->memoryObjListMutex_);
220 audioCodecObj->bufferObjList_.clear();
221 }
222 audioCodecObj->isStop_.store(true);
223 int32_t ret = audioCodecObj->audioCodec_->Release();
224 if (ret != AVCS_ERR_OK) {
225 AVCODEC_LOGE("audioCodec Release failed!");
226 delete codec;
227 return AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret));
228 }
229 } else {
230 AVCODEC_LOGD("audioCodec_ is nullptr!");
231 }
232
233 delete codec;
234 return AV_ERR_OK;
235 }
236
OH_AudioCodec_Configure(struct OH_AVCodec * codec,const OH_AVFormat * format)237 OH_AVErrCode OH_AudioCodec_Configure(struct OH_AVCodec *codec, const OH_AVFormat *format)
238 {
239 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
240 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
241 AV_ERR_INVALID_VAL, "magic error!");
242 CHECK_AND_RETURN_RET_LOG(format != nullptr, AV_ERR_INVALID_VAL, "input format is nullptr!");
243 CHECK_AND_RETURN_RET_LOG(format->magic_ == MFMagic::MFMAGIC_FORMAT, AV_ERR_INVALID_VAL, "magic error!");
244
245 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
246 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec is nullptr!");
247
248 int32_t ret = audioCodecObj->audioCodec_->Configure(format->format_);
249 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
250 "audioCodec Configure failed!");
251
252 return AV_ERR_OK;
253 }
254
OH_AudioCodec_Prepare(struct OH_AVCodec * codec)255 OH_AVErrCode OH_AudioCodec_Prepare(struct OH_AVCodec *codec)
256 {
257 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
258 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
259 AV_ERR_INVALID_VAL, "magic error!");
260
261 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
262 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
263
264 int32_t ret = audioCodecObj->audioCodec_->Prepare();
265 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
266 "audioCodec Prepare failed!");
267 return AV_ERR_OK;
268 }
269
OH_AudioCodec_Start(struct OH_AVCodec * codec)270 OH_AVErrCode OH_AudioCodec_Start(struct OH_AVCodec *codec)
271 {
272 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
273 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
274 AV_ERR_INVALID_VAL, "magic error!");
275
276 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
277 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
278 audioCodecObj->isStop_.store(false);
279 audioCodecObj->isEOS_.store(false);
280 audioCodecObj->isFlushed_.store(false);
281 int32_t ret = audioCodecObj->audioCodec_->Start();
282 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
283 "audioCodec Start failed!");
284
285 return AV_ERR_OK;
286 }
287
OH_AudioCodec_Stop(struct OH_AVCodec * codec)288 OH_AVErrCode OH_AudioCodec_Stop(struct OH_AVCodec *codec)
289 {
290 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
291 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
292 AV_ERR_INVALID_VAL, "magic error!");
293
294 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
295 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
296
297 audioCodecObj->isStop_.store(true);
298 AVCODEC_LOGD("set stop status to true");
299
300 int32_t ret = audioCodecObj->audioCodec_->Stop();
301 if (ret != AVCS_ERR_OK) {
302 audioCodecObj->isStop_.store(false);
303 AVCODEC_LOGE("audioCodec Stop failed!, set stop status to false");
304 return AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret));
305 }
306 std::lock_guard<std::shared_mutex> lock(audioCodecObj->memoryObjListMutex_);
307 audioCodecObj->bufferObjList_.clear();
308
309 return AV_ERR_OK;
310 }
311
OH_AudioCodec_Flush(struct OH_AVCodec * codec)312 OH_AVErrCode OH_AudioCodec_Flush(struct OH_AVCodec *codec)
313 {
314 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
315 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
316 AV_ERR_INVALID_VAL, "magic error!");
317
318 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
319 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
320 audioCodecObj->isFlushing_.store(true);
321 AVCODEC_LOGD("Set flush status to true");
322 int32_t ret = audioCodecObj->audioCodec_->Flush();
323 if (ret != AVCS_ERR_OK) {
324 audioCodecObj->isFlushing_.store(false);
325 audioCodecObj->isFlushed_.store(false);
326 AVCODEC_LOGE("audioCodec Flush failed! Set flush status to false");
327 return AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret));
328 }
329
330 audioCodecObj->isFlushed_.store(true);
331 audioCodecObj->isFlushing_.store(false);
332 AVCODEC_LOGD("set flush status to false");
333 std::lock_guard<std::shared_mutex> lock(audioCodecObj->memoryObjListMutex_);
334 audioCodecObj->bufferObjList_.clear();
335 return AV_ERR_OK;
336 }
337
OH_AudioCodec_Reset(struct OH_AVCodec * codec)338 OH_AVErrCode OH_AudioCodec_Reset(struct OH_AVCodec *codec)
339 {
340 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
341 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
342 AV_ERR_INVALID_VAL, "magic error!");
343
344 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
345 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
346 audioCodecObj->isStop_.store(true);
347 AVCODEC_LOGD("Set stop status to true");
348
349 int32_t ret = audioCodecObj->audioCodec_->Reset();
350 if (ret != AVCS_ERR_OK) {
351 audioCodecObj->isStop_.store(false);
352 AVCODEC_LOGE("audioCodec Reset failed! Set stop status to false");
353 return AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret));
354 }
355
356 std::lock_guard<std::shared_mutex> lock(audioCodecObj->memoryObjListMutex_);
357 audioCodecObj->bufferObjList_.clear();
358 return AV_ERR_OK;
359 }
360
OH_AudioCodec_PushInputBuffer(struct OH_AVCodec * codec,uint32_t index)361 OH_AVErrCode OH_AudioCodec_PushInputBuffer(struct OH_AVCodec *codec, uint32_t index)
362 {
363 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
364 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
365 AV_ERR_INVALID_VAL, "magic error!");
366
367 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
368 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
369
370 int32_t ret = audioCodecObj->audioCodec_->QueueInputBuffer(index);
371 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
372 "audioCodec QueueInputBuffer failed!");
373 return AV_ERR_OK;
374 }
375
OH_AudioCodec_GetOutputDescription(struct OH_AVCodec * codec)376 OH_AVFormat *OH_AudioCodec_GetOutputDescription(struct OH_AVCodec *codec)
377 {
378 CHECK_AND_RETURN_RET_LOG(codec != nullptr, nullptr, "input codec is nullptr!");
379 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER, nullptr, "magic error!");
380
381 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
382 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, nullptr, "audioCodec_ is nullptr!");
383
384 Format format;
385 int32_t ret = audioCodecObj->audioCodec_->GetOutputFormat(format);
386 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, nullptr, "audioCodec GetOutputFormat failed!");
387
388 OH_AVFormat *avFormat = OH_AVFormat_Create();
389 CHECK_AND_RETURN_RET_LOG(avFormat != nullptr, nullptr, "audioCodec OH_AVFormat_Create failed!");
390 avFormat->format_ = format;
391
392 return avFormat;
393 }
394
OH_AudioCodec_FreeOutputBuffer(struct OH_AVCodec * codec,uint32_t index)395 OH_AVErrCode OH_AudioCodec_FreeOutputBuffer(struct OH_AVCodec *codec, uint32_t index)
396 {
397 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
398 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
399 AV_ERR_INVALID_VAL, "magic error!");
400
401 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
402 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
403
404 int32_t ret = audioCodecObj->audioCodec_->ReleaseOutputBuffer(index);
405 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
406 "audioCodec ReleaseOutputBuffer failed!");
407
408 return AV_ERR_OK;
409 }
410
OH_AudioCodec_SetParameter(struct OH_AVCodec * codec,const OH_AVFormat * format)411 OH_AVErrCode OH_AudioCodec_SetParameter(struct OH_AVCodec *codec, const OH_AVFormat *format)
412 {
413 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
414 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
415 AV_ERR_INVALID_VAL, "magic error!");
416 CHECK_AND_RETURN_RET_LOG(format != nullptr, AV_ERR_INVALID_VAL, "input format is nullptr!");
417 CHECK_AND_RETURN_RET_LOG(format->magic_ == MFMagic::MFMAGIC_FORMAT, AV_ERR_INVALID_VAL, "magic error!");
418
419 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
420 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
421
422 int32_t ret = audioCodecObj->audioCodec_->SetParameter(format->format_);
423 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
424 "audioCodec SetParameter failed!");
425
426 return AV_ERR_OK;
427 }
428
OH_AudioCodec_RegisterCallback(OH_AVCodec * codec,OH_AVCodecCallback callback,void * userData)429 OH_AVErrCode OH_AudioCodec_RegisterCallback(OH_AVCodec *codec, OH_AVCodecCallback callback, void *userData)
430 {
431 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
432 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
433 AV_ERR_INVALID_VAL, "magic error!");
434 CHECK_AND_RETURN_RET_LOG(callback.onError != nullptr,
435 AV_ERR_INVALID_VAL, "Callback onError is nullptr");
436 CHECK_AND_RETURN_RET_LOG(callback.onNeedInputBuffer != nullptr,
437 AV_ERR_INVALID_VAL, "Callback onNeedInputBuffer is nullptr");
438 CHECK_AND_RETURN_RET_LOG(callback.onNewOutputBuffer != nullptr,
439 AV_ERR_INVALID_VAL, "Callback onNewOutputBuffer is nullptr");
440 CHECK_AND_RETURN_RET_LOG(callback.onStreamChanged != nullptr,
441 AV_ERR_INVALID_VAL, "Callback onStreamChanged is nullptr");
442
443 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
444 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
445
446 audioCodecObj->callback_ = std::make_shared<NativeAudioCodec>(codec, callback, userData);
447
448 int32_t ret = audioCodecObj->audioCodec_->SetCallback(audioCodecObj->callback_);
449 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
450 "audioCodec SetCallback failed!");
451
452 return AV_ERR_OK;
453 }
454
OH_AudioCodec_IsValid(OH_AVCodec * codec,bool * isValid)455 OH_AVErrCode OH_AudioCodec_IsValid(OH_AVCodec *codec, bool *isValid)
456 {
457 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "Input codec is nullptr!");
458 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER, AV_ERR_INVALID_VAL, "Magic error!");
459 CHECK_AND_RETURN_RET_LOG(isValid != nullptr, AV_ERR_INVALID_VAL, "Input isValid is nullptr!");
460 *isValid = true;
461 return AV_ERR_OK;
462 }
463
464 #ifdef SUPPORT_DRM
OH_AudioCodec_SetDecryptionConfig(OH_AVCodec * codec,MediaKeySession * mediaKeySession,bool secureAudio)465 OH_AVErrCode OH_AudioCodec_SetDecryptionConfig(OH_AVCodec *codec, MediaKeySession *mediaKeySession,
466 bool secureAudio)
467 {
468 AVCODEC_LOGI("OH_AudioCodec_SetDecryptionConfig");
469 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
470 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
471 AV_ERR_INVALID_VAL, "magic error!");
472
473 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
474 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
475
476 DrmStandard::MediaKeySessionObject *sessionObject =
477 reinterpret_cast<DrmStandard::MediaKeySessionObject *>(mediaKeySession);
478 CHECK_AND_RETURN_RET_LOG(sessionObject != nullptr, AV_ERR_INVALID_VAL, "sessionObject is nullptr!");
479 AVCODEC_LOGD("DRM sessionObject impl :0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(sessionObject));
480
481 CHECK_AND_RETURN_RET_LOG(sessionObject->sessionImpl_ != nullptr, AV_ERR_INVALID_VAL,
482 "sessionObject->impl is nullptr!");
483 AVCODEC_LOGD("DRM impl :0x%{public}06" PRIXPTR " Instances create",
484 FAKE_POINTER(sessionObject->sessionImpl_.GetRefPtr()));
485 CHECK_AND_RETURN_RET_LOG(sessionObject->sessionImpl_ ->GetMediaKeySessionServiceProxy() != nullptr,
486 AV_ERR_INVALID_VAL, "MediaKeySessionServiceProxy is nullptr!");
487
488 int32_t ret = audioCodecObj->audioCodec_->SetAudioDecryptionConfig(
489 sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy(), secureAudio);
490 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret)),
491 "audioCodec SetAudioDecryptionConfig failed!");
492
493 return AV_ERR_OK;
494 }
495 #else
OH_AudioCodec_SetDecryptionConfig(OH_AVCodec * codec,MediaKeySession * mediaKeySession,bool secureAudio)496 OH_AVErrCode OH_AudioCodec_SetDecryptionConfig(OH_AVCodec *codec, MediaKeySession *mediaKeySession,
497 bool secureAudio)
498 {
499 AVCODEC_LOGI("OH_AudioCodec_SetDecryptionConfig");
500 (void)codec;
501 (void)mediaKeySession;
502 (void)secureAudio;
503 return AV_ERR_OK;
504 }
505 #endif
506
OH_AudioCodec_QueryInputBuffer(OH_AVCodec * codec,uint32_t * index,int64_t timeoutUs)507 OH_AVErrCode OH_AudioCodec_QueryInputBuffer(OH_AVCodec *codec, uint32_t *index, int64_t timeoutUs)
508 {
509 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
510 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
511 AV_ERR_INVALID_VAL, "magic error!");
512 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
513 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
514 int32_t ret = audioCodecObj->audioCodec_->QueryInputBuffer(index, timeoutUs);
515 return AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret));
516 }
517
OH_AudioCodec_GetInputBuffer(OH_AVCodec * codec,uint32_t index)518 OH_AVBuffer *OH_AudioCodec_GetInputBuffer(OH_AVCodec *codec, uint32_t index)
519 {
520 CHECK_AND_RETURN_RET_LOG(codec != nullptr, nullptr, "input codec is nullptr!");
521 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER, nullptr, "magic error!");
522 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
523 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, nullptr, "audioCodec_ is nullptr!");
524 if (audioCodecObj->isFlushing_.load() || audioCodecObj->isFlushed_.load() ||
525 audioCodecObj->isStop_.load()) {
526 AVCODEC_LOGD("At flush or stop, ignore");
527 return nullptr;
528 }
529 std::shared_ptr<AVBuffer> buffer = audioCodecObj->audioCodec_->GetInputBuffer(index);
530 if (buffer == nullptr) {
531 return nullptr;
532 }
533 return GetTransData(codec, index, buffer);
534 }
535
OH_AudioCodec_QueryOutputBuffer(OH_AVCodec * codec,uint32_t * index,int64_t timeoutUs)536 OH_AVErrCode OH_AudioCodec_QueryOutputBuffer(OH_AVCodec *codec, uint32_t *index, int64_t timeoutUs)
537 {
538 CHECK_AND_RETURN_RET_LOG(codec != nullptr, AV_ERR_INVALID_VAL, "input codec is nullptr!");
539 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER,
540 AV_ERR_INVALID_VAL, "magic error!");
541 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
542 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, AV_ERR_INVALID_VAL, "audioCodec_ is nullptr!");
543 int32_t ret = audioCodecObj->audioCodec_->QueryOutputBuffer(index, timeoutUs);
544 return AVCSErrorToOHAVErrCode(static_cast<AVCodecServiceErrCode>(ret));
545 }
546
OH_AudioCodec_GetOutputBuffer(OH_AVCodec * codec,uint32_t index)547 OH_AVBuffer *OH_AudioCodec_GetOutputBuffer(OH_AVCodec *codec, uint32_t index)
548 {
549 CHECK_AND_RETURN_RET_LOG(codec != nullptr, nullptr, "input codec is nullptr!");
550 CHECK_AND_RETURN_RET_LOG(codec->magic_ == AVMagic::AVCODEC_MAGIC_AUDIO_DECODER, nullptr, "magic error!");
551 struct AudioCodecObject *audioCodecObj = reinterpret_cast<AudioCodecObject *>(codec);
552 CHECK_AND_RETURN_RET_LOG(audioCodecObj->audioCodec_ != nullptr, nullptr, "audioCodec_ is nullptr!");
553 if (audioCodecObj->isFlushing_.load() || audioCodecObj->isFlushed_.load() ||
554 audioCodecObj->isStop_.load()) {
555 AVCODEC_LOGD("At flush or stop, ignore");
556 return nullptr;
557 }
558 std::shared_ptr<AVBuffer> buffer = audioCodecObj->audioCodec_->GetOutputBuffer(index);
559 if (buffer == nullptr) {
560 return nullptr;
561 }
562 return GetTransData(codec, index, buffer);
563 }
564
565 #ifdef __cplusplus
566 };
567 #endif
568 } // namespace MediaAVCodec
569 } // namespace OHOS