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