From ac4686c73d7f8699be97f404fe3ecf1a6ddcd3cc Mon Sep 17 00:00:00 2001 From: w30042960 Date: Thu, 4 Sep 2025 14:42:15 +0800 Subject: [PATCH] add water Signed-off-by: w30042960 --- audiohandler/src/daudio_handler.cpp | 4 +- .../include/daudio_source_handler.h | 2 +- .../src/daudio_source_handler.cpp | 2 +- .../audio_source/src/daudio_source_proxy.cpp | 4 +- .../managersource/include/daudio_io_dev.h | 7 +- .../managersource/include/dmic_dev.h | 17 +- .../managersource/src/dmic_dev.cpp | 178 ++++++++++++------ .../servicesource/src/daudio_source_stub.cpp | 13 +- .../sourcedevice/src/dmic_dev_test.cpp | 78 +++++++- 9 files changed, 229 insertions(+), 76 deletions(-) diff --git a/audiohandler/src/daudio_handler.cpp b/audiohandler/src/daudio_handler.cpp index 8cf59a9b..ded3cf65 100644 --- a/audiohandler/src/daudio_handler.cpp +++ b/audiohandler/src/daudio_handler.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-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 @@ -51,7 +51,7 @@ int32_t DAudioHandler::Initialize() bool DAudioHandler::AddItemsToObject(DHItem &dhItem, cJSON* infoJson, const int32_t &dhId) { - DHLOGD("get dhId and then add other items into cjson object"); + DHLOGD("Get dhId and then add other items into cjson object"); int32_t deviceType = GetDevTypeByDHId(dhId); if (deviceType == AUDIO_DEVICE_TYPE_MIC) { return AddParamsToJson(dhItem, infoJson, MIC, micInfos_); diff --git a/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h b/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h index 771608b6..2f71fb7d 100644 --- a/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h +++ b/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h @@ -43,7 +43,7 @@ public: int32_t UnLoadDistributedHDF() override; void OnRemoteSourceSvrDied(const wptr &remote); void FinishStartSA(const std::string ¶m, const sptr &remoteObject); - int32_t UpdateDistributedHardwareWorkMode(const std::string &networkId, const std::string &dhId, + int32_t UpdateDistributedHardwareWorkMode(const std::string &devId, const std::string &dhId, const WorkModeParam ¶m) override; private: diff --git a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp index c1b22c74..ace10f85 100644 --- a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp +++ b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp @@ -228,7 +228,7 @@ int32_t DAudioSourceHandler::UpdateDistributedHardwareWorkMode(const std::string const WorkModeParam ¶m) { DHLOGI("Update distributed hardware workmode, devId: %{public}s, dhId: %{public}s.", - GetAnonyString(devId).c_str(), dhId.c_str()); + GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str()); std::lock_guard lock(sourceProxyMutex_); CHECK_NULL_RETURN(dAudioSourceProxy_, ERR_DH_AUDIO_SA_PROXY_NOT_INIT); if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) { diff --git a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_proxy.cpp b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_proxy.cpp index 1617bf45..f79797cf 100644 --- a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_proxy.cpp +++ b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_proxy.cpp @@ -180,8 +180,8 @@ int32_t DAudioSourceProxy::UpdateDistributedHardwareWorkMode(const std::string & MessageOption option; CHECK_AND_RETURN_RET_LOG(!data.WriteInterfaceToken(GetDescriptor()), ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED, "Write InterfaceToken failed"); - CHECK_AND_RETURN_RET_LOG(devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN, - ERR_DH_AUDIO_SA_DEVID_ILLEGAL, "Id is illegal."); + CHECK_AND_RETURN_RET_LOG(devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN || + param.fd < 0 || param.sharedMemLen < 0, ERR_DH_AUDIO_SA_DEVID_ILLEGAL, "Id or workmode param is illegal."); CHECK_AND_RETURN_RET_LOG(!data.WriteString(devId) || !data.WriteString(dhId) || !data.WriteFileDescriptor(param.fd) || !data.WriteInt32(param.sharedMemLen) || !data.WriteUint32(param.scene) || !data.WriteInt32(param.isAVsync), diff --git a/services/audiomanager/managersource/include/daudio_io_dev.h b/services/audiomanager/managersource/include/daudio_io_dev.h index 05c3512c..412f8bc8 100644 --- a/services/audiomanager/managersource/include/daudio_io_dev.h +++ b/services/audiomanager/managersource/include/daudio_io_dev.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-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 @@ -39,6 +39,11 @@ struct AudioAsyncParam { bool isAVsync; }; +enum class AudioAVScene : uint32_t { + BROADCAST = 1, + VIDEOCALL = 2, +}; + class DAudioIoDev : public IDAudioHdiCallback { public: explicit DAudioIoDev(const std::string &devId) diff --git a/services/audiomanager/managersource/include/dmic_dev.h b/services/audiomanager/managersource/include/dmic_dev.h index 78d50f2f..430a7efc 100644 --- a/services/audiomanager/managersource/include/dmic_dev.h +++ b/services/audiomanager/managersource/include/dmic_dev.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-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 @@ -104,6 +104,11 @@ private: void AddToVec(std::vector &container, const AudioCodecType value); bool IsMimeSupported(const AudioCodecType coder); int32_t GetAudioDataFromQueue(std::shared_ptr &data); + int32_t WriteTimeStampToAVsync(const int64_t timePts); + int32_t ReadTimeStampFromAVsync(int64_t &timePts, int64_t &videoUpdatePts); + uint32_t GetQueSize(); + bool IsAVsync(); + int32_t AVsyncMacthScene(std::shared_ptr &data); private: static constexpr uint8_t CHANNEL_WAIT_SECONDS = 5; @@ -111,12 +116,16 @@ private: static constexpr uint8_t SCENE_WAIT_SECONDS = 5; static constexpr size_t DATA_QUEUE_MAX_SIZE = 10; static constexpr size_t DATA_QUEUE_HALF_SIZE = DATA_QUEUE_MAX_SIZE >> 1U; + static constexpr size_t DATA_QUEUE_BROADCAST_SIZE = 20; + static constexpr size_t DATA_QUEUE_VIDEOCALL_SIZE = 20; + static constexpr int64_t TIMESTAMP_COMPENSATION = 0; static constexpr uint32_t LOW_LATENCY_JITTER_MAX_TIME_MS = 150; static constexpr uint32_t LOW_LATENCY_JITTER_TIME_MS = 50; static constexpr uint8_t MMAP_NORMAL_PERIOD = 5; static constexpr uint8_t MMAP_VOIP_PERIOD = 20; static constexpr uint32_t MMAP_WAIT_FRAME_US = 5000; - constexpr static int64_t TIMESTAMP_COMPENSATION = 1333; + static constexpr uint32_t DADUIO_TIME_DIFF_MIN = -80; + static constexpr uint32_t DADUIO_TIME_DIFF_MAX = 5; constexpr static int64_t ONE_FRAME_COMPENSATION = 20000; static constexpr const char* ENQUEUE_THREAD = "micEnqueueTh"; const std::string DUMP_DAUDIO_MIC_READ_FROM_BUF_NAME = "dump_source_mic_read_from_trans.pcm"; @@ -181,8 +190,8 @@ private: std::mutex ptsMutex_; AudioAsyncParam avSyncParam_ {}; std::mutex avSyncMutex_; - uint32_t scene_ = 0; - std::atomic isFirstCaptureFrame_ = true; + uint32_t scene_ = DATA_QUEUE_HALF_SIZE; + std::atomic isStartStatus_ = true; sptr avsyncAshmem_ = nullptr; constexpr static int64_t TIME_CONVERSION_NTOU = 1000; constexpr static int64_t TIME_CONVERSION_STOU = 1000000; diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp index ca843234..7c32dfcd 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -353,7 +353,7 @@ int32_t DMicDev::NotifyEvent(const int32_t streamId, const AudioEvent &event) case AudioEventType::AUDIO_START: curStatus_ = AudioStatus::STATUS_START; isExistedEmpty_.store(false); - isFirstCaptureFrame_.store(true); + isStartStatus_.store(true); break; case AudioEventType::AUDIO_STOP: curStatus_ = AudioStatus::STATUS_STOP; @@ -523,18 +523,102 @@ int32_t DMicDev::WriteStreamData(const int32_t streamId, std::shared_ptr &data) +int32_t DMicDev::ReadTimeStampFromAVsync(int64_t &timePts, int64_t &videoUpdatePts) { - DHLOGI("Data queue size %{public}zu", dataQueue_.size()); - if (dataQueue_.size() < scene_ && isFirstCaptureFrame_.load()) { - DHLOGI("Data queue size less than scene_"); - data = std::make_shared(param_.comParam.frameSize); - return DH_SUCCESS; + if (IsAVsync() && avsyncAshmem_ != nullptr) { + auto syncData = avsyncAshmem_->ReadFromAshmem(avSyncParam_.sharedMemLen, 0); + AVsyncShareData *readSyncShareData = reinterpret_cast(const_cast(syncData)); + while (!readSyncShareData->lock) { + DHLOGE("AVsync lock is false"); + syncData = avsyncAshmem_->ReadFromAshmem(avSyncParam_.sharedMemLen, 0); + readSyncShareData = reinterpret_cast(const_cast(syncData)); + } + DHLOGI("AVsync lock is true"); + readSyncShareData->lock = 0; + bool ret = avsyncAshmem_->WriteToAshmem(static_cast(readSyncShareData), sizeof(AVsyncShareData), 0); + CHECK_AND_RETURN_RET_LOG(!ret, ERR_DH_AUDIO_FAILED, "Write avsync data failed."); + timePts = readSyncShareData->video_current_pts; + videoUpdatePts = readSyncShareData->video_update_clock; + readSyncShareData->lock = 1; + ret = avsyncAshmem_->WriteToAshmem(static_cast(readSyncShareData), sizeof(AVsyncShareData), 0); + CHECK_AND_RETURN_RET_LOG(!ret, ERR_DH_AUDIO_FAILED, "Write avsync data failed."); + DHLOGI("readSyncShareData->audio_current_pts: %{public}" PRId64", readSyncShareData->audio_update_clock: " + "%{public}" PRId64, readSyncShareData->audio_current_pts, readSyncShareData->audio_update_clock); } - isFirstCaptureFrame_.store(false); + return DH_SUCCESS; +} + +int32_t DMicDev::WriteTimeStampToAVsync(const int64_t timePts) +{ + if (IsAVsync() && avsyncAshmem_ != nullptr) { + auto syncData = avsyncAshmem_->ReadFromAshmem(avSyncParam_.sharedMemLen, 0); + AVsyncShareData *readSyncShareData = reinterpret_cast(const_cast(syncData)); + while (!readSyncShareData->lock) { + DHLOGE("AVsync lock is false"); + syncData = avsyncAshmem_->ReadFromAshmem(avSyncParam_.sharedMemLen, 0); + readSyncShareData = reinterpret_cast(const_cast(syncData)); + } + DHLOGI("AVsync lock is true"); + readSyncShareData->lock = 0; + bool ret = avsyncAshmem_->WriteToAshmem(static_cast(readSyncShareData), sizeof(AVsyncShareData), 0); + CHECK_AND_RETURN_RET_LOG(!ret, ERR_DH_AUDIO_FAILED, "Write avsync data failed."); + struct timespec time = {0, 0}; + clock_gettime(CLOCK_REALTIME, &time); + int64_t updatePts = static_cast(time.tv_sec) * TIME_CONVERSION_STOU + + static_cast(time.tv_nsec) / TIME_CONVERSION_NTOU; + readSyncShareData->lock = 1; + readSyncShareData->audio_current_pts = timePts; + readSyncShareData->audio_update_clock = updatePts; + ret = avsyncAshmem_->WriteToAshmem(static_cast(readSyncShareData), sizeof(AVsyncShareData), 0); + CHECK_AND_RETURN_RET_LOG(!ret, ERR_DH_AUDIO_FAILED, "Write avsync data failed."); + DHLOGI("readSyncShareData->audio_current_pts: %{public}" PRId64", readSyncShareData->audio_update_clock: " + "%{public}" PRId64, readSyncShareData->audio_current_pts, readSyncShareData->audio_update_clock); + } + return DH_SUCCESS; +} + +uint32_t DMicDev::GetQueSize() +{ std::lock_guard lock(dataQueueMtx_); - uint32_t queSize = dataQueue_.size(); - if (queSize == 0) { + return dataQueue_.size(); +} + +bool DMicDev::IsAVsync() +{ + bool isAVsync = false; + std::lock_guard lock(avSyncMutex_); + isAVsync = avSyncParam_.isAVsync; + return isAVsync; +} + +int32_t DMicDev::AVsyncMacthScene(std::shared_ptr &data) +{ + if (GetQueSize() < scene_ && isStartStatus_.load()) { + int64_t videoPts = 0; + int64_t audioPts = 0; + int64_t videoUpdatePts = 0; + int32_t ret = ReadTimeStampFromAVsync(videoPts, videoUpdatePts); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "ReadTimeStampFromAVsync failed."); + if (GetQueSize() != 0) { + CHECK_NULL_RETURN(dataQueue_.back(), ERR_DH_AUDIO_FAILED); + audioPts = dataQueue_.back()->GetPts(); + } + int64_t currentTime = static_cast(GetNowTimeUs()); + int64_t estimatedPts = static_cast(audioPts/1000 + (currentTime - videoUpdatePts)/1000); + int64_t diff = static_cast(estimatedPts - videoPts/1000000); + DHLOGD("diff: %{public}" PRId64", videoPts: %{public}" PRId64 + ", audioPts: %{public}" PRId64, diff, videoPts, audioPts); + if (diff > DADUIO_TIME_DIFF_MAX || diff < DADUIO_TIME_DIFF_MIN) { + data = std::make_shared(param_.comParam.frameSize); + } else { + isStartStatus_.store(false); + data = dataQueue_.front(); + dataQueue_.pop_front(); + } + return DH_SUCCESS; + } + isStartStatus_.store(false); + if (GetQueSize() == 0) { isExistedEmpty_.store(true); DHLOGD("Data queue is empty"); data = std::make_shared(param_.comParam.frameSize); @@ -545,6 +629,24 @@ int32_t DMicDev::GetAudioDataFromQueue(std::shared_ptr &data) return DH_SUCCESS; } +int32_t DMicDev::GetAudioDataFromQueue(std::shared_ptr &data) +{ + if (IsAVsync()) { + int32_t ret = AVsyncMacthScene(data); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "AVsyncMacthScene failed."); + } else { + if (GetQueSize() == 0) { + isExistedEmpty_.store(true); + DHLOGD("Data queue is empty"); + data = std::make_shared(param_.comParam.frameSize); + } else { + data = dataQueue_.front(); + dataQueue_.pop_front(); + } + } + return DH_SUCCESS; +} + int32_t DMicDev::ReadStreamData(const int32_t streamId, std::shared_ptr &data) { int64_t startTime = GetNowTimeUs(); @@ -553,36 +655,9 @@ int32_t DMicDev::ReadStreamData(const int32_t streamId, std::shared_ptrlock(avSyncMutex_); - isAVsync = avSyncParam_.isAVsync; - } - if (isAVsync && avsyncAshmem_ != nullptr) { - auto syncData = avsyncAshmem_->ReadFromAshmem(avSyncParam_.sharedMemLen, 0); - AVsyncShareData *readSyncSharedData = reinterpret_cast(const_cast(syncData)); - while (!readSyncSharedData->lock) { - DHLOGE("readSyncSharedData->lock == false"); - syncData = avsyncAshmem_->ReadFromAshmem(avSyncParam_.sharedMemLen, 0); - readSyncSharedData = reinterpret_cast(const_cast(syncData)); - } - avsyncShareData_ = std::make_shared(); - avsyncShareData_->lock = 0; - ret = avsyncAshmem_->WriteToAshmem(static_cast(avsyncShareData_.get()), sizeof(AVsyncShareData), 0); - CHECK_AND_RETURN_RET_LOG(!ret, ERR_DH_AUDIO_FAILED, "Write avsnc data failed"); - struct timespec time = {0, 0}; - clock_gettime(CLOCK_REALTIME, &time); - int64_t updatePts = static_cast(time.tv_sec) * TIME_CONVERSION_STOU + - static_cast(time.tv_nsec) / TIME_CONVERSION_NTOU; - avsyncShareData_->audio_current_pts = data->GetPts(); - avsyncShareData_->audio_update_clock = updatePts; - avsyncShareData_->lock = 1; - ret = avsyncAshmem_->WriteToAshmem(static_cast(avsyncShareData_.get()), sizeof(AVsyncShareData), 0); - CHECK_AND_RETURN_RET_LOG(!ret, ERR_DH_AUDIO_FAILED, "Write avsync data failed."); - DHLOGI("avsyncShareData_->audio_current_pts: %{public}" PRId64", avsyncShareData_->audio_update_clock: " - "%{public}" PRId64, avsyncShareData_->audio_current_pts, avsyncShareData_->audio_update_clock); - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS || data == nullptr, ERR_DH_AUDIO_NULLPTR, "GetAudioData failed"); + ret = WriteTimeStampToAVsync(data->GetPts()); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "WriteTimeStampToAVsync failed"); DumpFileUtil::WriteDumpFile(dumpFileCommn_, static_cast(data->Data()), data->Size()); int64_t endTime = GetNowTimeUs(); @@ -668,7 +743,6 @@ void DMicDev::EnqueueThread() audioData = std::make_shared(param_.comParam.frameSize); } else { audioData = dataQueue_.front(); - DHLOGI("shared_ptr audioData: %{public}" PRId64, audioData->GetPts()); dataQueue_.pop_front(); } if (audioData == nullptr) { @@ -777,26 +851,16 @@ int32_t DMicDev::SendMessage(uint32_t type, std::string content, std::string dst int32_t DMicDev::OnDecodeTransDataDone(const std::shared_ptr &audioData) { - DHLOGD("On Decode Trans Data Done."); - int32_t scene = DATA_QUEUE_HALF_SIZE; - int32_t sceneMax = DATA_QUEUE_MAX_SIZE; - { - std::lock_guard lock(avSyncMutex_); - if (avSyncParam_.isAVsync) { - scene = scene_; - sceneMax = scene_ + scene_; - } - } CHECK_NULL_RETURN(audioData, ERR_DH_AUDIO_NULLPTR); std::lock_guard lock(dataQueueMtx_); dataQueSize_ = curStatus_ != AudioStatus::STATUS_START ? - (param_.captureOpts.capturerFlags == MMAP_MODE ? lowLatencyHalfSize_ : scene) : - (param_.captureOpts.capturerFlags == MMAP_MODE ? lowLatencyMaxfSize_ : sceneMax); + (param_.captureOpts.capturerFlags == MMAP_MODE ? lowLatencyHalfSize_ : scene_) : + (param_.captureOpts.capturerFlags == MMAP_MODE ? lowLatencyMaxfSize_ : scene_ + scene_); if (isExistedEmpty_.load()) { dataQueSize_ = param_.captureOpts.capturerFlags == MMAP_MODE ? dataQueSize_ : DATA_QUEUE_EXT_SIZE; } uint64_t queueSize; - while (dataQueue_.size() > scene_) { + while (dataQueue_.size() > dataQueSize_) { queueSize = static_cast(dataQueue_.size()); DHLOGI("Data queue overflow. buf current size: %{public}" PRIu64, queueSize); dataQueue_.pop_front(); @@ -811,6 +875,7 @@ int32_t DMicDev::OnDecodeTransDataDone(const std::shared_ptr &audioDa DHLOGI("Push new mic data, buf len: %{public}" PRIu64, queueSize); return DH_SUCCESS; } + int32_t DMicDev::AVsyncRefreshAshmem(int32_t fd, int32_t ashmemLength) { DHLOGD("AVsync mode: fd:%{public}d, ashmemLength: %{public}d", fd, ashmemLength); @@ -824,6 +889,7 @@ int32_t DMicDev::AVsyncRefreshAshmem(int32_t fd, int32_t ashmemLength) } return DH_SUCCESS; } + void DMicDev::AVsyncDeintAshmem() { if (avsyncAshmem_ != nullptr) { @@ -839,14 +905,14 @@ int32_t DMicDev::UpdateWorkModeParam(const std::string &devId, const std::string avSyncParam_ = param; if (avSyncParam_.isAVsync) { auto ret = AVsyncRefreshAshmem(avSyncParam_.fd, avSyncParam_.sharedMemLen); - scene_ = indexFlag_; CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "AVsyncRefreshAshmemInfo failed"); + scene_ = avSyncParam_.scene == static_cast(AudioAVScene::BROADCAST) ? + DATA_QUEUE_BROADCAST_SIZE : DATA_QUEUE_VIDEOCALL_SIZE; DHLOGI("AVsync mode opened"); } else { AVsyncDeintAshmem(); avSyncParam_.fd = -1; avSyncParam_.sharedMemLen = 0; - scene_ = indexFlag_; DHLOGI("AVsync mode closed"); } return DH_SUCCESS; diff --git a/services/audiomanager/servicesource/src/daudio_source_stub.cpp b/services/audiomanager/servicesource/src/daudio_source_stub.cpp index 35b37fb0..2d123224 100644 --- a/services/audiomanager/servicesource/src/daudio_source_stub.cpp +++ b/services/audiomanager/servicesource/src/daudio_source_stub.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-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 @@ -184,25 +184,24 @@ int32_t DAudioSourceStub::DAudioNotifyInner(MessageParcel &data, MessageParcel & int32_t DAudioSourceStub::UpdateDAudioWorkModeInner(MessageParcel &data, MessageParcel &reply, MessageOption &option) { - if (!VerifyPermission()) { - DHLOGE("Permission verification fail."); - return ERR_DH_AUDIO_SA_PERMISSION_FAIED; - } int32_t ret = 0; do { + CHECK_AND_RETURN_RET_LOG(!VerifyPermission(), ERR_DH_AUDIO_SA_PERMISSION_FAIED, + "Permission verification fail."); std::string devId = data.ReadString(); std::string dhId = data.ReadString(); WorkModeParam params(-1, 0, 0, 0); params.fd = data.ReadFileDescriptor(); - params.sharedMemLen = data.ReadInt32(); params.scene = data.ReadUint32(); params.isAVsync = data.ReadInt32(); + CHECK_AND_RETURN_RET_LOG(devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN + || params.fd < 0 || params.sharedMemLen < 0, ERR_DH_AUDIO_SA_DEVID_ILLEGAL, "Workmode param is illegal."); ret = UpdateDistributedHardwareWorkMode(devId, dhId, params); DHLOGI("DistributedAudioSourceStub UpdateDistributedHardwareWorkMode %{public}d", ret); } while (0); reply.WriteInt32(ret); - return DH_SUCCESS; + return ret; } } // namespace DistributedHardware } // namespace OHOS 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 332f9ac1..b53b1d70 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp @@ -344,6 +344,61 @@ HWTEST_F(DMicDevTest, Release_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, mic_->RefreshAshmemInfo(streamId, fd, ashmemLength, lengthPerTrans)); } + +/** + * @tc.name: ReadTimeStampFromAVsync_001 + * @tc.desc: Verify ReadTimeStampFromAVsync function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DMicDevTest, ReadTimeStampFromAVsync_001, TestSize.Level1) +{ + int64_t timePts = 0; + int64_t videoUpdatePts = 0; + mic_->avSyncParam_.isAVsync = 0; + EXPECT_EQ(DH_SUCCESS, mic_->ReadTimeStampFromAVsync(timePts, videoUpdatePts)); + mic_->avSyncParam_.isAVsync = 1; + EXPECT_EQ(DH_SUCCESS, mic_->ReadTimeStampFromAVsync(timePts, videoUpdatePts)); +} + +/** + * @tc.name: WriteTimeStampToAVsync_001 + * @tc.desc: Verify WriteTimeStampToAVsync function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DMicDevTest, WriteTimeStampToAVsync_001, TestSize.Level1) +{ + int64_t timePts = 0; + mic_->avSyncParam_.isAVsync = 0; + EXPECT_EQ(DH_SUCCESS, mic_->WriteTimeStampToAVsync(timePts)); + mic_->avSyncParam_.isAVsync = 1; + EXPECT_EQ(DH_SUCCESS, mic_->WriteTimeStampToAVsync(timePts)); +} + +/** + * @tc.name: AVsyncMacthScene_001 + * @tc.desc: Verify AVsyncMacthScene function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DMicDevTest, AVsyncMacthScene_001, TestSize.Level1) +{ + std::shared_ptr writedata = nullptr; + EXPECT_EQ(DH_SUCCESS, mic_->AVsyncMacthScene(writedata)); + auto data = std::make_shared(DEFAULT_AUDIO_DATA_SIZE); + mic_->dataQueue_.push_back(data); + EXPECT_EQ(DH_SUCCESS, mic_->AVsyncMacthScene(writedata)); + mic_->isStartStatus_ = false; + EXPECT_EQ(DH_SUCCESS, mic_->AVsyncMacthScene(writedata)); + mic_->isStartStatus_ = true; + for (size_t i = 0; i < 6; ++i) { + auto data = std::make_shared(DEFAULT_AUDIO_DATA_SIZE); + mic_->dataQueue_.push_back(data); + } + EXPECT_EQ(DH_SUCCESS, mic_->AVsyncMacthScene(writedata)); +} + /** * @tc.name: GetAudioDataFromQueue_001 * @tc.desc: Verify GetAudioDataFromQueue function. @@ -353,7 +408,7 @@ HWTEST_F(DMicDevTest, Release_001, TestSize.Level1) HWTEST_F(DMicDevTest, GetAudioDataFromQueue_001, TestSize.Level1) { mic_->scene_ = 2; - mic_->isFirstCaptureFrame_ = true; + mic_->isStartStatus_ = true; const size_t capacity = 1; auto writeData = std::make_shared(capacity); mic_->dataQueue_.push_back(writeData); @@ -361,12 +416,31 @@ HWTEST_F(DMicDevTest, GetAudioDataFromQueue_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, mic_->GetAudioDataFromQueue(readData)); mic_->dataQueue_.push_back(writeData); EXPECT_EQ(DH_SUCCESS, mic_->GetAudioDataFromQueue(readData)); - mic_->isFirstCaptureFrame_ = false; + mic_->isStartStatus_ = false; EXPECT_EQ(DH_SUCCESS, mic_->GetAudioDataFromQueue(readData)); mic_->scene_ = 3; EXPECT_EQ(DH_SUCCESS, mic_->GetAudioDataFromQueue(readData)); } +/** + * @tc.name: GetAudioDataFromQueue_002 + * @tc.desc: Verify GetAudioDataFromQueue function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DMicDevTest, GetAudioDataFromQueue_002, TestSize.Level1) +{ + mic_->avSyncParam_.isAVsync = 0; + const size_t capacity = 1; + std::shared_ptr readData = nullptr; + EXPECT_EQ(DH_SUCCESS, mic_->GetAudioDataFromQueue(readData)); + auto writeData = std::make_shared(capacity); + mic_->dataQueue_.push_back(writeData); + EXPECT_EQ(DH_SUCCESS, mic_->GetAudioDataFromQueue(readData)); + mic_->avSyncParam_.isAVsync = 1; + EXPECT_EQ(DH_SUCCESS, mic_->GetAudioDataFromQueue(readData)); +} + /** * @tc.name: ReadStreamData_001 * @tc.desc: Verify ReadStreamData and WriteStreamData function. -- Gitee