From 7b376258a84353babb40db096b6828de12a15651 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:26:39 +0000 Subject: [PATCH 01/17] add services/services/codec/server/audio_codec_server.cpp. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- .../codec/server/audio_codec_server.cpp | 706 ++++++++++++++++++ 1 file changed, 706 insertions(+) create mode 100644 services/services/codec/server/audio_codec_server.cpp diff --git a/services/services/codec/server/audio_codec_server.cpp b/services/services/codec/server/audio_codec_server.cpp new file mode 100644 index 000000000..293ffc5df --- /dev/null +++ b/services/services/codec/server/audio_codec_server.cpp @@ -0,0 +1,706 @@ +/* + * Copyright (C) 2023-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_codec_server.h" +#include +#include +#include +#include +#include +#include +#include "avcodec_codec_name.h" +#include "avcodec_errors.h" +#include "avcodec_log.h" +#include "buffer/avbuffer.h" +#include "codec_ability_singleton.h" +#include "codec_factory.h" +#include "media_description.h" +#include "meta/meta_key.h" + +namespace { +constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_FRAMEWORK, "AudioCodecServer"}; + +const std::map CODEC_STATE_MAP = { + {OHOS::MediaAVCodec::CodecServer::UNINITIALIZED, "uninitialized"}, + {OHOS::MediaAVCodec::CodecServer::INITIALIZED, "initialized"}, + {OHOS::MediaAVCodec::CodecServer::CONFIGURED, "configured"}, + {OHOS::MediaAVCodec::CodecServer::RUNNING, "running"}, + {OHOS::MediaAVCodec::CodecServer::FLUSHED, "flushed"}, + {OHOS::MediaAVCodec::CodecServer::END_OF_STREAM, "EOS"}, + {OHOS::MediaAVCodec::CodecServer::ERROR, "error"}, +}; + +int32_t GetAudioCodecName(const OHOS::MediaAVCodec::AVCodecType type, std::string &name) +{ + using namespace OHOS::MediaAVCodec; + if (name.compare(AVCodecCodecName::AUDIO_DECODER_API9_AAC_NAME) == 0) { + name = AVCodecCodecName::AUDIO_DECODER_AAC_NAME; + } else if (name.compare(AVCodecCodecName::AUDIO_ENCODER_API9_AAC_NAME) == 0) { + name = AVCodecCodecName::AUDIO_ENCODER_AAC_NAME; + } + if (name.find("Audio") != name.npos) { + if ((name.find("Decoder") != name.npos && type != AVCODEC_TYPE_AUDIO_DECODER) || + (name.find("Encoder") != name.npos && type != AVCODEC_TYPE_AUDIO_ENCODER)) { + AVCODEC_LOGE("AudioCodec name:%{public}s invalid", name.c_str()); + return AVCS_ERR_INVALID_OPERATION; + } + } + return AVCS_ERR_OK; +} + +} // namespace + +namespace OHOS { +namespace MediaAVCodec { +using namespace Media; +std::shared_ptr AudioCodecServer::Create(int32_t instanceId) +{ + std::shared_ptr server = std::make_shared(); + + int32_t ret = server->InitServer(instanceId); + CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, nullptr, "Server init failed, ret: %{public}d!", ret); + return server; +} + +AudioCodecServer::AudioCodecServer() +{ + AVCODEC_LOGD_WITH_TAG("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); +} + +AudioCodecServer::~AudioCodecServer() +{ + codecBase_ = nullptr; + avBufCallback_ = nullptr; + (void)mallopt(M_FLUSH_THREAD_CACHE, 0); + + AVCODEC_LOGD_WITH_TAG("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this)); +} + +int32_t AudioCodecServer::InitServer(int32_t instanceId) +{ + return AVCS_ERR_OK; +} + +int32_t AudioCodecServer::Init(AVCodecType type, bool isMimeType, const std::string &name, + Meta &callerInfo, API_VERSION apiVersion) +{ + std::lock_guard lock(mutex_); + (void)mallopt(M_SET_THREAD_CACHE, M_THREAD_CACHE_DISABLE); + (void)mallopt(M_DELAYED_FREE, M_DELAYED_FREE_DISABLE); + codecType_ = type; + codecName_ = name; + codecMime_ = isMimeType ? name : CodecAbilitySingleton::GetInstance().GetMimeByCodecName(name); + + int32_t ret = isMimeType ? InitByMime(callerInfo, apiVersion) : InitByName(callerInfo, apiVersion); + + CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, + "Init failed. isMimeType:(%{public}d), name:(%{public}s), error:(%{public}d)", + isMimeType, name.c_str(), ret); + shareBufCallback_ = std::make_shared(shared_from_this()); + ret = codecBase_->SetCallback(shareBufCallback_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, "SetCallback failed"); + + avBufCallback_ = std::make_shared(shared_from_this()); + ret = codecBase_->SetCallback(avBufCallback_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, "SetCallback failed"); + AVCODEC_LOGI_WITH_TAG("Create codec %{public}s by %{public}s success", codecName_.c_str(), + (isMimeType ? "mime" : "name")); + StatusChanged(INITIALIZED); + return AVCS_ERR_OK; +} + +int32_t AudioCodecServer::SetLowPowerPlayerMode(bool isLpp) +{ + return 0; +} + +int32_t AudioCodecServer::InitByName(Meta &callerInfo, API_VERSION apiVersion) +{ + int32_t ret = GetAudioCodecName(codecType_, codecName_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, "CodecName get failed"); + + codecBase_ = CodecFactory::Instance().CreateCodecByName(codecName_, apiVersion); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr"); + return codecBase_->Init(callerInfo); +} + + + + + + + + +int32_t AudioCodecServer::InitByMime(Meta &callerInfo, API_VERSION apiVersion) +{ + int32_t ret = AVCS_ERR_NO_MEMORY; + bool isEncoder = (codecType_ == AVCODEC_TYPE_AUDIO_ENCODER); + std::vector nameArray = CodecFactory::Instance().GetCodecNameArrayByMime(codecName_, isEncoder); + std::vector::iterator iter; + for (iter = nameArray.begin(); iter != nameArray.end(); ++iter) { + ret = AVCS_ERR_NO_MEMORY; + codecBase_ = CodecFactory::Instance().CreateCodecByName(*iter, apiVersion); + CHECK_AND_CONTINUE_LOG_WITH_TAG(codecBase_ != nullptr, "Skip creation failure. name:(%{public}s)", + iter->c_str()); + ret = codecBase_->Init(callerInfo); + CHECK_AND_CONTINUE_LOG_WITH_TAG(ret == AVCS_ERR_OK, "Skip initialization failure. name:(%{public}s)", + iter->c_str()); + codecName_ = *iter; + break; + } + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr"); + return iter == nameArray.end() ? ret : AVCS_ERR_OK; +} + +int32_t AudioCodecServer::Configure(const Format &format) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + int32_t paramCheckRet = AVCS_ERR_OK; + int32_t ret = codecBase_->Configure(format); + if (ret != AVCS_ERR_OK) { + StatusChanged(ERROR); + return ret; + } + StatusChanged(CONFIGURED); + return paramCheckRet; +} + + + +int32_t AudioCodecServer::SetCustomBuffer(std::shared_ptr buffer) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == CONFIGURED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + return codecBase_->SetCustomBuffer(buffer); +} + +int32_t AudioCodecServer::Start() +{ + SetFreeStatus(false); + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == FLUSHED || status_ == CONFIGURED, AVCS_ERR_INVALID_STATE, + "In invalid state, %{public}s", GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + int32_t ret = 0; + + ret = codecBase_->Start(); + if (ret != AVCS_ERR_OK) { + StatusChanged(ERROR); + } else { + StatusChanged(RUNNING); + } + return ret; +} + +int32_t AudioCodecServer::Stop() +{ + SetFreeStatus(true); + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOGW_WITH_TAG(status_ != CONFIGURED, AVCS_ERR_OK, "Already in %{public}s state", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING || status_ == END_OF_STREAM || status_ == FLUSHED, + AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + int32_t retCodec = codecBase_->Stop(); + StatusChanged(CONFIGURED); + return AVCS_ERR_OK; +} + +int32_t AudioCodecServer::Flush() +{ + SetFreeStatus(true); + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOGW_WITH_TAG(status_ != FLUSHED, AVCS_ERR_OK, "Already in %{public}s state", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE, + "In invalid state, %{public}s", GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + codecBase_->Flush(); + StatusChanged(FLUSHED); + return AVCS_ERR_OK; +} + +int32_t AudioCodecServer::NotifyEos() +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + int32_t ret = codecBase_->NotifyEos(); + if (ret == AVCS_ERR_OK) { + CodecStatus newStatus = END_OF_STREAM; + StatusChanged(newStatus); + } + return ret; +} + +int32_t AudioCodecServer::Reset() +{ + SetFreeStatus(true); + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + int32_t ret = codecBase_->Reset(); + CodecStatus newStatus = (ret == AVCS_ERR_OK ? INITIALIZED : ERROR); + StatusChanged(newStatus); + if (ret != AVCS_ERR_OK) { + StatusChanged(ERROR); + } + lastErrMsg_.clear(); + + return ret; +} + +int32_t AudioCodecServer::Release() +{ + SetFreeStatus(true); + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + int32_t ret = codecBase_->Release(); + + codecBase_ = nullptr; + avBufCallback_ = nullptr; + return ret; +} + +int32_t AudioCodecServer::GetChannelId(int32_t &channelId) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + int32_t ret = codecBase_->GetChannelId(channelId); + return ret; +} + +int32_t AudioCodecServer::QueueInputBuffer(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag) +{ + std::shared_lock freeLock(freeMutex_); + if (isFree_) { + AVCODEC_LOGE_WITH_TAG("In invalid state, free out"); + return AVCS_ERR_INVALID_STATE; + } + + int32_t ret = AVCS_ERR_OK; + if (flag & AVCODEC_BUFFER_FLAG_EOS) { + std::lock_guard lock(mutex_); + ret = QueueInputBufferIn(index, info, flag); + if (ret == AVCS_ERR_OK) { + CodecStatus newStatus = END_OF_STREAM; + StatusChanged(newStatus); + } + } else { + std::shared_lock lock(mutex_); + ret = QueueInputBufferIn(index, info, flag); + } + return ret; +} + +int32_t AudioCodecServer::QueueInputBufferIn(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag) +{ + int32_t ret = AVCS_ERR_OK; + CHECK_AND_RETURN_RET_LOG_WITH_TAG( + status_ == RUNNING || ((isSetParameterCb_ || inputParamTask_ != nullptr) && status_ == END_OF_STREAM), + AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + if (codecCb_ != nullptr) { + ret = codecBase_->QueueInputBuffer(index, info, flag); + } + return ret; +} + +int32_t AudioCodecServer::QueueInputBuffer(uint32_t index) +{ + (void)index; + return AVCS_ERR_UNSUPPORT; +} + +int32_t AudioCodecServer::QueueInputParameter(uint32_t index) +{ + (void)index; + return AVCS_ERR_UNSUPPORT; +} + +int32_t AudioCodecServer::GetOutputFormat(Format &format) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + return codecBase_->GetOutputFormat(format); +} + +int32_t AudioCodecServer::ReleaseOutputBuffer(uint32_t index, bool render) +{ + std::shared_lock freeLock(freeMutex_); + if (isFree_) { + AVCODEC_LOGE_WITH_TAG("In invalid state, free out"); + return AVCS_ERR_INVALID_STATE; + } + std::shared_lock lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE, + "In invalid state, %{public}s", GetStatusDescription(status_).data()); + + return ReleaseOutputBufferOfCodec(index, render); +} + +int32_t AudioCodecServer::ReleaseOutputBufferOfCodec(uint32_t index, bool render) +{ + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + int32_t ret; + if (render) { + ret = codecBase_->RenderOutputBuffer(index); + } else { + ret = codecBase_->ReleaseOutputBuffer(index); + } + return ret; +} + +int32_t AudioCodecServer::RenderOutputBufferAtTime(uint32_t index, [[maybe_unused]]int64_t renderTimestampNs) +{ + return ReleaseOutputBuffer(index, true); +} + +int32_t AudioCodecServer::SetParameter(const Format &format) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE, + "In invalid state, %{public}s", GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + return codecBase_->SetParameter(format); +} + +int32_t AudioCodecServer::SetCallback(const std::shared_ptr &callback) +{ + std::lock_guard cbLock(cbMutex_); + codecCb_ = callback; + return AVCS_ERR_OK; +} + +int32_t AudioCodecServer::SetCallback(const std::shared_ptr &callback) +{ + std::lock_guard cbLock(cbMutex_); + videoCb_ = callback; + return AVCS_ERR_OK; +} + +int32_t AudioCodecServer::SetCodecCallback(const std::shared_ptr &codecCallback) +{ + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + avBufCallback_ = codecCallback; + return codecBase_->SetCallback(codecCallback); +} + +int32_t AudioCodecServer::SetCallback(const std::shared_ptr &callback) +{ + (void)callback; + return AVCS_ERR_UNSUPPORT; +} + +int32_t AudioCodecServer::SetCallback(const std::shared_ptr &callback) +{ + (void)callback; + return AVCS_ERR_UNSUPPORT; +} + +int32_t AudioCodecServer::GetInputFormat(Format &format) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG( + status_ == CONFIGURED || status_ == RUNNING || status_ == FLUSHED || status_ == END_OF_STREAM, + AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + return codecBase_->GetInputFormat(format); +} + +int32_t AudioCodecServer::ChangePlugin(const std::string &mime, bool isEncoder, const std::shared_ptr &meta) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + return codecBase_->ChangePlugin(mime, isEncoder, meta); +} + +void AudioCodecServer::SetDumpInfo(bool isDump, uint64_t instanceId) +{ + CHECK_AND_RETURN_LOG(codecBase_ != nullptr, "Codecbase is nullptr"); + return codecBase_->SetDumpInfo(isDump, instanceId); +} + +inline const std::string &AudioCodecServer::GetStatusDescription(CodecStatus status) +{ + if (status < UNINITIALIZED || status >= ERROR) { + return CODEC_STATE_MAP.at(ERROR); + } + return CODEC_STATE_MAP.at(status); +} + +inline void AudioCodecServer::StatusChanged(CodecStatus newStatus) +{ + if (status_ == newStatus) { + return; + } + if (status_ == ERROR && videoCb_ != nullptr && + (codecType_ == AVCODEC_TYPE_VIDEO_DECODER)) { + videoCb_->OnError(AVCODEC_ERROR_FRAMEAORK_FAILED, AVCS_ERR_INVALID_STATE); + } + AVCODEC_LOGI_WITH_TAG("Status %{public}s -> %{public}s", GetStatusDescription(status_).data(), + GetStatusDescription(newStatus).data()); + status_ = newStatus; +} + +void AudioCodecServer::OnError(int32_t errorType, int32_t errorCode) +{ + std::lock_guard lock(cbMutex_); + lastErrMsg_ = AVCSErrorToString(static_cast(errorCode)); + AVCODEC_LOGW_WITH_TAG("%{public}s", lastErrMsg_.c_str()); + if (codecCb_ != nullptr) { + codecCb_->OnError(static_cast(errorType), errorCode); + } +} + +void AudioCodecServer::OnOutputFormatChanged(const Format &format) +{ + std::lock_guard lock(cbMutex_); + if (videoCb_ != nullptr) { + videoCb_->OnOutputFormatChanged(format); + } + if (codecCb_ != nullptr) { + codecCb_->OnOutputFormatChanged(format); + } +} + +void AudioCodecServer::OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer) +{ + std::shared_lock lock(cbMutex_); + if (codecCb_ == nullptr) { + return; + } + codecCb_->OnInputBufferAvailable(index, buffer); +} + +void AudioCodecServer::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag, + std::shared_ptr buffer) +{ + std::shared_lock lock(cbMutex_); + if (codecCb_ == nullptr) { + return; + } + codecCb_->OnOutputBufferAvailable(index, info, flag, buffer); +} + +void AudioCodecServer::OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer) +{ + std::shared_lock lock(cbMutex_); +} + +void AudioCodecServer::OnOutputBufferAvailable(uint32_t index, std::shared_ptr buffer) +{ + CHECK_AND_RETURN_LOG_WITH_TAG(buffer != nullptr, "buffer is nullptr!"); + + std::shared_lock lock(cbMutex_); + CHECK_AND_RETURN_LOG_WITH_TAG(videoCb_ != nullptr, "videoCb_ is nullptr!"); + videoCb_->OnOutputBufferAvailable(index, buffer); +} + +CodecBaseCallback::CodecBaseCallback(const std::shared_ptr &codec) : codec_(codec) +{ + AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); +} + +CodecBaseCallback::~CodecBaseCallback() +{ + codec_ = nullptr; + AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this)); +} + +void CodecBaseCallback::OnError(AVCodecErrorType errorType, int32_t errorCode) +{ + if (codec_ != nullptr) { + codec_->OnError(errorType, errorCode); + } +} + +void CodecBaseCallback::OnOutputFormatChanged(const Format &format) +{ + if (codec_ != nullptr) { + codec_->OnOutputFormatChanged(format); + } else { + AVCODEC_LOGI("CodecBaseCallback receive output format changed but codec is nullptr"); + } +} + +void CodecBaseCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer) +{ + if (codec_ != nullptr) { + codec_->OnInputBufferAvailable(index, buffer); + } +} + +void CodecBaseCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag, + std::shared_ptr buffer) +{ + if (codec_ != nullptr) { + codec_->OnOutputBufferAvailable(index, info, flag, buffer); + } +} + +VCodecBaseCallback::VCodecBaseCallback(const std::shared_ptr &codec) : codec_(codec) +{ + AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); +} + +VCodecBaseCallback::~VCodecBaseCallback() +{ + codec_ = nullptr; + AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this)); +} + +void VCodecBaseCallback::OnError(AVCodecErrorType errorType, int32_t errorCode) +{ + if (codec_ != nullptr) { + codec_->OnError(errorType, errorCode); + } +} + +void VCodecBaseCallback::OnOutputFormatChanged(const Format &format) +{ + if (codec_ != nullptr) { + codec_->OnOutputFormatChanged(format); + } else { + AVCODEC_LOGE("receive output format changed, but codec is nullptr"); + } +} + +void VCodecBaseCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer) +{ + if (codec_ != nullptr) { + codec_->OnInputBufferAvailable(index, buffer); + } +} + +void VCodecBaseCallback::OnOutputBufferAvailable(uint32_t index, std::shared_ptr buffer) +{ + if (codec_ != nullptr) { + codec_->OnOutputBufferAvailable(index, buffer); + } +} + +int32_t AudioCodecServer::Configure(const std::shared_ptr &meta) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(meta != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + + int32_t ret = codecBase_->Configure(meta); + + CodecStatus newStatus = (ret == AVCS_ERR_OK ? CONFIGURED : ERROR); + StatusChanged(newStatus); + return ret; +} + +int32_t AudioCodecServer::SetParameter(const std::shared_ptr ¶meter) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(parameter != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE, + "In invalid state, %{public}s", GetStatusDescription(status_).data()); + return codecBase_->SetParameter(parameter); +} + +int32_t AudioCodecServer::GetOutputFormat(std::shared_ptr ¶meter) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "codecBase is nullptr"); + return codecBase_->GetOutputFormat(parameter); +} + +int32_t AudioCodecServer::SetOutputBufferQueue(const sptr &bufferQueueProducer) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(bufferQueueProducer != nullptr, AVCS_ERR_NO_MEMORY, "bufferQueueProducer is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "codecBase_ is nullptr"); + return codecBase_->SetOutputBufferQueue(bufferQueueProducer); +} +int32_t AudioCodecServer::Prepare() +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "codecBase_ is nullptr"); + return codecBase_->Prepare(); +} +sptr AudioCodecServer::GetInputBufferQueue() +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, nullptr, "codecBase_ is nullptr"); + return codecBase_->GetInputBufferQueue(); +} + +sptr AudioCodecServer::GetInputBufferQueueConsumer() +{ + std::lock_guard lock(mutex_); + return codecBase_ != nullptr ? codecBase_->GetInputBufferQueueConsumer() : nullptr; +} + +sptr AudioCodecServer::GetOutputBufferQueueProducer() +{ + std::lock_guard lock(mutex_); + return codecBase_ != nullptr ? codecBase_->GetOutputBufferQueueProducer() : nullptr; +} + +void AudioCodecServer::ProcessInputBufferInner(bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_LOG(codecBase_ != nullptr, "ProcessInputBufferInner codecBase is nullptr"); + return codecBase_->ProcessInputBufferInner(isTriggeredByOutPort, isFlushed, bufferStatus); +} + +void AudioCodecServer::ProcessInputBuffer() +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_LOG(codecBase_ != nullptr, "codecBase_ is nullptr"); + return codecBase_->ProcessInputBuffer(); +} + +bool AudioCodecServer::CheckRunning() +{ + if (status_ == CodecServer::RUNNING) { + return true; + } + return false; +} + +void AudioCodecServer::SetFreeStatus(bool isFree) +{ + std::lock_guard lock(freeMutex_); + isFree_ = isFree; +} + +} // namespace MediaAVCodec +} // namespace OHOS -- Gitee From 4c8cc479fdea00f468b697c405bb501230f36ccb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:27:48 +0000 Subject: [PATCH 02/17] add services/services/codec/server/audio_codec_server.h. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- .../codec/server/audio_codec_server.h | 164 ++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 services/services/codec/server/audio_codec_server.h diff --git a/services/services/codec/server/audio_codec_server.h b/services/services/codec/server/audio_codec_server.h new file mode 100644 index 000000000..3157a925d --- /dev/null +++ b/services/services/codec/server/audio_codec_server.h @@ -0,0 +1,164 @@ +/* + * Copyright (C) 2023-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_CODEC_SERVER_H +#define AUDIO_CODEC_SERVER_H + +#include +#include +#include +#include "codecbase.h" +#include "nocopyable.h" +#include "task_thread.h" +#include "meta/meta.h" +#include "avcodec_info.h" + +namespace OHOS { +namespace MediaAVCodec { +using namespace Media; +class AudioCodecServer : public std::enable_shared_from_this, + public NoCopyable { +public: + static std::shared_ptr Create(); + CodecServer(); + virtual ~CodecServer(); + + enum CodecStatus { + UNINITIALIZED = 0, + INITIALIZED, + CONFIGURED, + RUNNING, + FLUSHED, + END_OF_STREAM, + ERROR, + }; + + int32_t Init(AVCodecType type, bool isMimeType, const std::string &name, + Meta &callerInfo, API_VERSION apiVersion = API_VERSION::API_VERSION_10); + int32_t Configure(const Format &format); + int32_t Start(); + int32_t Stop(); + int32_t Flush(); + int32_t Reset(); + int32_t Release(); + int32_t GetChannelId(int32_t &channelId); + int32_t NotifyEos(); + int32_t SetLowPowerPlayerMode(bool isLpp); + int32_t QueueInputBuffer(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag); + int32_t QueueInputBuffer(uint32_t index); + int32_t QueueInputParameter(uint32_t index); + int32_t GetOutputFormat(Format &format); + int32_t ReleaseOutputBuffer(uint32_t index, bool render); + int32_t RenderOutputBufferAtTime(uint32_t index, int64_t renderTimestampNs); + int32_t SetParameter(const Format &format); + int32_t SetCallback(const std::shared_ptr &callback); + int32_t SetCallback(const std::shared_ptr &callback); + int32_t SetCallback(const std::shared_ptr &callback); + int32_t SetCallback(const std::shared_ptr &callback); + int32_t GetInputFormat(Format &format); + int32_t ChangePlugin(const std::string &mime, bool isEncoder, const std::shared_ptr &meta); + int32_t SetCodecCallback(const std::shared_ptr &codecCallback); + void SetDumpInfo(bool isDump, uint64_t instanceId); + + int32_t SetCustomBuffer(std::shared_ptr buffer); + std::shared_ptr GetCallerInfo(); + + void OnError(int32_t errorType, int32_t errorCode); + void OnOutputFormatChanged(const Format &format); + void OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer); + void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag, + std::shared_ptr buffer); + + void OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer); + void OnOutputBufferAvailable(uint32_t index, std::shared_ptr buffer); + + int32_t Configure(const std::shared_ptr &meta); + int32_t SetParameter(const std::shared_ptr ¶meter); + int32_t GetOutputFormat(std::shared_ptr ¶meter); + + int32_t SetOutputBufferQueue(const sptr &bufferQueueProducer); + int32_t Prepare(); + sptr GetInputBufferQueue(); + sptr GetInputBufferQueueConsumer(); + sptr GetOutputBufferQueueProducer(); + void ProcessInputBufferInner(bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus); + void ProcessInputBuffer(); + bool CheckRunning(); + +#ifdef SUPPORT_DRM + int32_t SetAudioDecryptionConfig(const sptr &keySession,nconst bool svpFlag); +#endif + +private: + int32_t InitByName(Meta &callerInfo, API_VERSION apiVersion); + int32_t InitByMime(Meta &callerInfo, API_VERSION apiVersion); + int32_t InitServer(int32_t instanceId = INVALID_INSTANCE_ID); + void StartInputParamTask(); + const std::string &GetStatusDescription(OHOS::MediaAVCodec::CodecServer::CodecStatus status); + void StatusChanged(CodecStatus newStatus); + void SetFreeStatus(bool isFree); + int32_t QueueInputBufferIn(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag); + int32_t ReleaseOutputBufferOfCodec(uint32_t index, bool render); + + CodecStatus status_ = UNINITIALIZED; + + std::shared_ptr codecBase_; + std::shared_ptr codecCb_; + std::shared_ptr videoCb_; + std::shared_mutex mutex_; + std::shared_mutex cbMutex_; + std::string lastErrMsg_; + std::string codecMime_; + std::string codecName_; + AVCodecType codecType_ = AVCODEC_TYPE_NONE; + + std::shared_mutex freeMutex_; + bool isFree_ = false; + std::shared_ptr inputParamTask_ = nullptr; + std::shared_ptr shareBufCallback_ = nullptr; + std::shared_ptr avBufCallback_ = nullptr; +}; + +class CodecBaseCallback : public AVCodecCallback, public NoCopyable { +public: + explicit CodecBaseCallback(const std::shared_ptr &codec); + virtual ~CodecBaseCallback(); + + void OnError(AVCodecErrorType errorType, int32_t errorCode); + void OnOutputFormatChanged(const Format &format); + void OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer); + void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag, + std::shared_ptr buffer); + +private: + std::shared_ptr codec_ = nullptr; +}; + +class VCodecBaseCallback : public MediaCodecCallback, public NoCopyable { +public: + explicit VCodecBaseCallback(const std::shared_ptr &codec); + virtual ~VCodecBaseCallback(); + + void OnError(AVCodecErrorType errorType, int32_t errorCode); + void OnOutputFormatChanged(const Format &format); + void OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer); + void OnOutputBufferAvailable(uint32_t index, std::shared_ptr buffer); + +private: + std::shared_ptr codec_ = nullptr; +}; +} // namespace MediaAVCodec +} // namespace OHOS +#endif // CODEC_SERVER_H \ No newline at end of file -- Gitee From 696bf414383f72d5211530aeb494e6eb99b50d6a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:31:20 +0000 Subject: [PATCH 03/17] update test/unittest/audio_test/audio_codec_inner_unit_test.cpp. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- .../audio_codec_inner_unit_test.cpp | 83 +++++++++---------- 1 file changed, 40 insertions(+), 43 deletions(-) diff --git a/test/unittest/audio_test/audio_codec_inner_unit_test.cpp b/test/unittest/audio_test/audio_codec_inner_unit_test.cpp index 493fb9c2b..77aec3397 100644 --- a/test/unittest/audio_test/audio_codec_inner_unit_test.cpp +++ b/test/unittest/audio_test/audio_codec_inner_unit_test.cpp @@ -19,60 +19,58 @@ constexpr int32_t DEFAULT_BUFFER_SIZE = 4; namespace OHOS { namespace Media { -class MockCodecService : public ICodecService { +class MockCodecService : public AudioCodecService { public: MOCK_METHOD(int32_t, Init, - (AVCodecType type, bool isMimeType, const std::string &name, Meta &callerInfo, API_VERSION apiVersion), - (override)); - MOCK_METHOD(int32_t, Configure, (const Format &format), (override)); - MOCK_METHOD(int32_t, SetCustomBuffer, (std::shared_ptr buffer), (override)); - MOCK_METHOD(int32_t, Start, (), (override)); - MOCK_METHOD(int32_t, Stop, (), (override)); - MOCK_METHOD(int32_t, Flush, (), (override)); - MOCK_METHOD(int32_t, Reset, (), (override)); - MOCK_METHOD(int32_t, Release, (), (override)); - MOCK_METHOD(int32_t, NotifyEos, (), (override)); - MOCK_METHOD(sptr, CreateInputSurface, (), (override)); - MOCK_METHOD(int32_t, SetOutputSurface, (sptr surface), (override)); + (AVCodecType type, bool isMimeType, const std::string &name, Meta &callerInfo, API_VERSION apiVersion)); + MOCK_METHOD(int32_t, Configure, (const Format &format)); + MOCK_METHOD(int32_t, SetCustomBuffer, (std::shared_ptr buffer)); + MOCK_METHOD(int32_t, Start, ()); + MOCK_METHOD(int32_t, Stop, ()); + MOCK_METHOD(int32_t, Flush, ()); + MOCK_METHOD(int32_t, Reset, ()); + MOCK_METHOD(int32_t, Release, ()); + MOCK_METHOD(int32_t, NotifyEos, ()); + MOCK_METHOD(sptr, CreateInputSurface, ()); + MOCK_METHOD(int32_t, SetOutputSurface, (sptr surface)); MOCK_METHOD( - int32_t, QueueInputBuffer, (uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag), (override)); - MOCK_METHOD(int32_t, QueueInputBuffer, (uint32_t index), (override)); - MOCK_METHOD(int32_t, QueueInputParameter, (uint32_t index), (override)); - MOCK_METHOD(int32_t, GetOutputFormat, (Format & format), (override)); - MOCK_METHOD(int32_t, ReleaseOutputBuffer, (uint32_t index, bool render), (override)); - MOCK_METHOD(int32_t, RenderOutputBufferAtTime, (uint32_t index, int64_t renderTimestampNs), (override)); - MOCK_METHOD(int32_t, SetParameter, (const Format &format), (override)); - MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr &callback), (override)); - MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr &callback), (override)); - MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr &callback), (override)); + int32_t, QueueInputBuffer, (uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag)); + MOCK_METHOD(int32_t, QueueInputBuffer, (uint32_t index)); + MOCK_METHOD(int32_t, QueueInputParameter, (uint32_t index)); + MOCK_METHOD(int32_t, GetOutputFormat, (Format & format)); + MOCK_METHOD(int32_t, ReleaseOutputBuffer, (uint32_t index, bool render)); + MOCK_METHOD(int32_t, RenderOutputBufferAtTime, (uint32_t index, int64_t renderTimestampNs)); + MOCK_METHOD(int32_t, SetParameter, (const Format &format)); + MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr &callback)); + MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr &callback)); + MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr &callback)); MOCK_METHOD( - int32_t, SetCallback, (const std::shared_ptr &callback), (override)); + int32_t, SetCallback, (const std::shared_ptr &callback)); MOCK_METHOD(int32_t, ChangePlugin, (const std::string &mime, bool isEncoder, const std::shared_ptr &meta), (override)); - MOCK_METHOD(int32_t, SetCodecCallback, (const std::shared_ptr &codecCallback), (override)); - MOCK_METHOD(void, SetDumpInfo, (bool isDump, uint64_t instanceId), (override)); - MOCK_METHOD(int32_t, GetInputFormat, (Format & format), (override)); + MOCK_METHOD(int32_t, SetCodecCallback, (const std::shared_ptr &codecCallback)); + MOCK_METHOD(void, SetDumpInfo, (bool isDump, uint64_t instanceId)); + MOCK_METHOD(int32_t, GetInputFormat, (Format & format)); MOCK_METHOD(int32_t, SetDecryptConfig, - (const sptr &keySession, const bool svpFlag), (override)); - MOCK_METHOD(int32_t, CreateCodecByName, (const std::string &name), (override)); - MOCK_METHOD(int32_t, Configure, (const std::shared_ptr &meta), (override)); - MOCK_METHOD(int32_t, SetParameter, (const std::shared_ptr ¶meter), (override)); - MOCK_METHOD(int32_t, GetOutputFormat, (std::shared_ptr & parameter), (override)); - MOCK_METHOD(int32_t, SetOutputBufferQueue, (const sptr &bufferQueueProducer), (override)); - MOCK_METHOD(int32_t, Prepare, (), (override)); - MOCK_METHOD(sptr, GetInputBufferQueue, (), (override)); - MOCK_METHOD(void, ProcessInputBuffer, (), (override)); - MOCK_METHOD(bool, CheckRunning, (), (override)); + (const sptr &keySession, const bool svpFlag)); + MOCK_METHOD(int32_t, CreateCodecByName, (const std::string &name)); + MOCK_METHOD(int32_t, Configure, (const std::shared_ptr &meta)); + MOCK_METHOD(int32_t, SetParameter, (const std::shared_ptr ¶meter)); + MOCK_METHOD(int32_t, GetOutputFormat, (std::shared_ptr & parameter)); + MOCK_METHOD(int32_t, SetOutputBufferQueue, (const sptr &bufferQueueProducer)); + MOCK_METHOD(int32_t, Prepare, ()); + MOCK_METHOD(sptr, GetInputBufferQueue, ()); + MOCK_METHOD(void, ProcessInputBuffer, ()); + MOCK_METHOD(bool, CheckRunning, ()); MOCK_METHOD(int32_t, SetAudioDecryptionConfig, - (const sptr &keySession, const bool svpFlag), (override)); - MOCK_METHOD(sptr, GetInputBufferQueueConsumer, (), (override)); - MOCK_METHOD(sptr, GetOutputBufferQueueProducer, (), (override)); + (const sptr &keySession, const bool svpFlag)); + MOCK_METHOD(sptr, GetInputBufferQueueConsumer, ()); + MOCK_METHOD(sptr, GetOutputBufferQueueProducer, ()); MOCK_METHOD( - void, ProcessInputBufferInner, (bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus), (override)); + void, ProcessInputBufferInner, (bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus)); MOCK_METHOD(int32_t, GetChannelId, (int32_t & channelId)); MOCK_METHOD(int32_t, SetLowPowerPlayerMode, (bool isLpp)); - MOCK_METHOD(int32_t, NotifyMemoryExchange, (const bool exchangeFlag), (override)); }; class AudioCodecInnerTest : public ::testing::Test { @@ -81,7 +79,6 @@ protected: { mockCodecService_ = std::make_shared(); avCodecAudioCodecInnerImpl_ = std::make_unique(); - avCodecAudioCodecInnerImpl_->codecService_ = mockCodecService_; innerBufferQueue_ = AVBufferQueue::Create(DEFAULT_BUFFER_SIZE, MemoryType::SHARED_MEMORY, "AudioCodecInnerTest"); } -- Gitee From 186c46c3d2c62cb7aa252b5a221cde7d56089105 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:32:15 +0000 Subject: [PATCH 04/17] update services/media_engine/filters/surface_encoder_adapter.cpp. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- .../filters/surface_encoder_adapter.cpp | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/services/media_engine/filters/surface_encoder_adapter.cpp b/services/media_engine/filters/surface_encoder_adapter.cpp index f2a894b48..fe19a9429 100644 --- a/services/media_engine/filters/surface_encoder_adapter.cpp +++ b/services/media_engine/filters/surface_encoder_adapter.cpp @@ -17,7 +17,6 @@ #include #include "avcodec_info.h" #include "avcodec_common.h" -#include "codec_server.h" #include "meta/format.h" #include "media_description.h" #include "native_avcapability.h" @@ -313,19 +312,8 @@ Status SurfaceEncoderAdapter::SetEncoderAdapterKeyFramePtsCallback( Status SurfaceEncoderAdapter::SetInputSurface(sptr surface) { - MEDIA_LOG_I("GetInputSurface"); - if (!codecServer_) { - SetFaultEvent("SurfaceEncoderAdapter::SetInputSurface, CodecServer is null"); - return Status::ERROR_UNKNOWN; - } - MediaAVCodec::CodecServer *codecServerPtr = (MediaAVCodec::CodecServer *)(codecServer_.get()); - int32_t ret = codecServerPtr->SetInputSurface(surface); - if (ret == 0) { - return Status::OK; - } else { - SetFaultEvent("SurfaceEncoderAdapter::SetInputSurface error", ret); - return Status::ERROR_UNKNOWN; - } + // audio test no need input surface + return Status::OK; } Status SurfaceEncoderAdapter::SetTransCoderMode() -- Gitee From a1d1ad221e9750f98eb72bbf905a630662cf8413 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:33:30 +0000 Subject: [PATCH 05/17] update interfaces/inner_api/native/BUILD.gn. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- interfaces/inner_api/native/BUILD.gn | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/interfaces/inner_api/native/BUILD.gn b/interfaces/inner_api/native/BUILD.gn index 0c9deff00..a3c102f88 100644 --- a/interfaces/inner_api/native/BUILD.gn +++ b/interfaces/inner_api/native/BUILD.gn @@ -258,11 +258,8 @@ ohos_shared_library("av_codec_client") { "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/common/hdi_codec.cpp", "$av_codec_root_dir/services/services/codec/server/codec_factory.cpp", "$av_codec_root_dir/services/services/codec/server/codec_param_checker.cpp", - "$av_codec_root_dir/services/services/codec/server/codec_server.cpp", - "$av_codec_root_dir/services/services/codec/server/post_processing/dynamic_controller.cpp", - "$av_codec_root_dir/services/services/codec/server/post_processing/dynamic_interface.cpp", + "$av_codec_root_dir/services/services/codec/server/audio_codec_server.cpp", "$av_codec_root_dir/services/services/codec/server/post_processing/state_machine.cpp", - "$av_codec_root_dir/services/services/codec/server/temporal_scalability.cpp", ] } if (av_codec_support_demuxer) { -- Gitee From 968bb193c8de3bbfc964e636511ffc80c873c8bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:35:19 +0000 Subject: [PATCH 06/17] update frameworks/native/avcodec/avcodec_audio_codec_impl.cpp. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_codec_impl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp b/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp index 5bedcf61d..bd2132c8f 100644 --- a/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp +++ b/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp @@ -20,7 +20,7 @@ #include "avcodec_trace.h" #include "avcodec_codec_name.h" #include "avcodec_mime_type.h" -#include "codec_server.h" +#include "audio_codec_server.h" #include "qos.h" namespace { @@ -62,7 +62,7 @@ int32_t AVCodecAudioCodecImpl::Init(AVCodecType type, bool isMimeType, const std } Format format; - codecService_ = CodecServer::Create(); + codecService_ = AudioCodecServer::Create(); CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_UNKNOWN, "failed to create codec service"); implBufferQueue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, -- Gitee From 2ddaa2b8ede0fcf4c8e5ff22a75b972859a42ca1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:36:16 +0000 Subject: [PATCH 07/17] update frameworks/native/avcodec/avcodec_audio_codec_impl.h. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_codec_impl.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_codec_impl.h b/frameworks/native/avcodec/avcodec_audio_codec_impl.h index 93f5d54a0..e06c1cb7d 100644 --- a/frameworks/native/avcodec/avcodec_audio_codec_impl.h +++ b/frameworks/native/avcodec/avcodec_audio_codec_impl.h @@ -19,7 +19,7 @@ #include "avcodec_audio_codec.h" #include "nocopyable.h" #include "task_thread.h" -#include "i_avcodec_service.h" +#include "audio_codec_server.h" #include "meta/meta.h" #include "buffer/avbuffer.h" #include "buffer/avbuffer_queue.h" @@ -110,7 +110,7 @@ private: private: std::atomic isRunning_ = false; std::atomic isSyncMode_ = false; - std::shared_ptr codecService_ = nullptr; + std::shared_ptr codecService_ = nullptr; std::shared_ptr implBufferQueue_; std::unique_ptr inputTask_; std::unique_ptr outputTask_; -- Gitee From 1d69dfc66d38757ade6c6d1c84a1e1b81eff2dda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:37:08 +0000 Subject: [PATCH 08/17] update frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp index ed8c25932..c3a12c436 100644 --- a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp +++ b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp @@ -18,7 +18,6 @@ #include "avcodec_errors.h" #include "avcodec_trace.h" #include "avcodec_codec_name.h" -#include "codec_server.h" #include "drm_i_keysession_service.h" namespace OHOS { @@ -100,7 +99,7 @@ int32_t AVCodecAudioCodecInnerImpl::Init(AVCodecType type, bool isMimeType, cons AVCODEC_SYNC_TRACE; AVCODEC_LOGI("AVCodecAudioCodecInnerImpl Init"); Format format; - codecService_ = CodecServer::Create(); + codecService_ = AudioCodecServer::Create(); CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, "failed to create codec service"); int32_t ret = codecService_->Init(type, isMimeType, name, *format.GetMeta(), API_VERSION::API_VERSION_11); @@ -278,7 +277,7 @@ int32_t AVCodecAudioCodecInnerImpl::SetAudioDecryptionConfig( AVCODEC_LOGD("AVCodecAudioCodecInnerImpl SetAudioDecryptionConfig"); CHECK_AND_RETURN_RET_LOG( codecService_ != nullptr, AVCodecServiceErrCode::AVCS_ERR_INVALID_OPERATION, "service died"); - return codecService_->SetAudioDecryptionConfig(keySession, svpFlag); + return 0; } void AVCodecAudioCodecInnerImpl::SetDumpInfo(bool isDump, uint64_t instanceId) -- Gitee From 76ca214c6fc1d6cf1fb034ffd91a5d239d61f7b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:37:56 +0000 Subject: [PATCH 09/17] update frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h index 4d872c6b6..95f847283 100644 --- a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h +++ b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h @@ -17,7 +17,7 @@ #include "avcodec_audio_codec.h" #include "nocopyable.h" -#include "i_avcodec_service.h" +#include "audio_codec_server.h" #include "drm_i_keysession_service.h" namespace OHOS { @@ -117,7 +117,7 @@ private: size_t outputAvaliableNum_; }; - std::shared_ptr codecService_ = nullptr; + std::shared_ptr codecService_ = nullptr; std::shared_ptr syncCodecAdapter_ = nullptr; }; } // namespace MediaAVCodec -- Gitee From 11425f684d2a3599c5b98a28365f94b4f97eaeaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:38:48 +0000 Subject: [PATCH 10/17] update frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp b/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp index 715f9549f..42fc55964 100644 --- a/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp +++ b/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp @@ -18,7 +18,7 @@ #include "avcodec_log.h" #include "avcodec_errors.h" #include "avcodec_trace.h" -#include "codec_server.h" +#include "audio_codec_server.h" namespace { constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "AVCodecAudioDecoderImpl"}; @@ -52,7 +52,7 @@ int32_t AVCodecAudioDecoderImpl::Init(AVCodecType type, bool isMimeType, const s { AVCODEC_SYNC_TRACE; Format format; - codecService_ = CodecServer::Create(); + codecService_ = AudioCodecServer::Create(); CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_UNKNOWN, "failed to create codec service"); return codecService_->Init(type, isMimeType, name, *format.GetMeta()); } -- Gitee From 21ef1df713befac06e0f708a2917f37802f8bf05 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:39:21 +0000 Subject: [PATCH 11/17] update frameworks/native/avcodec/avcodec_audio_decoder_impl.h. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_decoder_impl.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_decoder_impl.h b/frameworks/native/avcodec/avcodec_audio_decoder_impl.h index bf91c1820..868ff9d19 100644 --- a/frameworks/native/avcodec/avcodec_audio_decoder_impl.h +++ b/frameworks/native/avcodec/avcodec_audio_decoder_impl.h @@ -17,7 +17,7 @@ #include "avcodec_audio_decoder.h" #include "nocopyable.h" -#include "i_avcodec_service.h" +#include "audio_codec_Server.h" namespace OHOS { namespace MediaAVCodec { @@ -41,7 +41,7 @@ public: int32_t Init(AVCodecType type, bool isMimeType, const std::string &name); private: - std::shared_ptr codecService_ = nullptr; + std::shared_ptr codecService_ = nullptr; }; } // namespace MediaAVCodec } // namespace OHOS -- Gitee From 616b1c57fca624a250ef4eccd8f4d59ce51e3f7c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:39:48 +0000 Subject: [PATCH 12/17] update frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp b/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp index 4c793d0b4..bd85990b7 100644 --- a/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp +++ b/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp @@ -18,7 +18,7 @@ #include "avcodec_log.h" #include "avcodec_errors.h" #include "avcodec_trace.h" -#include "codec_server.h" +#include "audio_codec_server.h" namespace { constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "AVCodecAudioEncoderImpl"}; @@ -52,7 +52,7 @@ int32_t AVCodecAudioEncoderImpl::Init(AVCodecType type, bool isMimeType, const s { AVCODEC_SYNC_TRACE; Format format; - codecService_ = CodecServer::Create(); + codecService_ = AudioCodecServer::Create(); CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_UNKNOWN, "failed to create codec service"); return codecService_->Init(type, isMimeType, name, *format.GetMeta()); -- Gitee From c32ecede6e1069b3fa6ecc39360d9ad863948df8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 07:40:23 +0000 Subject: [PATCH 13/17] update frameworks/native/avcodec/avcodec_audio_encoder_impl.h. rebuild server MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- frameworks/native/avcodec/avcodec_audio_encoder_impl.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/native/avcodec/avcodec_audio_encoder_impl.h b/frameworks/native/avcodec/avcodec_audio_encoder_impl.h index fd803bfe7..5f65e7a66 100644 --- a/frameworks/native/avcodec/avcodec_audio_encoder_impl.h +++ b/frameworks/native/avcodec/avcodec_audio_encoder_impl.h @@ -18,7 +18,7 @@ #include "avcodec_audio_encoder.h" #include "nocopyable.h" -#include "i_avcodec_service.h" +#include "audio_codec_server.h" namespace OHOS { namespace MediaAVCodec { @@ -42,7 +42,7 @@ public: int32_t Init(AVCodecType type, bool isMimeType, const std::string &name); private: - std::shared_ptr codecService_ = nullptr; + std::shared_ptr codecService_ = nullptr; }; } // namespace MediaAVCodec } // namespace OHOS -- Gitee From 138131a26a9a5d7031cb18950f50a1262509846d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Wed, 27 Aug 2025 08:29:49 +0000 Subject: [PATCH 14/17] update services/services/codec/server/audio_codec_server.cpp. rebuild mediacodec MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- .../codec/server/audio_codec_server.cpp | 153 ++++++++---------- 1 file changed, 70 insertions(+), 83 deletions(-) diff --git a/services/services/codec/server/audio_codec_server.cpp b/services/services/codec/server/audio_codec_server.cpp index 293ffc5df..219756d79 100644 --- a/services/services/codec/server/audio_codec_server.cpp +++ b/services/services/codec/server/audio_codec_server.cpp @@ -30,16 +30,16 @@ #include "meta/meta_key.h" namespace { -constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_FRAMEWORK, "AudioCodecServer"}; - -const std::map CODEC_STATE_MAP = { - {OHOS::MediaAVCodec::CodecServer::UNINITIALIZED, "uninitialized"}, - {OHOS::MediaAVCodec::CodecServer::INITIALIZED, "initialized"}, - {OHOS::MediaAVCodec::CodecServer::CONFIGURED, "configured"}, - {OHOS::MediaAVCodec::CodecServer::RUNNING, "running"}, - {OHOS::MediaAVCodec::CodecServer::FLUSHED, "flushed"}, - {OHOS::MediaAVCodec::CodecServer::END_OF_STREAM, "EOS"}, - {OHOS::MediaAVCodec::CodecServer::ERROR, "error"}, +constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "AudioCodecServer"}; + +const std::map CODEC_STATE_MAP = { + {OHOS::MediaAVCodec::AudioCodecServer::UNINITIALIZED, "uninitialized"}, + {OHOS::MediaAVCodec::AudioCodecServer::INITIALIZED, "initialized"}, + {OHOS::MediaAVCodec::AudioCodecServer::CONFIGURED, "configured"}, + {OHOS::MediaAVCodec::AudioCodecServer::RUNNING, "running"}, + {OHOS::MediaAVCodec::AudioCodecServer::FLUSHED, "flushed"}, + {OHOS::MediaAVCodec::AudioCodecServer::END_OF_STREAM, "EOS"}, + {OHOS::MediaAVCodec::AudioCodecServer::ERROR, "error"}, }; int32_t GetAudioCodecName(const OHOS::MediaAVCodec::AVCodecType type, std::string &name) @@ -65,18 +65,18 @@ int32_t GetAudioCodecName(const OHOS::MediaAVCodec::AVCodecType type, std::strin namespace OHOS { namespace MediaAVCodec { using namespace Media; -std::shared_ptr AudioCodecServer::Create(int32_t instanceId) +std::shared_ptr AudioCodecServer::Create(int32_t instanceId) { std::shared_ptr server = std::make_shared(); - int32_t ret = server->InitServer(instanceId); + int32_t ret = server->InitServer(); CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, nullptr, "Server init failed, ret: %{public}d!", ret); return server; } AudioCodecServer::AudioCodecServer() { - AVCODEC_LOGD_WITH_TAG("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); + AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); } AudioCodecServer::~AudioCodecServer() @@ -85,10 +85,10 @@ AudioCodecServer::~AudioCodecServer() avBufCallback_ = nullptr; (void)mallopt(M_FLUSH_THREAD_CACHE, 0); - AVCODEC_LOGD_WITH_TAG("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this)); + AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this)); } -int32_t AudioCodecServer::InitServer(int32_t instanceId) +int32_t AudioCodecServer::InitServer() { return AVCS_ERR_OK; } @@ -105,17 +105,17 @@ int32_t AudioCodecServer::Init(AVCodecType type, bool isMimeType, const std::str int32_t ret = isMimeType ? InitByMime(callerInfo, apiVersion) : InitByName(callerInfo, apiVersion); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, + CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Init failed. isMimeType:(%{public}d), name:(%{public}s), error:(%{public}d)", isMimeType, name.c_str(), ret); shareBufCallback_ = std::make_shared(shared_from_this()); ret = codecBase_->SetCallback(shareBufCallback_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, "SetCallback failed"); + CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "SetCallback failed"); avBufCallback_ = std::make_shared(shared_from_this()); ret = codecBase_->SetCallback(avBufCallback_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, "SetCallback failed"); - AVCODEC_LOGI_WITH_TAG("Create codec %{public}s by %{public}s success", codecName_.c_str(), + CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "SetCallback failed"); + AVCODEC_LOGI("Create codec %{public}s by %{public}s success", codecName_.c_str(), (isMimeType ? "mime" : "name")); StatusChanged(INITIALIZED); return AVCS_ERR_OK; @@ -129,20 +129,13 @@ int32_t AudioCodecServer::SetLowPowerPlayerMode(bool isLpp) int32_t AudioCodecServer::InitByName(Meta &callerInfo, API_VERSION apiVersion) { int32_t ret = GetAudioCodecName(codecType_, codecName_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(ret == AVCS_ERR_OK, ret, "CodecName get failed"); + CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "CodecName get failed"); codecBase_ = CodecFactory::Instance().CreateCodecByName(codecName_, apiVersion); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr"); return codecBase_->Init(callerInfo); } - - - - - - - int32_t AudioCodecServer::InitByMime(Meta &callerInfo, API_VERSION apiVersion) { int32_t ret = AVCS_ERR_NO_MEMORY; @@ -152,24 +145,24 @@ int32_t AudioCodecServer::InitByMime(Meta &callerInfo, API_VERSION apiVersion) for (iter = nameArray.begin(); iter != nameArray.end(); ++iter) { ret = AVCS_ERR_NO_MEMORY; codecBase_ = CodecFactory::Instance().CreateCodecByName(*iter, apiVersion); - CHECK_AND_CONTINUE_LOG_WITH_TAG(codecBase_ != nullptr, "Skip creation failure. name:(%{public}s)", + CHECK_AND_CONTINUE_LOG(codecBase_ != nullptr, "Skip creation failure. name:(%{public}s)", iter->c_str()); ret = codecBase_->Init(callerInfo); - CHECK_AND_CONTINUE_LOG_WITH_TAG(ret == AVCS_ERR_OK, "Skip initialization failure. name:(%{public}s)", + CHECK_AND_CONTINUE_LOG(ret == AVCS_ERR_OK, "Skip initialization failure. name:(%{public}s)", iter->c_str()); codecName_ = *iter; break; } - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr"); return iter == nameArray.end() ? ret : AVCS_ERR_OK; } int32_t AudioCodecServer::Configure(const Format &format) { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + CHECK_AND_RETURN_RET_LOG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); int32_t paramCheckRet = AVCS_ERR_OK; int32_t ret = codecBase_->Configure(format); @@ -181,14 +174,12 @@ int32_t AudioCodecServer::Configure(const Format &format) return paramCheckRet; } - - int32_t AudioCodecServer::SetCustomBuffer(std::shared_ptr buffer) { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == CONFIGURED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + CHECK_AND_RETURN_RET_LOG(status_ == CONFIGURED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); return codecBase_->SetCustomBuffer(buffer); } @@ -196,12 +187,10 @@ int32_t AudioCodecServer::Start() { SetFreeStatus(false); std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == FLUSHED || status_ == CONFIGURED, AVCS_ERR_INVALID_STATE, + CHECK_AND_RETURN_RET_LOG(status_ == FLUSHED || status_ == CONFIGURED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); - int32_t ret = 0; - - ret = codecBase_->Start(); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + int32_t ret = codecBase_->Start(); if (ret != AVCS_ERR_OK) { StatusChanged(ERROR); } else { @@ -214,14 +203,13 @@ int32_t AudioCodecServer::Stop() { SetFreeStatus(true); std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOGW_WITH_TAG(status_ != CONFIGURED, AVCS_ERR_OK, "Already in %{public}s state", + CHECK_AND_RETURN_RET_LOGW(status_ != CONFIGURED, AVCS_ERR_OK, "Already in %{public}s state", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING || status_ == END_OF_STREAM || status_ == FLUSHED, + CHECK_AND_RETURN_RET_LOG(status_ == RUNNING || status_ == END_OF_STREAM || status_ == FLUSHED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); - - int32_t retCodec = codecBase_->Stop(); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + codecBase_->Stop(); // perhaps need check? StatusChanged(CONFIGURED); return AVCS_ERR_OK; } @@ -230,11 +218,11 @@ int32_t AudioCodecServer::Flush() { SetFreeStatus(true); std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOGW_WITH_TAG(status_ != FLUSHED, AVCS_ERR_OK, "Already in %{public}s state", + CHECK_AND_RETURN_RET_LOGW(status_ != FLUSHED, AVCS_ERR_OK, "Already in %{public}s state", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE, + CHECK_AND_RETURN_RET_LOG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); codecBase_->Flush(); StatusChanged(FLUSHED); return AVCS_ERR_OK; @@ -243,9 +231,9 @@ int32_t AudioCodecServer::Flush() int32_t AudioCodecServer::NotifyEos() { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + CHECK_AND_RETURN_RET_LOG(status_ == RUNNING, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); int32_t ret = codecBase_->NotifyEos(); if (ret == AVCS_ERR_OK) { CodecStatus newStatus = END_OF_STREAM; @@ -258,7 +246,7 @@ int32_t AudioCodecServer::Reset() { SetFreeStatus(true); std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); int32_t ret = codecBase_->Reset(); CodecStatus newStatus = (ret == AVCS_ERR_OK ? INITIALIZED : ERROR); @@ -275,7 +263,7 @@ int32_t AudioCodecServer::Release() { SetFreeStatus(true); std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); int32_t ret = codecBase_->Release(); @@ -296,7 +284,7 @@ int32_t AudioCodecServer::QueueInputBuffer(uint32_t index, AVCodecBufferInfo inf { std::shared_lock freeLock(freeMutex_); if (isFree_) { - AVCODEC_LOGE_WITH_TAG("In invalid state, free out"); + AVCODEC_LOGE("In invalid state, free out"); return AVCS_ERR_INVALID_STATE; } @@ -318,10 +306,10 @@ int32_t AudioCodecServer::QueueInputBuffer(uint32_t index, AVCodecBufferInfo inf int32_t AudioCodecServer::QueueInputBufferIn(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag) { int32_t ret = AVCS_ERR_OK; - CHECK_AND_RETURN_RET_LOG_WITH_TAG( - status_ == RUNNING || ((isSetParameterCb_ || inputParamTask_ != nullptr) && status_ == END_OF_STREAM), + CHECK_AND_RETURN_RET_LOG( + status_ == RUNNING || ((inputParamTask_ != nullptr) && status_ == END_OF_STREAM), AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); if (codecCb_ != nullptr) { ret = codecBase_->QueueInputBuffer(index, info, flag); @@ -344,9 +332,9 @@ int32_t AudioCodecServer::QueueInputParameter(uint32_t index) int32_t AudioCodecServer::GetOutputFormat(Format &format) { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", - GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); return codecBase_->GetOutputFormat(format); } @@ -355,19 +343,19 @@ int32_t AudioCodecServer::ReleaseOutputBuffer(uint32_t index, bool render) { std::shared_lock freeLock(freeMutex_); if (isFree_) { - AVCODEC_LOGE_WITH_TAG("In invalid state, free out"); + AVCODEC_LOGE("In invalid state, free out"); return AVCS_ERR_INVALID_STATE; } std::shared_lock lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE, - "In invalid state, %{public}s", GetStatusDescription(status_).data()); + CHECK_AND_RETURN_RET_LOG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE, + "In invalid state, %{public}s", GetStatusDescription(status_).data()); return ReleaseOutputBufferOfCodec(index, render); } int32_t AudioCodecServer::ReleaseOutputBufferOfCodec(uint32_t index, bool render) { - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); int32_t ret; if (render) { @@ -386,9 +374,9 @@ int32_t AudioCodecServer::RenderOutputBufferAtTime(uint32_t index, [[maybe_unuse int32_t AudioCodecServer::SetParameter(const Format &format) { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE, + CHECK_AND_RETURN_RET_LOG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); return codecBase_->SetParameter(format); } @@ -429,10 +417,10 @@ int32_t AudioCodecServer::SetCallback(const std::shared_ptr lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG( + CHECK_AND_RETURN_RET_LOG( status_ == CONFIGURED || status_ == RUNNING || status_ == FLUSHED || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); return codecBase_->GetInputFormat(format); } @@ -462,11 +450,10 @@ inline void AudioCodecServer::StatusChanged(CodecStatus newStatus) if (status_ == newStatus) { return; } - if (status_ == ERROR && videoCb_ != nullptr && - (codecType_ == AVCODEC_TYPE_VIDEO_DECODER)) { + if (status_ == ERROR && videoCb_ != nullptr) { videoCb_->OnError(AVCODEC_ERROR_FRAMEAORK_FAILED, AVCS_ERR_INVALID_STATE); } - AVCODEC_LOGI_WITH_TAG("Status %{public}s -> %{public}s", GetStatusDescription(status_).data(), + AVCODEC_LOGI("Status %{public}s -> %{public}s", GetStatusDescription(status_).data(), GetStatusDescription(newStatus).data()); status_ = newStatus; } @@ -475,7 +462,7 @@ void AudioCodecServer::OnError(int32_t errorType, int32_t errorCode) { std::lock_guard lock(cbMutex_); lastErrMsg_ = AVCSErrorToString(static_cast(errorCode)); - AVCODEC_LOGW_WITH_TAG("%{public}s", lastErrMsg_.c_str()); + AVCODEC_LOGW("%{public}s", lastErrMsg_.c_str()); if (codecCb_ != nullptr) { codecCb_->OnError(static_cast(errorType), errorCode); } @@ -518,14 +505,14 @@ void AudioCodecServer::OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer) { - CHECK_AND_RETURN_LOG_WITH_TAG(buffer != nullptr, "buffer is nullptr!"); + CHECK_AND_RETURN_LOG(buffer != nullptr, "buffer is nullptr!"); std::shared_lock lock(cbMutex_); - CHECK_AND_RETURN_LOG_WITH_TAG(videoCb_ != nullptr, "videoCb_ is nullptr!"); + CHECK_AND_RETURN_LOG(videoCb_ != nullptr, "videoCb_ is nullptr!"); videoCb_->OnOutputBufferAvailable(index, buffer); } -CodecBaseCallback::CodecBaseCallback(const std::shared_ptr &codec) : codec_(codec) +CodecBaseCallback::CodecBaseCallback(const std::shared_ptr &codec) : codec_(codec) { AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); } @@ -567,7 +554,7 @@ void CodecBaseCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInf } } -VCodecBaseCallback::VCodecBaseCallback(const std::shared_ptr &codec) : codec_(codec) +VCodecBaseCallback::VCodecBaseCallback(const std::shared_ptr &codec) : codec_(codec) { AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); } @@ -611,11 +598,11 @@ void VCodecBaseCallback::OnOutputBufferAvailable(uint32_t index, std::shared_ptr int32_t AudioCodecServer::Configure(const std::shared_ptr &meta) { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(meta != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(meta != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + CHECK_AND_RETURN_RET_LOG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); int32_t ret = codecBase_->Configure(meta); @@ -627,8 +614,8 @@ int32_t AudioCodecServer::Configure(const std::shared_ptr &meta) int32_t AudioCodecServer::SetParameter(const std::shared_ptr ¶meter) { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(parameter != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); - CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE, + CHECK_AND_RETURN_RET_LOG(parameter != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN_RET_LOG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); return codecBase_->SetParameter(parameter); } @@ -690,7 +677,7 @@ void AudioCodecServer::ProcessInputBuffer() bool AudioCodecServer::CheckRunning() { - if (status_ == CodecServer::RUNNING) { + if (status_ == AudioCodecServer::RUNNING) { return true; } return false; -- Gitee From e8b56f00a4eabab5e67c672bb9824a7edb4c6bf3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Wed, 27 Aug 2025 08:50:14 +0000 Subject: [PATCH 15/17] update services/services/codec/server/audio_codec_server.cpp. rebuild mediacodec MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- services/services/codec/server/audio_codec_server.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/services/services/codec/server/audio_codec_server.cpp b/services/services/codec/server/audio_codec_server.cpp index 219756d79..36a41e185 100644 --- a/services/services/codec/server/audio_codec_server.cpp +++ b/services/services/codec/server/audio_codec_server.cpp @@ -65,7 +65,7 @@ int32_t GetAudioCodecName(const OHOS::MediaAVCodec::AVCodecType type, std::strin namespace OHOS { namespace MediaAVCodec { using namespace Media; -std::shared_ptr AudioCodecServer::Create(int32_t instanceId) +std::shared_ptr AudioCodecServer::Create() { std::shared_ptr server = std::make_shared(); @@ -332,9 +332,9 @@ int32_t AudioCodecServer::QueueInputParameter(uint32_t index) int32_t AudioCodecServer::GetOutputFormat(Format &format) { std::lock_guard lock(mutex_); - CHECK_AND_RETURN_RET_LOG(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", + CHECK_AND_RETURN(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data()); - CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); + CHECK_AND_RETURN(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr"); return codecBase_->GetOutputFormat(format); } -- Gitee From 9caea9c0a057bb8b05ab73c62fd8163e8f431df1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Wed, 27 Aug 2025 08:59:44 +0000 Subject: [PATCH 16/17] update services/services/codec/server/audio_codec_server.h. rebulid mediacodec MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- .../codec/server/audio_codec_server.h | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/services/services/codec/server/audio_codec_server.h b/services/services/codec/server/audio_codec_server.h index 3157a925d..f79496b1b 100644 --- a/services/services/codec/server/audio_codec_server.h +++ b/services/services/codec/server/audio_codec_server.h @@ -28,12 +28,12 @@ namespace OHOS { namespace MediaAVCodec { using namespace Media; -class AudioCodecServer : public std::enable_shared_from_this, +class AudioCodecServer : public std::enable_shared_from_this, public NoCopyable { public: static std::shared_ptr Create(); - CodecServer(); - virtual ~CodecServer(); + AudioCodecServer(); + virtual ~AudioCodecServer(); enum CodecStatus { UNINITIALIZED = 0, @@ -60,7 +60,7 @@ public: int32_t QueueInputBuffer(uint32_t index); int32_t QueueInputParameter(uint32_t index); int32_t GetOutputFormat(Format &format); - int32_t ReleaseOutputBuffer(uint32_t index, bool render); + int32_t ReleaseOutputBuffer(uint32_t index, bool render = false); int32_t RenderOutputBufferAtTime(uint32_t index, int64_t renderTimestampNs); int32_t SetParameter(const Format &format); int32_t SetCallback(const std::shared_ptr &callback); @@ -98,15 +98,15 @@ public: bool CheckRunning(); #ifdef SUPPORT_DRM - int32_t SetAudioDecryptionConfig(const sptr &keySession,nconst bool svpFlag); + int32_t SetAudioDecryptionConfig(const sptr &keySession, const bool svpFlag); #endif private: int32_t InitByName(Meta &callerInfo, API_VERSION apiVersion); int32_t InitByMime(Meta &callerInfo, API_VERSION apiVersion); - int32_t InitServer(int32_t instanceId = INVALID_INSTANCE_ID); + int32_t InitServer(); void StartInputParamTask(); - const std::string &GetStatusDescription(OHOS::MediaAVCodec::CodecServer::CodecStatus status); + const std::string &GetStatusDescription(OHOS::MediaAVCodec::AudioCodecServer::CodecStatus status); void StatusChanged(CodecStatus newStatus); void SetFreeStatus(bool isFree); int32_t QueueInputBufferIn(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag); @@ -133,7 +133,7 @@ private: class CodecBaseCallback : public AVCodecCallback, public NoCopyable { public: - explicit CodecBaseCallback(const std::shared_ptr &codec); + explicit CodecBaseCallback(const std::shared_ptr &codec); virtual ~CodecBaseCallback(); void OnError(AVCodecErrorType errorType, int32_t errorCode); @@ -143,12 +143,12 @@ public: std::shared_ptr buffer); private: - std::shared_ptr codec_ = nullptr; + std::shared_ptr codec_ = nullptr; }; class VCodecBaseCallback : public MediaCodecCallback, public NoCopyable { public: - explicit VCodecBaseCallback(const std::shared_ptr &codec); + explicit VCodecBaseCallback(const std::shared_ptr &codec); virtual ~VCodecBaseCallback(); void OnError(AVCodecErrorType errorType, int32_t errorCode); @@ -157,7 +157,7 @@ public: void OnOutputBufferAvailable(uint32_t index, std::shared_ptr buffer); private: - std::shared_ptr codec_ = nullptr; + std::shared_ptr codec_ = nullptr; }; } // namespace MediaAVCodec } // namespace OHOS -- Gitee From 2a4c5daa01cb519ca09d8decc3c7245476ea8f6e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=80=81=E6=B2=B9=E6=9D=A1321?= <12635798+laoyoutiao-321@user.noreply.gitee.com> Date: Wed, 27 Aug 2025 09:19:47 +0000 Subject: [PATCH 17/17] update test/unittest/audio_test/audio_codec_inner_unit_test.cpp. rebuild mediacodec MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 老油条321 <12635798+laoyoutiao-321@user.noreply.gitee.com> --- test/unittest/audio_test/audio_codec_inner_unit_test.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/unittest/audio_test/audio_codec_inner_unit_test.cpp b/test/unittest/audio_test/audio_codec_inner_unit_test.cpp index 77aec3397..75908024d 100644 --- a/test/unittest/audio_test/audio_codec_inner_unit_test.cpp +++ b/test/unittest/audio_test/audio_codec_inner_unit_test.cpp @@ -3,7 +3,7 @@ #define private public #include "avcodec_audio_codec_inner_impl.h" #undef private -#include "i_avcodec_service.h" +#include "audio_codec_server.h" #include "avcodec_log.h" #include "avcodec_errors.h" #include "avcodec_trace.h" @@ -19,7 +19,7 @@ constexpr int32_t DEFAULT_BUFFER_SIZE = 4; namespace OHOS { namespace Media { -class MockCodecService : public AudioCodecService { +class MockCodecService : public AudioCodecServer { public: MOCK_METHOD(int32_t, Init, (AVCodecType type, bool isMimeType, const std::string &name, Meta &callerInfo, API_VERSION apiVersion)); @@ -46,8 +46,7 @@ public: MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr &callback)); MOCK_METHOD( int32_t, SetCallback, (const std::shared_ptr &callback)); - MOCK_METHOD(int32_t, ChangePlugin, (const std::string &mime, bool isEncoder, const std::shared_ptr &meta), - (override)); + MOCK_METHOD(int32_t, ChangePlugin, (const std::string &mime, bool isEncoder, const std::shared_ptr &meta)); MOCK_METHOD(int32_t, SetCodecCallback, (const std::shared_ptr &codecCallback)); MOCK_METHOD(void, SetDumpInfo, (bool isDump, uint64_t instanceId)); MOCK_METHOD(int32_t, GetInputFormat, (Format & format)); @@ -79,6 +78,7 @@ protected: { mockCodecService_ = std::make_shared(); avCodecAudioCodecInnerImpl_ = std::make_unique(); + avCodecAudioCodecInnerImpl_->codecService_ = mockCodecService_; innerBufferQueue_ = AVBufferQueue::Create(DEFAULT_BUFFER_SIZE, MemoryType::SHARED_MEMORY, "AudioCodecInnerTest"); } -- Gitee