From 7154711ab8469e948aa28411fa4cde08a228b525 Mon Sep 17 00:00:00 2001 From: zhuzhihui Date: Wed, 19 Mar 2025 17:17:33 +0800 Subject: [PATCH] support opus. Signed-off-by: zhuzhihui --- audiohandler/BUILD.gn | 1 + audiohandler/include/daudio_handler.h | 2 + audiohandler/src/daudio_handler.cpp | 37 ++++++++- .../test/unittest/src/daudio_handler_test.cpp | 28 +++++++ bundle.json | 1 + common/include/daudio_constants.h | 1 + common/src/daudio_util.cpp | 1 + .../managersink/src/daudio_sink_dev.cpp | 8 -- .../managersink/src/daudio_sink_manager.cpp | 5 -- .../managersource/include/dmic_dev.h | 5 +- .../managersource/include/dspeaker_dev.h | 5 +- .../src/daudio_echo_cannel_manager.cpp | 1 - .../managersource/src/dmic_dev.cpp | 51 +++++++++--- .../managersource/src/dspeaker_dev.cpp | 45 +++++++++-- .../src/daudio_echo_cannel_manager_test.cpp | 4 +- .../sourcedevice/src/dmic_dev_test.cpp | 54 +++++++++++++ .../sourcedevice/src/dspeaker_dev_test.cpp | 77 +++++++++++++++++++ services/common/audioparam/audio_param.h | 3 +- 18 files changed, 288 insertions(+), 41 deletions(-) diff --git a/audiohandler/BUILD.gn b/audiohandler/BUILD.gn index 683a1910..0a49359d 100644 --- a/audiohandler/BUILD.gn +++ b/audiohandler/BUILD.gn @@ -38,6 +38,7 @@ ohos_shared_library("distributed_audio_handler") { "audio_framework:audio_capturer", "audio_framework:audio_client", "audio_framework:audio_renderer", + "av_codec:av_codec_client", "cJSON:cjson", "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", diff --git a/audiohandler/include/daudio_handler.h b/audiohandler/include/daudio_handler.h index a7933d0d..e4180f8b 100644 --- a/audiohandler/include/daudio_handler.h +++ b/audiohandler/include/daudio_handler.h @@ -54,6 +54,8 @@ private: bool AddItemsToObject(DHItem &dhItem, cJSON *infoJson, const int32_t &dhId); bool AddParamsToJson(DHItem &dhItem, cJSON* infoJson, const std::string &subtype, const AudioInfo &infos); std::vector RealQuery(const std::string &dataType); + bool IsMimeSupported(const std::string &coder); + void AddToVec(std::vector &container, const std::string &value); private: AudioInfo spkInfos_; AudioInfo micInfos_; diff --git a/audiohandler/src/daudio_handler.cpp b/audiohandler/src/daudio_handler.cpp index c1f270b2..d1d12b04 100644 --- a/audiohandler/src/daudio_handler.cpp +++ b/audiohandler/src/daudio_handler.cpp @@ -18,6 +18,7 @@ #include #include "audio_system_manager.h" +#include "avcodec_list.h" #include "string_ex.h" #include "daudio_constants.h" @@ -172,6 +173,31 @@ std::vector DAudioHandler::ablityForDump() return ablityForDumpVec_; } +bool DAudioHandler::IsMimeSupported(const std::string &coder) +{ + DHLOGD("Craete avCodecList start."); + std::shared_ptr avCodecList = MediaAVCodec::AVCodecListFactory::CreateAVCodecList(); + if (avCodecList == nullptr) { + DHLOGE("Create avCodecList failed."); + return false; + } + MediaAVCodec::CapabilityData *capData = avCodecList->GetCapability(coder, true, + MediaAVCodec::AVCodecCategory::AVCODEC_NONE); + if (capData == nullptr) { + DHLOGI("%{public}s is not supported.", coder.c_str()); + return false; + } + return true; +} + +void DAudioHandler::AddToVec(std::vector &container, const std::string &value) +{ + auto it = std::find(container.begin(), container.end(), value); + if (it == container.end()) { + container.push_back(value); + } +} + int32_t DAudioHandler::QueryAudioInfo() { DHLOGD("Start to query codec information."); @@ -181,9 +207,14 @@ int32_t DAudioHandler::QueryAudioInfo() spkInfos_.sampleRates = OHOS::AudioStandard::AudioRenderer::GetSupportedSamplingRates(); spkInfos_.formats = OHOS::AudioStandard::AudioRenderer::GetSupportedFormats(); spkInfos_.channels = OHOS::AudioStandard::AudioRenderer::GetSupportedChannels(); - supportedStream_.push_back(MUSIC); - codec_.push_back(AAC); - codec_.push_back(PCM); + AddToVec(supportedStream_, MUSIC); + AddToVec(codec_, PCM); + if (IsMimeSupported(std::string(MediaAVCodec::CodecMimeType::AUDIO_AAC))) { + AddToVec(codec_, AAC); + } + if (IsMimeSupported(std::string(MediaAVCodec::CodecMimeType::AUDIO_OPUS))) { + AddToVec(codec_, OPUS); + } return DH_SUCCESS; } diff --git a/audiohandler/test/unittest/src/daudio_handler_test.cpp b/audiohandler/test/unittest/src/daudio_handler_test.cpp index 53fa86d2..bfa26a8c 100644 --- a/audiohandler/test/unittest/src/daudio_handler_test.cpp +++ b/audiohandler/test/unittest/src/daudio_handler_test.cpp @@ -17,6 +17,7 @@ #include #include +#include using namespace testing::ext; @@ -65,5 +66,32 @@ HWTEST_F(DAudioHandlerTest, Query_001, TestSize.Level1) int32_t actual = DAudioHandler::GetInstance().Query().size(); EXPECT_LE(DH_SUCCESS, actual); } + +/** + * @tc.name: IsMimeSupported_001 + * @tc.desc: Verify the IsMimeSupported function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioHandlerTest, IsMimeSupported_001, TestSize.Level1) +{ + std::string coder = "AAAA"; + bool isSupport = DAudioHandler::GetInstance().IsMimeSupported(coder); + EXPECT_EQ(false, isSupport); +} + +/** + * @tc.name: AddToVec_001 + * @tc.desc: Verify the AddToVec function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioHandlerTest, AddToVec_001, TestSize.Level1) +{ + std::vector container; + std::string coder = "AAAA"; + DAudioHandler::GetInstance().AddToVec(container, coder); + EXPECT_EQ(container.size(), 1); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/bundle.json b/bundle.json index ca318f31..f07fe62c 100755 --- a/bundle.json +++ b/bundle.json @@ -31,6 +31,7 @@ "access_token", "accessibility", "audio_framework", + "av_codec", "cJSON", "c_utils", "device_security_level", diff --git a/common/include/daudio_constants.h b/common/include/daudio_constants.h index 4b198e66..48f1de95 100644 --- a/common/include/daudio_constants.h +++ b/common/include/daudio_constants.h @@ -158,6 +158,7 @@ constexpr const char *CHANNELMASKS = "ChannelMasks"; constexpr const char *FORMATS = "Formats"; const std::string MUSIC = "Music"; const std::string PCM = "PCM"; +const std::string OPUS = "OPUS"; const std::string AAC = "AAC"; const std::string MIC = "mic"; const std::string SPEAKER = "speaker"; diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp index 0b2f2441..ffb487ba 100644 --- a/common/src/daudio_util.cpp +++ b/common/src/daudio_util.cpp @@ -67,6 +67,7 @@ std::map typeCheckMap = { std::map::value_type(KEY_STREAM_USAGE, &DistributedHardware::IsInt32), std::map::value_type(KEY_DATATYPE, &DistributedHardware::IsString), std::map::value_type(KEY_CODEC_TYPE, &DistributedHardware::IsInt32), + std::map::value_type(CODEC, &DistributedHardware::IsString), }; std::map eventNameMap = { diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 0562f506..97fd01f8 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -292,7 +292,6 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) ret = micClient->StartCapture(); CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, jParam, "Start capture failed, ret: %{public}d.", ret); - PullUpPage(); isMicInUse_.store(true); cJSON_Delete(jParam); return ret; @@ -315,13 +314,6 @@ int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args) ret = micClient->Release(); CHECK_AND_LOG(ret != DH_SUCCESS, "Release mic client failed, ret: %{public}d.", ret); micClientMap_.erase(dhId); - if (isPageStatus_.load() && ipcSinkCallback_ != nullptr) { - bool isSensitive = false; - bool isSameAccount = false; - ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, SUBTYPE, devId_, - isSensitive, isSameAccount); - isPageStatus_.store(false); - } DHLOGI("Close mic device task excute success."); return DH_SUCCESS; } diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp index 79a0f2c7..1a459634 100644 --- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp @@ -231,11 +231,6 @@ int32_t DAudioSinkManager::InitAudioDevice(std::shared_ptr dev, c if (isSpkOrMic) { ret = dev->InitAVTransEngines(ChannelState::SPK_CONTROL_OPENED, rcvProviderPtr_); } else { - ret = VerifySecurityLevel(devId); - if (ret != DH_SUCCESS) { - DHLOGE("Verify security level failed."); - return ERR_DH_AUDIO_FAILED; - } dev->SetDevLevelStatus(true); ret = dev->InitAVTransEngines(ChannelState::MIC_CONTROL_OPENED, sendProviderPtr_); } diff --git a/services/audiomanager/managersource/include/dmic_dev.h b/services/audiomanager/managersource/include/dmic_dev.h index 42ec7161..46a42261 100644 --- a/services/audiomanager/managersource/include/dmic_dev.h +++ b/services/audiomanager/managersource/include/dmic_dev.h @@ -96,6 +96,9 @@ private: void FillJitterQueue(); void ReadFromRingbuffer(); void SendToProcess(const std::shared_ptr &audioData); + void GetCodecCaps(const std::string &capability); + void AddToVec(std::vector &container, const AudioCodecType value); + bool IsMimeSupported(const AudioCodecType coder); private: static constexpr uint8_t CHANNEL_WAIT_SECONDS = 5; @@ -132,7 +135,6 @@ private: AudioParam param_; std::atomic isExistedEmpty_ = false; - std::atomic isNeedCodec_ = true; size_t dataQueSize_ = 0; sptr ashmem_ = nullptr; std::atomic isEnqueueRunning_ = false; @@ -160,6 +162,7 @@ private: std::thread ringbufferThread_; std::atomic isRingbufferOn_ = false; std::mutex ringbufferMutex_; + std::vector codec_; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersource/include/dspeaker_dev.h b/services/audiomanager/managersource/include/dspeaker_dev.h index 42c549e4..68d2eaea 100644 --- a/services/audiomanager/managersource/include/dspeaker_dev.h +++ b/services/audiomanager/managersource/include/dspeaker_dev.h @@ -87,6 +87,9 @@ public: private: void EnqueueThread(); + void GetCodecCaps(const std::string &capability); + void AddToVec(std::vector &container, const AudioCodecType value); + bool IsMimeSupported(const AudioCodecType coder); private: static constexpr const char* ENQUEUE_THREAD = "spkEnqueueTh"; @@ -110,7 +113,6 @@ private: sptr ashmem_ = nullptr; std::atomic isEnqueueRunning_ = false; - std::atomic isNeedCodec_ = true; int32_t ashmemLength_ = -1; int32_t lengthPerTrans_ = -1; int32_t readIndex_ = -1; @@ -124,6 +126,7 @@ private: int32_t dhId_ = -1; FILE *dumpFileCommn_ = nullptr; FILE *dumpFileFast_ = nullptr; + std::vector codec_; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp b/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp index 9c5161e0..5f148291 100644 --- a/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp +++ b/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp @@ -305,7 +305,6 @@ int32_t DAudioEchoCannelManager::AudioCaptureStop() } if (!audioCapturer_->Stop()) { DHLOGE("Audio capturer stop failed."); - return ERR_DH_AUDIO_FAILED; } return DH_SUCCESS; } diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp index 7a2290a1..a1cbbfc8 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -175,14 +175,30 @@ int32_t DMicDev::EnableDevice(const int32_t dhId, const std::string &capability) return ret; } dhId_ = dhId; - auto pos = capability.find(SUB_PROTOCOLVER); + GetCodecCaps(capability); + return DH_SUCCESS; +} + +void DMicDev::AddToVec(std::vector &container, const AudioCodecType value) +{ + auto it = std::find(container.begin(), container.end(), value); + if (it == container.end()) { + container.push_back(value); + } +} + +void DMicDev::GetCodecCaps(const std::string &capability) +{ + auto pos = capability.find(AAC); if (pos != std::string::npos) { - DHLOGD("ProtocolVer : 2.0"); - } else { - isNeedCodec_.store(false); - DHLOGD("ProtocolVer : 1.0"); + AddToVec(codec_, AudioCodecType::AUDIO_CODEC_AAC_EN); + DHLOGI("Daudio codec cap: AAC"); + } + pos = capability.find(OPUS); + if (pos != std::string::npos) { + AddToVec(codec_, AudioCodecType::AUDIO_CODEC_OPUS); + DHLOGI("Daudio codec cap: OPUS"); } - return DH_SUCCESS; } int32_t DMicDev::DisableDevice(const int32_t dhId) @@ -198,6 +214,16 @@ int32_t DMicDev::DisableDevice(const int32_t dhId) return DH_SUCCESS; } +bool DMicDev::IsMimeSupported(const AudioCodecType coder) +{ + auto iter = std::find(codec_.begin(), codec_.end(), coder); + if (iter == codec_.end()) { + DHLOGI("devices have no cap: %{public}d", static_cast(coder)); + return false; + } + return true; +} + int32_t DMicDev::CreateStream(const int32_t streamId) { DHLOGI("Open stream of mic device streamId: %{public}d.", streamId); @@ -269,11 +295,6 @@ int32_t DMicDev::SetParameters(const int32_t streamId, const AudioParamHDF ¶ param_.comParam.sampleRate = paramHDF_.sampleRate; param_.comParam.channelMask = paramHDF_.channelMask; param_.comParam.bitFormat = paramHDF_.bitFormat; - param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC; - if (isNeedCodec_.load()) { - param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC_EN; - } - DHLOGD("isNeedCodec_ : %{public}d.", isNeedCodec_.load()); param_.comParam.frameSize = paramHDF_.frameSize; if (paramHDF_.streamUsage == StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION) { param_.captureOpts.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION; @@ -285,6 +306,14 @@ int32_t DMicDev::SetParameters(const int32_t streamId, const AudioParamHDF ¶ lowLatencyHalfSize_ = LOW_LATENCY_JITTER_TIME_MS / paramHDF_.period; lowLatencyMaxfSize_ = LOW_LATENCY_JITTER_MAX_TIME_MS / paramHDF_.period; } + param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC; + if (paramHDF_.streamUsage == StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION && + IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS)) { + param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_OPUS; + } else if (IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN)) { + param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC_EN; + } + DHLOGI("codecType : %{public}d.", static_cast(param_.comParam.codecType)); return DH_SUCCESS; } diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp index b1ef6bec..18ee5172 100644 --- a/services/audiomanager/managersource/src/dspeaker_dev.cpp +++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp @@ -48,14 +48,30 @@ int32_t DSpeakerDev::EnableDevice(const int32_t dhId, const std::string &capabil return ret; } dhId_ = dhId; - auto pos = capability.find(SUB_PROTOCOLVER); + GetCodecCaps(capability); + return DH_SUCCESS; +} + +void DSpeakerDev::AddToVec(std::vector &container, const AudioCodecType value) +{ + auto it = std::find(container.begin(), container.end(), value); + if (it == container.end()) { + container.push_back(value); + } +} + +void DSpeakerDev::GetCodecCaps(const std::string &capability) +{ + auto pos = capability.find(AAC); if (pos != std::string::npos) { - DHLOGD("ProtocolVer : 2.0"); - } else { - isNeedCodec_.store(false); - DHLOGD("ProtocolVer : 1.0"); + AddToVec(codec_, AudioCodecType::AUDIO_CODEC_AAC_EN); + DHLOGI("Daudio codec cap: AAC"); + } + pos = capability.find(OPUS); + if (pos != std::string::npos) { + AddToVec(codec_, AudioCodecType::AUDIO_CODEC_OPUS); + DHLOGI("Daudio codec cap: OPUS"); } - return DH_SUCCESS; } int32_t DSpeakerDev::DisableDevice(const int32_t dhId) @@ -71,6 +87,16 @@ int32_t DSpeakerDev::DisableDevice(const int32_t dhId) return DH_SUCCESS; } +bool DSpeakerDev::IsMimeSupported(const AudioCodecType coder) +{ + auto iter = std::find(codec_.begin(), codec_.end(), coder); + if (iter == codec_.end()) { + DHLOGI("devices have no cap: %{public}d", static_cast(coder)); + return false; + } + return true; +} + int32_t DSpeakerDev::InitReceiverEngine(IAVEngineProvider *providerPtr) { DHLOGI("InitReceiverEngine enter."); @@ -216,10 +242,13 @@ int32_t DSpeakerDev::SetParameters(const int32_t streamId, const AudioParamHDF & param_.renderOpts.contentType = CONTENT_TYPE_MUSIC; param_.renderOpts.renderFlags = paramHDF_.renderFlags; param_.renderOpts.streamUsage = paramHDF_.streamUsage; - if (isNeedCodec_.load()) { + if (paramHDF_.streamUsage == StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION && + IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS)) { + param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_OPUS; + } else if (IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN)) { param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC_EN; } - DHLOGD("isNeedCodec_: %{public}d", isNeedCodec_.load()); + DHLOGI("codecType: %{public}d", static_cast(param_.comParam.codecType)); return DH_SUCCESS; } diff --git a/services/audiomanager/test/unittest/sourcedevice/src/daudio_echo_cannel_manager_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/daudio_echo_cannel_manager_test.cpp index 7158b4da..1db1fb32 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/daudio_echo_cannel_manager_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/daudio_echo_cannel_manager_test.cpp @@ -76,7 +76,7 @@ HWTEST_F(DAudioEchoCannelManagerTest, AudioCaptureSetUp_001, TestSize.Level1) { EXPECT_EQ(ERR_DH_AUDIO_FAILED, echoCannelManager_->AudioCaptureSetUp()); EXPECT_EQ(ERR_DH_AUDIO_FAILED, echoCannelManager_->AudioCaptureStart()); - EXPECT_EQ(ERR_DH_AUDIO_FAILED, echoCannelManager_->AudioCaptureStop()); + EXPECT_EQ(DH_SUCCESS, echoCannelManager_->AudioCaptureStop()); EXPECT_EQ(DH_SUCCESS, echoCannelManager_->AudioCaptureRelease()); } @@ -89,7 +89,7 @@ HWTEST_F(DAudioEchoCannelManagerTest, AudioCaptureSetUp_001, TestSize.Level1) HWTEST_F(DAudioEchoCannelManagerTest, AudioCaptureSetUp_002, TestSize.Level1) { EXPECT_EQ(ERR_DH_AUDIO_FAILED, echoCannelManager_->AudioCaptureStart()); - EXPECT_EQ(ERR_DH_AUDIO_FAILED, echoCannelManager_->AudioCaptureStop()); + EXPECT_EQ(DH_SUCCESS, echoCannelManager_->AudioCaptureStop()); EXPECT_EQ(DH_SUCCESS, echoCannelManager_->AudioCaptureRelease()); } diff --git a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp index 7f2c81f1..18f804d3 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp @@ -153,6 +153,10 @@ HWTEST_F(DMicDevTest, SetParameters_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param)); param.period = 20; EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param)); + mic_->GetCodecCaps(AAC); + mic_->GetCodecCaps(OPUS); + param.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION; + EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param)); } /** @@ -414,5 +418,55 @@ HWTEST_F(DMicDevTest, SendMessage_001, TestSize.Level1) mic_->InitCtrlTrans(); EXPECT_EQ(DH_SUCCESS, mic_->SendMessage(OPEN_MIC, content, dstDevId)); } + +/** + * @tc.name: AddToVec001 + * @tc.desc: Verify AddToVec function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DMicDevTest, AddToVec001, TestSize.Level1) +{ + std::vector container; + mic_->AddToVec(container, AudioCodecType::AUDIO_CODEC_AAC); + EXPECT_EQ(1, container.size()); +} + +/** + * @tc.name: GetCodecCaps001 + * @tc.desc: Verify GetCodecCaps function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DMicDevTest, GetCodecCaps001, TestSize.Level1) +{ + std::vector container = mic_->codec_; + mic_->codec_.clear(); + mic_->GetCodecCaps(AAC); + auto num = mic_->codec_.size(); + EXPECT_EQ(1, num); + mic_->GetCodecCaps(OPUS); + num = mic_->codec_.size(); + mic_->codec_ = container; + EXPECT_EQ(2, num); +} + +/** + * @tc.name: IsMimeSupported001 + * @tc.desc: Verify IsMimeSupported function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DMicDevTest, IsMimeSupported001, TestSize.Level1) +{ + std::vector container = mic_->codec_; + mic_->codec_.clear(); + mic_->GetCodecCaps(AAC); + bool ret = mic_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN); + EXPECT_EQ(ret, true); + ret = mic_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS); + mic_->codec_ = container; + EXPECT_EQ(ret, false); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp index a94f16ad..38801366 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp @@ -154,6 +154,33 @@ HWTEST_F(DSpeakerDevTest, SetParameters_001, TestSize.Level1) spk_->GetAudioParam(); } +/** + * @tc.name: SetParameters_002 + * @tc.desc: Verify SetParameters and GetAudioParam function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DSpeakerDevTest, SetParameters_002, TestSize.Level1) +{ + const AudioParamHDF param = { + .sampleRate = SAMPLE_RATE_8000, + .channelMask = STEREO, + .bitFormat = SAMPLE_U8, + .streamUsage = STREAM_USAGE_VOICE_COMMUNICATION, + .frameSize = 30, + .period = 0, + .ext = "Test", + }; + std::vector container = spk_->codec_; + spk_->codec_.clear(); + spk_->GetCodecCaps(OHOS::DistributedHardware::AAC); + spk_->GetCodecCaps(OHOS::DistributedHardware::OPUS); + auto ret = spk_->SetParameters(streamId_, param); + spk_->GetAudioParam(); + spk_->codec_ = container; + EXPECT_EQ(DH_SUCCESS, ret); +} + /** * @tc.name: NotifyEvent_001 * @tc.desc: Verify NotifyEvent function. @@ -455,5 +482,55 @@ HWTEST_F(DSpeakerDevTest, SendMessage_001, TestSize.Level1) spk_->InitCtrlTrans(); EXPECT_EQ(DH_SUCCESS, spk_->SendMessage(OPEN_SPEAKER, content, dstDevId)); } + +/** + * @tc.name: AddToVec_001 + * @tc.desc: Verify AddToVec function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DSpeakerDevTest, AddToVec_001, TestSize.Level1) +{ + std::vector container; + spk_->AddToVec(container, AudioCodecType::AUDIO_CODEC_AAC); + EXPECT_EQ(1, container.size()); +} + +/** + * @tc.name: GetCodecCaps_001 + * @tc.desc: Verify GetCodecCaps function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DSpeakerDevTest, GetCodecCaps_001, TestSize.Level1) +{ + std::vector container = spk_->codec_; + spk_->codec_.clear(); + spk_->GetCodecCaps(OHOS::DistributedHardware::AAC); + auto num = spk_->codec_.size(); + EXPECT_EQ(1, num); + spk_->GetCodecCaps(OHOS::DistributedHardware::OPUS); + num = spk_->codec_.size(); + spk_->codec_ = container; + EXPECT_EQ(2, num); +} + +/** + * @tc.name: IsMimeSupported_001 + * @tc.desc: Verify IsMimeSupported function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DSpeakerDevTest, IsMimeSupported_001, TestSize.Level1) +{ + std::vector container = spk_->codec_; + spk_->codec_.clear(); + spk_->GetCodecCaps(OHOS::DistributedHardware::AAC); + bool ret = spk_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN); + EXPECT_EQ(ret, true); + ret = spk_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS); + spk_->codec_ = container; + EXPECT_EQ(ret, false); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/common/audioparam/audio_param.h b/services/common/audioparam/audio_param.h index 95d36594..1b03f4d8 100644 --- a/services/common/audioparam/audio_param.h +++ b/services/common/audioparam/audio_param.h @@ -58,7 +58,8 @@ typedef enum { typedef enum { AUDIO_CODEC_AAC = 0, AUDIO_CODEC_FLAC = 1, - AUDIO_CODEC_AAC_EN = 2 + AUDIO_CODEC_AAC_EN = 2, + AUDIO_CODEC_OPUS = 3 } AudioCodecType; typedef enum { -- Gitee