From b0d56effe5bbcea76d232ae06d455122fe1571d4 Mon Sep 17 00:00:00 2001 From: zenglifeng Date: Tue, 2 Aug 2022 10:38:12 +0800 Subject: [PATCH 01/33] test:part8 add audio testcase of hdi_service Signed-off-by: zenglifeng --- .../src/audio_idl_hdicapture_attr_test.cpp | 36 + .../src/audio_idl_hdirender_attr_test.cpp | 904 ++++++++++++++++++ .../render/src/audio_idl_hdirender_test.cpp | 173 +++- .../src/audio_idl_hdirender_volume_test.cpp | 5 +- ...dl_hdicapture_hardware_dependence_test.cpp | 723 ++++++++++++++ 5 files changed, 1802 insertions(+), 39 deletions(-) create mode 100644 audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp create mode 100644 audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp diff --git a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp index 32af972ec9..3b108ee9b8 100644 --- a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp +++ b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp @@ -595,4 +595,40 @@ attr-sampling-rate=48000"; ret = capture->Stop(capture); EXPECT_EQ(HDF_SUCCESS, ret); } +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via setting the capture is nullptr . +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_Null_007 +* @tc.desc Test AudioCaptureSetSampleAttributes interface, return -3/-4 if the capture is nullptr. +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetSampleAttributes_Null_007, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioCapture *captureNull = nullptr; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + ret = capture->SetSampleAttributes(captureNull, &attrs); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + ret = capture->SetSampleAttributes(capture, nullptr); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** +* @tc.name Test AudioCaptureGetSampleAttributes API via setting the capture is nullptr . +* @tc.number SUB_Audio_HDI_CaptureGetSampleAttributes_Null_002 +* @tc.desc Test AudioCaptureGetSampleAttributes interface, return -3/-4 if the capture is nullptr. +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetSampleAttributes_Null_002, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioCapture *captureNull = nullptr; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + ret = capture->GetSampleAttributes(captureNull, &attrs); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + ret = capture->GetSampleAttributes(capture, nullptr); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} } diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp new file mode 100644 index 0000000000..838aaad017 --- /dev/null +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp @@ -0,0 +1,904 @@ +/* + * Copyright (c) 2022 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 "hdi_service_common.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS::Audio; + +namespace { +class AudioIdlHdiRenderAttrTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + static TestAudioManager *(*GetAudioManager)(const char *); + static TestAudioManager *manager; + static void *handle; + static void (*AudioManagerRelease)(struct AudioManager *); + static void (*AudioAdapterRelease)(struct AudioAdapter *); + static void (*AudioRenderRelease)(struct AudioRender *); + void ReleaseAudioSource(void); +}; + +using THREAD_FUNC = void *(*)(void *); +TestAudioManager *(*AudioIdlHdiRenderAttrTest::GetAudioManager)(const char *) = nullptr; +TestAudioManager *AudioIdlHdiRenderAttrTest::manager = nullptr; +void *AudioIdlHdiRenderAttrTest::handle = nullptr; +void (*AudioIdlHdiRenderAttrTest::AudioManagerRelease)(struct AudioManager *) = nullptr; +void (*AudioIdlHdiRenderAttrTest::AudioAdapterRelease)(struct AudioAdapter *) = nullptr; +void (*AudioIdlHdiRenderAttrTest::AudioRenderRelease)(struct AudioRender *) = nullptr; + +void AudioIdlHdiRenderAttrTest::SetUpTestCase(void) +{ + char absPath[PATH_MAX] = {0}; + char *path = realpath(RESOLVED_PATH.c_str(), absPath); + ASSERT_NE(nullptr, path); + handle = dlopen(absPath, RTLD_LAZY); + ASSERT_NE(nullptr, handle); + GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); + ASSERT_NE(nullptr, GetAudioManager); + manager = GetAudioManager(IDL_SERVER_NAME.c_str()); + ASSERT_NE(nullptr, manager); + AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); + ASSERT_NE(nullptr, AudioManagerRelease); + AudioAdapterRelease = (void (*)(struct AudioAdapter *))(dlsym(handle, "AudioAdapterRelease")); + ASSERT_NE(nullptr, AudioAdapterRelease); + AudioRenderRelease = (void (*)(struct AudioRender *))(dlsym(handle, "AudioRenderRelease")); + ASSERT_NE(nullptr, AudioRenderRelease); +} + +void AudioIdlHdiRenderAttrTest::TearDownTestCase(void) +{ + if (AudioManagerRelease !=nullptr) { + AudioManagerRelease(manager); + manager = nullptr; + } + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; + } + if (handle != nullptr) { + dlclose(handle); + handle = nullptr; + } +} + +void AudioIdlHdiRenderAttrTest::SetUp(void) +{ + int32_t ret; + ASSERT_NE(nullptr, manager); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); +} + +void AudioIdlHdiRenderAttrTest::TearDown(void) +{ + ReleaseAudioSource(); +} + +void AudioIdlHdiRenderAttrTest::ReleaseAudioSource(void) +{ + int32_t ret; + if (render != nullptr && AudioRenderRelease != nullptr) { + ret = adapter->DestroyRender(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + AudioRenderRelease(render); + render = nullptr; + } + if (adapter != nullptr && AudioAdapterRelease != nullptr) { + ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str()); + EXPECT_EQ(HDF_SUCCESS, ret); + AudioAdapterRelease(adapter); + adapter = nullptr; + } +} + +/** + * @tc.name Test RenderGetFrameSize API via legal input + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_001 + * @tc.desc Test RenderGetFrameSize interface,return 0 if the FrameSize was obtained successfully + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_001, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + uint64_t zero = 0; + ASSERT_NE(nullptr, render); + + ret = render->GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, zero); +} +/** + * @tc.name Test AudioCaptureGetFrameSize API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_Null_002 + * @tc.desc Test RenderGetFrameSize interface,return -3/-4 if failed to get the FrameSize when handle is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_Null_002, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + struct AudioRender *renderNull = nullptr; + ASSERT_NE(nullptr, render); + + ret = render->GetFrameSize(renderNull, &size); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** + * @tc.name Test RenderGetFrameCount API via legal + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_001 + * @tc.desc Test RenderGetFrameCount interface, return 0 if the FrameSize was obtained successfully + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_001, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + uint64_t zero = 0; + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = render->GetFrameCount(render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, zero); + render->Stop(render); +} +/** + * @tc.name Test RenderGetFrameCount API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_Null_002 + * @tc.desc Test RenderGetFrameCount interface,return -3/-4 if the incoming parameter handle is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_Null_002, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioRender *renderNull = nullptr; + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = render->GetFrameCount(renderNull, &count); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + render->Stop(render); +} +/** + * @tc.name Test RenderGetFrameCount API setting the incoming parameter count is nullptr + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_Null_003 + * @tc.desc Test RenderGetFrameCount interface,return -3 if the incoming parameter count is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_Null_003, TestSize.Level1) +{ + int32_t ret; + uint64_t *countNull = nullptr; + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = render->GetFrameCount(render, countNull); + EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); + + render->Stop(render); +} +/** + * @tc.name Test RenderGetCurrentChannelId API via legal input + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_001 + * @tc.desc Test RenderGetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_001, TestSize.Level1) +{ + int32_t ret; + uint32_t channelId = 0; + uint32_t channelIdValue = CHANNELCOUNT; + + ASSERT_NE(nullptr, render); + ret = render->GetCurrentChannelId(render, &channelId); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelIdValue, channelId); +} +/** + * @tc.name Test GetCurrentChannelId API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_Null_003 + * @tc.desc Test GetCurrentChannelId interface,return -3/-4 if set the parameter render is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_Null_003, TestSize.Level1) +{ + int32_t ret; + uint32_t channelId = 0; + struct AudioRender *renderNull = nullptr; + ASSERT_NE(nullptr, render); + + ret = render->GetCurrentChannelId(renderNull, &channelId); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** + * @tc.name Test RenderGetCurrentChannelId API via setting the parameter channelId is nullptr + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_Null_004 + * @tc.desc Test RenderGetCurrentChannelId interface, return -3 if setting the parameter channelId is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_Null_004, TestSize.Level1) +{ + int32_t ret; + uint32_t *channelIdNull = nullptr; + + ASSERT_NE(nullptr, render); + ret = render->GetCurrentChannelId(render, channelIdNull); + EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting ExtraParams during playback + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_001 + * @tc.desc Test RenderSetExtraParams interface,return 0 if the ExtraParams is set during playback + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_001, TestSize.Level1) +{ + int32_t ret; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000"; + char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000"; + size_t index = 1; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + ASSERT_NE(nullptr, render); + struct PrepareAudioPara audiopara = { + .path = AUDIO_FILE.c_str(), .render = render + }; + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + sleep(1); + if (audiopara.render != nullptr) { + ret = audiopara.render->SetExtraParams(audiopara.render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->GetExtraParams(audiopara.render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + string strGetValue = keyValueListValue; + size_t indexAttr = strGetValue.find("attr-frame-count"); + size_t indexFlag = strGetValue.rfind(";"); + if (indexAttr != string::npos && indexFlag != string::npos) { + strGetValue.replace(indexAttr, indexFlag - indexAttr + index, ""); + } + EXPECT_STREQ(keyValueListExp, strGetValue.c_str()); + } + + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting some parameters after playing + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_002 + * @tc.desc Test RenderSetExtraParams interface,return 0 if some parameters is set after playing + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_002, TestSize.Level1) +{ + int32_t ret; + char keyValueListOne[] = "attr-frame-count=1024;"; + char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\ +attr-sampling-rate=48000"; + char keyValueListTwo[] = "attr-format=16;attr-frame-count=1024;"; + char keyValueListTwoExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\ +attr-sampling-rate=48000"; + char keyValueListThr[] = "attr-route=1;attr-channels=1;attr-frame-count=1024;"; + char keyValueListThrExp[] = "attr-route=1;attr-format=16;attr-channels=1;attr-frame-count=1024;\ +attr-sampling-rate=48000"; + char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000"; + char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListValueOne[256] = {}; + char keyValueListValueTwo[256] = {}; + char keyValueListValueThr[256] = {}; + char keyValueListValueFour[256] = {}; + int32_t listLenth = 256; + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetExtraParams(render, keyValueListOne); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValueOne, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne); + ret = render->SetExtraParams(render, keyValueListTwo); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValueTwo, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo); + ret = render->SetExtraParams(render, keyValueListThr); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValueThr, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr); + ret = render->SetExtraParams(render, keyValueListFour); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValueFour, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour); + ret = render->Stop(render); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting keyvaluelist to a value outside the range + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_003 + * @tc.desc Test RenderSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_003, TestSize.Level1) +{ + int32_t ret; + char keyValueList[] = "attr-para=abc;"; + + ASSERT_NE(nullptr, render); + ret = ret = render->SetExtraParams(render, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via adding parameters to keyvaluelist + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_004 + * @tc.desc Test RenderSetExtraParams interface,return -1 if adding parameters to keyvaluelist + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_004, TestSize.Level1) +{ + int32_t ret; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\ +attr-frame-count=82;attr-sampling-rate=48000;attr-para=123"; + + ASSERT_NE(nullptr, render); + ret = render->SetExtraParams(render, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting ExtraParams When the key is the same and the value is + different + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_005 + * @tc.desc Test RenderSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value + is different + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_005, TestSize.Level1) +{ + int32_t ret; + char keyValueList[] = "attr-sampling-rate=48000;attr-sampling-rate=96000;attr-frame-count=4096;"; + char keyValueListExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=96000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetExtraParams(render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListExp, keyValueListValue); + + ret = render->Stop(render); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting the parameter in keyvaluelist as an abnormal value + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_006 + * @tc.desc Test RenderSetExtraParams interface,return -1 if Set the parameter in keyvaluelist + as an abnormal value + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_006, TestSize.Level1) +{ + int32_t ret; + char attrSamplingRateError[] = "attr-sampling-rate=1234567;"; + char attrChannelsError[] = "attr-channels=3;"; + char attrFrameCountError[] = "attr-frame-count=111111111111111111111;"; + char attrRouteError[] = "attr-route=5;"; + char attrFormateError[] = "attr-formate=12;"; + + ASSERT_NE(nullptr, render); + ret = render->SetExtraParams(render, attrSamplingRateError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->SetExtraParams(render, attrChannelsError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->SetExtraParams(render, attrFrameCountError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->SetExtraParams(render, attrRouteError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->SetExtraParams(render, attrFormateError); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_Null_007 + * @tc.desc Test RenderSetExtraParams interface,return -3/-4 if set the parameter render is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_Null_007, TestSize.Level1) +{ + int32_t ret; + struct AudioRender *renderNull = nullptr; + char keyValueList[] = "attr-format=2;"; + + ASSERT_NE(nullptr, render); + ret = render->SetExtraParams(renderNull, keyValueList); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** + * @tc.name Test RenderSetExtraParams API via setting the format of ExtraParams is nullptr + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_008 + * @tc.desc Test RenderSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_008, TestSize.Level1) +{ + int32_t ret; + char keyValueLnullptr[] = "attr-format=;"; + + ASSERT_NE(nullptr, render); + ret = render->SetExtraParams(render, keyValueLnullptr); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting the format of ExtraParams is nullptr + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_Null_009 + * @tc.desc Test RenderSetExtraParams interface,return -3 if set the format of ExtraParams is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_Null_009, TestSize.Level1) +{ + int32_t ret; + char *keyValueListNull = nullptr; + + ASSERT_NE(nullptr, render); + ret = render->SetExtraParams(render, keyValueListNull); + EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); +} +/** + +* @tc.name Test RenderGetExtraParams API via legal input +* @tc.number SUB_Audio_HDI_RenderGetExtraParams_001 +* @tc.desc Test RenderGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_001, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioSampleAttributes attrsValue = {}; + char keyValueList[] = "attr-format=24;attr-frame-count=4096;"; + char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + int32_t formatExp = 3; + uint32_t sampleRateExp = 48000; + uint32_t channelCountExp = 2; + uint32_t frameCountExp = 4096; + + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetExtraParams(render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListExp, keyValueListValue); + + ret = render->GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(formatExp, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + ret = render->GetFrameCount(render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(count, frameCountExp); + + ret = render->Stop(render); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test RenderGetExtraParams API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderGetExtraParams_Null_002 + * @tc.desc Test RenderGetExtraParams interface,return -3/-4 if set the parameter render is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_Null_002, TestSize.Level1) +{ + int32_t ret; + struct AudioRender *renderNull = nullptr; + char keyValueList[] = "attr-format=32;"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + + ASSERT_NE(nullptr, render); + ret = render->SetExtraParams(render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(renderNull, keyValueListValue, listLenth); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** + * @tc.name Test RenderGetExtraParams API via setting listlength to be less than the actual length + * @tc.number SUB_Audio_HDI_RenderGetExtraParams_003 + * @tc.desc Test RenderGetExtraParams interface,return -1 if set listlength to be less than the actual length + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_003, TestSize.Level1) +{ + int32_t ret; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;"; + char keyValueListValue[256] = {}; + int32_t listLenth = 8; + + ASSERT_NE(nullptr, render); + ret = render->SetExtraParams(render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** + * @tc.name Test RenderGetExtraParams API via setting listlenth equal to the actual length + * @tc.number SUB_Audio_HDI_RenderGetExtraParams_004 + * @tc.desc Test RenderGetExtraParams interface,return 0 if set listlenth equal to the actual length + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_004, TestSize.Level1) +{ + int32_t ret; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\ +attr-sampling-rate=48000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 107; + + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetExtraParams(render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetExtraParams(render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueList, keyValueListValue); + + ret = render->Stop(render); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name Test ReqMmapBuffer API via legal input +* @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_001 +* @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully +* @tc.author: liweiming +*/ + +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderReqMmapBuffer_001, TestSize.Level1) +{ + int32_t ret; + bool isRender = true; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc = {}; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, render); + + InitAttrs(attrs); + attrs.startThreshold = 0; + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->Start(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->ReqMmapBuffer(render, reqSize, &desc); + EXPECT_EQ(HDF_SUCCESS, ret); + if (ret == 0) { + munmap(desc.memoryAddress, reqSize); + } + render->Stop(render); + free(desc.filePath); +} +/** +* @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is bigger than + the size of actual audio file +* @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_002 +* @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessfully when setting the + incoming parameter reqSize is bigger than the size of actual audio file +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderReqMmapBuffer_002, TestSize.Level1) +{ + int32_t ret; + bool isRender = true; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc = {}; + ASSERT_NE(nullptr, render); + + ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender); + EXPECT_EQ(HDF_SUCCESS, ret); + reqSize = reqSize + BUFFER_LENTH; + ret = render->Start(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->ReqMmapBuffer(render, reqSize, &desc); + EXPECT_EQ(HDF_FAILURE, ret); + render->Stop(render); + free(desc.filePath); +} +/** +* @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is smaller than + the size of actual audio file +* @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_003 +* @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the + incoming parameter reqSize is smaller than the size of actual audio file +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderReqMmapBuffer_003, TestSize.Level1) +{ + int32_t ret; + bool isRender = true; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc = {}; + ASSERT_NE(nullptr, render); + + ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender); + EXPECT_EQ(HDF_SUCCESS, ret); + reqSize = reqSize / 2; + ret = render->Start(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->ReqMmapBuffer(render, reqSize, &desc); + EXPECT_EQ(HDF_SUCCESS, ret); + if (ret == 0) { + munmap(desc.memoryAddress, reqSize); + } + render->Stop(render); + free(desc.filePath); +} +/** +* @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is zero +* @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_004 +* @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessfully when setting the + incoming parameter reqSize is zero +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderReqMmapBuffer_004, TestSize.Level1) +{ + int32_t ret; + bool isRender = true; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc = {}; + ASSERT_NE(nullptr, render); + + ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender); + EXPECT_EQ(HDF_SUCCESS, ret); + reqSize = 0; + ret = render->Start(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->ReqMmapBuffer(render, reqSize, &desc); + EXPECT_EQ(HDF_FAILURE, ret); + render->Stop(render); + free(desc.filePath); +} +/** +* @tc.name Test ReqMmapBuffer API via setting the incoming parameter memoryFd of desc is illegal +* @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_005 +* @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the + incoming parameter memoryFd of desc is illegal +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderReqMmapBuffer_005, TestSize.Level1) +{ + int32_t ret; + bool isRender = true; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc = {}; + + ASSERT_NE(nullptr, render); + ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender); + EXPECT_EQ(HDF_SUCCESS, ret); + free(desc.filePath); + desc.filePath = strdup("/bin/audio.wav"); + ret = render->Start(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->ReqMmapBuffer(render, reqSize, &desc); + EXPECT_EQ(HDF_FAILURE, ret); + render->Stop(render); + free(desc.filePath); +} +/** +* @tc.name Test ReqMmapBuffer API via the incoming parameter handle is nullptr +* @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_Null_006 +* @tc.desc Test ReqMmapBuffer interface,return -3/-4 if call ReqMmapBuffer interface unsuccessfully when setting the + incoming parameter handle is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderReqMmapBuffer_Null_006, TestSize.Level1) +{ + int32_t ret; + bool isRender = true; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc = {}; + struct AudioRender *renderNull = nullptr; + + ASSERT_NE(nullptr, render); + ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->Start(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->ReqMmapBuffer(renderNull, reqSize, &desc); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + render->Stop(render); + free(desc.filePath); +} +/** +* @tc.name Test ReqMmapBuffer API via the incoming parameter desc is nullptr +* @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_Null_007 +* @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the + incoming parameter desc is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderReqMmapBuffer_Null_007, TestSize.Level1) +{ + int32_t ret; + bool isRender = true; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc = {}; + struct AudioMmapBufferDescripter *descNull = nullptr; + ASSERT_NE(nullptr, render); + ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->Start(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->ReqMmapBuffer(render, reqSize, descNull); + EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); + render->Stop(render); + free(desc.filePath); +} +/** +* @tc.name Test GetMmapPosition API via Getting position is normal in Before playing and Playing. +* @tc.number SUB_Audio_HDI_RenderGetMmapPosition_001 +* @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully. +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetMmapPosition_001, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + uint64_t framesRendering = 0; + uint64_t framesexpRender = 0; + int64_t timeExp = 0; + ASSERT_NE(nullptr, render); + struct PrepareAudioPara audiopara = { + .path = LOW_LATENCY_AUDIO_FILE.c_str(), .render = render + }; + + InitAttrs(audiopara.attrs); + audiopara.attrs.startThreshold = 0; + ret = audiopara.render->SetSampleAttributes(audiopara.render, &(audiopara.attrs)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->GetMmapPosition(audiopara.render, &frames, &(audiopara.time)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp); + EXPECT_EQ(frames, INITIAL_VALUE); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + sleep(1); + ret = audiopara.render->GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp); + EXPECT_GT(framesRendering, INITIAL_VALUE); + int64_t timeExprendering = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec); + void *result = nullptr; + pthread_join(audiopara.tids, &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + ret = audiopara.render->GetMmapPosition(audiopara.render, &framesexpRender, &(audiopara.time)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GE((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExprendering); + EXPECT_GE(framesexpRender, framesRendering); + audiopara.render->Stop(audiopara.render); +} + +/** +* @tc.name Test ReqMmapBuffer API via inputtint frame is nullptr. +* @tc.number SUB_Audio_HDI_RenderGetMmapPosition_Null_003 +* @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetMmapPosition_Null_003, TestSize.Level1) +{ + int32_t ret; + uint64_t *frames = nullptr; + struct AudioTimeStamp time = {}; + + ASSERT_NE(nullptr, render); + ret = render->GetMmapPosition(render, frames, &time); + EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); +} +/** +* @tc.name Test ReqMmapBuffer API via inputtint time is nullptr. +* @tc.number SUB_Audio_HDI_RenderGetMmapPosition_Null_004 +* @tc.desc Test GetMmapPosition interface,return -3/-4 if Error in incoming parameter. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetMmapPosition_Null_004, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + struct AudioTimeStamp *time = nullptr; + + ASSERT_NE(nullptr, render); + ret = render->GetMmapPosition(render, &frames, time); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** +* @tc.name Test ReqMmapBuffer API via inputtint render is nullptr. +* @tc.number SUB_Audio_HDI_RenderGetMmapPosition_Null_005 +* @tc.desc Test GetMmapPosition interface,return -3/-4 if Error in incoming parameter. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetMmapPosition_Null_005, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + struct AudioTimeStamp time = {}; + struct AudioRender *renderNull = nullptr; + + ASSERT_NE(nullptr, render); + ret = render->GetMmapPosition(renderNull, &frames, &time); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** +* @tc.name Test RenderSetSampleAttributes API via setting the render is nullptr . +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_Null_007 +* @tc.desc Test RenderSetSampleAttributes interface, return -3/-4 if the render is nullptr. +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderSetSampleAttributes_Null_007, TestSize.Level1) +{ + int32_t ret; + struct AudioRender *renderNull = nullptr; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + + ret = render->SetSampleAttributes(renderNull, &attrs); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + ret = render->SetSampleAttributes(render, nullptr); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** +* @tc.name Test AudioRendereGetSampleAttributes API via setting the render is nullptr . +* @tc.number SUB_Audio_HDI_RenderGetSampleAttributes_Null_002 +* @tc.desc Test AudioRendereGetSampleAttributes interface, return -3/-4 if the render is nullptr. +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderAttrTest, SUB_Audio_HDI_RenderGetSampleAttributes_Null_002, TestSize.Level1) +{ + int32_t ret; + struct AudioRender *renderNull = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes *attrsValue = nullptr; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + + ret = render->GetSampleAttributes(renderNull, &attrs); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + ret = render->GetSampleAttributes(render, attrsValue); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp index f4f7a09d87..b5aa654be5 100644 --- a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp @@ -30,7 +30,7 @@ public: struct AudioRender *render = nullptr;; static TestAudioManager *(*GetAudioManager)(const char *); static TestAudioManager *manager; - static void *handleSo; + static void *handle; static void (*AudioManagerRelease)(struct AudioManager *); static void (*AudioAdapterRelease)(struct AudioAdapter *); static void (*AudioRenderRelease)(struct AudioRender *); @@ -40,7 +40,7 @@ public: using THREAD_FUNC = void *(*)(void *); TestAudioManager *(*AudioIdlHdiRenderTest::GetAudioManager)(const char *) = nullptr; TestAudioManager *AudioIdlHdiRenderTest::manager = nullptr; -void *AudioIdlHdiRenderTest::handleSo = nullptr; +void *AudioIdlHdiRenderTest::handle = nullptr; void (*AudioIdlHdiRenderTest::AudioManagerRelease)(struct AudioManager *) = nullptr; void (*AudioIdlHdiRenderTest::AudioAdapterRelease)(struct AudioAdapter *) = nullptr; void (*AudioIdlHdiRenderTest::AudioRenderRelease)(struct AudioRender *) = nullptr; @@ -49,17 +49,17 @@ void AudioIdlHdiRenderTest::SetUpTestCase(void) char absPath[PATH_MAX] = {0}; char *path = realpath(RESOLVED_PATH.c_str(), absPath); ASSERT_NE(nullptr, path); - handleSo = dlopen(absPath, RTLD_LAZY); - ASSERT_NE(nullptr, handleSo); - GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); + handle = dlopen(absPath, RTLD_LAZY); + ASSERT_NE(nullptr, handle); + GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); - AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); + AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); ASSERT_NE(nullptr, AudioManagerRelease); - AudioAdapterRelease = (void (*)(struct AudioAdapter *))(dlsym(handleSo, "AudioAdapterRelease")); + AudioAdapterRelease = (void (*)(struct AudioAdapter *))(dlsym(handle, "AudioAdapterRelease")); ASSERT_NE(nullptr, AudioAdapterRelease); - AudioRenderRelease = (void (*)(struct AudioRender *))(dlsym(handleSo, "AudioRenderRelease")); + AudioRenderRelease = (void (*)(struct AudioRender *))(dlsym(handle, "AudioRenderRelease")); ASSERT_NE(nullptr, AudioRenderRelease); } @@ -72,9 +72,9 @@ void AudioIdlHdiRenderTest::TearDownTestCase(void) if (GetAudioManager != nullptr) { GetAudioManager = nullptr; } - if (handleSo != nullptr) { - dlclose(handleSo); - handleSo = nullptr; + if (handle != nullptr) { + dlclose(handle); + handle = nullptr; } } @@ -93,7 +93,7 @@ void AudioIdlHdiRenderTest::TearDown(void) void AudioIdlHdiRenderTest::ReleaseAudioSource(void) { - int32_t ret = -1; + int32_t ret; if (render != nullptr && AudioRenderRelease != nullptr) { ret = adapter->DestroyRender(adapter); EXPECT_EQ(HDF_SUCCESS, ret); @@ -116,7 +116,7 @@ void AudioIdlHdiRenderTest::ReleaseAudioSource(void) */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetLatency_001, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint32_t latencyTime = 0; uint32_t expectLatency = 0; ASSERT_NE(nullptr, render); @@ -137,7 +137,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetLatency_001, TestSize.Lev */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetLatency_Null_002, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint32_t latencyTime = 0; struct AudioRender *renderNull = nullptr; ASSERT_NE(nullptr, render); @@ -157,7 +157,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetLatency_Null_002, TestSiz */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetLatency_Null_003, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint32_t *latencyTime = nullptr; ASSERT_NE(nullptr, render); ret = AudioRenderStartAndOneFrame(render); @@ -176,7 +176,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetLatency_Null_003, TestSiz */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_001, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t requestBytes = 0; uint64_t replyBytes = 0; char *frame = nullptr; @@ -203,7 +203,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_001, TestSize.Level1) */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_Null_002, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t requestBytes = 0; uint64_t replyBytes = 0; struct AudioRender *renderNull = nullptr; @@ -232,7 +232,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_Null_002, TestSize.Lev */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_Null_003, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t requestBytes = 0; uint64_t replyBytes = 0; char *frame = nullptr; @@ -253,7 +253,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_Null_003, TestSize.Lev */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_Null_004, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t requestBytes = 0; char *frame = nullptr; uint64_t *replyBytes = nullptr; @@ -281,7 +281,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_Null_004, TestSize.Lev */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_005, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t replyBytes = 0; uint64_t requestBytes = 0; char *frame = nullptr; @@ -306,7 +306,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderFrame_005, TestSize.Level1) */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_001, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t frames = 0; int64_t timeExp = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; @@ -336,7 +336,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_001, TestS */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_002, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; int64_t timeExp = 0; uint64_t frames = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; @@ -378,7 +378,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_002, TestS */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_003, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; int64_t timeExp = 0; uint64_t frames = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; @@ -401,7 +401,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_003, TestS */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_004, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t frames = 0; int64_t timeExp = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; @@ -419,7 +419,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_004, TestS */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_Null_005, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t frames = 0; struct AudioTimeStamp time = {}; struct AudioRender *renderNull = nullptr; @@ -436,7 +436,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_Null_005, */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_Null_006, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t *framesNull = nullptr; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; @@ -452,7 +452,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_Null_006, */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_Null_007, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; uint64_t frames = 0; struct AudioTimeStamp *timeNull = nullptr; @@ -468,7 +468,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_Null_007, */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_008, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; int64_t timeExp = 0; uint64_t frames = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; @@ -491,7 +491,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderPosition_008, TestS */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderSetRenderSpeed_001, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; float speed = 100; ASSERT_NE(nullptr, render); ret = AudioRenderStartAndOneFrame(render); @@ -509,7 +509,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderSetRenderSpeed_001, TestSize */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderSetRenderSpeed_Null_002, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; float speed = 0; struct AudioRender *renderNull = nullptr; ASSERT_NE(nullptr, render); @@ -528,7 +528,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderSetRenderSpeed_Null_002, Tes */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderSpeed_001, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; float speed = 0; ASSERT_NE(nullptr, render); ret = AudioRenderStartAndOneFrame(render); @@ -545,7 +545,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderSpeed_001, TestSize */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderSpeed_Null_002, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; struct AudioRender *renderNull = nullptr; float speed = 0; ASSERT_NE(nullptr, render); @@ -565,7 +565,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderSpeed_Null_002, Tes */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderSpeed_Null_003, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; float *speedNull = nullptr; ASSERT_NE(nullptr, render); ret = AudioRenderStartAndOneFrame(render); @@ -585,7 +585,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetRenderSpeed_Null_003, Tes */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_001, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; ASSERT_NE(nullptr, render); struct AudioCallback audioCallBack; @@ -608,7 +608,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_001, TestSize.Le */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_002, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; struct AudioSampleAttributes attrs; struct AudioHeadInfo headInfo; ASSERT_NE(nullptr, render); @@ -649,7 +649,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_002, TestSize.Le */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_003, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; struct AudioRender *renderNull = nullptr; ASSERT_NE(nullptr, render); struct AudioCallback audioCallBack; @@ -666,7 +666,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_003, TestSize.Le */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_004, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; struct AudioCallback *AudioRenderCallbackNull = nullptr; ASSERT_NE(nullptr, render); @@ -681,7 +681,7 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_004, TestSize.Le */ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_005, TestSize.Level1) { - int32_t ret = -1; + int32_t ret; ASSERT_NE(nullptr, render); struct AudioCallback audioCallBack; audioCallBack.RenderCallback = nullptr; @@ -689,4 +689,101 @@ HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderRegCallback_005, TestSize.Le EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); } #endif +/** + * @tc.name Test SetChannelMode API via setting channel mode after render object is created + * @tc.number SUB_Audio_HDI_RenderSetChannelMode_003 + * @tc.desc Test SetChannelMode interface,return 0 if set channel mode after render object is created + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderSetChannelMode_003, TestSize.Level1) +{ + int32_t ret; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + ASSERT_NE(nullptr, render); + + ret = render->SetChannelMode(render, mode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); +} + +/** + * @tc.name Test SetChannelMode API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderSetChannelMode_Null_004 + * @tc.desc Test SetChannelMode interface,return -3/-4 if set the parameter render is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderSetChannelMode_Null_004, TestSize.Level1) +{ + int32_t ret; + struct AudioRender *renderNull = nullptr; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + ASSERT_NE(nullptr, render); + + ret = render->SetChannelMode(renderNull, mode); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); +} +/** + * @tc.name Test GetChannelMode API via getting the channel mode after setting + * @tc.number SUB_Audio_HDI_RenderGetChannelMode_001 + * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after setting + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetChannelMode_001, TestSize.Level1) +{ + int32_t ret; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = render->GetChannelMode(render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetChannelMode(render, mode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); + render->Stop(render); +} +/** + * @tc.name Test GetChannelMode API via getting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderGetChannelMode_Null_002 + * @tc.desc Test GetChannelMode interface,return -3/-4 if getting the parameter render is nullptr + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetChannelMode_Null_002, TestSize.Level1) +{ + int32_t ret; + struct AudioRender *renderNull = nullptr; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode *modeNull = nullptr; + + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = render->GetChannelMode(renderNull, &mode); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + ret = render->GetChannelMode(render, modeNull); + EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true); + render->Stop(render); +} +/** + * @tc.name Test GetChannelMode API via getting the channel mode after the render object is created + * @tc.number SUB_Audio_HDI_enderGetChannelMode_003 + * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after the object is created + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderTest, SUB_Audio_HDI_RenderGetChannelMode_003, TestSize.Level1) +{ + int32_t ret; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + ASSERT_NE(nullptr, render); + + ret = render->GetChannelMode(render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); +} } \ No newline at end of file diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp index 40fef0a09f..2326cbc3ab 100644 --- a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp @@ -420,8 +420,11 @@ HWTEST_F(AudioIdlHdiRendervolumeTest, SUB_Audio_HDI_RenderGetMute_001, TestSize. int32_t ret = -1; bool muteTrue = true; bool muteFalse = false; +#ifdef ALSA_LIB_MODE + bool defaultmute = false; +#else bool defaultmute = true; - +#endif ASSERT_NE(nullptr, render); ret = render->GetMute(render, &muteTrue); EXPECT_EQ(HDF_SUCCESS, ret); diff --git a/audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp b/audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp new file mode 100644 index 0000000000..82f3732e8a --- /dev/null +++ b/audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp @@ -0,0 +1,723 @@ +/* + * Copyright (c) 2022 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 "hdi_service_common.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS::Audio; + +namespace { +class AudioIdlHdiCaptureHardwareDependenceTest : public testing::Test { +public: +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + static TestAudioManager *(*GetAudioManager)(const char *); + static TestAudioManager *manager; + static void *handle; + static void (*AudioManagerRelease)(struct AudioManager *); + static void (*AudioAdapterRelease)(struct AudioAdapter *); + static void (*AudioCaptureRelease)(struct AudioCapture *); + void ReleaseCaptureSource(void); +}; + +using THREAD_FUNC = void *(*)(void *); + +TestAudioManager *(*AudioIdlHdiCaptureHardwareDependenceTest::GetAudioManager)(const char *) = nullptr; +TestAudioManager *AudioIdlHdiCaptureHardwareDependenceTest::manager = nullptr; +void *AudioIdlHdiCaptureHardwareDependenceTest::handle = nullptr; +void (*AudioIdlHdiCaptureHardwareDependenceTest::AudioManagerRelease)(struct AudioManager *) = nullptr; +void (*AudioIdlHdiCaptureHardwareDependenceTest::AudioAdapterRelease)(struct AudioAdapter *) = nullptr; +void (*AudioIdlHdiCaptureHardwareDependenceTest::AudioCaptureRelease)(struct AudioCapture *) = nullptr; + +void AudioIdlHdiCaptureHardwareDependenceTest::SetUpTestCase(void) +{ + char absPath[PATH_MAX] = {0}; + char *path = realpath(RESOLVED_PATH.c_str(), absPath); + ASSERT_NE(nullptr, path); + handle = dlopen(absPath, RTLD_LAZY); + ASSERT_NE(nullptr, handle); + GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); + ASSERT_NE(nullptr, GetAudioManager); + manager = GetAudioManager(IDL_SERVER_NAME.c_str()); + ASSERT_NE(nullptr, manager); + AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); + ASSERT_NE(nullptr, AudioManagerRelease); + AudioAdapterRelease = (void (*)(struct AudioAdapter *))(dlsym(handle, "AudioAdapterRelease")); + ASSERT_NE(nullptr, AudioAdapterRelease); + AudioCaptureRelease = (void (*)(struct AudioCapture *))(dlsym(handle, "AudioCaptureRelease")); + ASSERT_NE(nullptr, AudioCaptureRelease); +} + +void AudioIdlHdiCaptureHardwareDependenceTest::TearDownTestCase(void) +{ + if (AudioManagerRelease !=nullptr) { + AudioManagerRelease(manager); + manager = nullptr; + } + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; + } + if (handle != nullptr) { + dlclose(handle); + handle = nullptr; + } +} + +void AudioIdlHdiCaptureHardwareDependenceTest::SetUp(void) +{ + int32_t ret; + ASSERT_NE(nullptr, manager); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); +} + +void AudioIdlHdiCaptureHardwareDependenceTest::TearDown(void) +{ + ReleaseCaptureSource(); +} + +void AudioIdlHdiCaptureHardwareDependenceTest::ReleaseCaptureSource(void) +{ + if (capture != nullptr && AudioCaptureRelease != nullptr) { + adapter->DestroyCapture(adapter); + AudioCaptureRelease(capture); + capture = nullptr; + } + if (adapter != nullptr && AudioAdapterRelease != nullptr) { + manager->UnloadAdapter(manager, ADAPTER_NAME.c_str()); + AudioAdapterRelease(adapter); + adapter = nullptr; + } +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_001 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_8000; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_001, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_002 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_11025; +* attrs.channelCount = 2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_002, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_11025); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_11025, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_003 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_22050; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_003, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_22050); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_004 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_32000; +* attrs.channelCount = 2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_004, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_32000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_32000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_005 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_44100; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_005, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_006 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_COMMUNICATION; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_48000; +* attrs.channelCount = 2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_006, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_008 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_12000; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_008, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_12000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_009 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_16000; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_009, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_16000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_010 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_24000; +* attrs.channelCount = 2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_010, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_24000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_24000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_011 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_64000; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_011, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_64000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_012 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_96000; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_012, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_96000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_013 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16; +* attrs.sampleRate = 0xFFFFFFFFu; +* attrs.channelCount = 2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_013, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, 0xFFFFFFFFu); + ret = capture->SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_014 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN; +* attrs.sampleRate = SAMPLE_RATE_8000/SAMPLE_RATE_11025/SAMPLE_RATE_22050; +* attrs.channelCount = 1/2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_014, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + struct AudioSampleAttributes attrs3 = {}; + ASSERT_NE(nullptr, capture); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_PCM_8_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + ret = capture->SetSampleAttributes(capture, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_PCM_32_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_11025); + ret = capture->SetSampleAttributes(capture, &attrs2); +#ifdef ALSA_LIB_MODE + EXPECT_EQ(HDF_SUCCESS, ret); +#else + EXPECT_EQ(HDF_FAILURE, ret); +#endif + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_22050); + ret = capture->SetSampleAttributes(capture, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_015 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD; +* attrs.sampleRate = SAMPLE_RATE_32000/SAMPLE_RATE_44100/SAMPLE_RATE_48000; +* attrs.channelCount = 1/2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_015, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + struct AudioSampleAttributes attrs3 = {}; + ASSERT_NE(nullptr, capture); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_32000); + ret = capture->SetSampleAttributes(capture, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + ret = capture->SetSampleAttributes(capture, &attrs2); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + ret = capture->SetSampleAttributes(capture, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_016 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2 +* attrs.sampleRate = SAMPLE_RATE_8000/SAMPLE_RATE_44100; +* attrs.channelCount = 1/2; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_016, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + ASSERT_NE(nullptr, capture); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + ret = capture->SetSampleAttributes(capture, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + ret = capture->SetSampleAttributes(capture, &attrs2); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_017 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT +* attrs.sampleRate = SAMPLE_RATE_8000; +* attrs.channelCount = 5; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_017, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, capture); + uint32_t channelCount = 5; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, channelCount, SAMPLE_RATE_8000); + ret = capture->SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); +} +#ifndef ALSA_LIB_MODE +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_018 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT +* attrs.sampleRate = SAMPLE_RATE_8000; +* attrs.channelCount = 2; +* silenceThreshold = 32*1024; +* @tc.author: ZENG LIFENG +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_018, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, capture); + uint32_t silenceThreshold = 32*1024; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_8000, silenceThreshold); + ret = capture->SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_CaptureSetSampleAttributes_019 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT +* attrs.sampleRate = SAMPLE_RATE_8000; +* attrs.channelCount = 2; +* silenceThreshold = 2*1024; +* @tc.author: ZENG LIFENG +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureSetSampleAttributes_019, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, capture); + uint32_t silenceThreshold = 2*1024; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, SAMPLE_RATE_8000, silenceThreshold); + ret = capture->SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); +} +#endif +/** +* @tc.name Test AudioCaptureGetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_CaptureGetSampleAttributes_001 +* @tc.desc Test AudioCaptureGetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_8000; +* attrs.channelCount = 1; +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureGetSampleAttributes_001, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + ret = capture->GetSampleAttributes(capture, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_32000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test CaptureGetFrameSize API via define format to different values +* @tc.number SUB_Audio_HDI_CaptureGetFrameSize_004 +* @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define format as different values +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureGetFrameSize_004, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = capture->GetFrameSize(capture, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); +} +/** +* @tc.name Test CaptureGetFrameSize API via define channelCount to different values +* @tc.number SUB_Audio_HDI_CaptureGetFrameSize_006 +* @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define channelCount as different values +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureGetFrameSize_006, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_44100, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = capture->GetFrameSize(capture, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); +} +/** +* @tc.name Test CaptureGetFrameCount API via define channelCount to different value +* @tc.number SUB_Audio_HDI_CaptureGetFrameCount_005 +* @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define channelCount as different values +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureGetFrameCount_005, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_8000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->GetFrameCount(capture, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = capture->Stop(capture); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name Test CaptureGetFrameCount API via define format to different value +* @tc.number SUB_Audio_HDI_CaptureGetFrameCount_006 +* @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define format as different values +* @tc.author: ZengLifeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureGetFrameCount_006, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, capture); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_8000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->GetFrameCount(capture, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = capture->Stop(capture); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_16_BIT +* @tc.number SUB_Audio_HDI_CaptureGetCapturePosition_009 +* @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT +* @tc.author: ZengLiFeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureGetCapturePosition_009, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + ASSERT_NE(nullptr, capture); + InitAttrs(attrs); + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_16_BIT; + attrs.sampleRate = SAMPLE_RATE_48000; + attrs.channelCount = 2; + ret = capture->SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->GetSampleAttributes(capture, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->GetCapturePosition(capture, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + capture->Stop(capture); +} +/** +* @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_24_BIT +* @tc.number SUB_Audio_HDI_CaptureGetCapturePosition_010 +* @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT +* @tc.author: ZengLiFeng +*/ +HWTEST_F(AudioIdlHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_CaptureGetCapturePosition_010, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + ASSERT_NE(nullptr, capture); + InitAttrs(attrs); + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_24_BIT; + attrs.sampleRate = SAMPLE_RATE_48000; + attrs.channelCount = 2; + ret = capture->SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->GetSampleAttributes(capture, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->GetCapturePosition(capture, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + capture->Stop(capture); +} +} -- Gitee From 05e205bae552edcf50f7bc3ccef09687934a7eb2 Mon Sep 17 00:00:00 2001 From: chenhaifan Date: Tue, 2 Aug 2022 09:55:08 +0800 Subject: [PATCH 02/33] Added mute, volume function interface Signed-off-by: chenhaifan --- .../hal/hdi_binder/proxy/src/audio_proxy_common.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c index 083dc36862..de0ed8afcf 100644 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c @@ -455,3 +455,18 @@ int32_t AudioProxyReqMmapBufferWrite(struct HdfSBuf *data, int32_t reqSize, } return HDF_SUCCESS; } + +int32_t SetMicMute(struct AudioAdapter *adapter, bool mute) +{ + return HDF_ERR_NOT_SUPPORT; +} + +int32_t GetMicMute(struct AudioAdapter *adapter, bool *mute) +{ + return HDF_ERR_NOT_SUPPORT; +} + +int32_t SetVoiceVolume(struct AudioAdapter *adapter, float volume) +{ + return HDF_ERR_NOT_SUPPORT; +} -- Gitee From 3fd2413bbcea9ece509a88cc7ab922d055adccd7 Mon Sep 17 00:00:00 2001 From: chenhaifan Date: Tue, 2 Aug 2022 14:40:37 +0800 Subject: [PATCH 03/33] Added mute and volume interface Signed-off-by: chenhaifan --- .../proxy/include/audio_proxy_internal.h | 3 +++ .../hdi_binder/proxy/src/audio_proxy_adapter.c | 15 +++++++++++++++ .../hal/hdi_binder/proxy/src/audio_proxy_common.c | 15 --------------- .../hdi_binder/proxy/src/audio_proxy_manager.c | 3 +++ 4 files changed, 21 insertions(+), 15 deletions(-) diff --git a/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h b/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h index 1ad51a3829..6e9d27024f 100644 --- a/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h @@ -111,5 +111,8 @@ int32_t AudioProxyCaptureReqMmapBuffer(const AudioHandle capture, int32_t AudioProxyCaptureGetMmapPosition(const AudioHandle capture, uint64_t *frames, struct AudioTimeStamp *time); int32_t AudioProxyCaptureTurnStandbyMode(const AudioHandle capture); int32_t AudioProxyCaptureAudioDevDump(AudioHandle capture, int32_t range, int32_t fd); +int32_t AudioProxyAdapterSetMicMute(struct AudioAdapter *adapter, bool mute); +int32_t AudioProxyAdapterGetMicMute(struct AudioAdapter *adapter, bool *mute); +int32_t AudioProxyAdapterSetVoiceVolume(struct AudioAdapter *adapter, float volume); #endif diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c index 42f63c79ac..1879fad906 100644 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c @@ -894,3 +894,18 @@ int32_t AudioProxyAdapterGetPassthroughMode(struct AudioAdapter *adapter, AudioProxyBufReplyRecycle(data, reply); return AUDIO_HAL_SUCCESS; } + +int32_t AudioProxyAdapterSetMicMute(struct AudioAdapter *adapter, bool mute) +{ + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioProxyAdapterGetMicMute(struct AudioAdapter *adapter, bool *mute) +{ + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioProxyAdapterSetVoiceVolume(struct AudioAdapter *adapter, float volume) +{ + return HDF_ERR_NOT_SUPPORT; +} diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c index de0ed8afcf..083dc36862 100644 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c @@ -455,18 +455,3 @@ int32_t AudioProxyReqMmapBufferWrite(struct HdfSBuf *data, int32_t reqSize, } return HDF_SUCCESS; } - -int32_t SetMicMute(struct AudioAdapter *adapter, bool mute) -{ - return HDF_ERR_NOT_SUPPORT; -} - -int32_t GetMicMute(struct AudioAdapter *adapter, bool *mute) -{ - return HDF_ERR_NOT_SUPPORT; -} - -int32_t SetVoiceVolume(struct AudioAdapter *adapter, float volume) -{ - return HDF_ERR_NOT_SUPPORT; -} diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c index 4809b9cc0e..60eb681b9f 100644 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c @@ -168,6 +168,9 @@ int32_t GetAudioProxyAdapterFunc(struct AudioHwAdapter *hwAdapter) hwAdapter->common.GetPortCapability = AudioProxyAdapterGetPortCapability; hwAdapter->common.SetPassthroughMode = AudioProxyAdapterSetPassthroughMode; hwAdapter->common.GetPassthroughMode = AudioProxyAdapterGetPassthroughMode; + hwAdapter->common.SetMicMute = AudioProxyAdapterSetMicMute; + hwAdapter->common.GetMicMute = AudioProxyAdapterGetMicMute; + hwAdapter->common.SetVoiceVolume = AudioProxyAdapterSetVoiceVolume; return HDF_SUCCESS; } int32_t AudioProxyManagerLoadAdapterDispatch(struct AudioHwAdapter *hwAdapter, struct AudioProxyManager *proxyManager, -- Gitee From 0f2b1447cbc9ffebeb0fae126d1fdb1a730d3773 Mon Sep 17 00:00:00 2001 From: yanchenyang Date: Wed, 3 Aug 2022 10:37:00 +0800 Subject: [PATCH 04/33] fix: free audio event demo listener Signed-off-by: yanchenyang --- audio/BUILD.gn | 2 +- audio/sample/framework_event.c | 32 +++++++++++--------------------- 2 files changed, 12 insertions(+), 22 deletions(-) diff --git a/audio/BUILD.gn b/audio/BUILD.gn index b2954d48ce..00f3010548 100644 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -69,7 +69,7 @@ group("audio_sample_client") { "sample:audio_sample_render", ] } - if (defined(ohos_lite) && ohos_lite == false) { + if (!defined(ohos_lite)) { deps += [ "sample:audio_sample_event" ] } } diff --git a/audio/sample/framework_event.c b/audio/sample/framework_event.c index cf9e8d0c65..2453f9b926 100644 --- a/audio/sample/framework_event.c +++ b/audio/sample/framework_event.c @@ -41,7 +41,6 @@ static int32_t AudioServiceDeviceVal(enum AudioDeviceType deviceType) case HDF_AUDIO_A2DP_DEVICE: // A2dp Service return HDF_ERR_NOT_SUPPORT; default: - printf("Unknown device type.\n"); return HDF_FAILURE; } } @@ -58,7 +57,6 @@ static int32_t AudioServiceDeviceInVal(enum AudioDeviceType deviceType) case HDF_AUDIO_A2DP_DEVICE: // A2dp Service return HDF_ERR_NOT_SUPPORT; default: - printf("Unknown device type.\n"); return HDF_FAILURE; } } @@ -77,7 +75,6 @@ static int32_t AudioServiceMsgParse(struct AudioEvent *svcMsg) case HDF_AUDIO_SERVICE_INVALID: return AudioServiceDeviceInVal(svcMsg->deviceType); default: - printf("Unknown event type.\n"); return HDF_FAILURE; } } @@ -119,7 +116,6 @@ static int32_t AudioLoadDeviceSucc(enum AudioDeviceType deviceType) case HDF_AUDIO_A2DP_DEVICE: // A2dp load return HDF_ERR_NOT_SUPPORT; default: - printf("Unknown device type.\n"); return HDF_FAILURE; } } @@ -136,7 +132,6 @@ static int32_t AudioLoadDeviceFail(enum AudioDeviceType deviceType) case HDF_AUDIO_A2DP_DEVICE: // A2dp load return HDF_ERR_NOT_SUPPORT; default: - printf("Unknown device type.\n"); return HDF_FAILURE; } } @@ -153,7 +148,6 @@ static int32_t AudioUnLoadDevice(enum AudioDeviceType deviceType) case HDF_AUDIO_A2DP_DEVICE: // A2dp load return HDF_ERR_NOT_SUPPORT; default: - printf("Unknown device type.\n"); return HDF_FAILURE; } } @@ -172,7 +166,6 @@ static int32_t AudioLoadMsgParse(struct AudioEvent *loadMsg) case HDF_AUDIO_UNLOAD: return AudioUnLoadDevice(loadMsg->deviceType); default: - printf("Unknown event type.\n"); return HDF_FAILURE; } } @@ -205,18 +198,17 @@ static int AudioGetLoadStatus(struct ServiceStatus *svcStatus) static int32_t AudioPnpDeviceAdd(enum AudioDeviceType deviceType) { switch (deviceType) { - case HDF_AUDIO_USB_HEADPHONE: // USB Type-C Add + case HDF_AUDIO_USB_HEADPHONE: // USB Audio Add case HDF_AUDIO_USBA_HEADPHONE: - printf("*****************: USB type-C earphone microphone add.\n"); + printf("*****************: USB Audio earphone microphone add.\n"); return HDF_SUCCESS; case HDF_AUDIO_USB_HEADSET: case HDF_AUDIO_USBA_HEADSET: - printf("*****************: USB type-C earphone mic&speaker add.\n"); + printf("*****************: USB Audio earphone mic&speaker add.\n"); return HDF_SUCCESS; case HDF_AUDIO_A2DP_DEVICE: // A2dp Add return HDF_ERR_NOT_SUPPORT; default: - printf("Unknown device type.\n"); return HDF_FAILURE; } } @@ -224,18 +216,17 @@ static int32_t AudioPnpDeviceAdd(enum AudioDeviceType deviceType) static int32_t AudioPnpDeviceRemove(enum AudioDeviceType deviceType) { switch (deviceType) { - case HDF_AUDIO_USB_HEADPHONE: // USB Type-C Remove + case HDF_AUDIO_USB_HEADPHONE: // USB Audio Remove case HDF_AUDIO_USBA_HEADPHONE: - printf("*****************: USB type-C earphone microphone remove.\n"); + printf("*****************: USB Audio earphone microphone remove.\n"); return HDF_SUCCESS; case HDF_AUDIO_USB_HEADSET: case HDF_AUDIO_USBA_HEADSET: - printf("*****************: USB Type-C earphone mic&speaker remove.\n"); + printf("*****************: USB Audio earphone mic&speaker remove.\n"); return HDF_SUCCESS; case HDF_AUDIO_A2DP_DEVICE: // A2dp Remove return HDF_ERR_NOT_SUPPORT; default: - printf("Unknown device type.\n"); return HDF_FAILURE; } } @@ -255,7 +246,6 @@ static int32_t AudioPnpMsgParse(struct AudioEvent *pnpMsg) case HDF_AUDIO_DEVICE_REMOVE: return AudioPnpDeviceRemove(pnpMsg->deviceType); default: - printf("Unknown event type.\n"); return HDF_FAILURE; } } @@ -300,11 +290,9 @@ static void AudioUsbPnpOnSvcStatusReceived(struct ServiceStatusListener *listene "\n===============================================================================\n", svcStatus->serviceName, svcStatus->deviceClass, svcStatus->status, svcStatus->info); - AudioGetUsbPnpStatus(svcStatus); - AudioGetLoadStatus(svcStatus); - AudioGetServiceStatus(svcStatus); - - return; + (void)AudioGetUsbPnpStatus(svcStatus); + (void)AudioGetLoadStatus(svcStatus); + (void)AudioGetServiceStatus(svcStatus); } static struct HDIServiceManager *g_servmgr = NULL; @@ -324,6 +312,7 @@ static void StopListenerBySig(int32_t sig) AUDIO_FUNC_LOGE("UnregisterServiceStatusListener fail! ret = %d.\n", ret); return; } + HdiServiceStatusListenerFree(g_listener); HDIServiceManagerRelease(g_servmgr); g_listenerState = false; g_servmgr = NULL; @@ -351,6 +340,7 @@ int main(void) AUDIO_FUNC_LOGE("RegisterServiceStatusListener fail! ret = %d.\n", status); HDIServiceManagerRelease(g_servmgr); g_servmgr = NULL; + HdiServiceStatusListenerFree(g_listener); return HDF_FAILURE; } g_listenerState = true; -- Gitee From 5d86111cf90b415f1e3d39f444014a23dd4dd487 Mon Sep 17 00:00:00 2001 From: zhi-min-huang Date: Wed, 3 Aug 2022 14:27:59 +0800 Subject: [PATCH 05/33] Modify the name of namespace Signed-off-by: zhi-min-huang Change-Id: I9e894dbc653291162c138d9fa3fc5fb5ddc07a04 --- pin_auth/hdi_service/main/inc/pin_auth.h | 4 ++-- pin_auth/hdi_service/main/src/pin_auth.cpp | 4 ++-- pin_auth/hdi_service/service/inc/executor_impl.h | 4 ++-- pin_auth/hdi_service/service/src/executor_impl.cpp | 6 +++--- .../hdi_service/service/src/pin_auth_interface_driver.cpp | 4 ++-- .../hdi_service/service/src/pin_auth_interface_service.cpp | 4 ++-- .../pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp | 2 +- user_auth/hdi_service/hal_sdk/useriam_common.cpp | 4 ++-- user_auth/hdi_service/interface/useriam_common.h | 4 ++-- .../hdi_service/service/user_auth_interface_service.cpp | 6 +++--- 10 files changed, 21 insertions(+), 21 deletions(-) diff --git a/pin_auth/hdi_service/main/inc/pin_auth.h b/pin_auth/hdi_service/main/inc/pin_auth.h index c06e034a54..5575f70a68 100644 --- a/pin_auth/hdi_service/main/inc/pin_auth.h +++ b/pin_auth/hdi_service/main/inc/pin_auth.h @@ -21,7 +21,7 @@ #include "nocopyable.h" namespace OHOS { -namespace UserIAM { +namespace UserIam { namespace PinAuth { struct PinCredentialInfo { uint64_t subType; @@ -50,6 +50,6 @@ private: int32_t PinResultToCoAuthResult(int resultCode); }; } // namespace PinAuth -} // namespace UserIAM +} // namespace UserIam } // namespace OHOS #endif // PIN_AUTH_H diff --git a/pin_auth/hdi_service/main/src/pin_auth.cpp b/pin_auth/hdi_service/main/src/pin_auth.cpp index 29a039b007..0a68a9bfce 100644 --- a/pin_auth/hdi_service/main/src/pin_auth.cpp +++ b/pin_auth/hdi_service/main/src/pin_auth.cpp @@ -25,7 +25,7 @@ #include "securec.h" namespace OHOS { -namespace UserIAM { +namespace UserIam { namespace PinAuth { std::map g_convertResult = { {RESULT_SUCCESS, ResultCodeForCoAuth::SUCCESS}, @@ -355,5 +355,5 @@ int32_t PinAuth::VerifyTemplateData(std::vector templateIdList) return PinResultToCoAuthResult(result); } } // namespace PinAuth -} // namespace UserIAM +} // namespace UserIam } // namespace OHOS diff --git a/pin_auth/hdi_service/service/inc/executor_impl.h b/pin_auth/hdi_service/service/inc/executor_impl.h index 188e3bcc5b..ddff8261de 100644 --- a/pin_auth/hdi_service/service/inc/executor_impl.h +++ b/pin_auth/hdi_service/service/inc/executor_impl.h @@ -30,7 +30,7 @@ namespace PinAuth { namespace V1_0 { class ExecutorImpl : public IExecutor, public NoCopyable { public: - explicit ExecutorImpl(std::shared_ptr pinHdi); + explicit ExecutorImpl(std::shared_ptr pinHdi); virtual ~ExecutorImpl() {} int32_t GetExecutorInfo(ExecutorInfo &info) override; int32_t GetTemplateInfo(uint64_t templateId, TemplateInfo &info) override; @@ -70,7 +70,7 @@ private: private: uint32_t NewSalt(std::vector &salt); void CallError(const sptr &callbackObj, const uint32_t errorCode); - std::shared_ptr pinHdi_; + std::shared_ptr pinHdi_; ScheduleMap scheduleMap_; }; } // V1_0 diff --git a/pin_auth/hdi_service/service/src/executor_impl.cpp b/pin_auth/hdi_service/service/src/executor_impl.cpp index 9cdd4e5ad4..a9fe110ada 100644 --- a/pin_auth/hdi_service/service/src/executor_impl.cpp +++ b/pin_auth/hdi_service/service/src/executor_impl.cpp @@ -35,7 +35,7 @@ static constexpr uint32_t AUTH_PIN = 1; static constexpr uint32_t OPENSSL_SUCCESS = 1; static constexpr uint32_t SUCCESS = 0; -ExecutorImpl::ExecutorImpl(std::shared_ptr pinHdi) : pinHdi_(pinHdi) {} +ExecutorImpl::ExecutorImpl(std::shared_ptr pinHdi) : pinHdi_(pinHdi) {} int32_t ExecutorImpl::GetExecutorInfo(ExecutorInfo &info) { @@ -67,7 +67,7 @@ int32_t ExecutorImpl::GetTemplateInfo(uint64_t templateId, TemplateInfo &info) IAM_LOGE("pinHdi_ is nullptr"); return HDF_FAILURE; } - OHOS::UserIAM::PinAuth::PinCredentialInfo infoRet = {}; + OHOS::UserIam::PinAuth::PinCredentialInfo infoRet = {}; int32_t result = pinHdi_->QueryPinInfo(templateId, infoRet); if (result != SUCCESS) { IAM_LOGE("Get TemplateInfo failed, fail code : %{public}d", result); @@ -176,7 +176,7 @@ int32_t ExecutorImpl::Authenticate(uint64_t scheduleId, uint64_t templateId, con CallError(callbackObj, GENERAL_ERROR); return result; } - OHOS::UserIAM::PinAuth::PinCredentialInfo infoRet = {}; + OHOS::UserIam::PinAuth::PinCredentialInfo infoRet = {}; result = pinHdi_->QueryPinInfo(templateId, infoRet); if (result != SUCCESS) { IAM_LOGE("Get TemplateInfo failed, fail code : %{public}d", result); diff --git a/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp b/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp index 03d4395d8f..b46690cdfd 100644 --- a/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp +++ b/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp @@ -69,8 +69,8 @@ static int HdfPinAuthInterfaceDriverInit(struct HdfDeviceObject *deviceObject) IAM_LOGE("deviceObject is nullptr"); return HDF_ERR_INVALID_PARAM; } - std::shared_ptr pinHdi = - OHOS::UserIam::Common::MakeShared(); + std::shared_ptr pinHdi = + OHOS::UserIam::Common::MakeShared(); constexpr uint32_t SUCCESS = 0; if (pinHdi == nullptr || pinHdi->Init() != SUCCESS) { IAM_LOGE("Pin hal init failed"); diff --git a/pin_auth/hdi_service/service/src/pin_auth_interface_service.cpp b/pin_auth/hdi_service/service/src/pin_auth_interface_service.cpp index 78f4c80d96..9ece9cc31b 100644 --- a/pin_auth/hdi_service/service/src/pin_auth_interface_service.cpp +++ b/pin_auth/hdi_service/service/src/pin_auth_interface_service.cpp @@ -39,8 +39,8 @@ extern "C" IPinAuthInterface *PinAuthInterfaceImplGetInstance(void) int32_t PinAuthInterfaceService::GetExecutorList(std::vector> &executorList) { IAM_LOGI("start"); - std::shared_ptr pinHdi = - OHOS::UserIam::Common::MakeShared(); + std::shared_ptr pinHdi = + OHOS::UserIam::Common::MakeShared(); if (pinHdi == nullptr) { IAM_LOGE("Generate pinHdi failed"); return HDF_FAILURE; diff --git a/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp b/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp index c063679900..e41d4af8da 100644 --- a/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp +++ b/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp @@ -62,7 +62,7 @@ private: int32_t onGetDataResult_; }; -ExecutorImpl g_executorImpl(make_shared()); +ExecutorImpl g_executorImpl(make_shared()); void FillFuzzExecutorInfo(Parcel &parcel, ExecutorInfo &executorInfo) { diff --git a/user_auth/hdi_service/hal_sdk/useriam_common.cpp b/user_auth/hdi_service/hal_sdk/useriam_common.cpp index 4e6b65d62d..b4e5dfb0f1 100644 --- a/user_auth/hdi_service/hal_sdk/useriam_common.cpp +++ b/user_auth/hdi_service/hal_sdk/useriam_common.cpp @@ -26,7 +26,7 @@ #include "ed25519_key.h" namespace OHOS { -namespace UserIAM { +namespace UserIam { namespace Common { static bool g_isInitUserIAM = false; @@ -78,5 +78,5 @@ bool IsIAMInited() return g_isInitUserIAM; } } // Common -} // UserIAM +} // UserIam } // OHOS \ No newline at end of file diff --git a/user_auth/hdi_service/interface/useriam_common.h b/user_auth/hdi_service/interface/useriam_common.h index be679d8293..8ec7be192e 100644 --- a/user_auth/hdi_service/interface/useriam_common.h +++ b/user_auth/hdi_service/interface/useriam_common.h @@ -20,13 +20,13 @@ #include "stdint.h" namespace OHOS { -namespace UserIAM { +namespace UserIam { namespace Common { int32_t Init(); int32_t Close(); bool IsIAMInited(); } // Common -} // UserIAM +} // UserIam } // OHOS #endif // USER_IAM_COMMON_INTERFACE \ No newline at end of file diff --git a/user_auth/hdi_service/service/user_auth_interface_service.cpp b/user_auth/hdi_service/service/user_auth_interface_service.cpp index a2b6945512..fc7bfb0f81 100644 --- a/user_auth/hdi_service/service/user_auth_interface_service.cpp +++ b/user_auth/hdi_service/service/user_auth_interface_service.cpp @@ -52,7 +52,7 @@ extern "C" IUserAuthInterface *UserAuthInterfaceImplGetInstance(void) return nullptr; } std::lock_guard lock(INTERFACE_MUTEX); - OHOS::UserIAM::Common::Init(); + OHOS::UserIam::Common::Init(); return userAuthInterfaceService; } @@ -60,8 +60,8 @@ int32_t UserAuthInterfaceService::Init() { IAM_LOGI("start"); std::lock_guard lock(INTERFACE_MUTEX); - OHOS::UserIAM::Common::Close(); - return OHOS::UserIAM::Common::Init(); + OHOS::UserIam::Common::Close(); + return OHOS::UserIam::Common::Init(); } static bool CopyScheduleInfo(const CoAuthSchedule *in, ScheduleInfo *out) -- Gitee From ce9e7ed7342584d7826e856c3d2079d0a458f9ab Mon Sep 17 00:00:00 2001 From: starfish002 Date: Wed, 3 Aug 2022 11:11:19 +0800 Subject: [PATCH 06/33] use product_name Signed-off-by: starfish002 --- audio/BUILD.gn | 2 +- audio/hal/hdi_binder/server/BUILD.gn | 6 +++--- audio/test/unittest/hdi/adapter/BUILD.gn | 2 +- audio/test/unittest/hdi/capture/BUILD.gn | 2 +- audio/test/unittest/hdi/jack/BUILD.gn | 2 +- audio/test/unittest/hdi/manager/BUILD.gn | 2 +- audio/test/unittest/hdi/render/BUILD.gn | 2 +- 7 files changed, 9 insertions(+), 9 deletions(-) diff --git a/audio/BUILD.gn b/audio/BUILD.gn index 00f3010548..1efda216a7 100644 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -19,7 +19,7 @@ group("hdi_audio") { if (drivers_peripheral_audio_user_mode == false) { deps = [ "hal/hdi_passthrough:hdi_audio" ] } else { - deps = [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps = [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } if (defined(ohos_lite)) { diff --git a/audio/hal/hdi_binder/server/BUILD.gn b/audio/hal/hdi_binder/server/BUILD.gn index 7f4de4cb08..00355ef863 100644 --- a/audio/hal/hdi_binder/server/BUILD.gn +++ b/audio/hal/hdi_binder/server/BUILD.gn @@ -36,7 +36,7 @@ if (drivers_peripheral_audio_hdf_proxy_stub == true) { if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } defines = [] @@ -82,7 +82,7 @@ if (drivers_peripheral_audio_hdf_proxy_stub == true) { if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } if (is_standard_system) { external_deps = [ @@ -126,7 +126,7 @@ if (drivers_peripheral_audio_hdf_proxy_stub == true) { if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } if (is_standard_system) { external_deps = [ diff --git a/audio/test/unittest/hdi/adapter/BUILD.gn b/audio/test/unittest/hdi/adapter/BUILD.gn index b17a7a57f5..f03684ced6 100644 --- a/audio/test/unittest/hdi/adapter/BUILD.gn +++ b/audio/test/unittest/hdi/adapter/BUILD.gn @@ -96,7 +96,7 @@ if (defined(ohos_lite)) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] external_deps = [ "hdf_core:libhdf_utils" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } cflags = [ "-Wall", diff --git a/audio/test/unittest/hdi/capture/BUILD.gn b/audio/test/unittest/hdi/capture/BUILD.gn index bea68fc27a..b5729b1b5a 100644 --- a/audio/test/unittest/hdi/capture/BUILD.gn +++ b/audio/test/unittest/hdi/capture/BUILD.gn @@ -97,7 +97,7 @@ if (defined(ohos_lite)) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] external_deps = [ "hdf_core:libhdf_utils" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } cflags = [ diff --git a/audio/test/unittest/hdi/jack/BUILD.gn b/audio/test/unittest/hdi/jack/BUILD.gn index 9d35c1a46a..07619240f9 100644 --- a/audio/test/unittest/hdi/jack/BUILD.gn +++ b/audio/test/unittest/hdi/jack/BUILD.gn @@ -87,7 +87,7 @@ if (defined(ohos_lite)) { if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } if (is_standard_system) { diff --git a/audio/test/unittest/hdi/manager/BUILD.gn b/audio/test/unittest/hdi/manager/BUILD.gn index 4cdec5e680..367c6cd795 100644 --- a/audio/test/unittest/hdi/manager/BUILD.gn +++ b/audio/test/unittest/hdi/manager/BUILD.gn @@ -88,7 +88,7 @@ if (defined(ohos_lite)) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] external_deps = [ "hdf_core:libhdf_utils" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } cflags = [ diff --git a/audio/test/unittest/hdi/render/BUILD.gn b/audio/test/unittest/hdi/render/BUILD.gn index c828259683..3d0da1ece6 100644 --- a/audio/test/unittest/hdi/render/BUILD.gn +++ b/audio/test/unittest/hdi/render/BUILD.gn @@ -96,7 +96,7 @@ if (defined(ohos_lite)) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] external_deps = [ "hdf_core:libhdf_utils" ] } else { - deps += [ "//device/soc/hisilicon/common/hal/media:hdi_audio" ] + deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } cflags = [ "-Wall", -- Gitee From d9dc151d883baed967da8ced8d665b16bbdf2e58 Mon Sep 17 00:00:00 2001 From: guodongqi Date: Wed, 3 Aug 2022 10:20:57 +0800 Subject: [PATCH 07/33] fix: optimize hdi-gen Signed-off-by: guodongqi --- .../hdi_service/src/battery_interface_driver.cpp | 8 ++++---- .../hdi/ohos/hardware/bt/v1_0/server/bt_hci_driver.cpp | 8 ++++---- .../interfaces/hdi_ipc/server/src/camera_host_driver.cpp | 8 ++++---- display/hdi_service/gralloc/server/allocator_host.cpp | 8 ++++---- .../hdi_service/video_layer/server/video_layer_driver.cpp | 8 ++++---- .../hdi_service/src/config/dcamera_host_config.cpp | 8 ++++---- .../hdi_service/src/config/dcamera_provider_config.cpp | 8 ++++---- face_auth/hdi_service/src/face_auth_interface_driver.cpp | 8 ++++---- .../hdi_service/src/fingerprint_auth_interface_driver.cpp | 8 ++++---- input/hdi_service/input_interfaces_driver.cpp | 8 ++++---- .../input_adapter/input_ipc/service/src/input_driver.cpp | 8 ++++---- light/hdi_service/light_interface_driver.cpp | 8 ++++---- location/agnss/hdi_service/agnss_interface_driver.cpp | 8 ++++---- .../geofence/hdi_service/geofence_interface_driver.cpp | 8 ++++---- location/gnss/hdi_service/gnss_interface_driver.cpp | 8 ++++---- .../hdi_service/src/memorytracker_interface_driver.cpp | 8 ++++---- motion/hdi_service/motion_interface_driver.cpp | 8 ++++---- .../v1_0/hdi_service/connected_tag_interface_driver.cpp | 8 ++++---- nfc/nfc_core/hdi_service/nfc_interface_driver.cpp | 8 ++++---- .../hdi_service/service/src/pin_auth_interface_driver.cpp | 8 ++++---- .../interfaces/hdi_service/src/power_interface_driver.cpp | 8 ++++---- sensor/hdi_service/sensor_interface_driver.cpp | 8 ++++---- .../hdi_service/src/thermal_interface_driver.cpp | 8 ++++---- usb/hdi_service/src/usb_interface_driver.cpp | 8 ++++---- .../hdi_service/service/user_auth_interface_driver.cpp | 8 ++++---- vibrator/hdi_service/vibrator_interface_driver.cpp | 8 ++++---- 26 files changed, 104 insertions(+), 104 deletions(-) diff --git a/battery/interfaces/hdi_service/src/battery_interface_driver.cpp b/battery/interfaces/hdi_service/src/battery_interface_driver.cpp index 257ca8b73b..5b927f38c2 100644 --- a/battery/interfaces/hdi_service/src/battery_interface_driver.cpp +++ b/battery/interfaces/hdi_service/src/battery_interface_driver.cpp @@ -103,10 +103,10 @@ static struct HdfDriverEntry g_batteryInterfaceDriverEntry = { .Release = HdfBatteryInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_batteryInterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/bluetooth/hdi/ohos/hardware/bt/v1_0/server/bt_hci_driver.cpp b/bluetooth/hdi/ohos/hardware/bt/v1_0/server/bt_hci_driver.cpp index 0804ef07eb..29170463fa 100644 --- a/bluetooth/hdi/ohos/hardware/bt/v1_0/server/bt_hci_driver.cpp +++ b/bluetooth/hdi/ohos/hardware/bt/v1_0/server/bt_hci_driver.cpp @@ -85,10 +85,10 @@ struct HdfDriverEntry g_bthciDriverEntry = { .Release = HdfBtHciDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_bthciDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp b/camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp index 38f3c7906a..1d97226c18 100644 --- a/camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp +++ b/camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp @@ -88,12 +88,12 @@ struct HdfDriverEntry g_cameraHostDriverEntry = { .Release = HdfCameraHostDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_cameraHostDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif \ No newline at end of file +#endif /* __cplusplus */ diff --git a/display/hdi_service/gralloc/server/allocator_host.cpp b/display/hdi_service/gralloc/server/allocator_host.cpp index 64df0521ff..871db7ab70 100644 --- a/display/hdi_service/gralloc/server/allocator_host.cpp +++ b/display/hdi_service/gralloc/server/allocator_host.cpp @@ -72,12 +72,12 @@ struct HdfDriverEntry g_AllocatorDriverEntry = { .Release = HdfAllocatorDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_AllocatorDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/display/hdi_service/video_layer/server/video_layer_driver.cpp b/display/hdi_service/video_layer/server/video_layer_driver.cpp index c842adbdff..3ca8590844 100644 --- a/display/hdi_service/video_layer/server/video_layer_driver.cpp +++ b/display/hdi_service/video_layer/server/video_layer_driver.cpp @@ -72,12 +72,12 @@ struct HdfDriverEntry g_displayHostDriverEntry = { .Release = HdfDisplayHostDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_displayHostDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp b/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp index 39f57ae31b..3392848a34 100644 --- a/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp +++ b/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp @@ -95,12 +95,12 @@ static struct HdfDriverEntry g_dCameraHostDriverEntry = { .Release = HdfDCameraHostDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif // __cplusplus +#endif /* __cplusplus */ HDF_INIT(g_dCameraHostDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif // __cplusplus \ No newline at end of file +#endif /* __cplusplus */ diff --git a/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp b/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp index 3c4df64694..ab275ee2ad 100644 --- a/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp +++ b/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp @@ -116,10 +116,10 @@ static struct HdfDriverEntry g_dcameraproviderDriverEntry = { .Release = HdfDCameraProviderDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_dcameraproviderDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/face_auth/hdi_service/src/face_auth_interface_driver.cpp b/face_auth/hdi_service/src/face_auth_interface_driver.cpp index 5f7b7035f1..f69f27305b 100644 --- a/face_auth/hdi_service/src/face_auth_interface_driver.cpp +++ b/face_auth/hdi_service/src/face_auth_interface_driver.cpp @@ -138,10 +138,10 @@ struct HdfDriverEntry g_faceAuthInterfaceDriverEntry = { }; } // namespace -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_faceAuthInterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/fingerprint_auth/hdi_service/src/fingerprint_auth_interface_driver.cpp b/fingerprint_auth/hdi_service/src/fingerprint_auth_interface_driver.cpp index 06be9f1283..6f13f3d36c 100644 --- a/fingerprint_auth/hdi_service/src/fingerprint_auth_interface_driver.cpp +++ b/fingerprint_auth/hdi_service/src/fingerprint_auth_interface_driver.cpp @@ -139,11 +139,11 @@ struct HdfDriverEntry g_fingerprintAuthInterfaceDriverEntry = { }; } // namespace -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_fingerprintAuthInterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/input/hdi_service/input_interfaces_driver.cpp b/input/hdi_service/input_interfaces_driver.cpp index 0739365a2b..fda805b157 100644 --- a/input/hdi_service/input_interfaces_driver.cpp +++ b/input/hdi_service/input_interfaces_driver.cpp @@ -106,10 +106,10 @@ struct HdfDriverEntry g_inputinterfacesDriverEntry = { .Release = HdfInputInterfacesDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_inputinterfacesDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/input/input_adapter/input_ipc/service/src/input_driver.cpp b/input/input_adapter/input_ipc/service/src/input_driver.cpp index 5c681329d8..ff89ed9ac6 100644 --- a/input/input_adapter/input_ipc/service/src/input_driver.cpp +++ b/input/input_adapter/input_ipc/service/src/input_driver.cpp @@ -74,10 +74,10 @@ struct HdfDriverEntry g_inputDriverEntry = { .Init = HdfInputDriverInit, .Release = HdfInputDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_inputDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/light/hdi_service/light_interface_driver.cpp b/light/hdi_service/light_interface_driver.cpp index 44f525f394..7001beb771 100644 --- a/light/hdi_service/light_interface_driver.cpp +++ b/light/hdi_service/light_interface_driver.cpp @@ -110,10 +110,10 @@ struct HdfDriverEntry g_lightinterfaceDriverEntry = { .Release = HdfLightInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_lightinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/location/agnss/hdi_service/agnss_interface_driver.cpp b/location/agnss/hdi_service/agnss_interface_driver.cpp index 2a73871133..004e73f56a 100644 --- a/location/agnss/hdi_service/agnss_interface_driver.cpp +++ b/location/agnss/hdi_service/agnss_interface_driver.cpp @@ -113,10 +113,10 @@ static struct HdfDriverEntry g_agnssinterfaceDriverEntry = { .Release = HdfAGnssInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_agnssinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/location/geofence/hdi_service/geofence_interface_driver.cpp b/location/geofence/hdi_service/geofence_interface_driver.cpp index 8bb83b5803..e4062f555c 100644 --- a/location/geofence/hdi_service/geofence_interface_driver.cpp +++ b/location/geofence/hdi_service/geofence_interface_driver.cpp @@ -113,10 +113,10 @@ static struct HdfDriverEntry g_geofenceinterfaceDriverEntry = { .Release = HdfGeofenceInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_geofenceinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/location/gnss/hdi_service/gnss_interface_driver.cpp b/location/gnss/hdi_service/gnss_interface_driver.cpp index 80382ad2ea..327b6a599b 100644 --- a/location/gnss/hdi_service/gnss_interface_driver.cpp +++ b/location/gnss/hdi_service/gnss_interface_driver.cpp @@ -113,10 +113,10 @@ static struct HdfDriverEntry g_gnssinterfaceDriverEntry = { .Release = HdfGnssInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_gnssinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/memorytracker/hdi_service/src/memorytracker_interface_driver.cpp b/memorytracker/hdi_service/src/memorytracker_interface_driver.cpp index 63f34cac8a..3e1727527d 100644 --- a/memorytracker/hdi_service/src/memorytracker_interface_driver.cpp +++ b/memorytracker/hdi_service/src/memorytracker_interface_driver.cpp @@ -104,10 +104,10 @@ static struct HdfDriverEntry g_memorytrackerinterfaceDriverEntry = { .Release = HdfMemoryTrackerInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_memorytrackerinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/motion/hdi_service/motion_interface_driver.cpp b/motion/hdi_service/motion_interface_driver.cpp index a2538a8c4c..b421c8e675 100644 --- a/motion/hdi_service/motion_interface_driver.cpp +++ b/motion/hdi_service/motion_interface_driver.cpp @@ -100,10 +100,10 @@ struct HdfDriverEntry g_motioninterfaceDriverEntry = { .Release = HdfMotionInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_motioninterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/nfc/connected_tag/v1_0/hdi_service/connected_tag_interface_driver.cpp b/nfc/connected_tag/v1_0/hdi_service/connected_tag_interface_driver.cpp index 264c994a20..a1e0ba5cc4 100644 --- a/nfc/connected_tag/v1_0/hdi_service/connected_tag_interface_driver.cpp +++ b/nfc/connected_tag/v1_0/hdi_service/connected_tag_interface_driver.cpp @@ -84,10 +84,10 @@ static struct HdfDriverEntry g_nfchdiDriverEntry = { .Release = HdfNfcHdiDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_nfchdiDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/nfc/nfc_core/hdi_service/nfc_interface_driver.cpp b/nfc/nfc_core/hdi_service/nfc_interface_driver.cpp index 7ecb98e179..4c98bfe97c 100644 --- a/nfc/nfc_core/hdi_service/nfc_interface_driver.cpp +++ b/nfc/nfc_core/hdi_service/nfc_interface_driver.cpp @@ -113,10 +113,10 @@ struct HdfDriverEntry g_nfcinterfaceDriverEntry = { .Release = HdfNfcInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_nfcinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp b/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp index b46690cdfd..9fbbce07bf 100644 --- a/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp +++ b/pin_auth/hdi_service/service/src/pin_auth_interface_driver.cpp @@ -145,10 +145,10 @@ static struct HdfDriverEntry g_pinAuthInterfaceDriverEntry = { .Release = HdfPinAuthInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_pinAuthInterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif \ No newline at end of file +#endif /* __cplusplus */ diff --git a/power/interfaces/hdi_service/src/power_interface_driver.cpp b/power/interfaces/hdi_service/src/power_interface_driver.cpp index 95c946c1e3..cb6bfb0be5 100644 --- a/power/interfaces/hdi_service/src/power_interface_driver.cpp +++ b/power/interfaces/hdi_service/src/power_interface_driver.cpp @@ -109,10 +109,10 @@ struct HdfDriverEntry g_powerinterfaceDriverEntry = { .Release = HdfPowerInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_powerinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/sensor/hdi_service/sensor_interface_driver.cpp b/sensor/hdi_service/sensor_interface_driver.cpp index b7fd7485cc..1cdaee422a 100644 --- a/sensor/hdi_service/sensor_interface_driver.cpp +++ b/sensor/hdi_service/sensor_interface_driver.cpp @@ -109,10 +109,10 @@ struct HdfDriverEntry g_sensorinterfaceDriverEntry = { .Release = HdfSensorInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_sensorinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/thermal/interfaces/hdi_service/src/thermal_interface_driver.cpp b/thermal/interfaces/hdi_service/src/thermal_interface_driver.cpp index 0ad0cafab5..0fd8ddec9a 100644 --- a/thermal/interfaces/hdi_service/src/thermal_interface_driver.cpp +++ b/thermal/interfaces/hdi_service/src/thermal_interface_driver.cpp @@ -108,10 +108,10 @@ struct HdfDriverEntry g_thermalinterfaceDriverEntry = { .Release = HdfThermalInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_thermalinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif \ No newline at end of file +#endif /* __cplusplus */ diff --git a/usb/hdi_service/src/usb_interface_driver.cpp b/usb/hdi_service/src/usb_interface_driver.cpp index 63845adb5d..c4186b5cd8 100644 --- a/usb/hdi_service/src/usb_interface_driver.cpp +++ b/usb/hdi_service/src/usb_interface_driver.cpp @@ -126,10 +126,10 @@ static struct HdfDriverEntry g_usbInterfaceDriverEntry = { .Release = HdfUsbInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_usbInterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/user_auth/hdi_service/service/user_auth_interface_driver.cpp b/user_auth/hdi_service/service/user_auth_interface_driver.cpp index d8c4190467..b5227a51e4 100644 --- a/user_auth/hdi_service/service/user_auth_interface_driver.cpp +++ b/user_auth/hdi_service/service/user_auth_interface_driver.cpp @@ -125,10 +125,10 @@ struct HdfDriverEntry g_userAuthInterfaceDriverEntry = { .Release = HdfUserAuthInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_userAuthInterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ diff --git a/vibrator/hdi_service/vibrator_interface_driver.cpp b/vibrator/hdi_service/vibrator_interface_driver.cpp index 44f21e54dd..baeb1330e1 100644 --- a/vibrator/hdi_service/vibrator_interface_driver.cpp +++ b/vibrator/hdi_service/vibrator_interface_driver.cpp @@ -108,10 +108,10 @@ struct HdfDriverEntry g_vibratorInterfaceDriverEntry = { .Release = HdfVibratorInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif /* __cplusplus */ HDF_INIT(g_vibratorInterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif /* __cplusplus */ -- Gitee From d7b95163a18ee7e3bf95785e98aaa4bcfd5183e6 Mon Sep 17 00:00:00 2001 From: hobbycao Date: Wed, 3 Aug 2022 17:42:41 +0800 Subject: [PATCH 08/33] fix: metadata DecodeFromString memory over write Signed-off-by: hobbycao --- camera/interfaces/metadata/src/metadata_utils.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/camera/interfaces/metadata/src/metadata_utils.cpp b/camera/interfaces/metadata/src/metadata_utils.cpp index d28151fef7..d391bc3421 100644 --- a/camera/interfaces/metadata/src/metadata_utils.cpp +++ b/camera/interfaces/metadata/src/metadata_utils.cpp @@ -230,8 +230,6 @@ std::shared_ptr MetadataUtils::DecodeFromString(std::string sett METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed to copy memory for metadata header"); return {}; } - header.item_capacity = header.item_count; - header.data_capacity = header.data_count; std::shared_ptr metadata = std::make_shared(header.item_capacity, header.data_capacity); common_metadata_header_t *meta = metadata->get(); -- Gitee From 604675269ccea55474267b75d67d836b0be50c39 Mon Sep 17 00:00:00 2001 From: zenglifeng Date: Wed, 27 Jul 2022 16:16:18 +0800 Subject: [PATCH 09/33] =?UTF-8?q?Revert=20"=E5=9B=9E=E9=80=80=20'Pull=20Re?= =?UTF-8?q?quest=20!1709=20:=20fix:=20added=20ALSA=20sound=20card=20config?= =?UTF-8?q?urable.'"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit a4adf80f93aca64ca7cd2564319b03027a839bc7. Signed-off-by: zenglifeng --- audio/BUILD.gn | 4 + audio/config/linux/BUILD.gn | 8 + audio/supportlibs/BUILD.gn | 4 + .../alsa_adapter/include/alsa_lib_capture.h | 2 +- .../alsa_adapter/include/alsa_lib_common.h | 90 ++- .../alsa_adapter/include/alsa_lib_render.h | 2 +- .../alsa_adapter/src/alsa_lib_capture.c | 483 ++++++++------ .../alsa_adapter/src/alsa_lib_common.c | 591 ++++++++++++++---- .../alsa_adapter/src/alsa_lib_render.c | 561 ++++++++++------- 9 files changed, 1182 insertions(+), 563 deletions(-) diff --git a/audio/BUILD.gn b/audio/BUILD.gn index 1efda216a7..c432a14794 100644 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -36,6 +36,10 @@ group("hdi_audio") { ] } deps += [ "hdi_service:idl_audio" ] + + if (drivers_peripheral_audio_alsa_lib) { + deps += [ "config/linux:hdf_alsa_adapter_json" ] + } } if (drivers_peripheral_audio_user_mode == false) { diff --git a/audio/config/linux/BUILD.gn b/audio/config/linux/BUILD.gn index 0851d468c6..93089130e8 100644 --- a/audio/config/linux/BUILD.gn +++ b/audio/config/linux/BUILD.gn @@ -40,4 +40,12 @@ if (is_standard_system) { subsystem_name = "hdf" part_name = "drivers_peripheral_audio" } + + ohos_prebuilt_etc("hdf_alsa_adapter_json") { + source = "//vendor/${product_company}/${product_name}/hals/audio/alsa_adapter.json" + relative_install_dir = "hdfconfig" + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_audio" + } } diff --git a/audio/supportlibs/BUILD.gn b/audio/supportlibs/BUILD.gn index 0ef86fd3f4..d235c3ee98 100644 --- a/audio/supportlibs/BUILD.gn +++ b/audio/supportlibs/BUILD.gn @@ -93,6 +93,7 @@ if (defined(ohos_lite)) { sources += [ "//drivers/peripheral/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c", "//drivers/peripheral/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c", + "//third_party/cJSON/cJSON.c", ] } else { sources += [ @@ -118,6 +119,7 @@ if (defined(ohos_lite)) { include_dirs += [ "//third_party/alsa-lib/include", "//drivers/peripheral/audio/supportlibs/alsa_adapter/include", + "//third_party/cJSON", ] deps += [ "//third_party/alsa-lib:libasound" ] } else { @@ -151,6 +153,7 @@ if (defined(ohos_lite)) { sources += [ "//drivers/peripheral/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c", "//drivers/peripheral/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c", + "//third_party/cJSON/cJSON.c", ] } else { sources += [ @@ -177,6 +180,7 @@ if (defined(ohos_lite)) { include_dirs += [ "//drivers/peripheral/audio/supportlibs/alsa_adapter/include", "//third_party/alsa-lib/include", + "//third_party/cJSON", ] deps += [ "//third_party/alsa-lib:libasound" ] } else { diff --git a/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h b/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h index d64d275cb2..d5b8ee5383 100644 --- a/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h @@ -16,7 +16,7 @@ #ifndef ALSA_LIB_CAPTURE_H #define ALSA_LIB_CAPTURE_H -#include "audio_if_lib_capture.h" #include "alsa_lib_common.h" +#include "audio_if_lib_capture.h" #endif /* ALSA_LIB_CAPTURE_H */ diff --git a/audio/supportlibs/alsa_adapter/include/alsa_lib_common.h b/audio/supportlibs/alsa_adapter/include/alsa_lib_common.h index 0abf20e369..f86065382c 100644 --- a/audio/supportlibs/alsa_adapter/include/alsa_lib_common.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_lib_common.h @@ -25,68 +25,62 @@ #define SERVIC_NAME_MAX_LEN 32 -#define MAX_VOLUME 100 -#define MIN_VOLUME 0 -#define MAX_ELEMENT 100 -#define AUDIO_MIN_CARD_NUM 1 -#define AUDIO_MAX_CARD_NUM 8 -#define MAX_CARD_NAME_LEN 64 -#define MAX_CARD_NUM (4 * AUDIO_MAX_CARD_NUM) - -#define SND_DEVCICE_DEFAULT "default" /** about SND_DEVCICE0 */ -#define SND_DEVCICE0 "hw:0,0" -#define SND_DEVCICE1 "hw:1,0" - -#define CTRL_DEVCICE_DEFAULT "hw:0" - -#define USB_AUDIO "USB Audio" - -/** Codec list supported by current driver */ -#define CODEC_CARD_ID "rockchiprk809co" /** rockchip,rk809-codec cid */ +#define MAX_VOLUME 100 +#define MIN_VOLUME 0 +#define AUDIO_MIN_CARD_NUM 1 +#define AUDIO_MAX_CARD_NUM 8 +#define CARD_ID_LEN_MAX 32 +#define MAX_CARD_NAME_LEN 64 +#define MAX_CARD_NUM (4 * (AUDIO_MAX_CARD_NUM)) #define AUDIO_ALSALIB_IOCTRL_RESUME 0 #define AUDIO_ALSALIB_IOCTRL_PAUSE 1 #define AUDIO_ALSALIB_MMAP_MAX 10 +#define AUDIO_ALSALIB_RETYR 3 enum SndRKPlayPathItem { - SND_OUT_CARD_OFF, - SND_OUT_CARD_RCV, - SND_OUT_CARD_SPK, - SND_OUT_CARD_HP, - SND_OUT_CARD_HP_NO_MIC, - SND_OUT_CARD_BT, - SND_OUT_CARD_SPK_HP, - SND_OUT_CARD_RING_SPK, - SND_OUT_CARD_RING_HP, - SND_OUT_CARD_RING_HP_NO_MIC, - SND_OUT_CARD_RING_SPK_HP + SND_OUT_CARD_OFF, /* close play path */ + SND_OUT_CARD_RCV, /* speaker */ + SND_OUT_CARD_SPK, /* speaker */ + SND_OUT_CARD_HP, /* headphone */ + SND_OUT_CARD_HP_NO_MIC, /* headphone */ + SND_OUT_CARD_BT, /* bluetooth (Don't set!!!) */ + SND_OUT_CARD_SPK_HP, /* speaker and headphone */ + SND_OUT_CARD_RING_SPK, /* speaker */ + SND_OUT_CARD_RING_HP, /* headphone */ + SND_OUT_CARD_RING_HP_NO_MIC, /* headphone */ + SND_OUT_CARD_RING_SPK_HP /* speaker and headphone */ }; enum SndRKCapPathItem { - SND_OUT_CARD_MIC_OFF, - SND_OUT_CARD_MAIN_MIC, - SND_OUT_CARD_HANDS_FREE_MIC, - SND_OUT_CARD_BT_SCO_MIC + SND_IN_CARD_MIC_OFF, /* close capture path */ + SND_IN_CARD_MAIN_MIC, /* main mic */ + SND_IN_CARD_HANDS_FREE_MIC, /* hands free mic */ + SND_IN_CARD_BT_SCO_MIC /* bluetooth sco mic (Don't set!!!) */ }; enum SndRKCtrlNumId { - SND_PLAY_PATH = 1, - SND_CAP_MIC_PATH, - SND_DACL_PLAY_VOL, - SND_DACR_PLAY_VOL, - SND_DACL_CAP_VOL, - SND_DACR_CAP_VOL + SND_PLAY_PATH = 1, /* play path */ + SND_CAP_MIC_PATH, /* capture path */ + SND_DACL_PLAY_VOL, /* play left volume path */ + SND_DACR_PLAY_VOL, /* play right volume path */ + SND_DACL_CAP_VOL, /* capture left volume path */ + SND_DACR_CAP_VOL /* capture right volume path */ }; -struct DeviceInfo { - const char *id; - int32_t card; - int32_t device; +enum SndCardType { + SND_CARD_UNKNOWN = -1, + SND_CARD_PRIMARY = 0, + SND_CARD_HDMI, + SND_CARD_USB, + SND_CARD_BT, + SND_CARD_MAX }; struct DevProcInfo { - const char *cid; /* cardX/id match */ - const char *did; /* dai id match */ + char cardName[CARD_ID_LEN_MAX]; + char cid[CARD_ID_LEN_MAX]; /* cardX/id match */ + char did[CARD_ID_LEN_MAX]; /* dai id match */ }; struct AlsaDevInfo { @@ -107,6 +101,7 @@ struct AudioCardInfo { bool captureMmapFlag; int32_t renderMuteValue; int32_t captureMuteValue; + float tempVolume; uint64_t renderMmapFrames; uint64_t capMmapFrames; uint64_t mmapFrames; @@ -132,8 +127,9 @@ void GetDeviceList(struct AudioCardInfo *cardIns, snd_pcm_stream_t stream); int32_t GetSelCardInfo(struct AudioCardInfo *cardIns, struct AlsaDevInfo *devInsHandle); int32_t MatchSelAdapter(const char *adapterName, struct AudioCardInfo *cardIns); int32_t GetPriMixerCtlElement(struct AudioCardInfo *cardIns, snd_mixer_elem_t *pcmElement); -int32_t AudioMixerSetCtrlMode(struct AudioCardInfo *cardIns, - const char *adapterName, const char *mixerCtrlName, int numId, int item); +int32_t AudioMixerSetCtrlMode( + struct AudioCardInfo *cardIns, const char *adapterName, const char *mixerCtrlName, int numId, int item); snd_mixer_elem_t *AudioUsbFindElement(snd_mixer_t *mixer); +int32_t CardInfoParseFromConfig(void); #endif /* ALSA_LIB_COMMON_H */ diff --git a/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h b/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h index a6a98f16c9..ffd95d7d7e 100644 --- a/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h @@ -16,7 +16,7 @@ #ifndef ALSA_LIB_RENDER_H #define ALSA_LIB_RENDER_H -#include "audio_if_lib_render.h" #include "alsa_lib_common.h" +#include "audio_if_lib_render.h" #endif /* ALSA_LIB_RENDER_H */ diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c index 1c22bd906b..ac7feb9ab3 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c @@ -18,19 +18,20 @@ #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB -#define AUDIO_TIMESTAMP_FREQ 8 /* Hz */ -#define AUDIO_SAMPLE_FREQ 48000 -#define AUDIO_PERIOD (AUDIO_SAMPLE_FREQ / AUDIO_TIMESTAMP_FREQ) -#define AUDIO_PCM_WAIT 100 -#define AUDIO_RESUME_POLL (10 * AUDIO_PCM_WAIT) // 1s - -static unsigned int g_bufferTime = 500000; /* ring buffer length in us */ -static unsigned int g_periodTime = 100000; /* period time in us */ +#define AUDIO_TIMESTAMP_FREQ 8 /* Hz */ +#define AUDIO_SAMPLE_FREQ 48000 +#define AUDIO_PERIOD ((AUDIO_SAMPLE_FREQ) / (AUDIO_TIMESTAMP_FREQ)) +#define AUDIO_PCM_WAIT 100 +#define AUDIO_RESUME_POLL (10 * (AUDIO_PCM_WAIT)) // 1s +#define ALSA_CAP_BUFFER_SIZE (2 * 2 * 6000) // format(S16LE) * channels(2) * period. + +static unsigned int g_bufferTime = 500000; /* (0.5s): ring buffer length in us */ +static unsigned int g_periodTime = 100000; /* (0.1s): period time in us */ static snd_pcm_sframes_t g_bufferSize = 0; static snd_pcm_sframes_t g_periodSize = 0; -static int g_resample = 1; /* enable alsa-lib resampling */ -static int g_periodEvent = 0; /* produce poll event after each period */ -static int g_canPause = 0; /* 0 Hardware doesn't support pause, 1 Hardware supports pause */ +static int g_resample = 1; /* enable alsa-lib resampling */ +static int g_periodEvent = 0; /* produce poll event after each period */ +static int g_canPause = 0; /* 0 Hardware doesn't support pause, 1 Hardware supports pause */ static int32_t AudioSetMixerCapVolume(snd_mixer_elem_t *pcmElemen, long vol) { @@ -44,8 +45,7 @@ static int32_t AudioSetMixerCapVolume(snd_mixer_elem_t *pcmElemen, long vol) /* Judge whether it is mono or stereo */ ret = snd_mixer_selem_is_capture_mono(pcmElemen); if (ret == 1) { // mono - ret = snd_mixer_selem_set_capture_volume(pcmElemen, - SND_MIXER_SCHN_MONO, vol); + ret = snd_mixer_selem_set_capture_volume(pcmElemen, SND_MIXER_SCHN_MONO, vol); if (ret < 0) { AUDIO_FUNC_LOGE("Failed to set volume: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; @@ -53,8 +53,7 @@ static int32_t AudioSetMixerCapVolume(snd_mixer_elem_t *pcmElemen, long vol) } else { // ret == 0: is not mono. (stereo) ret = snd_mixer_selem_set_capture_volume_all(pcmElemen, vol); if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to set all channel volume: %{public}s.", - snd_strerror(ret)); + AUDIO_FUNC_LOGE("Failed to set all channel volume: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } } @@ -72,13 +71,18 @@ static int32_t AudioCaptureSetPauseState(snd_pcm_t *pcm, int32_t pause) } if (pause == AUDIO_ALSALIB_IOCTRL_RESUME) { - ret = snd_pcm_resume(pcm); + ret = snd_pcm_prepare(pcm); if (ret < 0) { - AUDIO_FUNC_LOGE("Resume fail: %{public}s", snd_strerror(ret)); + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + ret = snd_pcm_start(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); return HDF_FAILURE; } } else if (pause == AUDIO_ALSALIB_IOCTRL_PAUSE) { - ret = snd_pcm_pause(pcm, pause); + ret = snd_pcm_drop(pcm); if (ret < 0) { AUDIO_FUNC_LOGE("Pause fail: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -90,25 +94,19 @@ static int32_t AudioCaptureSetPauseState(snd_pcm_t *pcm, int32_t pause) return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetPauseStu(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetPauseStu( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; int32_t pause; struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Param is NULL!"); return HDF_FAILURE; } - /* The hardware does not support pause/resume, - * so a success message is returned. - * The software processing scheme is implemented - * in AudioCaptureReadFrame interface. - */ - return HDF_SUCCESS; - const char *adapterName = handleData->captureMode.hwInfo.adapterName; cardIns = GetCardIns(adapterName); if (cardIns == NULL) { @@ -116,8 +114,7 @@ int32_t AudioCtlCaptureSetPauseStu(const struct DevHandleCapture *handle, return HDF_FAILURE; } - pause = handleData->captureMode.ctlParam.pause ? - AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; + pause = handleData->captureMode.ctlParam.pause ? AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; ret = AudioCaptureSetPauseState(cardIns->capturePcmHandle, pause); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("set pause error!"); @@ -127,17 +124,18 @@ int32_t AudioCtlCaptureSetPauseStu(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetVolume(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetVolume( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - long volEverage; - long volLeft = 0; - long volRight = 0; + long volEverage; + long volLeft = 0; + long volRight = 0; struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderSetVolume parameter is NULL!"); + AUDIO_FUNC_LOGE("AudioCtlCaptureSetVolume parameter is NULL!"); return HDF_FAILURE; } @@ -160,13 +158,11 @@ int32_t AudioCtlCaptureGetVolume(const struct DevHandleCapture *handle, } /* Read the two channel volume */ - ret = snd_mixer_selem_get_capture_volume(cardIns->ctrlLeftVolume, - SND_MIXER_SCHN_FRONT_LEFT, &volLeft); + ret = snd_mixer_selem_get_capture_volume(cardIns->ctrlLeftVolume, SND_MIXER_SCHN_FRONT_LEFT, &volLeft); if (ret < 0) { AUDIO_FUNC_LOGE("Get left channel volume fail: %{public}s.", snd_strerror(ret)); } - ret = snd_mixer_selem_get_capture_volume(cardIns->ctrlLeftVolume, - SND_MIXER_SCHN_FRONT_RIGHT, &volRight); + ret = snd_mixer_selem_get_capture_volume(cardIns->ctrlLeftVolume, SND_MIXER_SCHN_FRONT_RIGHT, &volRight); if (ret < 0) { AUDIO_FUNC_LOGE("Get right channel volume fail: %{public}s.", snd_strerror(ret)); } @@ -176,13 +172,14 @@ int32_t AudioCtlCaptureGetVolume(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetVolume(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetVolume( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; int32_t vol; struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("parameter is NULL!"); return HDF_FAILURE; @@ -216,13 +213,14 @@ int32_t AudioCtlCaptureSetVolume(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetMuteStu(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetMuteStu( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; bool muteState; struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -237,15 +235,11 @@ int32_t AudioCtlCaptureSetMuteStu(const struct DevHandleCapture *handle, muteState = (bool)cardIns->captureMuteValue; if (muteState == false) { - ret = AudioMixerSetCtrlMode(cardIns, adapterName, - "Digital Capture mute", - SND_CAP_MIC_PATH, - SND_OUT_CARD_MIC_OFF); + ret = + AudioMixerSetCtrlMode(cardIns, adapterName, "Digital Capture mute", SND_CAP_MIC_PATH, SND_IN_CARD_MIC_OFF); } else { - ret = AudioMixerSetCtrlMode(cardIns, adapterName, - "Digital Capture mute", - SND_CAP_MIC_PATH, - SND_OUT_CARD_MAIN_MIC); + ret = + AudioMixerSetCtrlMode(cardIns, adapterName, "Digital Capture mute", SND_CAP_MIC_PATH, SND_IN_CARD_MAIN_MIC); } if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("AudioMixerSetCtrlMode failed!"); @@ -256,11 +250,12 @@ int32_t AudioCtlCaptureSetMuteStu(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetMuteStu(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetMuteStu( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -282,9 +277,10 @@ int32_t AudioCtlCaptureGetMuteStu(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetGainStu(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetGainStu( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -293,9 +289,10 @@ int32_t AudioCtlCaptureSetGainStu(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetGainStu(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetGainStu( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -304,11 +301,12 @@ int32_t AudioCtlCaptureGetGainStu(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureSceneSelect(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSceneSelect( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t deviceNum; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -323,9 +321,10 @@ int32_t AudioCtlCaptureSceneSelect(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetGainThreshold(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetGainThreshold( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -334,15 +333,16 @@ int32_t AudioCtlCaptureGetGainThreshold(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetVolThreshold(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetVolThreshold( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns; long volMax = MIN_VOLUME; long volMin = MIN_VOLUME; - if (handleData == NULL) { + (void)cmdId; + if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Param is NULL!"); return HDF_FAILURE; } @@ -360,8 +360,7 @@ int32_t AudioCtlCaptureGetVolThreshold(const struct DevHandleCapture *handle, return HDF_SUCCESS; } - ret = snd_mixer_selem_get_capture_volume_range(cardIns->ctrlLeftVolume, - &volMin, &volMax); + ret = snd_mixer_selem_get_capture_volume_range(cardIns->ctrlLeftVolume, &volMin, &volMax); if (ret < 0) { AUDIO_FUNC_LOGE("Get capture volume range fail: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; @@ -372,8 +371,8 @@ int32_t AudioCtlCaptureGetVolThreshold(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioInterfaceLibCtlCapture(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioInterfaceLibCtlCapture( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; @@ -445,11 +444,12 @@ static int32_t GetCapHwParams(struct AudioCardInfo *cardIns, const struct AudioH return HDF_SUCCESS; } -static int32_t SetHWParamsSub(snd_pcm_t *handle, snd_pcm_hw_params_t *params, - struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access) +static int32_t SetHWParamsSub( + snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access) { int32_t ret; snd_pcm_format_t pcmFormat; + if (handle == NULL || params == NULL) { AUDIO_FUNC_LOGE("SetHWParamsSub parameter is null!"); return HDF_FAILURE; @@ -468,9 +468,9 @@ static int32_t SetHWParamsSub(snd_pcm_t *handle, snd_pcm_hw_params_t *params, return HDF_FAILURE; } ret = CheckParaFormat(hwCapParams, &pcmFormat); - if (ret < 0) { + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CheckParaFormat error."); - return HDF_FAILURE; + return ret; } /* set the sample format */ ret = snd_pcm_hw_params_set_format(handle, params, pcmFormat); @@ -482,8 +482,8 @@ static int32_t SetHWParamsSub(snd_pcm_t *handle, snd_pcm_hw_params_t *params, /* set the count of channels */ ret = snd_pcm_hw_params_set_channels(handle, params, hwCapParams.channels); if (ret < 0) { - AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for capture: %{public}s", - hwCapParams.channels, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for capture: %{public}s", hwCapParams.channels, + snd_strerror(ret)); return HDF_FAILURE; } @@ -503,18 +503,16 @@ static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_ /* set the stream rate */ rRate = *rate; - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, dir); + ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", - *rate, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", *rate, snd_strerror(ret)); return HDF_FAILURE; } if (rRate != *rate) { - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, dir); + ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", - *rate, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", *rate, snd_strerror(ret)); return HDF_FAILURE; } } @@ -539,15 +537,14 @@ static int32_t SetHWBuffer(snd_pcm_t *handle, snd_pcm_hw_params_t *params) ret = snd_pcm_hw_params_set_buffer_time_near(handle, params, &g_bufferTime, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set buffer time %u for capture: %{public}s", - g_bufferTime, snd_strerror(ret)); + AUDIO_FUNC_LOGE( + "Unable to set buffer time %{public}u for capture: %{public}s", g_bufferTime, snd_strerror(ret)); return HDF_FAILURE; } ret = snd_pcm_hw_params_get_buffer_size(params, &size); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get buffer size for capture: %{public}s", - snd_strerror(ret)); + AUDIO_FUNC_LOGE("Unable to get buffer size for capture: %{public}s", snd_strerror(ret)); return HDF_FAILURE; } g_bufferSize = size; @@ -568,15 +565,14 @@ static int32_t SetHWPeriod(snd_pcm_t *handle, snd_pcm_hw_params_t *params) ret = snd_pcm_hw_params_set_period_time_near(handle, params, &g_periodTime, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set period time %{public}u for capture: %{public}s", - g_periodTime, snd_strerror(ret)); + AUDIO_FUNC_LOGE( + "Unable to set period time %{public}u for capture: %{public}s", g_periodTime, snd_strerror(ret)); return HDF_FAILURE; } ret = snd_pcm_hw_params_get_period_size(params, &size, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get period size for capture: %{public}s", - snd_strerror(ret)); + AUDIO_FUNC_LOGE("Unable to get period size for capture: %{public}s", snd_strerror(ret)); return HDF_FAILURE; } g_periodSize = size; @@ -584,8 +580,8 @@ static int32_t SetHWPeriod(snd_pcm_t *handle, snd_pcm_hw_params_t *params) return HDF_SUCCESS; } -static int32_t SetHWParams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, - struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access) +static int32_t SetHWParams( + snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access) { int32_t ret; @@ -596,8 +592,8 @@ static int32_t SetHWParams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, ret = snd_pcm_hw_params_any(handle, params); // choose all parameters if (ret < 0) { - AUDIO_FUNC_LOGE("Broken configuration for capture: no configurations available: %{public}s.", - snd_strerror(ret)); + AUDIO_FUNC_LOGE( + "Broken configuration for capture: no configurations available: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } @@ -628,8 +624,7 @@ static int32_t SetHWParams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, /* write the parameters to device. */ ret = snd_pcm_hw_params(handle, params); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set hw params for capture: %{public}s", - snd_strerror(ret)); + AUDIO_FUNC_LOGE("Unable to set hw params for capture: %{public}s", snd_strerror(ret)); return HDF_FAILURE; } @@ -648,8 +643,7 @@ static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) /* get the current swparams */ ret = snd_pcm_sw_params_current(handle, swparams); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", - snd_strerror(ret)); + AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } @@ -659,8 +653,7 @@ static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) } /* start the transfer when the buffer is almost full: */ /* (buffer_size / avail_min) * avail_min */ - ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, - (g_bufferSize / g_periodSize) * g_periodSize); + ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, (g_bufferSize / g_periodSize) * g_periodSize); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set start threshold mode for capture: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; @@ -693,14 +686,15 @@ static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) return HDF_SUCCESS; } -int32_t AudioOutputCaptureHwParams(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureHwParams( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns; snd_pcm_hw_params_t *hwParams = NULL; snd_pcm_sw_params_t *swParams = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("The parameter is empty"); return HDF_FAILURE; @@ -713,31 +707,35 @@ int32_t AudioOutputCaptureHwParams(const struct DevHandleCapture *handle, return HDF_FAILURE; } + ret = (int32_t)snd_pcm_state(cardIns->capturePcmHandle); + if (ret >= SND_PCM_STATE_RUNNING) { + AUDIO_FUNC_LOGE("Unable to set parameters during capture!"); + return HDF_FAILURE; + } + ret = GetCapHwParams(cardIns, handleData); - if (ret < 0) { + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("GetCapHwParams error."); - return HDF_FAILURE; + return ret; } snd_pcm_hw_params_alloca(&hwParams); snd_pcm_sw_params_alloca(&swParams); - ret = SetHWParams(cardIns->capturePcmHandle, hwParams, - cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED); - if (ret < 0) { - AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; + ret = SetHWParams(cardIns->capturePcmHandle, hwParams, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret); + return ret; } ret = SetSWParams(cardIns->capturePcmHandle, swParams); - if (ret < 0) { - AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret); + return ret; } return HDF_SUCCESS; } -static int32_t InitMixerCtrlCapVolumeRange(const char *adapterName, - struct AudioCardInfo *cardIns) +static int32_t InitMixerCtrlCapVolumeRange(const char *adapterName, struct AudioCardInfo *cardIns) { int32_t ret; @@ -754,7 +752,7 @@ static int32_t InitMixerCtrlCapVolumeRange(const char *adapterName, if (cardIns->ctrlLeftVolume != NULL) { ret = snd_mixer_selem_set_capture_volume_range(cardIns->ctrlLeftVolume, MIN_VOLUME, MAX_VOLUME); if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to set capture left volume range"); + AUDIO_FUNC_LOGE("Failed to set capture left volume range: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } } @@ -762,7 +760,7 @@ static int32_t InitMixerCtrlCapVolumeRange(const char *adapterName, if (cardIns->ctrlRightVolume != NULL) { ret = snd_mixer_selem_set_capture_volume_range(cardIns->ctrlRightVolume, MIN_VOLUME, MAX_VOLUME); if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to set capture right volume range"); + AUDIO_FUNC_LOGE("Failed to set capture right volume range: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } } @@ -770,8 +768,7 @@ static int32_t InitMixerCtrlCapVolumeRange(const char *adapterName, return HDF_SUCCESS; } -static int32_t InitMixerCtlElement(const char *adapterName, - struct AudioCardInfo *cardIns, snd_mixer_t *mixer) +static int32_t InitMixerCtlElement(const char *adapterName, struct AudioCardInfo *cardIns, snd_mixer_t *mixer) { int32_t ret; @@ -783,9 +780,9 @@ static int32_t InitMixerCtlElement(const char *adapterName, snd_mixer_elem_t *pcmElement = snd_mixer_first_elem(mixer); if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { ret = GetPriMixerCtlElement(cardIns, pcmElement); - if (ret < 0) { + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture GetPriMixerCtlElement failed."); - return HDF_FAILURE; + return ret; } } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { cardIns->ctrlLeftVolume = AudioUsbFindElement(mixer); @@ -800,10 +797,7 @@ static int32_t InitMixerCtlElement(const char *adapterName, return ret; } - ret = AudioMixerSetCtrlMode(cardIns, adapterName, - "Capture MIC Path", - SND_CAP_MIC_PATH, - SND_OUT_CARD_MAIN_MIC); + ret = AudioMixerSetCtrlMode(cardIns, adapterName, "Capture MIC Path", SND_CAP_MIC_PATH, SND_IN_CARD_MAIN_MIC); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("AudioMixerSetCtrlMode failed!"); return ret; @@ -816,13 +810,14 @@ static int32_t InitMixerCtlElement(const char *adapterName, * brief: Opens a capture PCM * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC) */ -int32_t AudioOutputCaptureOpen(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureOpen( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns; - if (handleData == NULL) { + (void)cmdId; + if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Function parameter is NULL!"); return HDF_FAILURE; } @@ -830,7 +825,7 @@ int32_t AudioOutputCaptureOpen(const struct DevHandleCapture *handle, const char *adapterName = handleData->captureMode.hwInfo.adapterName; cardIns = AudioGetCardInfo(adapterName, SND_PCM_STREAM_CAPTURE); if (cardIns == NULL) { - AUDIO_FUNC_LOGE("AudioRenderGetCardIns failed."); + AUDIO_FUNC_LOGE("AudioCaptureGetCardIns failed."); return HDF_FAILURE; } @@ -838,8 +833,7 @@ int32_t AudioOutputCaptureOpen(const struct DevHandleCapture *handle, AUDIO_FUNC_LOGE("Resource busy!!"); return HDF_ERR_DEVICE_BUSY; } - ret = snd_pcm_open(&cardIns->capturePcmHandle, cardIns->devName, - SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK); + ret = snd_pcm_open(&cardIns->capturePcmHandle, cardIns->devName, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK); if (ret < 0) { AUDIO_FUNC_LOGE("Capture open device error: %{public}s.", snd_strerror(ret)); CheckCardStatus(cardIns); @@ -860,8 +854,7 @@ int32_t AudioOutputCaptureOpen(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioCaptureResetParams(snd_pcm_t *handle, - struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access) +int32_t AudioCaptureResetParams(snd_pcm_t *handle, struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access) { int32_t ret; snd_pcm_hw_params_t *hwParams = NULL; @@ -876,23 +869,20 @@ int32_t AudioCaptureResetParams(snd_pcm_t *handle, snd_pcm_sw_params_alloca(&swParams); ret = SetHWParams(handle, hwParams, audioHwParams, access); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}s", - snd_strerror(ret)); - return HDF_FAILURE; + AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret); + return ret; } ret = SetSWParams(handle, swParams); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}s", - snd_strerror(ret)); - return HDF_FAILURE; + AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret); + return ret; } return HDF_SUCCESS; } -static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, - char *buffer, uint64_t frames) +static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buffer, uint64_t frames) { int32_t ret; uint32_t channels; @@ -904,13 +894,6 @@ static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, return HDF_FAILURE; } - if (g_canPause == 0) { /* Hardware does not support pause, enable soft solution */ - if (handleData->captureMode.ctlParam.pause) { - AUDIO_FUNC_LOGE("Currently in pause, please check!"); - return HDF_FAILURE; - } - } - if (handleData->frameCaptureMode.buffer == NULL) { AUDIO_FUNC_LOGE("frameCaptureMode.buffer is NULL!"); return HDF_FAILURE; @@ -918,7 +901,7 @@ static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, channels = handleData->frameCaptureMode.attrs.channelCount; format = (uint32_t)handleData->frameCaptureMode.attrs.format; recvDataSize = (uint64_t)(frames * channels * format); - ret = memcpy_s(handleData->frameCaptureMode.buffer, CAPTURE_FRAME_DATA, buffer, recvDataSize); + ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, recvDataSize); if (ret != EOK) { AUDIO_FUNC_LOGE("memcpy frame data failed!"); return HDF_FAILURE; @@ -929,58 +912,161 @@ static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, return HDF_SUCCESS; } -static int32_t AudioCaptureReadFrame(struct AudioHwCaptureParam *handleData, - struct AudioCardInfo *cardIns, snd_pcm_uframes_t bufferSize, snd_pcm_uframes_t periodSize) +static int32_t CheckCapFrameBufferSize(struct AudioHwCaptureParam *handleData, snd_pcm_uframes_t *periodSize) +{ + uint32_t capFrameSize; + uint64_t capReqBufferSize; + + if (handleData == NULL || periodSize == NULL) { + AUDIO_FUNC_LOGE("Param is NULL!"); + return HDF_FAILURE; + } + + capFrameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; + if (capFrameSize == 0) { + AUDIO_FUNC_LOGE("capFrameSize is zero."); + return HDF_FAILURE; + } + capReqBufferSize = capFrameSize * (*periodSize); + if (capReqBufferSize > FRAME_DATA) { + *periodSize = FRAME_DATA / capFrameSize; + } + + return HDF_SUCCESS; +} + +static int32_t CheckPcmStatus(snd_pcm_t *capturePcmHandle) +{ + int32_t ret; + + if (capturePcmHandle == NULL) { + AUDIO_FUNC_LOGE("Param is NULL."); + return HDF_FAILURE; + } + + ret = snd_pcm_wait(capturePcmHandle, -1); /* -1 for timeout, Waiting forever */ + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_wait failed: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + if (snd_pcm_state(capturePcmHandle) == SND_PCM_STATE_SETUP) { + ret = snd_pcm_prepare(capturePcmHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +static int32_t AudioCaptureReadFrameSub(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf, snd_pcm_uframes_t bufSize) { int32_t ret; long frames; + int32_t tryNum = AUDIO_ALSALIB_RETYR; + + if (pcm == NULL || frameCnt == NULL || dataBuf == NULL || bufSize == 0) { + AUDIO_FUNC_LOGE("The parameter is error."); + return HDF_FAILURE; + } + + do { + /* Read interleaved frames to a PCM. */ + frames = snd_pcm_readi(pcm, dataBuf, bufSize); + if (frames > 0) { + *frameCnt = (uint64_t)frames; + return HDF_SUCCESS; + } + + if (frames == -EBADFD) { + AUDIO_FUNC_LOGE("PCM is not in the right state: %{public}s", snd_strerror(frames)); + ret = snd_pcm_prepare(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } else { + /* -ESTRPIPE: a suspend event occurred, + * stream is suspended and waiting for an application recovery. + * -EPIPE: an underrun occurred. + */ + ret = snd_pcm_recover(pcm, frames, 0); // 0 for open log + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_writei failed: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + ret = snd_pcm_start(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + tryNum--; + } while (tryNum > 0); + + return HDF_SUCCESS; +} + +static int32_t AudioCaptureReadFrame( + struct AudioHwCaptureParam *handleData, struct AudioCardInfo *cardIns, snd_pcm_uframes_t periodSize) +{ + int32_t ret; + uint64_t frames = 0; char *buffer = NULL; if (handleData == NULL || cardIns == NULL) { AUDIO_FUNC_LOGE("Param is NULL!"); return HDF_FAILURE; } - buffer = OsalMemCalloc(bufferSize); + + buffer = OsalMemCalloc(ALSA_CAP_BUFFER_SIZE); if (buffer == NULL) { - AUDIO_FUNC_LOGE("Failed to alloc buffer"); + AUDIO_FUNC_LOGE("Failed to Calloc buffer"); return HDF_FAILURE; } - ret = snd_pcm_wait(cardIns->capturePcmHandle, -1); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_wait failed: %{public}s.", snd_strerror(ret)); + ret = CheckCapFrameBufferSize(handleData, &periodSize); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CheckCapFrameBufferSize failed."); AudioMemFree((void **)&buffer); - return HDF_FAILURE; + return ret; } - frames = snd_pcm_readi(cardIns->capturePcmHandle, buffer, periodSize); - if (frames < 0) { - frames = snd_pcm_recover(cardIns->capturePcmHandle, frames, 0); // 0 for open log + + ret = CheckPcmStatus(cardIns->capturePcmHandle); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CheckPcmStatus failed."); + AudioMemFree((void **)&buffer); + return ret; } - if (frames < 0) { - AUDIO_FUNC_LOGE("snd_pcm_writei fail: %{public}s.", snd_strerror(frames)); + + ret = AudioCaptureReadFrameSub(cardIns->capturePcmHandle, &frames, buffer, periodSize); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("AudioCaptureReadFrameSub is error!"); AudioMemFree((void **)&buffer); - return HDF_FAILURE; + return ret; } - ret = CaptureDataCopy(handleData, buffer, (uint64_t)frames); + ret = CaptureDataCopy(handleData, buffer, frames); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Failed to copy data. It may be paused. Check the status!"); AudioMemFree((void **)&buffer); - return HDF_FAILURE; + return ret; } AudioMemFree((void **)&buffer); return HDF_SUCCESS; } -int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns; snd_pcm_uframes_t bufferSize = 0; snd_pcm_uframes_t periodSize = 0; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Param is NULL!"); return HDF_FAILURE; @@ -1000,9 +1086,8 @@ int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle, } if (!cardIns->captureMmapFlag) { - ret = AudioCaptureResetParams(cardIns->capturePcmHandle, - cardIns->hwCaptureParams, - SND_PCM_ACCESS_RW_INTERLEAVED); + ret = + AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); return ret; @@ -1015,7 +1100,7 @@ int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle, cardIns->captureMmapFlag = true; } - ret = AudioCaptureReadFrame(handleData, cardIns, bufferSize, periodSize); + ret = AudioCaptureReadFrame(handleData, cardIns, periodSize); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("AudioOutputCaptureRead failed"); return ret; @@ -1024,9 +1109,10 @@ int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioOutputCaptureStart(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureStart( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Param is NULL!"); return HDF_FAILURE; @@ -1035,13 +1121,14 @@ int32_t AudioOutputCaptureStart(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioOutputCapturePrepare(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCapturePrepare( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns; - if (handleData == NULL) { + (void)cmdId; + if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Param is NULL!"); return HDF_FAILURE; } @@ -1062,12 +1149,13 @@ int32_t AudioOutputCapturePrepare(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioOutputCaptureClose(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureClose( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Parameter is NULL!"); return HDF_FAILURE; @@ -1105,12 +1193,13 @@ int32_t AudioOutputCaptureClose(const struct DevHandleCapture *handle, } // Stop capture first, and then close the resource -int32_t AudioOutputCaptureStop(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureStop( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("Param is NULL!"); return HDF_FAILURE; @@ -1143,8 +1232,7 @@ static int32_t UpdateSetParams(struct AudioCardInfo *cardIns) } cardIns->captureMmapFlag = false; - ret = AudioCaptureResetParams(cardIns->capturePcmHandle, - cardIns->hwCaptureParams, SND_PCM_ACCESS_MMAP_INTERLEAVED); + ret = AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_MMAP_INTERLEAVED); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); return ret; @@ -1183,10 +1271,14 @@ static int32_t MmapDescWriteBufferCapture(const struct AudioHwCaptureParam *hand ret = UpdateSetParams(cardIns); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Update set params failed!"); - return HDF_FAILURE; + return ret; } mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress; + if (mmapAddr == NULL) { + AUDIO_FUNC_LOGE("mmapAddr is NULL!"); + return HDF_FAILURE; + } size = (snd_pcm_sframes_t)handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames; frameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; while (size > 0) { @@ -1210,11 +1302,12 @@ static int32_t MmapDescWriteBufferCapture(const struct AudioHwCaptureParam *hand return HDF_SUCCESS; } -int32_t AudioOutputCaptureReqMmapBuffer(const struct DevHandleCapture *handle, - int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureReqMmapBuffer( + const struct DevHandleCapture *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -1223,17 +1316,18 @@ int32_t AudioOutputCaptureReqMmapBuffer(const struct DevHandleCapture *handle, ret = MmapDescWriteBufferCapture(handleData); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture mmap write buffer failed!"); - return HDF_FAILURE; + return ret; } return HDF_SUCCESS; } -int32_t AudioOutputCaptureGetMmapPosition(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureGetMmapPosition( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { struct AudioCardInfo *cardIns; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("param is NULL!"); return HDF_FAILURE; @@ -1250,8 +1344,7 @@ int32_t AudioOutputCaptureGetMmapPosition(const struct DevHandleCapture *handle, return HDF_SUCCESS; } -static int32_t AudioBindServiceCaptureObject(struct DevHandleCapture * const handle, - const char *name) +static int32_t AudioBindServiceCaptureObject(struct DevHandleCapture * const handle, const char *name) { int32_t ret; char *serviceName; @@ -1310,6 +1403,14 @@ struct DevHandleCapture *AudioBindServiceCapture(const char *name) AudioMemFree((void **)&handle); return NULL; } + + /* Parsing primary sound card from configuration file */ + ret = CardInfoParseFromConfig(); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CardInfoParseFromConfig failed!"); + AudioMemFree((void **)&handle); + return NULL; + } AUDIO_FUNC_LOGI("BIND SERVICE SUCCESS!"); return handle; @@ -1325,8 +1426,8 @@ void AudioCloseServiceCapture(const struct DevHandleCapture *handle) } } -int32_t AudioInterfaceLibOutputCapture(const struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioInterfaceLibOutputCapture( + const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; @@ -1375,8 +1476,8 @@ int32_t AudioInterfaceLibOutputCapture(const struct DevHandleCapture *handle, return ret; } -int32_t AudioInterfaceLibModeCapture(const struct DevHandleCapture *handle, - struct AudioHwCaptureParam *handleData, int cmdId) +int32_t AudioInterfaceLibModeCapture( + const struct DevHandleCapture *handle, struct AudioHwCaptureParam *handleData, int cmdId) { AUDIO_FUNC_LOGI(); if (handle == NULL || handleData == NULL) { diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c index 29118bf63e..c40aabcaac 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c @@ -14,87 +14,28 @@ */ #include "alsa_lib_common.h" +#include +#include +#include "cJSON.h" #include "osal_mem.h" #include "audio_internal.h" #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB -static struct AudioCardInfo *g_audioCardIns = NULL; -struct AlsaDevInfo *g_alsadevInfo = NULL; - -struct DevProcInfo g_speakerOutName[] = { - {"realtekrt5616c", NULL}, - {"realtekrt5651co", "rt5651-aif1"}, - {"realtekrt5670c", NULL}, - {"realtekrt5672c", NULL}, - {"realtekrt5678co", NULL}, - {"rkhdmianalogsnd", NULL}, - {"rockchipcx2072x", NULL}, - {"rockchipes8316c", NULL}, - {"rockchipes8323c", NULL}, - {"rockchipes8388c", NULL}, - {"rockchipes8396c", NULL}, - {"rockchiprk", NULL}, - {"rockchiprk809co", NULL}, - {"rockchiprk817co", NULL}, - {"rockchiprt5640c", "rt5640-aif1"}, - {"rockchiprt5670c", NULL}, - {"rockchiprt5672c", NULL}, - {NULL, NULL} -}; - -struct DevProcInfo g_hdmiOutName[] = { - {"realtekrt5651co", "i2s-hifi"}, - {"realtekrt5670co", "i2s-hifi"}, - {"rkhdmidpsound", NULL}, - {"hdmisound", NULL}, - {"rockchiphdmi", NULL}, - {"rockchiprt5640c", "i2s-hifi"}, - {NULL, NULL} -}; - -struct DevProcInfo g_SPDIFOutName[] = { - {"ROCKCHIPSPDIF", "dit-hifi"}, - {"rockchipspdif", NULL}, - {"rockchipcdndp", NULL}, - {NULL, NULL} -}; - -struct DevProcInfo g_BTOutName[] = { - {"rockchipbt", NULL}, - {NULL, NULL} -}; +#define USB_AUDIO "USB Audio" -struct DevProcInfo g_micInName[] = { - {"realtekrt5616c", NULL}, - {"realtekrt5651co", "rt5651-aif1"}, - {"realtekrt5670c", NULL}, - {"realtekrt5672c", NULL}, - {"realtekrt5678co", NULL}, - {"rockchipes8316c", NULL}, - {"rockchipes8323c", NULL}, - {"rockchipes8396c", NULL}, - {"rockchipes7210", NULL}, - {"rockchipes7243", NULL}, - {"rockchiprk", NULL}, - {"rockchiprk809co", NULL}, - {"rockchiprk817co", NULL}, - {"rockchiprt5640c", NULL}, - {"rockchiprt5670c", NULL}, - {"rockchiprt5672c", NULL}, - {NULL, NULL} -}; +#define MAX_ELEMENT 100 +#define ALSA_CARD_CONFIG_FILE HDF_CONFIG_DIR "/alsa_adapter.json" +#define ALSA_CONFIG_FILE_MAX (2 * 1024) // 2KB -struct DevProcInfo HdmiInName[] = { - {"realtekrt5651co", "tc358749x-audio"}, - {"hdmiin", NULL}, - {NULL, NULL} +struct CardStream { + int card; + snd_pcm_stream_t stream; /** Playback stream or Capture stream */ }; -struct DevProcInfo BTInName[] = { - {"rockchipbt", NULL}, - {NULL, NULL} -}; +static struct AudioCardInfo *g_audioCardIns = NULL; +struct AlsaDevInfo *g_alsadevInfo = NULL; +static bool g_parseFlag = false; char *g_usbVolCtlNameTable[] = { "Earpiece", @@ -105,16 +46,17 @@ char *g_usbVolCtlNameTable[] = { "PCM", }; -struct CardStream { - int card; - snd_pcm_stream_t stream; /** Playback stream or Capture stream */ -}; +static struct DevProcInfo *g_sndCardList[SND_CARD_MAX][AUDIO_MAX_CARD_NUM] = {{NULL}}; + +static struct DevProcInfo **AudioGetSoundCardsInfo(enum SndCardType cardType) +{ + return (struct DevProcInfo **)(g_sndCardList + cardType); +} int32_t InitCardIns(void) { if (g_audioCardIns == NULL) { - g_audioCardIns = (struct AudioCardInfo *)OsalMemCalloc(MAX_CARD_NUM * - sizeof(struct AudioCardInfo)); + g_audioCardIns = (struct AudioCardInfo *)OsalMemCalloc(MAX_CARD_NUM * sizeof(struct AudioCardInfo)); if (g_audioCardIns == NULL) { AUDIO_FUNC_LOGE("Failed to allocate memory!"); return HDF_FAILURE; @@ -142,8 +84,7 @@ static struct AudioCardInfo *AddCardIns(const char *cardName) for (i = 0; i < MAX_CARD_NUM; i++) { if (g_audioCardIns[i].cardStatus == 0) { (void)memset_s(&g_audioCardIns[i], sizeof(struct AudioCardInfo), 0, sizeof(struct AudioCardInfo)); - ret = strncpy_s(g_audioCardIns[i].cardName, - MAX_CARD_NAME_LEN + 1, cardName, strlen(cardName)); + ret = strncpy_s(g_audioCardIns[i].cardName, MAX_CARD_NAME_LEN + 1, cardName, strlen(cardName)); if (ret != 0) { AUDIO_FUNC_LOGE("strncpy_s failed!"); return NULL; @@ -240,6 +181,19 @@ void CheckCardStatus(struct AudioCardInfo *cardIns) } } +static void CardInfoRelease(void) +{ + for (int i = 0; i < SND_CARD_MAX; i++) { + for (int j = 0; j < AUDIO_MAX_CARD_NUM; j++) { + if (g_sndCardList[i][j] != NULL) { + AudioMemFree((void **)&(g_sndCardList[i][j])); + g_sndCardList[i][j] = NULL; + } + } + } + g_parseFlag = false; +} + int32_t DestroyCardList(void) { int32_t i; @@ -253,13 +207,15 @@ int32_t DestroyCardList(void) } AudioMemFree((void **)&g_audioCardIns); g_audioCardIns = NULL; + + /* Release the sound card configuration space */ + CardInfoRelease(); } return HDF_SUCCESS; } -static int32_t GetDevIns(struct AudioCardInfo *cardIns, - int card, const char *cardId, int dev, const char *pcmInfoId) +static int32_t GetDevIns(struct AudioCardInfo *cardIns, int card, const char *cardId, int dev, const char *pcmInfoId) { int32_t i; int32_t ret; @@ -273,14 +229,12 @@ static int32_t GetDevIns(struct AudioCardInfo *cardIns, if (strlen(cardIns->alsaDevIns[i].cardId) == 0) { cardIns->alsaDevIns[i].card = card; cardIns->alsaDevIns[i].device = dev; - ret = strncpy_s(cardIns->alsaDevIns[i].cardId, - MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)); + ret = strncpy_s(cardIns->alsaDevIns[i].cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)); if (ret != 0) { AUDIO_FUNC_LOGE("strncpy_s failed!"); return HDF_FAILURE; } - ret = strncpy_s(cardIns->alsaDevIns[i].pcmInfoId, - MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)); + ret = strncpy_s(cardIns->alsaDevIns[i].pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)); if (ret != 0) { AUDIO_FUNC_LOGE("strncpy_s failed!"); return HDF_FAILURE; @@ -358,13 +312,14 @@ void InitSound(snd_mixer_t **mixer, char *hwCtlName) struct HdfIoService *HdfIoServiceBindName(const char *serviceName) { + (void)serviceName; /* Nothing to do */ static struct HdfIoService hdfIoService; return &hdfIoService; } -static void GetDevCardsInfo(snd_ctl_t *handle, snd_ctl_card_info_t *info, - snd_pcm_info_t *pcmInfo, struct AudioCardInfo *cardIns, struct CardStream cardStream) +static void GetDevCardsInfo(snd_ctl_t *handle, snd_ctl_card_info_t *info, snd_pcm_info_t *pcmInfo, + struct AudioCardInfo *cardIns, struct CardStream cardStream) { int dev = -1; int32_t ret; @@ -388,8 +343,8 @@ static void GetDevCardsInfo(snd_ctl_t *handle, snd_ctl_card_info_t *info, snd_pcm_info_set_stream(pcmInfo, cardStream.stream); if ((ret = snd_ctl_pcm_info(handle, pcmInfo)) < 0) { if (ret != -ENOENT) { - AUDIO_FUNC_LOGE("control digital audio info (%{public}d): %{public}s", - cardStream.card, snd_strerror(ret)); + AUDIO_FUNC_LOGE( + "control digital audio info (%{public}d): %{public}s", cardStream.card, snd_strerror(ret)); } continue; } @@ -466,14 +421,12 @@ int32_t GetSelCardInfo(struct AudioCardInfo *cardIns, struct AlsaDevInfo *devIns return HDF_FAILURE; } - ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, - "hw:%d,%d", devInsHandle->card, devInsHandle->device); + ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d,%d", devInsHandle->card, + devInsHandle->device); if (ret >= 0) { - ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, - "hw:%d", devInsHandle->card); + ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInsHandle->card); if (ret >= 0) { - ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, - "%s", devInsHandle->cardId); + ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInsHandle->cardId); if (ret >= 0) { return HDF_SUCCESS; } @@ -484,19 +437,57 @@ int32_t GetSelCardInfo(struct AudioCardInfo *cardIns, struct AlsaDevInfo *devIns return HDF_FAILURE; } +static const char *MatchProfileSoundCard(struct DevProcInfo *cardInfo[], char *adapterName) +{ + if (cardInfo == NULL || adapterName == NULL) { + AUDIO_FUNC_LOGE("The parameter is empty."); + return NULL; + } + + if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) != 0) { + AUDIO_FUNC_LOGE("The user sound card name %{public}s is incorrect!", adapterName); + return NULL; + } + + for (int i = 0; i < AUDIO_MAX_CARD_NUM; i++) { + if (cardInfo[i] != NULL) { + if (strncmp(cardInfo[i]->cardName, PRIMARY, strlen(PRIMARY)) == 0) { + return cardInfo[i]->cid; + } + } + } + AUDIO_FUNC_LOGE("No sound card selected by the user is matched from the configuration file."); + + return NULL; +} + static int32_t GetPrimaryCardInfo(struct AudioCardInfo *cardIns) { int32_t i; int32_t ret; + const char *cardId = NULL; + struct DevProcInfo **cardInfoPri = NULL; if (cardIns == NULL) { AUDIO_FUNC_LOGE("The parameter is empty."); return HDF_FAILURE; } + cardInfoPri = AudioGetSoundCardsInfo(SND_CARD_PRIMARY); + if (cardInfoPri == NULL) { + AUDIO_FUNC_LOGE("The parameter is empty."); + return HDF_FAILURE; + } + + cardId = MatchProfileSoundCard(cardInfoPri, cardIns->cardName); + if (cardId == NULL) { + AUDIO_FUNC_LOGE("get cardId is null."); + return HDF_FAILURE; + } + for (i = 0; i < MAX_CARD_NUM; i++) { /** Built in codec */ - if (strcmp(CODEC_CARD_ID, cardIns->alsaDevIns[i].cardId) == 0) { + if (strcmp(cardId, cardIns->alsaDevIns[i].cardId) == 0) { ret = GetSelCardInfo(cardIns, &cardIns->alsaDevIns[i]); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("GetSelCardInfo error."); @@ -550,7 +541,7 @@ int32_t MatchSelAdapter(const char *adapterName, struct AudioCardInfo *cardIns) } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { ret = GetUsbCardInfo(cardIns); if (ret < 0) { - AUDIO_FUNC_LOGE("GetPrimaryCardInfo error."); + AUDIO_FUNC_LOGE("GetUsbCardInfo error."); return HDF_FAILURE; } } else if (strncmp(adapterName, A2DP, strlen(A2DP)) == 0) { @@ -578,8 +569,7 @@ snd_mixer_elem_t *AudioUsbFindElement(snd_mixer_t *mixer) } count = sizeof(g_usbVolCtlNameTable) / sizeof(char *); - for (element = snd_mixer_first_elem(mixer); - element != NULL && maxLoop >= 0; + for (element = snd_mixer_first_elem(mixer); element != NULL && maxLoop >= 0; element = snd_mixer_elem_next(element)) { for (i = 0; i < count; i++) { mixerCtlName = g_usbVolCtlNameTable[i]; @@ -637,8 +627,8 @@ int32_t GetPriMixerCtlElement(struct AudioCardInfo *cardIns, snd_mixer_elem_t *p return HDF_SUCCESS; } -int32_t AudioMixerSetCtrlMode(struct AudioCardInfo *cardIns, - const char *adapterName, const char *mixerCtrlName, int numId, int item) +int32_t AudioMixerSetCtrlMode( + struct AudioCardInfo *cardIns, const char *adapterName, const char *mixerCtrlName, int numId, int item) { int32_t ret; snd_ctl_t *alsaHandle = NULL; @@ -745,37 +735,414 @@ int32_t CheckParaFormat(struct AudioPcmHwParams hwParams, snd_pcm_format_t *alsa if (!isBigEndian) { switch (audioFormat) { case AUDIO_FORMAT_PCM_8_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ - return HDF_SUCCESS; + *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ + break; case AUDIO_FORMAT_PCM_16_BIT: *alsaPcmFormat = SND_PCM_FORMAT_S16_LE; /** Signed 16 bit Little Endian */ - return HDF_SUCCESS; + break; case AUDIO_FORMAT_PCM_24_BIT: *alsaPcmFormat = SND_PCM_FORMAT_S24_LE; /** Signed 24 bit Little Endian */ - return HDF_SUCCESS; + break; case AUDIO_FORMAT_PCM_32_BIT: *alsaPcmFormat = SND_PCM_FORMAT_S32_LE; /** Signed 32 bit Little Endian */ - return HDF_SUCCESS; + break; default: return HDF_ERR_NOT_SUPPORT; } } else { /** Big Endian */ switch (audioFormat) { case AUDIO_FORMAT_PCM_8_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ - return HDF_SUCCESS; + *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ + break; case AUDIO_FORMAT_PCM_16_BIT: *alsaPcmFormat = SND_PCM_FORMAT_S16_BE; /** Signed 16 bit Big Endian */ - return HDF_SUCCESS; + break; case AUDIO_FORMAT_PCM_24_BIT: *alsaPcmFormat = SND_PCM_FORMAT_S24_BE; /** Signed 24 bit Big Endian */ - return HDF_SUCCESS; + break; case AUDIO_FORMAT_PCM_32_BIT: *alsaPcmFormat = SND_PCM_FORMAT_S32_BE; /** Signed 32 bit Big Endian */ - return HDF_SUCCESS; + break; default: return HDF_ERR_NOT_SUPPORT; } } + + return HDF_SUCCESS; } +static char *AudioAdaptersGetConfig(const char *fpath) +{ + int32_t jsonStrSize; + FILE *fp = NULL; + char *pJsonStr = NULL; + char pathBuf[PATH_MAX] = {0}; + + if (fpath == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); + return NULL; + } + if (realpath(fpath, pathBuf) == NULL) { + AUDIO_FUNC_LOGE("file name invalid!"); + return NULL; + } + + fp = fopen(pathBuf, "r"); + if (fp == NULL) { + AUDIO_FUNC_LOGE("Can not open config file [ %{public}s ].", fpath); + return NULL; + } + if (fseek(fp, 0, SEEK_END) != 0) { + AUDIO_FUNC_LOGE("fseek configuration file error!"); + (void)fclose(fp); + return NULL; + } + jsonStrSize = ftell(fp); + if (jsonStrSize <= 0) { + AUDIO_FUNC_LOGE("The configuration file size error!"); + (void)fclose(fp); + return NULL; + } + rewind(fp); + if (jsonStrSize > ALSA_CONFIG_FILE_MAX) { + AUDIO_FUNC_LOGE("The configuration file is too large to load!"); + (void)fclose(fp); + return NULL; + } + pJsonStr = (char *)OsalMemCalloc((uint32_t)jsonStrSize + 1); + if (pJsonStr == NULL) { + AUDIO_FUNC_LOGE("calloc pJsonStr failed!"); + (void)fclose(fp); + return NULL; + } + if (fread(pJsonStr, jsonStrSize, 1, fp) != 1) { + AUDIO_FUNC_LOGE("read to file fail!"); + (void)fclose(fp); + AudioMemFree((void **)&pJsonStr); + return NULL; + } + (void)fclose(fp); + + return pJsonStr; +} + +static cJSON *AudioCardGetConfig(const char *fpath) +{ + char *pJsonStr = NULL; + cJSON *cJsonObj = NULL; + + if (fpath == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); + return NULL; + } + + pJsonStr = AudioAdaptersGetConfig(fpath); + if (pJsonStr == NULL) { + AUDIO_FUNC_LOGE("AudioAdaptersGetConfig failed!"); + return NULL; + } + + cJsonObj = cJSON_Parse(pJsonStr); + if (cJsonObj == NULL) { + AUDIO_FUNC_LOGE("AudioAdaptersGetConfig failed!"); + AudioMemFree((void **)&pJsonStr); + return NULL; + } + AudioMemFree((void **)&pJsonStr); + + return cJsonObj; +} + +static int32_t AudioAdapterCheckName(const char *name) +{ + uint32_t len; + const char *strName = name; + + if (strName == NULL) { + AUDIO_FUNC_LOGE("Invalid parameter!"); + return HDF_FAILURE; + } + + len = strlen(strName); + if (len == 0 || len >= CARD_ID_LEN_MAX) { + AUDIO_FUNC_LOGE("name len is zero or too long!"); + return HDF_FAILURE; + } + + if (!isalpha(*strName++)) { // Names must begin with a letter + AUDIO_FUNC_LOGE("The name of the illegal!"); + return HDF_FAILURE; + } + + while (*strName != '\0') { + if (*strName == '_' || *strName == '-') { + strName++; + continue; + } + + if (!isalnum(*strName++)) { + AUDIO_FUNC_LOGE("The name of the illegal!"); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +static enum SndCardType AudioAdapterNameToType(const char *name) +{ + enum SndCardType cardType = SND_CARD_UNKNOWN; + + if (name == NULL) { + AUDIO_FUNC_LOGE("Invalid parameter!"); + return SND_CARD_UNKNOWN; + } + + if (strcmp(name, "primary") == 0) { + cardType = SND_CARD_PRIMARY; + } else if (strcmp(name, "hdmi") == 0) { + cardType = SND_CARD_HDMI; + } else if (strcmp(name, "usb") == 0) { + cardType = SND_CARD_USB; + } else if (strcmp(name, "bt") == 0) { + cardType = SND_CARD_BT; + } + + return cardType; +} + +static int32_t AudioAdapterInfoSet(struct DevProcInfo *cardDev, enum SndCardType cardType) +{ + int32_t ret; + struct DevProcInfo *adapter = NULL; + + if (cardDev == NULL) { + AUDIO_FUNC_LOGE("Invalid parameter!"); + return HDF_FAILURE; + } + + adapter = (struct DevProcInfo *)OsalMemCalloc(sizeof(struct DevProcInfo)); + if (adapter == NULL) { + AUDIO_FUNC_LOGE("calloc cardDev failed!"); + return HDF_FAILURE; + } + + ret = memcpy_s(adapter->cardName, CARD_ID_LEN_MAX - 1, cardDev->cardName, CARD_ID_LEN_MAX - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapter card name fail!"); + AudioMemFree((void **)&adapter); + return HDF_FAILURE; + } + ret = memcpy_s(adapter->cid, CARD_ID_LEN_MAX - 1, cardDev->cid, CARD_ID_LEN_MAX - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!"); + AudioMemFree((void **)&adapter); + return HDF_FAILURE; + } + ret = memcpy_s(adapter->did, CARD_ID_LEN_MAX - 1, cardDev->did, CARD_ID_LEN_MAX - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapter dai id fail!"); + /* Only log is printed and cannot be returned */ + } + + for (int cardNum = 0; cardNum < AUDIO_MAX_CARD_NUM; cardNum++) { + if (g_sndCardList[cardType][cardNum] == NULL) { + g_sndCardList[cardType][cardNum] = adapter; + break; + } + + if (cardNum == AUDIO_MAX_CARD_NUM - 1) { + AUDIO_FUNC_LOGE("The maximum limit for a single type of sound card is %{public}d.", AUDIO_MAX_CARD_NUM); + AudioMemFree((void **)&adapter); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +static cJSON *AudioGetItemString(cJSON *adapter, char *name) +{ + int32_t ret; + cJSON *item = NULL; + + if (adapter == NULL || name == NULL) { + AUDIO_FUNC_LOGE("Invalid parameter!"); + return NULL; + } + + item = cJSON_GetObjectItem(adapter, name); + if (item == NULL) { + AUDIO_FUNC_LOGE("item is null!"); + return NULL; + } + if (item->valuestring == NULL) { + AUDIO_FUNC_LOGE("item valuestring is null!"); + return NULL; + } + + ret = AudioAdapterCheckName(item->valuestring); + if (ret < 0) { + if (strncmp(name, "daiId", sizeof("daiId"))) { + AUDIO_FUNC_LOGE("The %{public}s name incorrect!", name); + } + return NULL; + } + + return item; +} + +static int32_t AudioGetAllItem(cJSON *adapter, struct DevProcInfo *cardDev) +{ + int32_t ret; + cJSON *adapterName = NULL; + cJSON *cid = NULL; + cJSON *did = NULL; + + if (adapter == NULL || cardDev == NULL) { + AUDIO_FUNC_LOGE("Invalid parameter!"); + return HDF_FAILURE; + } + + adapterName = AudioGetItemString(adapter, "name"); + if (adapterName == NULL) { + AUDIO_FUNC_LOGE("Get adapterName failed!"); + return HDF_FAILURE; + } + ret = memcpy_s(cardDev->cardName, CARD_ID_LEN_MAX - 1, adapterName->valuestring, CARD_ID_LEN_MAX - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapter card name fail!"); + return HDF_FAILURE; + } + + cid = AudioGetItemString(adapter, "cardId"); + if (cid == NULL) { + AUDIO_FUNC_LOGE("Get cid failed!"); + return HDF_FAILURE; + } + ret = memcpy_s(cardDev->cid, CARD_ID_LEN_MAX - 1, cid->valuestring, CARD_ID_LEN_MAX - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!"); + return HDF_FAILURE; + } + + did = AudioGetItemString(adapter, "daiId"); + if (did == NULL) { // Not all sound cards have dai id. + return HDF_SUCCESS; + } + ret = memcpy_s(cardDev->did, CARD_ID_LEN_MAX - 1, did->valuestring, CARD_ID_LEN_MAX - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!"); + /* Only log is printed and cannot be returned */ + } + + return HDF_SUCCESS; +} + +static int32_t AudioParseAdapter(cJSON *adapter) +{ + int ret; + struct DevProcInfo cardDev; + enum SndCardType cardType = SND_CARD_UNKNOWN; + + if (adapter == NULL) { + AUDIO_FUNC_LOGE("Parameter error!\n"); + return HDF_FAILURE; + } + + (void)memset_s(&cardDev, sizeof(struct DevProcInfo), 0, sizeof(struct DevProcInfo)); + ret = AudioGetAllItem(adapter, &cardDev); + if (ret < 0) { + AUDIO_FUNC_LOGE("AudioGetAllItem failed!\n"); + return ret; + } + cardType = AudioAdapterNameToType(cardDev.cardName); + switch (cardType) { + case SND_CARD_PRIMARY: + case SND_CARD_HDMI: + case SND_CARD_USB: + case SND_CARD_BT: + ret = AudioAdapterInfoSet(&cardDev, cardType); + if (ret < 0) { + AUDIO_FUNC_LOGE("AudioAdapterInfoSet failed!\n"); + return ret; + } + break; + default: + AUDIO_FUNC_LOGE("Sound card unknown!\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t AudioAdaptersSetAdapterVar(cJSON *cJsonObj) +{ + int32_t ret, adaptersArraySize; + cJSON *adapterObj = NULL; + + if (cJsonObj == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); + return HDF_FAILURE; + } + + adaptersArraySize = cJSON_GetArraySize(cJsonObj); + if (adaptersArraySize <= 0) { + AUDIO_FUNC_LOGE("Failed to get JSON array size!"); + return HDF_FAILURE; + } + if (adaptersArraySize > MAX_CARD_NUM) { + AUDIO_FUNC_LOGE("Read adapters number is %{public}d!", adaptersArraySize); + AUDIO_FUNC_LOGE("The number of sound cards exceeds the upper limit %{public}d.", MAX_CARD_NUM); + return HDF_FAILURE; + } + + for (int32_t i = 0; i < adaptersArraySize; i++) { + adapterObj = cJSON_GetArrayItem(cJsonObj, i); + if (adapterObj != NULL) { + ret = AudioParseAdapter(adapterObj); + if (ret < 0) { + AUDIO_FUNC_LOGE("AudioParseAdapter (%{public}d) error!", i); + return HDF_FAILURE; + } + adapterObj = NULL; + } + } + + return HDF_SUCCESS; +} + +int32_t CardInfoParseFromConfig(void) +{ + int32_t ret; + cJSON *cJsonObj = NULL; + cJSON *adaptersObj = NULL; + + if (g_parseFlag) { + return HDF_SUCCESS; + } + + cJsonObj = AudioCardGetConfig(ALSA_CARD_CONFIG_FILE); + if (cJsonObj == NULL) { + AUDIO_FUNC_LOGE("AudioCardGetConfig failed!\n"); + return HDF_FAILURE; + } + + adaptersObj = cJSON_GetObjectItem(cJsonObj, "adapters"); + if (adaptersObj == NULL) { + AUDIO_FUNC_LOGE("cJSON_GetObjectItem adapters failed!\n"); + cJSON_Delete(cJsonObj); + return HDF_FAILURE; + } + + ret = AudioAdaptersSetAdapterVar(adaptersObj); + if (ret < 0) { + AUDIO_FUNC_LOGE("AudioAdaptersSetAdapterVar is failed!\n"); + cJSON_Delete(cJsonObj); + return HDF_FAILURE; + } + cJSON_Delete(cJsonObj); + g_parseFlag = true; + + return HDF_SUCCESS; +} diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c index 10229a8c6b..630bc503d3 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c @@ -18,21 +18,22 @@ #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB -#define MAX_PERIOD_SIZE (8 * 1024) -#define MIN_PERIOD_SIZE (4 * 1024) - -static unsigned int g_bufferTime = 500000; /* ring buffer length in us */ -static unsigned int g_periodTime = 100000; /* period time in us */ -static snd_pcm_sframes_t g_bufferSize; -static snd_pcm_sframes_t g_periodSize; -static int g_resample = 1; /* enable alsa-lib resampling */ -static int g_periodEvent = 0; /* produce poll event after each period */ -static int g_canPause = 0; /* 0 Hardware doesn't support pause, 1 Hardware supports pause */ +#define MAX_PERIOD_SIZE (8 * 1024) +#define MIN_PERIOD_SIZE (4 * 1024) +#define AUDIO_RENDER_RECOVER_DELAY (10 * 1000) + +static snd_pcm_sframes_t g_bufferSize = 0; +static snd_pcm_sframes_t g_periodSize = 0; +static unsigned int g_bufferTime = 500000; /* (0.5s): ring buffer length in us */ +static unsigned int g_periodTime = 100000; /* (0.1s): period time in us */ +static int g_resample = 1; /* enable alsa-lib resampling */ +static int g_periodEvent = 0; /* produce poll event after each period */ +static int g_canPause = 0; /* 0 Hardware doesn't support pause, 1 Hardware supports pause */ static int32_t GetHwParams(struct AudioCardInfo *cardIns, const struct AudioHwRenderParam *handleData) { if (cardIns == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -57,7 +58,7 @@ static int32_t AudioSetMixerVolume(snd_mixer_elem_t *pcmElemen, long vol) int32_t ret; if (pcmElemen == NULL) { - AUDIO_FUNC_LOGE("AudioSetMixerVolume parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -65,13 +66,13 @@ static int32_t AudioSetMixerVolume(snd_mixer_elem_t *pcmElemen, long vol) if (snd_mixer_selem_is_playback_mono(pcmElemen)) { ret = snd_mixer_selem_set_playback_volume(pcmElemen, SND_MIXER_SCHN_FRONT_LEFT, vol); if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetMixerVolume failed: %{public}s", snd_strerror(ret)); + AUDIO_FUNC_LOGE("AudioSetMixerVolume failed: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } } else { ret = snd_mixer_selem_set_playback_volume_all(pcmElemen, vol); if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetMixerVolume failed: %{public}s", snd_strerror(ret)); + AUDIO_FUNC_LOGE("AudioSetMixerVolume failed: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } } @@ -79,15 +80,15 @@ static int32_t AudioSetMixerVolume(snd_mixer_elem_t *pcmElemen, long vol) return HDF_SUCCESS; } -int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle, int cmdId, - const struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { long vol; int32_t ret; struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderSetVolume parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -118,63 +119,80 @@ int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle, int cmdId, return HDF_SUCCESS; } -int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +static int32_t AudioRenderGetVolumeSub(struct AudioCardInfo *cardIns, long *vol) { - int32_t ret; - float vol; - long volLeft; - long volRight; - struct AudioCardInfo *cardIns = NULL; + long volLeft = MIN_VOLUME; + long volRight = MIN_VOLUME; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderSetVolume parameter is NULL!"); + if (cardIns == NULL || vol == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL || cardIns->ctrlLeftVolume == NULL || cardIns->mixer == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); + if (cardIns->ctrlLeftVolume == NULL || cardIns->mixer == NULL) { + AUDIO_FUNC_LOGE("cardIns's ctrlLeftVolume or mixer is null!"); return HDF_FAILURE; } // Handling events - ret = snd_mixer_handle_events(cardIns->mixer); + int32_t ret = snd_mixer_handle_events(cardIns->mixer); if (ret < 0) { AUDIO_FUNC_LOGE("snd_mixer_handle_events fail!"); return HDF_FAILURE; } // Left channel - ret = snd_mixer_selem_get_playback_volume(cardIns->ctrlLeftVolume, - SND_MIXER_SCHN_FRONT_LEFT, &volLeft); + ret = snd_mixer_selem_get_playback_volume(cardIns->ctrlLeftVolume, SND_MIXER_SCHN_FRONT_LEFT, &volLeft); if (ret < 0) { AUDIO_FUNC_LOGE("Set left channel fail!"); return HDF_FAILURE; } // right channel - ret = snd_mixer_selem_get_playback_volume(cardIns->ctrlLeftVolume, - SND_MIXER_SCHN_FRONT_RIGHT, &volRight); + ret = snd_mixer_selem_get_playback_volume(cardIns->ctrlLeftVolume, SND_MIXER_SCHN_FRONT_RIGHT, &volRight); if (ret < 0) { AUDIO_FUNC_LOGE("Set right channel fail!"); return HDF_FAILURE; } - vol = (float)((volLeft + volRight) >> 1); - handleData->renderMode.ctlParam.volume = vol; + *vol = (volLeft + volRight) >> 1; + + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +{ + int32_t ret; + long vol; + struct AudioCardInfo *cardIns = NULL; + + (void)cmdId; + if (handle == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); + return HDF_FAILURE; + } + + const char *adapterName = handleData->renderMode.hwInfo.adapterName; + cardIns = GetCardIns(adapterName); + ret = AudioRenderGetVolumeSub(cardIns, &vol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("AudioRenderGetVolumeSub failed!"); + return HDF_FAILURE; + } + + handleData->renderMode.ctlParam.volume = (float)vol; return HDF_SUCCESS; } -int32_t AudioCtlRenderSetPauseStu(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetPauseStu( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; int32_t pause; struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderSetVolume parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -182,7 +200,7 @@ int32_t AudioCtlRenderSetPauseStu(const struct DevHandle *handle, * so a success message is returned. * The software processing scheme is implemented * in AudioOutputRenderWrite interface. - */ + */ return HDF_SUCCESS; const char *adapterName = handleData->renderMode.hwInfo.adapterName; @@ -192,8 +210,7 @@ int32_t AudioCtlRenderSetPauseStu(const struct DevHandle *handle, return HDF_FAILURE; } - pause = handleData->renderMode.ctlParam.pause ? - AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; + pause = handleData->renderMode.ctlParam.pause ? AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; if (pause == AUDIO_ALSALIB_IOCTRL_RESUME) { ret = snd_pcm_resume(cardIns->renderPcmHandle); } else { @@ -216,7 +233,7 @@ static int32_t RenderSetMuteStuSub(struct AudioCardInfo *cardIns, int32_t muteSt return HDF_FAILURE; } - /** Mono (Front left alias) */ + /* Mono (Front left alias) */ if (cardIns->ctrlLeftVolume == NULL) { AUDIO_FUNC_LOGE("Unable to get Mono."); return HDF_FAILURE; @@ -237,15 +254,66 @@ static int32_t RenderSetMuteStuSub(struct AudioCardInfo *cardIns, int32_t muteSt return HDF_SUCCESS; } -int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +static int32_t AudioPrimarySetMuteState(struct AudioCardInfo *cardIns, int32_t muteState, float volume) +{ + long vol; + long alsaVol; + float volRangeMin = 0.0; + float volRangeMax = 100.0; + if (cardIns == NULL) { + AUDIO_FUNC_LOGE("cardIns is NULL!"); + return HDF_FAILURE; + } + int32_t ret = RenderSetMuteStuSub(cardIns, muteState); + /* ret return HDF_FAILURE : no control is present */ + if (ret != HDF_SUCCESS) { + /* Try to set the volume is 0 to change the mute state */ + ret = AudioRenderGetVolumeSub(cardIns, &vol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("AudioRenderGetVolumeSub error!"); + return HDF_FAILURE; + } + + if (muteState == false) { + alsaVol = 0; /* 0 for mute */ + cardIns->tempVolume = (float)vol; + } else { + if (volume > volRangeMin && volume <= volRangeMax) { + alsaVol = (long)volume; + } else { + alsaVol = (long)cardIns->tempVolume; + } + } + + if (cardIns->ctrlLeftVolume != NULL) { + ret = AudioSetMixerVolume(cardIns->ctrlLeftVolume, alsaVol); + if (ret < 0) { + AUDIO_FUNC_LOGE("AudioSetMixerVolume left fail!"); + return HDF_FAILURE; + } + } + + if (cardIns->ctrlRightVolume != NULL) { + ret = AudioSetMixerVolume(cardIns->ctrlRightVolume, alsaVol); + if (ret < 0) { + AUDIO_FUNC_LOGE("AudioSetMixerVolume right fail!"); + return HDF_FAILURE; + } + } + } + + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - bool muteState; + int32_t muteState; struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderSetMuteStu parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -256,27 +324,17 @@ int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle, return HDF_FAILURE; } - muteState = (bool)cardIns->renderMuteValue; + muteState = cardIns->renderMuteValue; if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - if (muteState == false) { - ret = AudioMixerSetCtrlMode(cardIns, adapterName, "Digital Playback mute", - SND_PLAY_PATH, SND_OUT_CARD_OFF); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioMixerSetCtrlMode failed!"); - return HDF_FAILURE; - } - } else { - ret = AudioMixerSetCtrlMode(cardIns, adapterName, "Digital Playback mute", - SND_PLAY_PATH, SND_OUT_CARD_SPK_HP); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioMixerSetCtrlMode failed!"); - return HDF_FAILURE; - } + ret = AudioPrimarySetMuteState(cardIns, muteState, handleData->renderMode.ctlParam.volume); + if (ret < 0) { + AUDIO_FUNC_LOGE("Render primary sound card SetMute failed!"); + return HDF_FAILURE; } } if (strncmp(adapterName, USB, strlen(USB)) == 0) { - ret = RenderSetMuteStuSub(cardIns, (int32_t)muteState); + ret = RenderSetMuteStuSub(cardIns, muteState); if (ret < 0) { AUDIO_FUNC_LOGE("Render usb sound card SetMute failed!"); return HDF_FAILURE; @@ -287,12 +345,13 @@ int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { struct AudioCardInfo *cardIns = NULL; + + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderGetMuteStu parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -302,42 +361,42 @@ int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, AUDIO_FUNC_LOGE("cardIns is NULL!"); return HDF_FAILURE; } - handleData->renderMode.ctlParam.mute = (bool)cardIns->renderMuteValue; return HDF_SUCCESS; } -int32_t AudioCtlRenderSetGainStu(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetGainStu(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderSetGainStu parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetGainStu(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSceneSelect(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSceneSelect( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { - struct AudioCardInfo *cardIns = NULL; enum AudioPortPin descPins; + struct AudioCardInfo *cardIns = NULL; - if (handle == NULL ||handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderSceneSelect parameter is NULL!"); + (void)cmdId; + if (handle == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -351,11 +410,10 @@ int32_t AudioCtlRenderSceneSelect(const struct DevHandle *handle, descPins = handleData->renderMode.hwInfo.deviceDescript.pins; switch (descPins) { case PIN_OUT_SPEAKER: - return AudioMixerSetCtrlMode(cardIns, adapterName, - "Digital Playback Path", SND_PLAY_PATH, SND_OUT_CARD_SPK); + return AudioMixerSetCtrlMode( + cardIns, adapterName, "Digital Playback Path", SND_PLAY_PATH, SND_OUT_CARD_SPK); case PIN_OUT_HEADSET: - return AudioMixerSetCtrlMode(cardIns, adapterName, - "Digital Playback Path", SND_PLAY_PATH, SND_OUT_CARD_HP); + return AudioMixerSetCtrlMode(cardIns, adapterName, "Digital Playback Path", SND_PLAY_PATH, SND_OUT_CARD_HP); default: AUDIO_FUNC_LOGE("This mode is not currently supported!"); break; @@ -364,27 +422,28 @@ int32_t AudioCtlRenderSceneSelect(const struct DevHandle *handle, return HDF_FAILURE; } -int32_t AudioCtlRenderSceneGetGainThreshold(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSceneGetGainThreshold( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; - long volMin = 0; - long volMax = 0; + long volMin = MIN_VOLUME; + long volMax = MIN_VOLUME; struct AudioCardInfo *cardIns = NULL; - if (handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlRenderGetVolThreshold parameter is NULL!"); + (void)cmdId; + if (handle == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -397,7 +456,7 @@ int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, ret = snd_mixer_selem_get_playback_volume_range(cardIns->ctrlLeftVolume, &volMin, &volMax); if (ret < 0) { - AUDIO_FUNC_LOGE("snd_mixer_selem_get_playback_volume_range fail: %{public}s", snd_strerror(ret)); + AUDIO_FUNC_LOGE("Get playback volume range fail: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } handleData->renderMode.ctlParam.volThreshold.volMin = (int)volMin; @@ -406,33 +465,33 @@ int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioCtlRenderSetChannelMode(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetChannelMode( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetChannelMode(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetChannelMode(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioInterfaceLibCtlRender(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioInterfaceLibCtlRender(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("paras is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -472,13 +531,14 @@ int32_t AudioInterfaceLibCtlRender(const struct DevHandle *handle, return HDF_FAILURE; } -static int32_t SetHWParamsSub(snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwParams, - snd_pcm_access_t access) +static int32_t SetHWParamsSub( + snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwParams, snd_pcm_access_t access) { int32_t ret; - snd_pcm_format_t pcmFormat; + snd_pcm_format_t pcmFormat = SND_PCM_FORMAT_S16_LE; + if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("SetHWParamsSub parameter is null!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -508,8 +568,8 @@ static int32_t SetHWParamsSub(snd_pcm_t *handle, snd_pcm_hw_params_t *params, st /* set the count of channels */ ret = snd_pcm_hw_params_set_channels(handle, params, hwParams.channels); if (ret < 0) { - AUDIO_FUNC_LOGE("Channels count (%u) not available for playbacks: %{public}s", - hwParams.channels, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for playbacks: %{public}s", hwParams.channels, + snd_strerror(ret)); return HDF_FAILURE; } @@ -520,24 +580,25 @@ static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_ { int32_t ret; uint32_t rRate; + int dir = 0; /* dir Value range (-1,0,1) */ if (handle == NULL || params == NULL || rate == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } /* set the stream rate */ rRate = *rate; - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, 0); + ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %uHz not available for playback: %{public}s", *rate, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for playback: %{public}s.", *rate, snd_strerror(ret)); return HDF_FAILURE; } if (rRate != *rate) { - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, 0); + ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %uHz not available for playback: %{public}s", *rate, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for playback: %{public}s.", *rate, snd_strerror(ret)); return HDF_FAILURE; } } @@ -547,14 +608,14 @@ static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_ return HDF_SUCCESS; } -static int32_t SetHWParams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, - struct AudioPcmHwParams hwParams, snd_pcm_access_t access) +static int32_t SetHWParams( + snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwParams, snd_pcm_access_t access) { int ret; int dir = 0; /* dir Value range (-1,0,1) */ if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -574,8 +635,8 @@ static int32_t SetHWParams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, } ret = snd_pcm_hw_params_set_buffer_time_near(handle, params, &g_bufferTime, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set buffer time %{public}u for playback: %{public}s", - g_bufferTime, snd_strerror(ret)); + AUDIO_FUNC_LOGE( + "Unable to set buffer time %{public}u for playback: %{public}s", g_bufferTime, snd_strerror(ret)); return HDF_FAILURE; } ret = snd_pcm_hw_params_get_buffer_size(params, &size); @@ -586,8 +647,8 @@ static int32_t SetHWParams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, g_bufferSize = size; ret = snd_pcm_hw_params_set_period_time_near(handle, params, &g_periodTime, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set period time %{public}u for playback: %{public}s", - g_bufferTime, snd_strerror(ret)); + AUDIO_FUNC_LOGE( + "Unable to set period time %{public}u for playback: %{public}s", g_bufferTime, snd_strerror(ret)); return HDF_FAILURE; } ret = snd_pcm_hw_params_get_period_size(params, &size, &dir); @@ -608,9 +669,10 @@ static int32_t SetHWParams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) { int32_t ret; + int32_t val = 1; /* val 0 = disable period event, 1 = enable period event */ if (handle == NULL || swparams == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -626,8 +688,7 @@ static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) AUDIO_FUNC_LOGE("g_periodSize=0"); return HDF_FAILURE; } - ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, - (g_bufferSize / g_periodSize) * g_periodSize); + ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, (g_bufferSize / g_periodSize) * g_periodSize); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set start threshold mode for playback: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -642,7 +703,7 @@ static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) /* enable period events when requested */ if (g_periodEvent) { - ret = snd_pcm_sw_params_set_period_event(handle, swparams, 1); + ret = snd_pcm_sw_params_set_period_event(handle, swparams, val); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -659,43 +720,45 @@ static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) return HDF_SUCCESS; } -static int32_t AudioResetParams(snd_pcm_t *handle, - struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access) +static int32_t AudioResetParams(snd_pcm_t *handle, struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access) { int32_t ret; snd_pcm_hw_params_t *hwParams = NULL; snd_pcm_sw_params_t *swParams = NULL; if (handle == NULL) { - AUDIO_FUNC_LOGE("Handle is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } snd_pcm_hw_params_alloca(&hwParams); snd_pcm_sw_params_alloca(&swParams); - if ((ret = SetHWParams(handle, hwParams, audioHwParams, access)) < 0) { + ret = SetHWParams(handle, hwParams, audioHwParams, access); + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Setting of hwparams failed."); - return HDF_FAILURE; + return ret; } - if ((ret = SetSWParams(handle, swParams)) < 0) { + ret = SetSWParams(handle, swParams); + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Setting of swparams failed."); - return HDF_FAILURE; + return ret; } return HDF_SUCCESS; } -int32_t AudioOutputRenderHwParams(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderHwParams( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns = NULL; snd_pcm_hw_params_t *hwParams = NULL; snd_pcm_sw_params_t *swParams = NULL; - if (handleData == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty"); + (void)cmdId; + if (handle == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -706,6 +769,12 @@ int32_t AudioOutputRenderHwParams(const struct DevHandle *handle, return HDF_FAILURE; } + ret = (int32_t)snd_pcm_state(cardIns->renderPcmHandle); + if (ret >= SND_PCM_STATE_RUNNING) { + AUDIO_FUNC_LOGE("Unable to set parameters during playback!"); + return HDF_FAILURE; + } + ret = GetHwParams(cardIns, handleData); if (ret < 0) { AUDIO_FUNC_LOGE("GetHwParams error."); @@ -714,13 +783,14 @@ int32_t AudioOutputRenderHwParams(const struct DevHandle *handle, snd_pcm_hw_params_alloca(&hwParams); snd_pcm_sw_params_alloca(&swParams); - if ((ret = SetHWParams(cardIns->renderPcmHandle, hwParams, cardIns->hwRenderParams, - SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) { + ret = SetHWParams(cardIns->renderPcmHandle, hwParams, cardIns->hwRenderParams, SND_PCM_ACCESS_RW_INTERLEAVED); + if (ret < 0) { AUDIO_FUNC_LOGE("Setting of hwparams failed."); return HDF_FAILURE; } - if ((ret = SetSWParams(cardIns->renderPcmHandle, swParams)) < 0) { + ret = SetSWParams(cardIns->renderPcmHandle, swParams); + if (ret < 0) { AUDIO_FUNC_LOGE("Setting of swparams failed."); return HDF_FAILURE; } @@ -728,23 +798,89 @@ int32_t AudioOutputRenderHwParams(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioOutputRenderWrite(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +static int32_t AudioRenderWriteFrameSub(snd_pcm_t *pcm, char *dataBuf, size_t bufSize) { int32_t ret; - size_t sbufFrameSize; long frames; - struct AudioCardInfo *cardIns = NULL; + int32_t tryNum = AUDIO_ALSALIB_RETYR; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); + if (pcm == NULL || dataBuf == NULL || bufSize == 0) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL || cardIns->renderPcmHandle == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); + do { + /* Write interleaved frames to a PCM. */ + frames = snd_pcm_writei(pcm, dataBuf, bufSize); + if (frames > 0) { + return HDF_SUCCESS; + } + + if (frames == -EBADFD) { + /* not #SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING */ + AUDIO_FUNC_LOGE("PCM is not in the right state: %{public}s", snd_strerror(frames)); + ret = snd_pcm_prepare(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } else { + /* -ESTRPIPE: a suspend event occurred, + * stream is suspended and waiting for an application recovery. + * -EPIPE: an underrun occurred. + */ + frames = snd_pcm_recover(pcm, frames, 0); // 0 for open log + if (frames < 0) { + AUDIO_FUNC_LOGE("snd_pcm_writei failed: %{public}s", snd_strerror(frames)); + return HDF_FAILURE; + } + usleep(AUDIO_RENDER_RECOVER_DELAY); + } + tryNum--; + } while (tryNum > 0); + + return HDF_SUCCESS; +} + +static int32_t AudioRenderWriteFrame(snd_pcm_t *pcm, const struct AudioHwRenderParam *handleData) +{ + int32_t ret; + size_t sbufFrameSize; + snd_pcm_state_t state; + + if (pcm == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); + return HDF_FAILURE; + } + + /* Check whether the PCM status is normal */ + state = snd_pcm_state(pcm); + if (state == SND_PCM_STATE_SETUP) { + ret = snd_pcm_prepare(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + sbufFrameSize = (size_t)handleData->frameRenderMode.bufferFrameSize; + ret = AudioRenderWriteFrameSub(pcm, handleData->frameRenderMode.buffer, sbufFrameSize); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("AudioRenderWriteFrameSub failed!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioOutputRenderWrite(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +{ + int32_t ret; + struct AudioCardInfo *cardIns = NULL; + + (void)cmdId; + if (handle == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -755,9 +891,15 @@ int32_t AudioOutputRenderWrite(const struct DevHandle *handle, } } + const char *adapterName = handleData->renderMode.hwInfo.adapterName; + cardIns = GetCardIns(adapterName); + if (cardIns == NULL) { + AUDIO_FUNC_LOGE("cardIns is NULL!"); + return HDF_FAILURE; + } + if (!cardIns->renderMmapFlag) { - ret = AudioResetParams(cardIns->renderPcmHandle, cardIns->hwRenderParams, - SND_PCM_ACCESS_RW_INTERLEAVED); + ret = AudioResetParams(cardIns->renderPcmHandle, cardIns->hwRenderParams, SND_PCM_ACCESS_RW_INTERLEAVED); if (ret < 0) { AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); return HDF_FAILURE; @@ -765,29 +907,23 @@ int32_t AudioOutputRenderWrite(const struct DevHandle *handle, cardIns->renderMmapFlag = true; } - /**Write interleaved frames to a PCM. */ - sbufFrameSize = (size_t)handleData->frameRenderMode.bufferFrameSize; - frames = snd_pcm_writei(cardIns->renderPcmHandle, - handleData->frameRenderMode.buffer, sbufFrameSize); - if (frames < 0) { - frames = snd_pcm_recover(cardIns->renderPcmHandle, frames, 0); - } - if (frames < 0) { - AUDIO_FUNC_LOGE("snd_pcm_writei failed: %{public}s", snd_strerror(frames)); + ret = AudioRenderWriteFrame(cardIns->renderPcmHandle, handleData); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("AudioRenderWriteFrame failed!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioOutputRenderPrepare(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderPrepare(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns = NULL; - if (handleData == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL!"); + (void)cmdId; + if (handle == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -810,11 +946,11 @@ int32_t AudioOutputRenderPrepare(const struct DevHandle *handle, int32_t InitMixerCtrlVolumeRange(struct AudioCardInfo *cardIns) { int32_t ret; - long volMin; - long volMax; + long volMin = MIN_VOLUME; + long volMax = MIN_VOLUME; if (cardIns == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } /** cardIns->ctrlLeftVolume is Mono (Front left alias) */ @@ -852,14 +988,13 @@ int32_t InitMixerCtrlVolumeRange(struct AudioCardInfo *cardIns) return HDF_SUCCESS; } -static int32_t InitMixerCtlElement(const char *adapterName, - struct AudioCardInfo *cardIns, snd_mixer_t *mixer) +static int32_t InitMixerCtlElement(const char *adapterName, struct AudioCardInfo *cardIns, snd_mixer_t *mixer) { int32_t ret; snd_mixer_elem_t *pcmElement = NULL; if (adapterName == NULL || cardIns == NULL || mixer == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -872,7 +1007,7 @@ static int32_t InitMixerCtlElement(const char *adapterName, ret = GetPriMixerCtlElement(cardIns, pcmElement); if (ret < 0) { - AUDIO_FUNC_LOGE("Capture GetPriMixerCtlElement failed."); + AUDIO_FUNC_LOGE("Render GetPriMixerCtlElement failed."); return HDF_FAILURE; } } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { @@ -888,9 +1023,7 @@ static int32_t InitMixerCtlElement(const char *adapterName, return HDF_FAILURE; } - ret = AudioMixerSetCtrlMode(cardIns, adapterName, - "Digital Playback Path", - SND_PLAY_PATH, SND_OUT_CARD_SPK_HP); + ret = AudioMixerSetCtrlMode(cardIns, adapterName, "Digital Playback Path", SND_PLAY_PATH, SND_OUT_CARD_SPK_HP); if (ret < 0) { AUDIO_FUNC_LOGE("AudioMixerSetCtrlMode failed!"); return HDF_FAILURE; @@ -903,12 +1036,12 @@ static int32_t InitMixerCtlElement(const char *adapterName, * brief: Opens a PCM * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC) */ -int32_t AudioOutputRenderOpen(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderOpen(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("The parameter is empty."); return HDF_FAILURE; @@ -947,12 +1080,12 @@ int32_t AudioOutputRenderOpen(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioOutputRenderStop(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderStop(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("The parameter is empty."); return HDF_FAILURE; @@ -974,14 +1107,14 @@ int32_t AudioOutputRenderStop(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioOutputRenderClose(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderClose(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioOutputRenderClose parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -1014,7 +1147,7 @@ int32_t AudioOutputRenderClose(const struct DevHandle *handle, (void)memset_s(cardIns->cardName, MAX_CARD_NAME_LEN + 1, 0, MAX_CARD_NAME_LEN + 1); ret = DestroyCardList(); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("DestroyCardList failed, reason: %d.", ret); + AUDIO_FUNC_LOGE("DestroyCardList failed, reason: %{public}d.", ret); return ret; } } @@ -1022,11 +1155,11 @@ int32_t AudioOutputRenderClose(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioOutputRenderStart(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderStart(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioOutputRenderStart parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -1042,11 +1175,11 @@ static int32_t RenderWriteiMmap(const struct AudioHwRenderParam *handleData, str uint32_t loopTimes; uint32_t looper = 0; uint32_t copyLen = 0; - int count = 0; + int32_t count = 0; struct AudioMmapBufferDescripter *mmapBufDesc = NULL; if (handleData == NULL || cardIns == NULL) { - AUDIO_FUNC_LOGE("AudioOutputRenderReqMmapBuffer parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -1058,13 +1191,12 @@ static int32_t RenderWriteiMmap(const struct AudioHwRenderParam *handleData, str mmapBufDesc = (struct AudioMmapBufferDescripter *)&(handleData->frameRenderMode.mmapBufDesc); totalSize = (uint32_t)mmapBufDesc->totalBufferFrames * frameSize; lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); - loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? - (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); + loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); while (looper < loopTimes) { copyLen = (looper < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; snd_pcm_uframes_t frames = (snd_pcm_uframes_t)(copyLen / frameSize); - ret = snd_pcm_mmap_writei(cardIns->renderPcmHandle, - (char *)mmapBufDesc->memoryAddress + mmapBufDesc->offset, frames); + ret = snd_pcm_mmap_writei( + cardIns->renderPcmHandle, (char *)mmapBufDesc->memoryAddress + mmapBufDesc->offset, frames); if (ret == -EAGAIN) { count++; if (count > AUDIO_ALSALIB_MMAP_MAX) { @@ -1078,7 +1210,7 @@ static int32_t RenderWriteiMmap(const struct AudioHwRenderParam *handleData, str AUDIO_FUNC_LOGE("Write error: %{public}s\n", snd_strerror(ret)); return HDF_FAILURE; } - looper ++; + looper++; mmapBufDesc->offset += copyLen; cardIns->renderMmapFrames += (uint64_t)frames; } @@ -1086,16 +1218,18 @@ static int32_t RenderWriteiMmap(const struct AudioHwRenderParam *handleData, str return HDF_SUCCESS; } -int32_t AudioOutputRenderReqMmapBuffer(const struct DevHandle *handle, - int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderReqMmapBuffer( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioOutputRenderReqMmapBuffer parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } + const char *adapterName = handleData->renderMode.hwInfo.adapterName; cardIns = GetCardIns(adapterName); if (cardIns == NULL) { @@ -1104,8 +1238,7 @@ int32_t AudioOutputRenderReqMmapBuffer(const struct DevHandle *handle, } cardIns->renderMmapFlag = false; - ret = AudioResetParams(cardIns->renderPcmHandle, - cardIns->hwRenderParams, SND_PCM_ACCESS_MMAP_INTERLEAVED); + ret = AudioResetParams(cardIns->renderPcmHandle, cardIns->hwRenderParams, SND_PCM_ACCESS_MMAP_INTERLEAVED); if (ret < 0) { AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); return HDF_FAILURE; @@ -1120,13 +1253,14 @@ int32_t AudioOutputRenderReqMmapBuffer(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioOutputRenderGetMmapPosition(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderGetMmapPosition( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { struct AudioCardInfo *cardIns = NULL; + (void)cmdId; if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioOutputRenderGetMmapPosition parameter is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } @@ -1141,18 +1275,17 @@ int32_t AudioOutputRenderGetMmapPosition(const struct DevHandle *handle, return HDF_SUCCESS; } -int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle, - int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; - if (handle == NULL) { - AUDIO_FUNC_LOGE("Input Render handle is NULL!"); + if (handle == NULL || handleData == NULL) { + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } - if (handle->object == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Input Render handle is error!"); + if (handle->object == NULL) { + AUDIO_FUNC_LOGE("handle's object is null!"); return HDF_FAILURE; } @@ -1203,18 +1336,17 @@ int32_t AudioBindServiceRenderObject(struct DevHandle *handle, const char *name) struct HdfIoService *service = NULL; if (handle == NULL || name == NULL) { - AUDIO_FUNC_LOGE("service name or handle is NULL!"); + AUDIO_FUNC_LOGE("Parameter error!"); return HDF_FAILURE; } serviceName = (char *)OsalMemCalloc(NAME_LEN); if (serviceName == NULL) { - AUDIO_FUNC_LOGE("Failed to alloc serviceName"); + AUDIO_FUNC_LOGE("Failed to allocate memory!"); return HDF_FAILURE; } - ret = snprintf_s(serviceName, NAME_LEN - 1, - SERVIC_NAME_MAX_LEN + 1, "hdf_audio_%s", name); + ret = snprintf_s(serviceName, NAME_LEN - 1, SERVIC_NAME_MAX_LEN + 1, "hdf_audio_%s", name); if (ret < 0) { AUDIO_FUNC_LOGE("Failed to snprintf_s"); AudioMemFree((void **)&serviceName); @@ -1256,6 +1388,14 @@ struct DevHandle *AudioBindServiceRender(const char *name) AudioMemFree((void **)&handle); return NULL; } + + /* Parsing primary sound card from configuration file */ + ret = CardInfoParseFromConfig(); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CardInfoParseFromConfig failed!"); + AudioMemFree((void **)&handle); + return NULL; + } AUDIO_FUNC_LOGI("BIND SERVICE SUCCESS!"); return handle; @@ -1271,8 +1411,7 @@ void AudioCloseServiceRender(const struct DevHandle *handle) } } -int32_t AudioInterfaceLibModeRender(const struct DevHandle *handle, - struct AudioHwRenderParam *handleData, int cmdId) +int32_t AudioInterfaceLibModeRender(const struct DevHandle *handle, struct AudioHwRenderParam *handleData, int cmdId) { if (handle == NULL || handleData == NULL) { AUDIO_FUNC_LOGE("paras is NULL!"); -- Gitee From 1a3840c37fa3b7debee4f59b3ee6cd5d2f2bf721 Mon Sep 17 00:00:00 2001 From: wanghongtao Date: Mon, 1 Aug 2022 18:40:20 +0800 Subject: [PATCH 10/33] camera module idl transformation Signed-off-by: wanghongtao --- camera/bundle.json | 12 - camera/hal/BUILD.gn | 7 +- camera/hal/buffer_manager/BUILD.gn | 1 + camera/hal/hdi_impl/BUILD.gn | 23 +- .../camera_device/camera_device_impl.h | 46 +- .../include/camera_host/camera_host.h | 2 +- .../include/camera_host/camera_host_config.h | 1 + .../include/camera_host/camera_host_impl.h | 27 +- .../offline_stream_operator/offline_stream.h | 9 +- .../offline_stream_operator.h | 11 +- .../include/stream_operator/capture_message.h | 3 +- .../include/stream_operator/stream_operator.h | 58 +-- camera/hal/hdi_impl/include/utils.h | 3 +- .../src/camera_device/camera_device_impl.cpp | 93 +++- .../src/camera_host/camera_host_impl.cpp | 71 +-- .../offline_stream.cpp | 26 +- .../offline_stream_operator.cpp | 14 +- .../src/stream_operator/stream_operator.cpp | 308 ++++++------ camera/hal/hdi_impl/test/BUILD.gn | 6 +- camera/hal/include/camera.h | 5 + camera/hal/init/BUILD.gn | 8 +- camera/hal/init/ohos_camera_demo.cpp | 239 +++++---- camera/hal/init/ohos_camera_demo.h | 57 ++- camera/hal/init/stream_customer.h | 2 +- .../include/host_stream_data_structure.h | 3 +- camera/hal/test/fuzz/BUILD.gn | 28 +- camera/hal/test/mpi/BUILD.gn | 6 +- camera/hal/test/mpi/dfxShell.sh | 6 +- camera/hal/test/v4l2/BUILD.gn | 6 +- camera/hal/utils/BUILD.gn | 1 + .../device/include/camera_device_callback.h | 9 +- .../include/camera_device_callback_proxy.h | 39 -- .../include/camera_device_callback_stub.h | 31 -- .../device/src/camera_device_callback.cpp | 7 +- .../src/camera_device_callback_proxy.cpp | 84 ---- .../src/camera_device_callback_stub.cpp | 59 --- .../host/include/camera_host_callback.h | 13 +- .../host/include/camera_host_callback_proxy.h | 39 -- .../host/include/camera_host_callback_stub.h | 31 -- .../host/src/camera_host_callback.cpp | 10 +- .../host/src/camera_host_callback_proxy.cpp | 105 ---- .../host/src/camera_host_callback_stub.cpp | 68 --- .../include/stream_operator_callback.h | 16 +- .../include/stream_operator_callback_proxy.h | 44 -- .../include/stream_operator_callback_stub.h | 35 -- .../operator/src/stream_operator_callback.cpp | 18 +- .../src/stream_operator_callback_proxy.cpp | 164 ------ .../src/stream_operator_callback_stub.cpp | 149 ------ .../interfaces/hdi_ipc/camera_host_driver.cpp | 116 +++++ camera/interfaces/hdi_ipc/client/BUILD.gn | 87 ---- .../client/include/camera_device_proxy.h | 44 -- .../client/include/camera_host_proxy.h | 43 -- .../include/offline_stream_operator_proxy.h | 38 -- .../client/include/stream_operator_proxy.h | 55 --- .../client/src/camera_device_proxy.cpp | 215 -------- .../hdi_ipc/client/src/camera_host_proxy.cpp | 215 -------- .../src/offline_stream_operator_proxy.cpp | 90 ---- .../client/src/stream_operator_proxy.cpp | 407 --------------- .../server/include/camera_device_stub.h | 41 -- .../hdi_ipc/server/include/camera_host_stub.h | 60 --- .../include/offline_stream_operator_stub.h | 37 -- .../server/include/stream_operator_stub.h | 47 -- .../hdi_ipc/server/src/camera_device_stub.cpp | 243 --------- .../hdi_ipc/server/src/camera_host_driver.cpp | 99 ---- .../hdi_ipc/server/src/camera_host_stub.cpp | 266 ---------- .../src/offline_stream_operator_stub.cpp | 107 ---- .../server/src/stream_operator_stub.cpp | 366 -------------- .../hdi_ipc/utils/include/utils_data_stub.h | 36 +- .../hdi_ipc/utils/src/utils_data_stub.cpp | 177 ++++++- camera/interfaces/include/icamera_device.h | 136 ----- .../include/icamera_device_callback.h | 67 --- camera/interfaces/include/icamera_host.h | 130 ----- .../include/icamera_host_callback.h | 75 --- .../include/ioffline_stream_operator.h | 77 --- camera/interfaces/include/istream_operator.h | 258 ---------- .../include/istream_operator_callback.h | 94 ---- camera/interfaces/include/types.h | 467 ------------------ .../metadata/include/metadata_utils.h | 33 +- .../metadata/src/metadata_utils.cpp | 171 +++++++ distributed_camera/hdi_service/BUILD.gn | 54 +- .../include/dcamera_device/dcamera_device.h | 26 +- .../dcamera_device/dmetadata_processor.h | 16 +- .../include/dcamera_host/dcamera_host.h | 29 +- .../include/dstream_operator/dcamera_stream.h | 14 +- .../include/dstream_operator/dimage_buffer.h | 2 + .../doffline_stream_operator.h | 12 +- .../dstream_operator/dstream_operator.h | 50 +- .../hdi_service/include/utils/constants.h | 18 +- .../hdi_service/include/utils/dcamera.h | 8 +- .../src/config/dcamera_host_config.cpp | 103 ++-- .../src/config/dcamera_provider_config.cpp | 4 +- .../src/dcamera_device/dcamera_device.cpp | 39 +- .../dcamera_device/dmetadata_processor.cpp | 52 +- .../src/dcamera_host/dcamera_host.cpp | 54 +- .../src/dcamera_provider/dcamera_provider.cpp | 8 +- .../src/dstream_operator/dcamera_stream.cpp | 68 ++- .../doffline_stream_operator.cpp | 6 +- .../src/dstream_operator/dstream_operator.cpp | 137 +++-- distributed_camera/hdi_service/test/BUILD.gn | 8 - .../hdi_service/test/common.cpp | 185 ++++--- distributed_camera/hdi_service/test/common.h | 41 +- .../hdi_service/test/dcamera_hdi_sample.cpp | 2 +- .../interfaces/hdi_ipc/ipc_data_utils.h | 104 ---- .../device/dcamera_device_callback_proxy.cpp | 88 ---- .../device/dcamera_device_callback_proxy.h | 40 -- .../server/device/dcamera_device_stub.cpp | 235 --------- .../server/device/dcamera_device_stub.h | 44 -- .../host/dcamera_host_callback_proxy.cpp | 107 ---- .../server/host/dcamera_host_callback_proxy.h | 41 -- .../hdi_ipc/server/host/dcamera_host_stub.cpp | 262 ---------- .../hdi_ipc/server/host/dcamera_host_stub.h | 69 --- .../doffline_stream_operator_stub.cpp | 107 ---- .../operator/doffline_stream_operator_stub.h | 39 -- .../dstream_operator_callback_proxy.cpp | 162 ------ .../dstream_operator_callback_proxy.h | 45 -- .../server/operator/dstream_operator_stub.cpp | 355 ------------- .../server/operator/dstream_operator_stub.h | 47 -- 117 files changed, 1671 insertions(+), 7310 deletions(-) delete mode 100644 camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_proxy.h delete mode 100644 camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_stub.h delete mode 100644 camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_proxy.cpp delete mode 100644 camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_stub.cpp delete mode 100644 camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_proxy.h delete mode 100644 camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_stub.h delete mode 100644 camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_proxy.cpp delete mode 100644 camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_stub.cpp delete mode 100644 camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_proxy.h delete mode 100644 camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_stub.h delete mode 100644 camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_proxy.cpp delete mode 100644 camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_stub.cpp create mode 100644 camera/interfaces/hdi_ipc/camera_host_driver.cpp delete mode 100644 camera/interfaces/hdi_ipc/client/BUILD.gn delete mode 100644 camera/interfaces/hdi_ipc/client/include/camera_device_proxy.h delete mode 100644 camera/interfaces/hdi_ipc/client/include/camera_host_proxy.h delete mode 100644 camera/interfaces/hdi_ipc/client/include/offline_stream_operator_proxy.h delete mode 100644 camera/interfaces/hdi_ipc/client/include/stream_operator_proxy.h delete mode 100644 camera/interfaces/hdi_ipc/client/src/camera_device_proxy.cpp delete mode 100644 camera/interfaces/hdi_ipc/client/src/camera_host_proxy.cpp delete mode 100644 camera/interfaces/hdi_ipc/client/src/offline_stream_operator_proxy.cpp delete mode 100644 camera/interfaces/hdi_ipc/client/src/stream_operator_proxy.cpp delete mode 100644 camera/interfaces/hdi_ipc/server/include/camera_device_stub.h delete mode 100644 camera/interfaces/hdi_ipc/server/include/camera_host_stub.h delete mode 100644 camera/interfaces/hdi_ipc/server/include/offline_stream_operator_stub.h delete mode 100644 camera/interfaces/hdi_ipc/server/include/stream_operator_stub.h delete mode 100644 camera/interfaces/hdi_ipc/server/src/camera_device_stub.cpp delete mode 100644 camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp delete mode 100644 camera/interfaces/hdi_ipc/server/src/camera_host_stub.cpp delete mode 100644 camera/interfaces/hdi_ipc/server/src/offline_stream_operator_stub.cpp delete mode 100644 camera/interfaces/hdi_ipc/server/src/stream_operator_stub.cpp delete mode 100644 camera/interfaces/include/icamera_device.h delete mode 100644 camera/interfaces/include/icamera_device_callback.h delete mode 100644 camera/interfaces/include/icamera_host.h delete mode 100644 camera/interfaces/include/icamera_host_callback.h delete mode 100644 camera/interfaces/include/ioffline_stream_operator.h delete mode 100644 camera/interfaces/include/istream_operator.h delete mode 100644 camera/interfaces/include/istream_operator_callback.h delete mode 100644 camera/interfaces/include/types.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/ipc_data_utils.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.cpp delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.cpp delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.cpp delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.cpp delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.cpp delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.cpp delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.h delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.cpp delete mode 100644 distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.h diff --git a/camera/bundle.json b/camera/bundle.json index 17488f08a9..e6c291e4d1 100644 --- a/camera/bundle.json +++ b/camera/bundle.json @@ -30,18 +30,6 @@ "//drivers/peripheral/camera/hal:camera_hal" ], "inner_kits": [ - { - "name": "//drivers/peripheral/camera/interfaces/hdi_ipc/client:libcamera_client", - "header": { - "header_files": [ - "camera_device_proxy.h", - "camera_host_proxy.h", - "offline_stream_operator_proxy.h", - "stream_operator_proxy.h" - ], - "header_base": "//drivers/peripheral/camera/interfaces/hdi_ipc/client/include" - } - }, { "name": "//drivers/peripheral/camera/interfaces/metadata:metadata", "header": { diff --git a/camera/hal/BUILD.gn b/camera/hal/BUILD.gn index 8ff1f57eae..d50a6c24c5 100644 --- a/camera/hal/BUILD.gn +++ b/camera/hal/BUILD.gn @@ -18,7 +18,7 @@ if (defined(ohos_lite)) { deps = [ "buffer_manager:camera_buffer_manager", "device_manager:camera_device_manager", - "hdi_impl:camera_hdi_impl", + "hdi_impl:camera_host_service_1.0", "init:ohos_camera_demo", "pipeline_core:camera_pipeline_core", "utils:camera_utils", @@ -32,13 +32,12 @@ if (defined(ohos_lite)) { group("camera_hal") { if (is_standard_system) { if (target_cpu == "x86_64") { - deps = [ "$camera_path/../interfaces/hdi_ipc/client:libcamera_client" ] + deps = [] } else { deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "buffer_manager:camera_buffer_manager", "device_manager:camera_device_manager", - "hdi_impl:camera_hdi_impl", + "hdi_impl:camera_host_service_1.0", "init:ohos_camera_demo", "pipeline_core:camera_pipeline_core", "utils:camera_utils", diff --git a/camera/hal/buffer_manager/BUILD.gn b/camera/hal/buffer_manager/BUILD.gn index 0b349df846..71b4c02e2c 100644 --- a/camera/hal/buffer_manager/BUILD.gn +++ b/camera/hal/buffer_manager/BUILD.gn @@ -129,6 +129,7 @@ if (defined(ohos_lite)) { "src/buffer_adapter/standard", "$camera_path/include", "//utils/native/base/include", + "//drivers/peripheral/camera/interfaces/metadata/include", ] libs = [] diff --git a/camera/hal/hdi_impl/BUILD.gn b/camera/hal/hdi_impl/BUILD.gn index f4fbbe9cc9..967e94c780 100644 --- a/camera/hal/hdi_impl/BUILD.gn +++ b/camera/hal/hdi_impl/BUILD.gn @@ -35,12 +35,10 @@ if (defined(ohos_lite)) { ldflags += [ "--coverage" ] } - ohos_shared_library("camera_hdi_impl") { + ohos_shared_library("camera_host_service_1.0") { output_extension = "z.so" sources = [ - "src/camera_device/camera_device.cpp", "src/camera_device/camera_device_impl.cpp", - "src/camera_host/camera_host.cpp", "src/camera_host/camera_host_config.cpp", "src/camera_host/camera_host_impl.cpp", "src/camera_host/hcs_deal.cpp", @@ -149,20 +147,12 @@ if (defined(ohos_lite)) { } } - ohos_shared_library("camera_hdi_impl") { + ohos_shared_library("camera_host_service_1.0") { sources = [ - "$camera_path/../interfaces/hdi_ipc/callback/device/src/camera_device_callback_proxy.cpp", - "$camera_path/../interfaces/hdi_ipc/callback/host/src/camera_host_callback_proxy.cpp", - "$camera_path/../interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_proxy.cpp", - "$camera_path/../interfaces/hdi_ipc/server/src/camera_device_stub.cpp", - "$camera_path/../interfaces/hdi_ipc/server/src/camera_host_driver.cpp", - "$camera_path/../interfaces/hdi_ipc/server/src/camera_host_stub.cpp", - "$camera_path/../interfaces/hdi_ipc/server/src/offline_stream_operator_stub.cpp", - "$camera_path/../interfaces/hdi_ipc/server/src/stream_operator_stub.cpp", - "$camera_path/../interfaces/hdi_ipc/utils/src/utils_data_stub.cpp", - "$camera_path/hdi_impl/src/camera_device/camera_device.cpp", + "$camera_path/../interfaces/hdi_ipc/camera_host_driver.cpp", + + #"$camera_path/../interfaces/hdi_ipc/utils/src/utils_data_stub.cpp", "$camera_path/hdi_impl/src/camera_device/camera_device_impl.cpp", - "$camera_path/hdi_impl/src/camera_host/camera_host.cpp", "$camera_path/hdi_impl/src/camera_host/camera_host_config.cpp", "$camera_path/hdi_impl/src/camera_host/camera_host_impl.cpp", "$camera_path/hdi_impl/src/camera_host/hcs_deal.cpp", @@ -182,8 +172,6 @@ if (defined(ohos_lite)) { "$camera_path/../interfaces/include", "$camera_path/../interfaces/hdi_ipc", "$camera_path/../interfaces/hdi_ipc/utils/include", - "$camera_path/../interfaces/hdi_ipc/utils/include", - "$camera_path/../interfaces/hdi_ipc/server/include", "$camera_path/../interfaces/hdi_ipc/callback/host/include", "$camera_path/../interfaces/hdi_ipc/callback/device/include", "$camera_path/../interfaces/hdi_ipc/callback/operator/include", @@ -229,6 +217,7 @@ if (defined(ohos_lite)) { "$camera_path/device_manager:camera_device_manager", "$camera_path/pipeline_core:camera_pipeline_core", "$camera_path/utils:camera_utils", + "//drivers/interface/camera/v1_0:libcamera_stub_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] diff --git a/camera/hal/hdi_impl/include/camera_device/camera_device_impl.h b/camera/hal/hdi_impl/include/camera_device/camera_device_impl.h index 0eb4aca9c5..c414584aff 100644 --- a/camera/hal/hdi_impl/include/camera_device/camera_device_impl.h +++ b/camera/hal/hdi_impl/include/camera_device/camera_device_impl.h @@ -16,15 +16,17 @@ #ifndef CAMERA_DEVICE_CAMERA_DEVICE_IMPL_H #define CAMERA_DEVICE_CAMERA_DEVICE_IMPL_H -#include "camera_device.h" +#include "v1_0/icamera_device.h" +#include "v1_0/icamera_device_callback.h" #include "camera.h" #include "camera_metadata_info.h" #include "stream_operator.h" #include namespace OHOS::Camera { +using namespace OHOS::HDI::Camera::V1_0; class IPipelineCore; -class CameraDeviceImpl : public CameraDevice, public std::enable_shared_from_this { +class CameraDeviceImpl : public ICameraDevice, public std::enable_shared_from_this { public: CameraDeviceImpl(const std::string &cameraId, const std::shared_ptr &pipelineCore); @@ -36,30 +38,28 @@ public: CameraDeviceImpl& operator=(CameraDeviceImpl &&other) = delete; public: - CamRetCode GetStreamOperator(const OHOS::sptr &callback, - OHOS::sptr &streamOperator) override; - CamRetCode UpdateSettings(const std::shared_ptr &settings) override; - CamRetCode SetResultMode(const ResultCallbackMode &mode) override; - CamRetCode GetEnabledResults(std::vector &results) override; - CamRetCode EnableResult(const std::vector &results) override; - CamRetCode DisableResult(const std::vector &results) override; - void Close() override; + int32_t GetStreamOperator(const sptr& callbackObj, + sptr& streamOperator) override; + int32_t UpdateSettings(const std::vector& settings) override; + int32_t SetResultMode(ResultCallbackMode mode) override; + int32_t GetEnabledResults(std::vector& results) override; + int32_t EnableResult(const std::vector& results) override; + int32_t DisableResult(const std::vector& results) override; + int32_t Close() override; - std::shared_ptr GetPipelineCore() const override; - CamRetCode SetCallback(const OHOS::sptr &callback) override; - ResultCallbackMode GetMetaResultMode() const override; + static std::shared_ptr CreateCameraDevice(const std::string &cameraId); + std::shared_ptr GetPipelineCore() const; + CamRetCode SetCallback(const OHOS::sptr &callback); + ResultCallbackMode GetMetaResultMode() const; /* RC_OK: metadata changed；RC_ERROR: metadata unchanged； */ - RetCode GetMetadataResults(std::shared_ptr &metadata) override; - void ResultMetadata() override; - void GetCameraId(std::string &cameraId) const override; - bool IsOpened() const override; - void SetStatus(bool isOpened) override; + RetCode GetMetadataResults(std::shared_ptr &metadata); + void ResultMetadata(); + void GetCameraId(std::string &cameraId) const; + void SetStatus(bool isOpened); void OnRequestTimeout(); - -protected: - void OnMetadataChanged(const std::shared_ptr &metadata) override; - void OnDevStatusErr() override; - + void OnMetadataChanged(const std::shared_ptr &metadata); + void OnDevStatusErr(); + bool IsOpened() const; private: RetCode GetEnabledFromCfg(); bool CompareTagData(const camera_metadata_item_t &baseEntry, diff --git a/camera/hal/hdi_impl/include/camera_host/camera_host.h b/camera/hal/hdi_impl/include/camera_host/camera_host.h index e2ee32211f..8e07848116 100644 --- a/camera/hal/hdi_impl/include/camera_host/camera_host.h +++ b/camera/hal/hdi_impl/include/camera_host/camera_host.h @@ -19,7 +19,7 @@ #include "icamera_host_callback.h" #include "icamera_device_callback.h" #include "camera.h" -#include "types.h" +#include "v1_0/types.h" namespace OHOS::Camera { class ICameraDevice; diff --git a/camera/hal/hdi_impl/include/camera_host/camera_host_config.h b/camera/hal/hdi_impl/include/camera_host/camera_host_config.h index 66040b7c9f..b27dacb57b 100644 --- a/camera/hal/hdi_impl/include/camera_host/camera_host_config.h +++ b/camera/hal/hdi_impl/include/camera_host/camera_host_config.h @@ -20,6 +20,7 @@ #include #include #include "utils.h" +#include "camera.h" namespace OHOS::Camera { class HcsDeal; diff --git a/camera/hal/hdi_impl/include/camera_host/camera_host_impl.h b/camera/hal/hdi_impl/include/camera_host/camera_host_impl.h index 2727e05733..0f25eec0fb 100644 --- a/camera/hal/hdi_impl/include/camera_host/camera_host_impl.h +++ b/camera/hal/hdi_impl/include/camera_host/camera_host_impl.h @@ -17,23 +17,24 @@ #define CAMERA_HOST_CAMERA_HOST_IMPL_H #include -#include "camera_host.h" +#include "v1_0/icamera_host.h" #include "utils.h" -#include "icamera_device.h" +#include "v1_0/icamera_device.h" +#include "camera_device_impl.h" namespace OHOS::Camera { -class CameraDevice; -class CameraHostImpl : public CameraHost { +using namespace OHOS::HDI::Camera::V1_0; + +class CameraHostImpl : public ICameraHost { public: CamRetCode Init(); - CamRetCode SetCallback(const OHOS::sptr &callback) override; - CamRetCode GetCameraIds(std::vector &cameraIds) override; - CamRetCode GetCameraAbility(const std::string &cameraId, - std::shared_ptr &ability) override; - CamRetCode OpenCamera(const std::string &cameraId, - const OHOS::sptr &callback, - OHOS::sptr &pDevice) override; - CamRetCode SetFlashlight(const std::string &cameraId, bool &isEnable) override; + int32_t SetCallback(const sptr& callbackObj) override; + int32_t GetCameraIds(std::vector &cameraIds) override; + int32_t GetCameraAbility(const std::string &cameraId, + std::vector& cameraAbility) override; + int32_t OpenCamera(const std::string& cameraId, const sptr& callbackObj, + sptr& device) override; + int32_t SetFlashlight(const std::string &cameraId, bool isEnable) override; public: CameraHostImpl(); @@ -54,7 +55,7 @@ private: private: // key: cameraId, value: CameraDevice - using CameraDeviceMap = std::map>; + using CameraDeviceMap = std::map>; CameraDeviceMap cameraDeviceMap_; OHOS::sptr cameraHostCallback_; // to keep remote object OHOS::sptr alive diff --git a/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream.h b/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream.h index a997d0e550..985d1b5c34 100644 --- a/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream.h +++ b/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream.h @@ -18,17 +18,18 @@ #include "camera.h" #include "offline_stream_context.h" -#include "istream_operator_callback.h" +#include "v1_0/istream_operator_callback.h" #include #include #include "capture_message.h" namespace OHOS::Camera { +using namespace OHOS::HDI::Camera::V1_0; class OfflineStream { public: OfflineStream() = default; virtual ~OfflineStream(); - OfflineStream(int32_t id, OHOS::sptr& callback); + OfflineStream(int32_t id, const OHOS::sptr& callback); RetCode Init(std::shared_ptr& context); RetCode CancelCapture(int32_t captureId); @@ -40,8 +41,8 @@ public: private: RetCode ReturnBuffer(std::shared_ptr& buffer); void HandleMessage(MessageGroup& message); - void OnCaptureEnded(int32_t captureId, const std::vector>& infos); - void OnCaptureError(int32_t captureId, const std::vector>& infos); + void OnCaptureEnded(int32_t captureId, const std::vector& infos); + void OnCaptureError(int32_t captureId, const std::vector& infos); private: int32_t streamId_ = -1; diff --git a/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream_operator.h b/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream_operator.h index 238ad00934..a8d6e779ec 100644 --- a/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream_operator.h +++ b/camera/hal/hdi_impl/include/offline_stream_operator/offline_stream_operator.h @@ -17,19 +17,20 @@ #define HOS_CAMERA_OFFLINE_STREAM_OPERATOR_H #include "camera.h" -#include "offline_stream_operator_stub.h" +#include "v1_0/ioffline_stream_operator.h" #include "offline_stream.h" #include #include namespace OHOS::Camera { -class OfflineStreamOperator : public OfflineStreamOperatorStub { +using namespace OHOS::HDI::Camera::V1_0; +class OfflineStreamOperator : public IOfflineStreamOperator { public: OfflineStreamOperator(); virtual ~OfflineStreamOperator(); - CamRetCode CancelCapture(int captureId) override; - CamRetCode ReleaseStreams(const std::vector& streamIds) override; - CamRetCode Release() override; + int32_t CancelCapture(int32_t captureId) override; + int32_t ReleaseStreams(const std::vector& streamIds) override; + int32_t Release() override; public: RetCode CommitOfflineStream(const std::shared_ptr& of); diff --git a/camera/hal/hdi_impl/include/stream_operator/capture_message.h b/camera/hal/hdi_impl/include/stream_operator/capture_message.h index eaaca8ab57..5181cbc34e 100644 --- a/camera/hal/hdi_impl/include/stream_operator/capture_message.h +++ b/camera/hal/hdi_impl/include/stream_operator/capture_message.h @@ -17,7 +17,7 @@ #define STREAM_OPERATOR_CAPTURE_MESSAGE_H #include "camera.h" -#include "types.h" +#include "v1_0/types.h" #include #include #include @@ -25,6 +25,7 @@ #include namespace OHOS::Camera { +using namespace OHOS::HDI::Camera::V1_0; enum CaptureMessageType { CAPTURE_MESSAGE_TYPE_INVALID = 0, CAPTURE_MESSAGE_TYPE_ON_STARTED, diff --git a/camera/hal/hdi_impl/include/stream_operator/stream_operator.h b/camera/hal/hdi_impl/include/stream_operator/stream_operator.h index 79d5a54aab..5bf656e3be 100644 --- a/camera/hal/hdi_impl/include/stream_operator/stream_operator.h +++ b/camera/hal/hdi_impl/include/stream_operator/stream_operator.h @@ -16,39 +16,36 @@ #ifndef STREAM_OPERATOR_STREAM_OPERATOR_H #define STREAM_OPERATOR_STREAM_OPERATOR_H -#include "camera_device.h" +#include +#include "v1_0/icamera_device.h" #include "capture_message.h" #include "istream.h" -#include "istream_operator.h" +#include "v1_0/istream_operator.h" #include "offline_stream_operator.h" #include "offline_stream.h" -#include "stream_operator_stub.h" #include "surface.h" -#include "types.h" +#include "v1_0/types.h" + namespace OHOS::Camera { -class StreamOperator : public StreamOperatorStub { +using namespace OHOS::HDI::Camera::V1_0; +class StreamOperator : public IStreamOperator { public: - CamRetCode IsStreamsSupported(OperationMode mode, - const std::shared_ptr& modeSetting, - const std::vector>& pInfo, - StreamSupportType& type) override; - CamRetCode CreateStreams(const std::vector>& streamInfos) override; - CamRetCode ReleaseStreams(const std::vector& streamIds) override; - CamRetCode CommitStreams(OperationMode mode, - const std::shared_ptr& modeSetting) override; - CamRetCode GetStreamAttributes(std::vector>& attributes) override; - CamRetCode AttachBufferQueue(int streamId, const OHOS::sptr& producer) override; - CamRetCode DetachBufferQueue(int streamId) override; - CamRetCode - Capture(int captureId, const std::shared_ptr& captureInfo, bool isStreaming) override; - CamRetCode CancelCapture(int captureId) override; - CamRetCode ChangeToOfflineStream(const std::vector& streamIds, - OHOS::sptr& callback, - OHOS::sptr& offlineOperator) override; + int32_t IsStreamsSupported(OperationMode mode, const std::vector& modeSetting, + const std::vector& infos, StreamSupportType& type) override; + int32_t CreateStreams(const std::vector& streamInfos) override; + int32_t ReleaseStreams(const std::vector& streamIds) override; + int32_t CommitStreams(OperationMode mode, const std::vector& modeSetting) override; + int32_t GetStreamAttributes(std::vector& attributes) override; + int32_t AttachBufferQueue(int32_t streamId, const sptr& bufferProducer); + int32_t DetachBufferQueue(int32_t streamId) override; + int32_t Capture(int32_t captureId, const CaptureInfo& info, bool isStreaming) override; + int32_t CancelCapture(int32_t captureId) override; + int32_t ChangeToOfflineStream(const std::vector& streamIds, + const sptr& callbackObj, sptr& offlineOperator) override; public: StreamOperator() = default; - StreamOperator(const OHOS::sptr& callback, const std::weak_ptr& device); + StreamOperator(const OHOS::sptr& callback, const std::weak_ptr& device); virtual ~StreamOperator(); StreamOperator(const StreamOperator& other) = delete; StreamOperator(StreamOperator&& other) = delete; @@ -61,17 +58,20 @@ public: private: void HandleCallbackMessage(MessageGroup& message); void OnCaptureStarted(int32_t captureId, const std::vector& streamIds); - void OnCaptureEnded(int32_t captureId, const std::vector>& infos); - void OnCaptureError(int32_t captureId, const std::vector>& infos); + void OnCaptureEnded(int32_t captureId, const std::vector& infos); + void OnCaptureError(int32_t captureId, const std::vector& infos); void OnFrameShutter(int32_t captureId, const std::vector& streamIds, uint64_t timestamp); - bool CheckStreamInfo(const std::shared_ptr& streamInfo); + bool CheckStreamInfo(const StreamInfo streamInfo); DynamicStreamSwitchMode CheckStreamsSupported(OperationMode mode, const std::shared_ptr& modeSetting, - const std::vector>& infos); - + const std::vector& infos); + void StreamInfoToStreamConfiguration(StreamConfiguration &scg, const StreamInfo info); + void GetStreamSupportType(std::set inputIDSet, + DynamicStreamSwitchMode method, + StreamSupportType& type); private: OHOS::sptr callback_ = nullptr; - std::weak_ptr device_; + std::weak_ptr device_; std::shared_ptr pipelineCore_ = nullptr; std::shared_ptr streamPipeline_ = nullptr; std::shared_ptr messenger_ = nullptr; diff --git a/camera/hal/hdi_impl/include/utils.h b/camera/hal/hdi_impl/include/utils.h index ba342f5717..d7dc3a43ef 100644 --- a/camera/hal/hdi_impl/include/utils.h +++ b/camera/hal/hdi_impl/include/utils.h @@ -16,12 +16,13 @@ #ifndef CAMERA_DEVICE_DRIVER_UTILS_H #define CAMERA_DEVICE_DRIVER_UTILS_H -#include #include #include +#include "v1_0/types.h" #include "surface.h" namespace OHOS::Camera { +using namespace OHOS::HDI::Camera::V1_0; using StreamSupported = struct _StreamSupported { OperationMode operationMode_; StreamSupportType streamSupportType_; diff --git a/camera/hal/hdi_impl/src/camera_device/camera_device_impl.cpp b/camera/hal/hdi_impl/src/camera_device/camera_device_impl.cpp index ac8384627f..08010c3430 100644 --- a/camera/hal/hdi_impl/src/camera_device/camera_device_impl.cpp +++ b/camera/hal/hdi_impl/src/camera_device/camera_device_impl.cpp @@ -20,6 +20,7 @@ #include "idevice_manager.h" #include "camera_metadata_info.h" #include "watchdog.h" +#include "metadata_utils.h" #define HDI_DEVICE_PLACE_A_WATCHDOG \ PLACE_A_NOKILL_WATCHDOG(std::bind(&CameraDeviceImpl::OnRequestTimeout, this)); @@ -38,18 +39,53 @@ CameraDeviceImpl::CameraDeviceImpl(const std::string &cameraId, { } -CamRetCode CameraDeviceImpl::GetStreamOperator( - const OHOS::sptr &callback, - OHOS::sptr &streamOperator) +std::shared_ptr CameraDeviceImpl::CreateCameraDevice(const std::string &cameraId) +{ + // create pipelineCore + std::shared_ptr pipelineCore = IPipelineCore::Create(); + if (pipelineCore == nullptr) { + CAMERA_LOGW("create pipeline core failed. [cameraId = %{public}s]", cameraId.c_str()); + return nullptr; + } + + RetCode rc = pipelineCore->Init(); + if (rc != RC_OK) { + CAMERA_LOGW("pipeline core init failed. [cameraId = %{public}s]", cameraId.c_str()); + return nullptr; + } + + std::shared_ptr device = std::make_shared(cameraId, pipelineCore); + if (device == nullptr) { + CAMERA_LOGW("create camera device failed. [cameraId = %{public}s]", cameraId.c_str()); + return nullptr; + } + CAMERA_LOGD("create camera device success. [cameraId = %{public}s]", cameraId.c_str()); + + // set deviceManager metadata & dev status callback + std::shared_ptr deviceManager = IDeviceManager::GetInstance(); + if (deviceManager != nullptr) { + deviceManager->SetMetaDataCallBack([device](const std::shared_ptr &metadata) { + device->OnMetadataChanged(metadata); + }); + deviceManager->SetDevStatusCallBack([device]() { + device->OnDevStatusErr(); + }); + } + + return device; +} + +int32_t CameraDeviceImpl::GetStreamOperator(const sptr& callbackObj, + sptr& streamOperator) { HDI_DEVICE_PLACE_A_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; - if (callback == nullptr) { + if (callbackObj == nullptr) { CAMERA_LOGW("input callback is null."); return INVALID_ARGUMENT; } - spCameraDeciceCallback_ = callback; + spCameraDeciceCallback_ = callbackObj; if (spStreamOperator_ == nullptr) { #ifdef CAMERA_BUILT_ON_OHOS_LITE spStreamOperator_ = std::make_shared(spCameraDeciceCallback_, shared_from_this()); @@ -72,15 +108,15 @@ CamRetCode CameraDeviceImpl::GetStreamOperator( }); #endif DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode CameraDeviceImpl::UpdateSettings(const std::shared_ptr &settings) +int32_t CameraDeviceImpl::UpdateSettings(const std::vector& settings) { HDI_DEVICE_PLACE_A_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; - if (settings == nullptr) { - CAMERA_LOGE("input settings is null."); + if (settings.empty()) { + CAMERA_LOGE("input vector settings is empty."); return INVALID_ARGUMENT; } @@ -89,12 +125,14 @@ CamRetCode CameraDeviceImpl::UpdateSettings(const std::shared_ptr return CAMERA_CLOSED; } - pipelineCore_->UpdateMetadata(settings); + std::shared_ptr updateSettings; + MetadataUtils::ConvertVecToMetadata(settings, updateSettings); + pipelineCore_->UpdateMetadata(updateSettings); DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode CameraDeviceImpl::SetResultMode(const ResultCallbackMode &mode) +int32_t CameraDeviceImpl::SetResultMode(ResultCallbackMode mode) { CAMERA_LOGD("entry."); if (mode < PER_FRAME || mode > ON_CHANGED) { @@ -106,7 +144,7 @@ CamRetCode CameraDeviceImpl::SetResultMode(const ResultCallbackMode &mode) } metaResultMode_ = mode; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } ResultCallbackMode CameraDeviceImpl::GetMetaResultMode() const @@ -114,7 +152,7 @@ ResultCallbackMode CameraDeviceImpl::GetMetaResultMode() const return metaResultMode_; } -CamRetCode CameraDeviceImpl::GetEnabledResults(std::vector &results) +int32_t CameraDeviceImpl::GetEnabledResults(std::vector& results) { HDI_DEVICE_PLACE_A_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; @@ -129,7 +167,7 @@ CamRetCode CameraDeviceImpl::GetEnabledResults(std::vector &results) std::unique_lock l(enabledRstMutex_); results = enabledResults_; DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } RetCode CameraDeviceImpl::GetEnabledFromCfg() @@ -171,7 +209,7 @@ RetCode CameraDeviceImpl::GetEnabledFromCfg() return RC_OK; } -CamRetCode CameraDeviceImpl::EnableResult(const std::vector &results) +int32_t CameraDeviceImpl::EnableResult(const std::vector& results) { HDI_DEVICE_PLACE_A_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; @@ -192,14 +230,14 @@ CamRetCode CameraDeviceImpl::EnableResult(const std::vector &results) } deviceManager->SetAbilityMetaDataTag(enabledResults_); DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode CameraDeviceImpl::DisableResult(const std::vector &results) +int32_t CameraDeviceImpl::DisableResult(const std::vector& results) { HDI_DEVICE_PLACE_A_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; - CamRetCode ret = NO_ERROR; + CamRetCode ret = HDI::Camera::V1_0::NO_ERROR; std::unique_lock l(enabledRstMutex_); for (auto &metaType : results) { auto itr = std::find(enabledResults_.begin(), enabledResults_.end(), metaType); @@ -218,7 +256,7 @@ CamRetCode CameraDeviceImpl::DisableResult(const std::vector &results) } deviceManager1->SetAbilityMetaDataTag(enabledResults_); DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } RetCode CameraDeviceImpl::GetMetadataResults(std::shared_ptr &metadata) @@ -316,7 +354,7 @@ bool CameraDeviceImpl::CompareTagData(const camera_metadata_item_t &baseEntry, return true; } -void CameraDeviceImpl::Close() +int32_t CameraDeviceImpl::Close() { HDI_DEVICE_PLACE_A_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; @@ -329,20 +367,20 @@ void CameraDeviceImpl::Close() std::shared_ptr deviceManager = IDeviceManager::GetInstance(); if (deviceManager == nullptr) { CAMERA_LOGW("device manager is null [dm name MpiDeviceManager]."); - return; + return INVALID_ARGUMENT; } CameraHostConfig *config = CameraHostConfig::GetInstance(); if (config == nullptr) { CAMERA_LOGD("CameraHostConfig get failed."); - return; + return INVALID_ARGUMENT; } std::vector phyCameraIds; RetCode rc = config->GetPhysicCameraIds(cameraId_, phyCameraIds); if (rc != RC_OK) { CAMERA_LOGW("get physic cameraId failed.[cameraId = %{public}s]", cameraId_.c_str()); - return; + return INVALID_ARGUMENT; } for (auto &phyCameraId : phyCameraIds) { @@ -363,6 +401,7 @@ void CameraDeviceImpl::Close() isOpened_ = false; DFX_LOCAL_HITRACE_END; CAMERA_LOGD("camera close success."); + return HDI::Camera::V1_0::NO_ERROR; } CamRetCode CameraDeviceImpl::SetCallback(const OHOS::sptr &callback) @@ -371,7 +410,7 @@ CamRetCode CameraDeviceImpl::SetCallback(const OHOS::sptr return INVALID_ARGUMENT; } cameraDeciceCallback_ = callback; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } std::shared_ptr CameraDeviceImpl::GetPipelineCore() const @@ -386,11 +425,13 @@ void CameraDeviceImpl::ResultMetadata() return; } + std::vector result; std::shared_ptr metadata; RetCode rc = GetMetadataResults(metadata); if (rc == RC_OK || metaResultMode_ == PER_FRAME) { uint64_t timestamp = GetCurrentLocalTimeStamp(); - cameraDeciceCallback_->OnResult(timestamp, metadata); + MetadataUtils::ConvertMetadataToVec(metadata, result); + cameraDeciceCallback_->OnResult(timestamp, result); } } diff --git a/camera/hal/hdi_impl/src/camera_host/camera_host_impl.cpp b/camera/hal/hdi_impl/src/camera_host/camera_host_impl.cpp index cc7d78e466..15c04cff4f 100644 --- a/camera/hal/hdi_impl/src/camera_host/camera_host_impl.cpp +++ b/camera/hal/hdi_impl/src/camera_host/camera_host_impl.cpp @@ -17,12 +17,23 @@ #include #include "idevice_manager.h" #include "camera_host_config.h" -#include "camera_device_impl.h" +#include "metadata_utils.h" -#include "icamera_host_callback.h" -#include "icamera_device.h" +#include "v1_0/icamera_host_callback.h" +#include "v1_0/icamera_device.h" namespace OHOS::Camera { +extern "C" ICameraHost *CameraHostImplGetInstance(void) +{ + using OHOS::Camera::CameraHostImpl; + CameraHostImpl *service = new (std::nothrow) CameraHostImpl(); + if (service == nullptr) { + return nullptr; + } + + service->Init(); + return service; +} CameraHostImpl::CameraHostImpl() { @@ -66,8 +77,8 @@ CamRetCode CameraHostImpl::Init() if (rc != RC_OK) { continue; } - std::shared_ptr cameraDevice = - CameraDevice::CreateCameraDevice(cameraId); + std::shared_ptr cameraDevice = + CameraDeviceImpl::CreateCameraDevice(cameraId); if (cameraDevice != nullptr) { cameraDeviceMap_.insert(std::make_pair(cameraId, cameraDevice)); } else { @@ -80,25 +91,25 @@ CamRetCode CameraHostImpl::Init() CameraStatus cameraStatus = status ? AVAILABLE : UN_AVAILABLE; OnCameraStatus(cameraId, cameraStatus, meta); }); - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode CameraHostImpl::SetCallback(const OHOS::sptr &callback) +int32_t CameraHostImpl::SetCallback(const OHOS::sptr &callbackObj) { DFX_LOCAL_HITRACE_BEGIN; - if (callback == nullptr) { + if (callbackObj == nullptr) { CAMERA_LOGW("host callback is null."); return INVALID_ARGUMENT; } - cameraHostCallback_ = callback; + cameraHostCallback_ = callbackObj; DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode CameraHostImpl::GetCameraIds(std::vector &cameraIds) +int32_t CameraHostImpl::GetCameraIds(std::vector &cameraIds) { DFX_LOCAL_HITRACE_BEGIN; @@ -112,32 +123,34 @@ CamRetCode CameraHostImpl::GetCameraIds(std::vector &cameraIds) } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode CameraHostImpl::GetCameraAbility(const std::string &cameraId, - std::shared_ptr &ability) +int32_t CameraHostImpl::GetCameraAbility(const std::string &cameraId, + std::vector& cameraAbility) { DFX_LOCAL_HITRACE_BEGIN; CameraHostConfig *config = CameraHostConfig::GetInstance(); if (config == nullptr) { return INVALID_ARGUMENT; } + std::shared_ptr ability; RetCode rc = config->GetCameraAbility(cameraId, ability); if (rc != RC_OK) { return INVALID_ARGUMENT; } + + MetadataUtils::ConvertMetadataToVec(ability, cameraAbility); DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode CameraHostImpl::OpenCamera(const std::string &cameraId, - const OHOS::sptr &callback, - OHOS::sptr &device) +int32_t CameraHostImpl::OpenCamera(const std::string& cameraId, const sptr& callbackObj, + sptr& device) { CAMERA_LOGD("OpenCamera entry"); DFX_LOCAL_HITRACE_BEGIN; - if (CameraIdInvalid(cameraId) != RC_OK || callback == nullptr) { + if (CameraIdInvalid(cameraId) != RC_OK || callbackObj == nullptr) { CAMERA_LOGW("open camera id is empty or callback is null."); return INVALID_ARGUMENT; } @@ -149,15 +162,14 @@ CamRetCode CameraHostImpl::OpenCamera(const std::string &cameraId, } CAMERA_LOGD("OpenCamera cameraId find success."); - std::shared_ptr cameraDevice = - std::static_pointer_cast(itr->second); + std::shared_ptr cameraDevice = itr->second; if (cameraDevice == nullptr) { CAMERA_LOGE("camera device is null."); return INSUFFICIENT_RESOURCES; } - CamRetCode ret = cameraDevice->SetCallback(callback); - CHECK_IF_NOT_EQUAL_RETURN_VALUE(ret, NO_ERROR, ret); + CamRetCode ret = cameraDevice->SetCallback(callbackObj); + CHECK_IF_NOT_EQUAL_RETURN_VALUE(ret, HDI::Camera::V1_0::NO_ERROR, ret); CameraHostConfig *config = CameraHostConfig::GetInstance(); CHECK_IF_PTR_NULL_RETURN_VALUE(config, INVALID_ARGUMENT); @@ -186,7 +198,7 @@ CamRetCode CameraHostImpl::OpenCamera(const std::string &cameraId, cameraDevice->SetStatus(true); CAMERA_LOGD("open camera success."); DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } RetCode CameraHostImpl::CameraIdInvalid(const std::string &cameraId) @@ -273,7 +285,7 @@ void CameraHostImpl::CameraPowerDown(const std::vector &phyCameraId } } -CamRetCode CameraHostImpl::SetFlashlight(const std::string &cameraId, bool &isEnable) +int32_t CameraHostImpl::SetFlashlight(const std::string &cameraId, bool isEnable) { DFX_LOCAL_HITRACE_BEGIN; if (CameraIdInvalid(cameraId) != RC_OK) { @@ -282,7 +294,8 @@ CamRetCode CameraHostImpl::SetFlashlight(const std::string &cameraId, bool &isE } for (auto &itr : cameraDeviceMap_) { - if (itr.second->IsOpened()) { + std::shared_ptr cameraDevice = itr.second; + if (cameraDevice->IsOpened()) { CAMERA_LOGE("camera id opend [cameraId = %{public}s].", itr.first.c_str()); return METHOD_NOT_SUPPORTED; } @@ -305,7 +318,7 @@ CamRetCode CameraHostImpl::SetFlashlight(const std::string &cameraId, bool &isE if (cameraHostCallback_ != nullptr) { cameraHostCallback_->OnFlashlightStatus(cameraId, flashlightStatus); } - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } else { return DEVICE_ERROR; } @@ -364,8 +377,8 @@ void CameraHostImpl::OnCameraStatus(CameraId cameraId, cameraHostCallback_->OnCameraStatus(logicalCameraId, status); } } - std::shared_ptr cameraDevice = - CameraDevice::CreateCameraDevice(logicalCameraId); + std::shared_ptr cameraDevice = + CameraDeviceImpl::CreateCameraDevice(logicalCameraId); if (cameraDevice != nullptr) { cameraDeviceMap_[logicalCameraId] = cameraDevice; } diff --git a/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream.cpp b/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream.cpp index a2d7f14696..fac1e13a9f 100644 --- a/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream.cpp +++ b/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream.cpp @@ -17,7 +17,7 @@ #include "offline_pipeline_manager.h" namespace OHOS::Camera { -OfflineStream::OfflineStream(int32_t id, OHOS::sptr& callback) +OfflineStream::OfflineStream(int32_t id, const OHOS::sptr& callback) { streamId_ = id; callback_ = callback; @@ -189,26 +189,26 @@ void OfflineStream::HandleMessage(MessageGroup& message) CaptureMessageType type = message[0]->GetMessageType(); switch (type) { case CAPTURE_MESSAGE_TYPE_ON_ERROR: { - std::vector> info = {}; - for (auto cm : message) { + std::vector info = {}; + for (const auto& cm : message) { auto m = std::static_pointer_cast(cm); CHECK_IF_PTR_NULL_RETURN_VOID(m); - auto edi = std::make_shared(); - edi->streamId_ = m->GetStreamId(); - edi->error_ = m->GetStreamError(); + CaptureErrorInfo edi = {0}; + edi.streamId_ = m->GetStreamId(); + edi.error_ = m->GetStreamError(); info.push_back(edi); } OnCaptureError(message[0]->GetCaptureId(), info); break; } case CAPTURE_MESSAGE_TYPE_ON_ENDED: { - std::vector> info = {}; - for (auto cm : message) { + std::vector info = {}; + for (const auto& cm : message) { auto m = std::static_pointer_cast(cm); CHECK_IF_PTR_NULL_RETURN_VOID(m); - auto edi = std::make_shared(); - edi->streamId_ = m->GetStreamId(); - edi->frameCount_ = (int32_t)(m->GetFrameCount()); + CaptureEndedInfo edi = {0}; + edi.streamId_ = m->GetStreamId(); + edi.frameCount_ = (int32_t)(m->GetFrameCount()); info.push_back(edi); } OnCaptureEnded(message[0]->GetCaptureId(), info); @@ -220,13 +220,13 @@ void OfflineStream::HandleMessage(MessageGroup& message) return; } -void OfflineStream::OnCaptureEnded(int32_t captureId, const std::vector>& infos) +void OfflineStream::OnCaptureEnded(int32_t captureId, const std::vector& infos) { CHECK_IF_EQUAL_RETURN_VOID(callback_, nullptr); callback_->OnCaptureEnded(captureId, infos); } -void OfflineStream::OnCaptureError(int32_t captureId, const std::vector>& infos) +void OfflineStream::OnCaptureError(int32_t captureId, const std::vector& infos) { CHECK_IF_EQUAL_RETURN_VOID(callback_, nullptr); callback_->OnCaptureError(captureId, infos); diff --git a/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream_operator.cpp b/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream_operator.cpp index 61f2cc562f..93be226def 100644 --- a/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream_operator.cpp +++ b/camera/hal/hdi_impl/src/offline_stream_operator/offline_stream_operator.cpp @@ -28,7 +28,7 @@ OfflineStreamOperator::~OfflineStreamOperator() offlineStreamMap_.clear(); } -CamRetCode OfflineStreamOperator::CancelCapture(int captureId) +int32_t OfflineStreamOperator::CancelCapture(int32_t captureId) { CHECK_IF_EQUAL_RETURN_VALUE(captureId < 0, true, INVALID_ARGUMENT); @@ -38,7 +38,7 @@ CamRetCode OfflineStreamOperator::CancelCapture(int captureId) std::shared_ptr stream = FindStreamByCaptureId(captureId); if (stream == nullptr) { CAMERA_LOGD("can't find stream by captureId %{public}d, buffer all returned.", captureId); - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } RetCode ret = stream->CancelCapture(captureId); if (ret != RC_OK) { @@ -47,10 +47,10 @@ CamRetCode OfflineStreamOperator::CancelCapture(int captureId) } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode OfflineStreamOperator::ReleaseStreams(const std::vector& streamIds) +int32_t OfflineStreamOperator::ReleaseStreams(const std::vector& streamIds) { PLACE_A_SELFKILL_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; @@ -68,10 +68,10 @@ CamRetCode OfflineStreamOperator::ReleaseStreams(const std::vector& streamI } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode OfflineStreamOperator::Release() +int32_t OfflineStreamOperator::Release() { PLACE_A_SELFKILL_WATCHDOG; DFX_LOCAL_HITRACE_BEGIN; @@ -86,7 +86,7 @@ CamRetCode OfflineStreamOperator::Release() } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } RetCode OfflineStreamOperator::CommitOfflineStream(const std::shared_ptr& of) diff --git a/camera/hal/hdi_impl/src/stream_operator/stream_operator.cpp b/camera/hal/hdi_impl/src/stream_operator/stream_operator.cpp index faa3777e21..d8e3e4d206 100644 --- a/camera/hal/hdi_impl/src/stream_operator/stream_operator.cpp +++ b/camera/hal/hdi_impl/src/stream_operator/stream_operator.cpp @@ -17,13 +17,13 @@ #include "stream_operator.h" #include "buffer_adapter.h" #include "camera_device_impl.h" +#include "metadata_utils.h" #include #include -#include namespace OHOS::Camera { StreamOperator::StreamOperator(const OHOS::sptr& callback, - const std::weak_ptr& device) + const std::weak_ptr& device) { CAMERA_LOGV("enter"); callback_ = callback; @@ -66,53 +66,10 @@ RetCode StreamOperator::Init() return RC_OK; } -CamRetCode StreamOperator::IsStreamsSupported(OperationMode mode, - const std::shared_ptr& modeSetting, - const std::vector>& pInfo, - StreamSupportType& type) +void StreamOperator::GetStreamSupportType(std::set inputIDSet, + DynamicStreamSwitchMode method, + StreamSupportType& type) { - CHECK_IF_PTR_NULL_RETURN_VALUE(streamPipeline_, DEVICE_ERROR); - CHECK_IF_PTR_NULL_RETURN_VALUE(modeSetting, INVALID_ARGUMENT); - PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); - DFX_LOCAL_HITRACE_BEGIN; - - std::set inputIDSet = {}; - std::vector checkStreamIdVec = {}; - for (auto it : pInfo) { - CHECK_IF_PTR_NULL_RETURN_VALUE(it, INVALID_ARGUMENT); - CHECK_IF_NOT_EQUAL_RETURN_VALUE(CheckStreamInfo(it), true, INVALID_ARGUMENT); - inputIDSet.emplace(it->streamId_); - checkStreamIdVec.push_back(it->streamId_); - } - CHECK_IF_EQUAL_RETURN_VALUE(inputIDSet.empty(), true, INVALID_ARGUMENT); - - auto uniqueIt = std::unique(checkStreamIdVec.begin(), checkStreamIdVec.end()); - if (checkStreamIdVec.size() != (uint32_t)(std::distance(checkStreamIdVec.begin(), uniqueIt))) { - CAMERA_LOGE("stream id must be unique"); - return INVALID_ARGUMENT; - } - - DynamicStreamSwitchMode method = CheckStreamsSupported(mode, modeSetting, pInfo); - if (method == DYNAMIC_STREAM_SWITCH_SUPPORT) { - type = DYNAMIC_SUPPORTED; - return NO_ERROR; - } - - if (method == DYNAMIC_STREAM_SWITCH_NOT_SUPPORT) { - type = NOT_SUPPORTED; - return NO_ERROR; - } - - // change mode need to update pipeline, and caller must restart streams - if (mode != streamPipeline_->GetCurrentMode()) { - if (method == DYNAMIC_STREAM_SWITCH_NEED_INNER_RESTART) { - type = RE_CONFIGURED_REQUIRED; - return NO_ERROR; - } - type = NOT_SUPPORTED; - return NO_ERROR; - } - std::set currentIDSet = {}; { std::lock_guard l(streamLock_); @@ -120,14 +77,15 @@ CamRetCode StreamOperator::IsStreamsSupported(OperationMode mode, currentIDSet.emplace(it.first); } } + // no streams are running if (currentIDSet.empty()) { if (method == DYNAMIC_STREAM_SWITCH_NEED_INNER_RESTART) { type = DYNAMIC_SUPPORTED; - return NO_ERROR; + return; } type = NOT_SUPPORTED; - return NO_ERROR; + return; } // the difference of currentSet from inputIDSet @@ -146,90 +104,152 @@ CamRetCode StreamOperator::IsStreamsSupported(OperationMode mode, // currentIDSet is subset of inputIDSet if (method == DYNAMIC_STREAM_SWITCH_NEED_INNER_RESTART) { type = DYNAMIC_SUPPORTED; - return NO_ERROR; + return; } + type = NOT_SUPPORTED; } else { if (method == DYNAMIC_STREAM_SWITCH_NEED_INNER_RESTART) { type = RE_CONFIGURED_REQUIRED; - return NO_ERROR; + return; } + type = NOT_SUPPORTED; + } + + return; +} + +int32_t StreamOperator::IsStreamsSupported(OperationMode mode, const std::vector& modeSetting, + const std::vector& infos, StreamSupportType& type) +{ + CHECK_IF_PTR_NULL_RETURN_VALUE(streamPipeline_, DEVICE_ERROR); + PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); + if (infos.empty() || modeSetting.empty()) { + CAMERA_LOGE("input vector is empty"); + return INVALID_ARGUMENT; + } + DFX_LOCAL_HITRACE_BEGIN; + + std::set inputIDSet = {}; + std::vector checkStreamIdVec = {}; + for (auto it : infos) { + CHECK_IF_NOT_EQUAL_RETURN_VALUE(CheckStreamInfo(it), true, INVALID_ARGUMENT); + inputIDSet.emplace(it.streamId_); + checkStreamIdVec.push_back(it.streamId_); + } + CHECK_IF_EQUAL_RETURN_VALUE(inputIDSet.empty(), true, INVALID_ARGUMENT); + + auto uniqueIt = std::unique(checkStreamIdVec.begin(), checkStreamIdVec.end()); + if (checkStreamIdVec.size() != (uint32_t)(std::distance(checkStreamIdVec.begin(), uniqueIt))) { + CAMERA_LOGE("stream id must be unique"); + return INVALID_ARGUMENT; + } + + std::shared_ptr settings; + MetadataUtils::ConvertVecToMetadata(modeSetting, settings); + DynamicStreamSwitchMode method = CheckStreamsSupported(mode, settings, infos); + if (method == DYNAMIC_STREAM_SWITCH_SUPPORT) { + type = DYNAMIC_SUPPORTED; + return HDI::Camera::V1_0::HDI::Camera::V1_0::NO_ERROR; + } + + if (method == DYNAMIC_STREAM_SWITCH_NOT_SUPPORT) { + type = NOT_SUPPORTED; + return HDI::Camera::V1_0::NO_ERROR; + } + + // change mode need to update pipeline, and caller must restart streams + if (mode != streamPipeline_->GetCurrentMode()) { + if (method == DYNAMIC_STREAM_SWITCH_NEED_INNER_RESTART) { + type = RE_CONFIGURED_REQUIRED; + return HDI::Camera::V1_0::NO_ERROR; + } + type = NOT_SUPPORTED; + return HDI::Camera::V1_0::NO_ERROR; + } + + if (method == DYNAMIC_STREAM_SWITCH_NEED_INNER_RESTART) { + GetStreamSupportType(inputIDSet, method, type); + return HDI::Camera::V1_0::NO_ERROR; } - type = NOT_SUPPORTED; DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } DynamicStreamSwitchMode StreamOperator::CheckStreamsSupported( OperationMode mode, const std::shared_ptr& modeSetting, - const std::vector>& infos) + const std::vector& infos) { CHECK_IF_PTR_NULL_RETURN_VALUE(streamPipeline_, DYNAMIC_STREAM_SWITCH_NOT_SUPPORT); std::vector configs = {}; for (auto& it : infos) { StreamConfiguration config = {}; - config.type = it->intent_; - config.width = it->width_; - config.height = it->height_; - PixelFormat pf = static_cast(it->format_); + config.type = it.intent_; + config.width = it.width_; + config.height = it.height_; + PixelFormat pf = static_cast(it.format_); config.format = BufferAdapter::PixelFormatToCameraFormat(pf); - config.dataspace = it->dataspace_; // fix spell error - config.tunnelMode = it->tunneledMode_; - config.minFrameDuration = it->minFrameDuration_; - config.encodeType = it->encodeType_; + config.dataspace = it.dataspace_; // fix spell error + config.tunnelMode = it.tunneledMode_; + config.minFrameDuration = it.minFrameDuration_; + config.encodeType = it.encodeType_; configs.emplace_back(config); } // search device capability to check if this configuration is supported. return streamPipeline_->CheckStreamsSupported(mode, modeSetting, configs); } -CamRetCode StreamOperator::CreateStreams(const std::vector>& streamInfos) +void StreamOperator::StreamInfoToStreamConfiguration(StreamConfiguration &scg, const StreamInfo info) +{ + scg.id = info.streamId_; + scg.type = info.intent_; + scg.width = info.width_; + scg.height = info.height_; + PixelFormat pf = static_cast(info.format_); + scg.format = BufferAdapter::PixelFormatToCameraFormat(pf); + scg.dataspace = info.dataspace_; // fix misspell + scg.tunnelMode = info.tunneledMode_; + scg.minFrameDuration = info.minFrameDuration_; + scg.encodeType = info.encodeType_; +} + +int32_t StreamOperator::CreateStreams(const std::vector& streamInfos) { PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); DFX_LOCAL_HITRACE_BEGIN; - for (auto it : streamInfos) { + for (const auto& it : streamInfos) { CHECK_IF_NOT_EQUAL_RETURN_VALUE(CheckStreamInfo(it), true, INVALID_ARGUMENT); CAMERA_LOGI("streamId:%{public}d and format:%{public}d and width:%{public}d and height:%{public}d", - it->streamId_, it->format_, it->width_, it->height_); - if (streamMap_.count(it->streamId_) > 0) { - CAMERA_LOGE("stream [id = %{public}d] has already been created.", it->streamId_); + it.streamId_, it.format_, it.width_, it.height_); + if (streamMap_.count(it.streamId_) > 0) { + CAMERA_LOGE("stream [id = %{public}d] has already been created.", it.streamId_); return INVALID_ARGUMENT; } std::shared_ptr stream = StreamFactory::Instance().CreateShared( - IStream::g_availableStreamType[it->intent_], it->streamId_, it->intent_, pipelineCore_, messenger_); + IStream::g_availableStreamType[it.intent_], it.streamId_, it.intent_, pipelineCore_, messenger_); if (stream == nullptr) { - CAMERA_LOGE("create stream [id = %{public}d] failed.", it->streamId_); + CAMERA_LOGE("create stream [id = %{public}d] failed.", it.streamId_); return INSUFFICIENT_RESOURCES; } StreamConfiguration scg; - scg.id = it->streamId_; - scg.type = it->intent_; - scg.width = it->width_; - scg.height = it->height_; - PixelFormat pf = static_cast(it->format_); - scg.format = BufferAdapter::PixelFormatToCameraFormat(pf); - scg.dataspace = it->dataspace_; // fix misspell - scg.tunnelMode = it->tunneledMode_; - scg.minFrameDuration = it->minFrameDuration_; - scg.encodeType = it->encodeType_; - + StreamInfoToStreamConfiguration(scg, it); RetCode rc = stream->ConfigStream(scg); if (rc != RC_OK) { - CAMERA_LOGE("configure stream %{public}d failed", it->streamId_); + CAMERA_LOGE("configure stream %{public}d failed", it.streamId_); return INVALID_ARGUMENT; } - if (!scg.tunnelMode && it->bufferQueue_ != nullptr) { - CAMERA_LOGE("stream [id:%{public}d] is not tunnel mode, can't bind a buffer producer", it->streamId_); + if (!scg.tunnelMode && (it.bufferQueue_)->producer_ != nullptr) { + CAMERA_LOGE("stream [id:%{public}d] is not tunnel mode, can't bind a buffer producer", it.streamId_); return INVALID_ARGUMENT; } - if (it->bufferQueue_ != nullptr) { + if ((it.bufferQueue_)->producer_ != nullptr) { auto tunnel = std::make_shared(); CHECK_IF_PTR_NULL_RETURN_VALUE(tunnel, INSUFFICIENT_RESOURCES); - RetCode rc = tunnel->AttachBufferQueue(it->bufferQueue_); + RetCode rc = tunnel->AttachBufferQueue((it.bufferQueue_)->producer_); CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, INVALID_ARGUMENT); if (stream->AttachStreamTunnel(tunnel) != RC_OK) { - CAMERA_LOGE("attach buffer queue to stream [id = %{public}d] failed", it->streamId_); + CAMERA_LOGE("attach buffer queue to stream [id = %{public}d] failed", it.streamId_); return INVALID_ARGUMENT; } } @@ -238,13 +258,13 @@ CamRetCode StreamOperator::CreateStreams(const std::vectorGetStreamId()] = stream; } CAMERA_LOGI("create stream success [id:%{public}d] [type:%{public}s]", stream->GetStreamId(), - IStream::g_availableStreamType[it->intent_].c_str()); + IStream::g_availableStreamType[it.intent_].c_str()); } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode StreamOperator::ReleaseStreams(const std::vector& streamIds) +int32_t StreamOperator::ReleaseStreams(const std::vector& streamIds) { PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); DFX_LOCAL_HITRACE_BEGIN; @@ -265,7 +285,7 @@ CamRetCode StreamOperator::ReleaseStreams(const std::vector& streamIds) } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } @@ -279,8 +299,7 @@ RetCode StreamOperator::ReleaseStreams() return RC_OK; } -CamRetCode StreamOperator::CommitStreams(OperationMode mode, - const std::shared_ptr& modeSetting) +int32_t StreamOperator::CommitStreams(OperationMode mode, const std::vector& modeSetting) { CAMERA_LOGV("enter"); CHECK_IF_PTR_NULL_RETURN_VALUE(streamPipeline_, DEVICE_ERROR); @@ -295,7 +314,9 @@ CamRetCode StreamOperator::CommitStreams(OperationMode mode, } } - DynamicStreamSwitchMode method = streamPipeline_->CheckStreamsSupported(mode, modeSetting, configs); + std::shared_ptr setting; + MetadataUtils::ConvertVecToMetadata(modeSetting, setting); + DynamicStreamSwitchMode method = streamPipeline_->CheckStreamsSupported(mode, setting, configs); if (method == DYNAMIC_STREAM_SWITCH_NOT_SUPPORT) { return INVALID_ARGUMENT; } @@ -314,7 +335,7 @@ CamRetCode StreamOperator::CommitStreams(OperationMode mode, } } } - RetCode rc = streamPipeline_->PreConfig(modeSetting); + RetCode rc = streamPipeline_->PreConfig(setting); if (rc != RC_OK) { CAMERA_LOGE("prepare mode settings failed"); return DEVICE_ERROR; @@ -326,10 +347,10 @@ CamRetCode StreamOperator::CommitStreams(OperationMode mode, } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode StreamOperator::GetStreamAttributes(std::vector>& attributes) +int32_t StreamOperator::GetStreamAttributes(std::vector& attributes) { PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); DFX_LOCAL_HITRACE_BEGIN; @@ -337,26 +358,26 @@ CamRetCode StreamOperator::GetStreamAttributes(std::vectorGetStreamAttribute(); - auto attribute = std::make_shared(); - attribute->streamId_ = it.first; - attribute->width_ = configuration.width; - attribute->height_ = configuration.height; - attribute->overrideFormat_ = (int32_t)BufferAdapter::CameraFormatToPixelFormat(configuration.format); - attribute->overrideDataspace_ = configuration.dataspace; - attribute->producerUsage_ = BufferAdapter::CameraUsageToGrallocUsage(configuration.usage); - attribute->producerBufferCount_ = configuration.bufferCount; - attribute->maxBatchCaptureCount_ = configuration.maxCaptureCount; - attribute->maxCaptureCount_ = configuration.maxCaptureCount; + StreamAttribute attribute = {}; + attribute.streamId_ = it.first; + attribute.width_ = configuration.width; + attribute.height_ = configuration.height; + attribute.overrideFormat_ = (int32_t)BufferAdapter::CameraFormatToPixelFormat(configuration.format); + attribute.overrideDataspace_ = configuration.dataspace; + attribute.producerUsage_ = BufferAdapter::CameraUsageToGrallocUsage(configuration.usage); + attribute.producerBufferCount_ = configuration.bufferCount; + attribute.maxBatchCaptureCount_ = configuration.maxCaptureCount; + attribute.maxCaptureCount_ = configuration.maxCaptureCount; attributes.emplace_back(attribute); } DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode StreamOperator::AttachBufferQueue(int streamId, const OHOS::sptr& producer) +int32_t StreamOperator::AttachBufferQueue(int32_t streamId, const sptr& bufferProducer) { CHECK_IF_EQUAL_RETURN_VALUE(streamId < 0, true, INVALID_ARGUMENT); - CHECK_IF_PTR_NULL_RETURN_VALUE(producer, INVALID_ARGUMENT); + CHECK_IF_PTR_NULL_RETURN_VALUE(bufferProducer, INVALID_ARGUMENT); PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); DFX_LOCAL_HITRACE_BEGIN; @@ -375,7 +396,7 @@ CamRetCode StreamOperator::AttachBufferQueue(int streamId, const OHOS::sptr(); CHECK_IF_EQUAL_RETURN_VALUE(tunnel, nullptr, INSUFFICIENT_RESOURCES); - auto bufferQueue = const_cast&>(producer); + auto bufferQueue = const_cast&>(bufferProducer->producer_); RetCode rc = tunnel->AttachBufferQueue(bufferQueue); CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, INVALID_ARGUMENT); @@ -385,10 +406,10 @@ CamRetCode StreamOperator::AttachBufferQueue(int streamId, const OHOS::sptr& captureInfo, bool isStreaming) +int32_t StreamOperator::Capture(int32_t captureId, const CaptureInfo& info, bool isStreaming) { CHECK_IF_EQUAL_RETURN_VALUE(captureId < 0, true, INVALID_ARGUMENT); PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); DFX_LOCAL_HITRACE_BEGIN; - for (auto id : captureInfo->streamIds_) { + for (auto id : info.streamIds_) { std::lock_guard l(streamLock_); auto it = streamMap_.find(id); if (it == streamMap_.end()) { @@ -441,11 +462,13 @@ CamRetCode StreamOperator::Capture(int captureId, const std::shared_ptrcaptureSetting_; + std::shared_ptr captureSetting; + MetadataUtils::ConvertVecToMetadata(info.captureSetting_, captureSetting); + CaptureSetting setting = captureSetting; auto request = - std::make_shared(captureId, captureInfo->streamIds_.size(), setting, - captureInfo->enableShutterCallback_, isStreaming); - for (auto id : captureInfo->streamIds_) { + std::make_shared(captureId, info.streamIds_.size(), setting, + info.enableShutterCallback_, isStreaming); + for (auto id : info.streamIds_) { RetCode rc = streamMap_[id]->AddRequest(request); if (rc != RC_OK) { return DEVICE_ERROR; @@ -456,10 +479,10 @@ CamRetCode StreamOperator::Capture(int captureId, const std::shared_ptr l(requestLock_); requestMap_[captureId] = request; } - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode StreamOperator::CancelCapture(int captureId) +int32_t StreamOperator::CancelCapture(int32_t captureId) { CHECK_IF_EQUAL_RETURN_VALUE(captureId < 0, true, INVALID_ARGUMENT); PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); @@ -479,16 +502,15 @@ CamRetCode StreamOperator::CancelCapture(int captureId) requestMap_.erase(itr); DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -CamRetCode StreamOperator::ChangeToOfflineStream(const std::vector& streamIds, - OHOS::sptr& callback, - OHOS::sptr& offlineOperator) +int32_t StreamOperator::ChangeToOfflineStream(const std::vector& streamIds, + const sptr& callbackObj, sptr& offlineOperator) { PLACE_A_NOKILL_WATCHDOG(requestTimeoutCB_); DFX_LOCAL_HITRACE_BEGIN; - CHECK_IF_PTR_NULL_RETURN_VALUE(callback, INVALID_ARGUMENT); + CHECK_IF_PTR_NULL_RETURN_VALUE(callbackObj, INVALID_ARGUMENT); // offlineOperator should not be null CHECK_IF_NOT_EQUAL_RETURN_VALUE(offlineOperator, nullptr, INVALID_ARGUMENT); CHECK_IF_EQUAL_RETURN_VALUE(streamIds.empty(), true, INVALID_ARGUMENT); @@ -513,7 +535,7 @@ CamRetCode StreamOperator::ChangeToOfflineStream(const std::vector& streamI return METHOD_NOT_SUPPORTED; } - auto offlineStream = std::make_shared(it, callback); + auto offlineStream = std::make_shared(it, callbackObj); CHECK_IF_PTR_NULL_RETURN_VALUE(offlineStream, INSUFFICIENT_RESOURCES); RetCode rc = streamMap_[it]->ChangeToOfflineStream(offlineStream); @@ -531,14 +553,14 @@ CamRetCode StreamOperator::ChangeToOfflineStream(const std::vector& streamI offlineOperator = oflstor_; DFX_LOCAL_HITRACE_END; - return NO_ERROR; + return HDI::Camera::V1_0::NO_ERROR; } -bool StreamOperator::CheckStreamInfo(const std::shared_ptr& streamInfo) +bool StreamOperator::CheckStreamInfo(const StreamInfo streamInfo) { - if (streamInfo->streamId_ < 0 || streamInfo->width_ < 0 || streamInfo->height_ < 0 || streamInfo->format_ < 0 || - streamInfo->dataspace_ < 0 || streamInfo->intent_ > CUSTOM || streamInfo->intent_ < PREVIEW || - streamInfo->minFrameDuration_ < 0) { + if (streamInfo.streamId_ < 0 || streamInfo.width_ < 0 || streamInfo.height_ < 0 || streamInfo.format_ < 0 || + streamInfo.dataspace_ < 0 || streamInfo.intent_ > CUSTOM || streamInfo.intent_ < PREVIEW || + streamInfo.minFrameDuration_ < 0) { return false; } return true; @@ -563,26 +585,26 @@ void StreamOperator::HandleCallbackMessage(MessageGroup& message) break; } case CAPTURE_MESSAGE_TYPE_ON_ERROR: { - std::vector> info = {}; + std::vector info = {}; for (auto cm : message) { auto m = std::static_pointer_cast(cm); CHECK_IF_PTR_NULL_RETURN_VOID(m); - auto edi = std::make_shared(); - edi->streamId_ = m->GetStreamId(); - edi->error_ = m->GetStreamError(); + CaptureErrorInfo edi = {}; + edi.streamId_ = m->GetStreamId(); + edi.error_ = m->GetStreamError(); info.push_back(edi); } OnCaptureError(message[0]->GetCaptureId(), info); break; } case CAPTURE_MESSAGE_TYPE_ON_ENDED: { - std::vector> info = {}; + std::vector info = {}; for (auto cm : message) { auto m = std::static_pointer_cast(cm); CHECK_IF_PTR_NULL_RETURN_VOID(m); - auto edi = std::make_shared(); - edi->streamId_ = m->GetStreamId(); - edi->frameCount_ = m->GetFrameCount(); + CaptureEndedInfo edi = {}; + edi.streamId_ = m->GetStreamId(); + edi.frameCount_ = m->GetFrameCount(); info.push_back(edi); } OnCaptureEnded(message[0]->GetCaptureId(), info); @@ -610,7 +632,7 @@ void StreamOperator::OnCaptureStarted(int32_t captureId, const std::vectorOnCaptureStarted(captureId, streamIds); } -void StreamOperator::OnCaptureEnded(int32_t captureId, const std::vector>& infos) +void StreamOperator::OnCaptureEnded(int32_t captureId, const std::vector& infos) { CHECK_IF_EQUAL_RETURN_VOID(callback_, nullptr); callback_->OnCaptureEnded(captureId, infos); @@ -623,7 +645,7 @@ void StreamOperator::OnCaptureEnded(int32_t captureId, const std::vector>& infos) +void StreamOperator::OnCaptureError(int32_t captureId, const std::vector& infos) { CHECK_IF_EQUAL_RETURN_VOID(callback_, nullptr); callback_->OnCaptureError(captureId, infos); diff --git a/camera/hal/hdi_impl/test/BUILD.gn b/camera/hal/hdi_impl/test/BUILD.gn index 1878a0ab98..3eccdf8615 100644 --- a/camera/hal/hdi_impl/test/BUILD.gn +++ b/camera/hal/hdi_impl/test/BUILD.gn @@ -118,7 +118,7 @@ if (defined(ohos_lite)) { deps = [ "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", "$hdf_uhdf_path/utils:libhdf_utils", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", @@ -219,11 +219,11 @@ if (defined(ohos_lite)) { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest", diff --git a/camera/hal/include/camera.h b/camera/hal/include/camera.h index 5d87311402..888c2461d9 100644 --- a/camera/hal/include/camera.h +++ b/camera/hal/include/camera.h @@ -29,6 +29,7 @@ #include #include #include +#include "camera_metadata_info.h" #ifdef HITRACE_LOG_ENABLED #include "hitrace.h" @@ -67,6 +68,10 @@ namespace Camera { constexpr uint32_t FRAME_SIZE_TAG_UINT32 = 100; const std::string FRAME_SIZE_TAG_STRING = "FRAME_SIZE"; +using CameraAbility = CameraMetadata; +using CameraSetting = CameraMetadata; +using MetaType = int32_t; + using RetCode = uint32_t; enum Ret : uint32_t { RC_OK = 0, diff --git a/camera/hal/init/BUILD.gn b/camera/hal/init/BUILD.gn index 11e024b42f..9879898f83 100644 --- a/camera/hal/init/BUILD.gn +++ b/camera/hal/init/BUILD.gn @@ -64,7 +64,7 @@ if (defined(ohos_lite)) { ] deps = [ - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", "//drivers/peripheral/camera/interfaces/metadata:metadata", "//foundation/graphic/surface:surface", @@ -96,8 +96,6 @@ if (defined(ohos_lite)) { "$camera_path/../interfaces/include", "$camera_path/../interfaces/hdi_ipc", "$camera_path/../interfaces/hdi_ipc/utils/include", - "$camera_path/../interfaces/hdi_ipc/client/include", - "$camera_path/../interfaces/hdi_ipc/server/include", "$camera_path/../interfaces/hdi_ipc/callback/host/include", "$camera_path/../interfaces/hdi_ipc/callback/device/include", "$camera_path/../interfaces/hdi_ipc/callback/operator/include", @@ -137,11 +135,11 @@ if (defined(ohos_lite)) { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] diff --git a/camera/hal/init/ohos_camera_demo.cpp b/camera/hal/init/ohos_camera_demo.cpp index dd104e08ae..30b398194a 100644 --- a/camera/hal/init/ohos_camera_demo.cpp +++ b/camera/hal/init/ohos_camera_demo.cpp @@ -14,6 +14,7 @@ */ #include "ohos_camera_demo.h" +#include "metadata_utils.h" namespace OHOS::Camera { OhosCameraDemo::OhosCameraDemo() {} @@ -27,39 +28,42 @@ const int32_t AF_REGIONS_X = 400; const int32_t AF_REGIONS_Y = 200; const int32_t FPS_RANGE = 30; -void OhosCameraDemo::SetStreamInfo(std::shared_ptr &streamInfo, +void OhosCameraDemo::SetStreamInfo(StreamInfo& streamInfo, const std::shared_ptr &streamCustomer, const int streamId, const StreamIntent intent) { constexpr uint32_t dataspace = 8; constexpr uint32_t tunneledMode = 5; + sptr producer; if (intent == PREVIEW) { constexpr uint32_t width = CAMERA_PREVIEW_WIDTH; constexpr uint32_t height = CAMERA_PREVIEW_HEIGHT; - streamInfo->width_ = width; - streamInfo->height_ = height; + streamInfo.width_ = width; + streamInfo.height_ = height; } else if (intent == STILL_CAPTURE) { constexpr uint32_t width = CAMERA_CAPTURE_WIDTH; constexpr uint32_t height = CAMERA_CAPTURE_HEIGHT; - streamInfo->width_ = width; - streamInfo->height_ = height; - streamInfo->encodeType_ = CAMERA_CAPTURE_ENCODE_TYPE; + streamInfo.width_ = width; + streamInfo.height_ = height; + streamInfo.encodeType_ = CAMERA_CAPTURE_ENCODE_TYPE; } else { constexpr uint32_t width = CAMERA_VIDEO_WIDTH; constexpr uint32_t height = CAMERA_VIDEO_HEIGHT; - streamInfo->width_ = width; - streamInfo->height_ = height; - streamInfo->encodeType_ = CAMERA_VIDEO_ENCODE_TYPE; - } - - streamInfo->streamId_ = streamId; - streamInfo->format_ = CAMERA_FORMAT; - streamInfo->dataspace_ = dataspace; - streamInfo->intent_ = intent; - streamInfo->tunneledMode_ = tunneledMode; - streamInfo->bufferQueue_ = streamCustomer->CreateProducer(); - streamInfo->bufferQueue_->SetQueueSize(8); // 8:set bufferQueue size + streamInfo.width_ = width; + streamInfo.height_ = height; + streamInfo.encodeType_ = CAMERA_VIDEO_ENCODE_TYPE; + } + + streamInfo.streamId_ = streamId; + streamInfo.format_ = CAMERA_FORMAT; + streamInfo.dataspace_ = dataspace; + streamInfo.intent_ = intent; + streamInfo.tunneledMode_ = tunneledMode; + + producer = streamCustomer->CreateProducer(); + streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer); + streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size } void OhosCameraDemo::GetStreamOpt() @@ -69,12 +73,12 @@ void OhosCameraDemo::GetStreamOpt() if (streamOperator_ == nullptr) { #ifdef CAMERA_BUILT_ON_OHOS_LITE const std::shared_ptr streamOperatorCallback = - std::make_shared(); + std::make_shared(); #else - const sptr streamOperatorCallback = new StreamOperatorCallback(); + const sptr streamOperatorCallback = new DemoStreamOperatorCallback(); #endif rc = demoCameraDevice_->GetStreamOperator(streamOperatorCallback, streamOperator_); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: GetStreamOpt GetStreamOperator fail\n"); streamOperator_ = nullptr; } @@ -109,19 +113,20 @@ RetCode OhosCameraDemo::CaptureON(const int streamId, captureSetting_->addEntry(OHOS_JPEG_GPS_COORDINATES, gps_.data(), gps_.size()); } - captureInfo_ = std::make_shared(); - captureInfo_->streamIds_ = {streamId}; + std::vector setting; + MetadataUtils::ConvertMetadataToVec(captureSetting_, setting); + captureInfo_.streamIds_ = {streamId}; if (mode == CAPTURE_SNAPSHOT) { - captureInfo_->captureSetting_ = captureSetting_; + captureInfo_.captureSetting_ = setting; } else { - captureInfo_->captureSetting_ = ability_; + captureInfo_.captureSetting_ = cameraAbility_; } - captureInfo_->enableShutterCallback_ = false; + captureInfo_.enableShutterCallback_ = false; int rc = streamOperator_->Capture(captureId, captureInfo_, true); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CaptureStart Capture error\n"); - streamOperator_->ReleaseStreams(captureInfo_->streamIds_); + streamOperator_->ReleaseStreams(captureInfo_.streamIds_); return RC_ERROR; } @@ -166,7 +171,7 @@ RetCode OhosCameraDemo::CaptureOff(const int captureId, const CaptureMode mode) videoFd_ = -1; } - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CaptureOff CancelCapture error mode %{public}d rc == %{public}d\n", mode, rc); return RC_ERROR; } @@ -187,30 +192,25 @@ RetCode OhosCameraDemo::CreateStream(const int streamId, std::shared_ptr streamInfo = std::make_shared(); - if (streamInfo == nullptr) { - CAMERA_LOGE("demo test: std::make_shared() is nullptr\n"); - return RC_ERROR; - } + StreamInfo streamInfo = {0}; SetStreamInfo(streamInfo, streamCustomer, streamId, intent); - if (streamInfo->bufferQueue_ == nullptr) { + if (streamInfo.bufferQueue_->producer_ == nullptr) { CAMERA_LOGE("demo test: CreateStream CreateProducer(); is nullptr\n"); return RC_ERROR; } - std::vector> streamInfos; - std::vector>().swap(streamInfos); + std::vector streamInfos; streamInfos.push_back(streamInfo); rc = streamOperator_->CreateStreams(streamInfos); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CreateStream CreateStreams error\n"); return RC_ERROR; } - rc = streamOperator_->CommitStreams(Camera::NORMAL, ability_); - if (rc != Camera::NO_ERROR) { + rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_); + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CreateStream CommitStreams error\n"); std::vector streamIds; streamIds.push_back(streamId); @@ -239,12 +239,9 @@ RetCode OhosCameraDemo::InitCameraDevice() return RC_ERROR; } const std::string cameraId = cameraIds_.front(); - demoCameraHost_->GetCameraAbility(cameraId, ability_); + demoCameraHost_->GetCameraAbility(cameraId, cameraAbility_); - if (ability_ == nullptr) { - CAMERA_LOGE("demo test: InitCameraDevice ability_ == nullptr"); - return RC_ERROR; - } + MetadataUtils::ConvertVecToMetadata(cameraAbility_, ability_); GetFaceDetectMode(ability_); GetFocalLength(ability_); @@ -268,7 +265,7 @@ RetCode OhosCameraDemo::InitCameraDevice() sptr callback = new DemoCameraDeviceCallback(); #endif rc = demoCameraHost_->OpenCamera(cameraIds_.front(), callback, demoCameraDevice_); - if (rc != Camera::NO_ERROR || demoCameraDevice_ == nullptr) { + if (rc != HDI::Camera::V1_0::NO_ERROR || demoCameraDevice_ == nullptr) { CAMERA_LOGE("demo test: InitCameraDevice OpenCamera failed"); return RC_ERROR; } @@ -300,7 +297,7 @@ RetCode OhosCameraDemo::InitSensors() demoCameraHost_ = OHOS::Camera::CameraHost::CreateCameraHost(); #else constexpr const char *DEMO_SERVICE_NAME = "camera_service"; - demoCameraHost_ = ICameraHost::Get(DEMO_SERVICE_NAME); + demoCameraHost_ = ICameraHost::Get(DEMO_SERVICE_NAME, false); #endif if (demoCameraHost_ == nullptr) { CAMERA_LOGE("demo test: ICameraHost::Get error"); @@ -308,12 +305,12 @@ RetCode OhosCameraDemo::InitSensors() } #ifdef CAMERA_BUILT_ON_OHOS_LITE - hostCallback_ = std::make_shared(); + hostCallback_ = std::make_shared(); #else - hostCallback_ = new CameraHostCallback(); + hostCallback_ = new DemoCameraHostCallback(); #endif rc = demoCameraHost_->SetCallback(hostCallback_); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: demoCameraHost_->SetCallback(hostCallback_) error"); return RC_ERROR; } @@ -393,8 +390,8 @@ void OhosCameraDemo::OpenVideoFile() RetCode OhosCameraDemo::CreateStreams(const int streamIdSecond, StreamIntent intent) { int rc = 0; - std::vector> streamInfos; - std::vector>().swap(streamInfos); + std::vector streamInfos; + std::vector().swap(streamInfos); CAMERA_LOGD("demo test: CreateStreams streamIdSecond = %{public}d", streamIdSecond); GetStreamOpt(); @@ -403,24 +400,16 @@ RetCode OhosCameraDemo::CreateStreams(const int streamIdSecond, StreamIntent int return RC_ERROR; } - std::shared_ptr previewStreamInfo = std::make_shared(); - if (previewStreamInfo == nullptr) { - CAMERA_LOGE("demo test: CreateStreams previewStreamInfo is nullptr\n"); - return RC_ERROR; - } + StreamInfo previewStreamInfo = {0}; SetStreamInfo(previewStreamInfo, streamCustomerPreview_, STREAM_ID_PREVIEW, PREVIEW); - if (previewStreamInfo->bufferQueue_ == nullptr) { + if (previewStreamInfo.bufferQueue_->producer_ == nullptr) { CAMERA_LOGE("demo test: CreateStream CreateProducer(); is nullptr\n"); return RC_ERROR; } streamInfos.push_back(previewStreamInfo); - std::shared_ptr secondStreamInfo = std::make_shared(); - if (secondStreamInfo == nullptr) { - CAMERA_LOGE("demo test: CreateStreams previewStreamInfo is nullptr\n"); - return RC_ERROR; - } + StreamInfo secondStreamInfo = {0}; if (streamIdSecond == STREAM_ID_CAPTURE) { SetStreamInfo(secondStreamInfo, streamCustomerCapture_, STREAM_ID_CAPTURE, intent); @@ -428,20 +417,20 @@ RetCode OhosCameraDemo::CreateStreams(const int streamIdSecond, StreamIntent int SetStreamInfo(secondStreamInfo, streamCustomerVideo_, STREAM_ID_VIDEO, intent); } - if (secondStreamInfo->bufferQueue_ == nullptr) { + if (secondStreamInfo.bufferQueue_->producer_ == nullptr) { CAMERA_LOGE("demo test: CreateStreams CreateProducer() secondStreamInfo is nullptr\n"); return RC_ERROR; } streamInfos.push_back(secondStreamInfo); rc = streamOperator_->CreateStreams(streamInfos); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CreateStream CreateStreams error\n"); return RC_ERROR; } - rc = streamOperator_->CommitStreams(Camera::NORMAL, ability_); - if (rc != Camera::NO_ERROR) { + rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_); + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CreateStream CommitStreams error\n"); std::vector streamIds = {STREAM_ID_PREVIEW, streamIdSecond}; streamOperator_->ReleaseStreams(streamIds); @@ -456,29 +445,29 @@ RetCode OhosCameraDemo::CaptureOnDualStreams(const int streamIdSecond) int rc = 0; CAMERA_LOGD("demo test: CaptuCaptureOnDualStreamsreON enter"); - std::shared_ptr previewCaptureInfo = std::make_shared(); - previewCaptureInfo->streamIds_ = {STREAM_ID_PREVIEW}; - previewCaptureInfo->captureSetting_ = ability_; - previewCaptureInfo->enableShutterCallback_ = false; + CaptureInfo previewCaptureInfo; + previewCaptureInfo.streamIds_ = {STREAM_ID_PREVIEW}; + previewCaptureInfo.captureSetting_ = cameraAbility_; + previewCaptureInfo.enableShutterCallback_ = false; rc = streamOperator_->Capture(CAPTURE_ID_PREVIEW, previewCaptureInfo, true); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CaptureOnDualStreams preview Capture error\n"); - streamOperator_->ReleaseStreams(previewCaptureInfo->streamIds_); + streamOperator_->ReleaseStreams(previewCaptureInfo.streamIds_); return RC_ERROR; } streamCustomerPreview_->ReceiveFrameOn(nullptr); - std::shared_ptr secondCaptureInfo = std::make_shared(); - secondCaptureInfo->streamIds_ = {streamIdSecond}; - secondCaptureInfo->captureSetting_ = ability_; - previewCaptureInfo->enableShutterCallback_ = false; + CaptureInfo secondCaptureInfo; + secondCaptureInfo.streamIds_ = {streamIdSecond}; + secondCaptureInfo.captureSetting_ = cameraAbility_; + previewCaptureInfo.enableShutterCallback_ = false; if (streamIdSecond == STREAM_ID_CAPTURE) { rc = streamOperator_->Capture(CAPTURE_ID_CAPTURE, secondCaptureInfo, true); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CaptureOnDualStreams CAPTURE_ID_CAPTURE error\n"); - streamOperator_->ReleaseStreams(secondCaptureInfo->streamIds_); + streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_); return RC_ERROR; } @@ -487,9 +476,9 @@ RetCode OhosCameraDemo::CaptureOnDualStreams(const int streamIdSecond) }); } else { rc = streamOperator_->Capture(CAPTURE_ID_VIDEO, secondCaptureInfo, true); - if (rc != Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: CaptureOnDualStreams CAPTURE_ID_VIDEO error\n"); - streamOperator_->ReleaseStreams(secondCaptureInfo->streamIds_); + streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_); return RC_ERROR; } @@ -678,10 +667,12 @@ void OhosCameraDemo::SetAwbMode(const int mode) const constexpr size_t dataCapacity = 2000; std::shared_ptr metaData = std::make_shared(entryCapacity, dataCapacity); + std::vector result; const uint8_t awbMode = mode; metaData->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1); - demoCameraDevice_->UpdateSettings(metaData); + MetadataUtils::ConvertMetadataToVec(metaData, result); + demoCameraDevice_->UpdateSettings(result); CAMERA_LOGD("demo test: SetAwbMode exit\n"); } @@ -696,6 +687,7 @@ void OhosCameraDemo::SetAeExpo() constexpr size_t dataCapacity = 2000; std::shared_ptr metaData = std::make_shared(entryCapacity, dataCapacity); + std::vector result; if (aeStatus_) { expo = 0xa0; @@ -704,7 +696,8 @@ void OhosCameraDemo::SetAeExpo() } aeStatus_ = !aeStatus_; metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1); - demoCameraDevice_->UpdateSettings(metaData); + MetadataUtils::ConvertMetadataToVec(metaData, result); + demoCameraDevice_->UpdateSettings(result); CAMERA_LOGD("demo test: SetAeExpo exit\n"); } @@ -773,7 +766,9 @@ void OhosCameraDemo::SetMetadata() uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE; metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode)); - demoCameraDevice_->UpdateSettings(metaData); + std::vector result; + MetadataUtils::ConvertMetadataToVec(metaData, result); + demoCameraDevice_->UpdateSettings(result); CAMERA_LOGI("demo test: SetMetadata exit\n"); } @@ -798,16 +793,16 @@ RetCode OhosCameraDemo::StreamOffline(const int streamId) constexpr size_t offlineDelayTime = 4; CAMERA_LOGD("demo test: StreamOffline enter\n"); #ifdef CAMERA_BUILT_ON_OHOS_LITE - std::shared_ptr streamOperatorCallback = std::make_shared(); + std::shared_ptr streamOperatorCallback = std::make_shared(); std::shared_ptr offlineStreamOperator = nullptr; #else - sptr streamOperatorCallback = new StreamOperatorCallback(); + sptr streamOperatorCallback = new DemoStreamOperatorCallback(); sptr offlineStreamOperator = nullptr; #endif std::vector streamIds; streamIds.push_back(streamId); rc = streamOperator_->ChangeToOfflineStream(streamIds, streamOperatorCallback, offlineStreamOperator); - if (rc != NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: StreamOffline ChangeToOfflineStream error\n"); return RC_ERROR; } @@ -821,13 +816,13 @@ RetCode OhosCameraDemo::StreamOffline(const int streamId) CAMERA_LOGD("demo test: begin to release offlne stream"); rc = offlineStreamOperator->CancelCapture(CAPTURE_ID_CAPTURE); - if (rc != NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: StreamOffline offlineStreamOperator->CancelCapture error\n"); return RC_ERROR; } rc = offlineStreamOperator->Release(); - if (rc != OHOS::Camera::NO_ERROR) { + if (rc != HDI::Camera::V1_0::NO_ERROR) { CAMERA_LOGE("demo test: StreamOffline offlineStreamOperator->Release() error\n"); return RC_ERROR; } @@ -1130,38 +1125,40 @@ RetCode OhosCameraDemo::GetFaceDetectMaxNum(std::shared_ptr &abil } #ifndef CAMERA_BUILT_ON_OHOS_LITE -void DemoCameraDeviceCallback::OnError(const Camera::ErrorType type, const int32_t errorMsg) +int32_t DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorCode) { - CAMERA_LOGI("demo test: OnError type : %{public}d, errorMsg : %{public}d", type, errorMsg); + CAMERA_LOGI("demo test: OnError type : %{public}d, errorCode : %{public}d", type, errorCode); } -void DemoCameraDeviceCallback::OnResult(const uint64_t timestamp, - const std::shared_ptr& result) +int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector& result) { CAMERA_LOGI("demo test: OnResult timestamp : %{public}ld,", timestamp); + std::shared_ptr updateSettings; + + MetadataUtils::ConvertVecToMetadata(result, updateSettings); for (auto it = results_list_.cbegin(); it != results_list_.cend(); it++) { switch (*it) { case OHOS_CONTROL_FOCUS_MODE: { - common_metadata_header_t* data = result->get(); + common_metadata_header_t* data = updateSettings->get(); uint8_t focusMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_MODE, &entry); if (ret != 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_FOCUS_MODE error\n"); - break; + return RC_ERROR; } focusMode = *(entry.data.u8); CAMERA_LOGI("demo test: focusMode %{public}d\n", focusMode); break; } case OHOS_CONTROL_EXPOSURE_MODE: { - common_metadata_header_t* data = result->get(); + common_metadata_header_t* data = updateSettings->get(); uint8_t exposureMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_EXPOSURE_MODE, &entry); if (ret != 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_EXPOSURE_MODE error\n"); - break; + return RC_ERROR; } exposureMode = *(entry.data.u8); CAMERA_LOGI("demo test: exposureMode %{public}d\n", exposureMode); @@ -1169,6 +1166,54 @@ void DemoCameraDeviceCallback::OnResult(const uint64_t timestamp, } } } + + return RC_OK; +} + +int32_t DemoCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status) +{ + CAMERA_LOGI("%{public}s, enter.", __func__); + return RC_OK; +} + +int32_t DemoCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) +{ + CAMERA_LOGI("%{public}s, enter. cameraId = %s, status = %d", + __func__, cameraId.c_str(), static_cast(status)); + return RC_OK; } + +int32_t DemoCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event) +{ + CAMERA_LOGI("%{public}s, enter. cameraId = %s, event = %d", + __func__, cameraId.c_str(), static_cast(event)); + return RC_OK; +} + +int32_t DemoStreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector& streamIds) +{ + CAMERA_LOGI("%{public}s, enter.", __func__); + return RC_OK; +} + +int32_t DemoStreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector& infos) +{ + CAMERA_LOGI("%{public}s, enter.", __func__); + return RC_OK; +} + +int32_t DemoStreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector& infos) +{ + CAMERA_LOGI("%{public}s, enter.", __func__); + return RC_OK; +} + +int32_t DemoStreamOperatorCallback::OnFrameShutter(int32_t captureId, + const std::vector& streamIds, uint64_t timestamp) +{ + CAMERA_LOGI("%{public}s, enter.", __func__); + return RC_OK; +} + #endif } // namespace OHOS::Camera diff --git a/camera/hal/init/ohos_camera_demo.h b/camera/hal/init/ohos_camera_demo.h index 67df832e86..10b7f2d626 100644 --- a/camera/hal/init/ohos_camera_demo.h +++ b/camera/hal/init/ohos_camera_demo.h @@ -27,13 +27,13 @@ #include "camera.h" #include "camera_metadata_info.h" #include "ibuffer.h" -#include "ioffline_stream_operator.h" -#include "icamera_host.h" +#include "v1_0/ioffline_stream_operator.h" +#include "v1_0/icamera_host.h" #include "camera_host_callback.h" #include "camera_device_callback.h" -#include "icamera_device.h" +#include "v1_0/icamera_device.h" #include "stream_operator_callback.h" -#include "istream_operator_callback.h" +#include "v1_0/istream_operator_callback.h" #include "stream_customer.h" #include "securec.h" #include "project_camera_demo.h" @@ -44,10 +44,12 @@ #else #include "if_system_ability_manager.h" #include "iservice_registry.h" -#include "camera_host_proxy.h" +#include "v1_0/camera_host_proxy.h" #endif namespace OHOS::Camera { +using namespace OHOS::HDI::Camera::V1_0; + enum CaptureMode { CAPTURE_PREVIEW = 0, CAPTURE_SNAPSHOT, @@ -63,6 +65,7 @@ enum DemoActionID { CAPTURE_ID_VIDEO, }; +class DemoCameraHostCallback; class OhosCameraDemo { public: OhosCameraDemo(); @@ -94,8 +97,8 @@ public: void QuitDemo(); private: - void SetStreamInfo(std::shared_ptr &streamInfo, - const std::shared_ptr &streamCustomer, + void SetStreamInfo(StreamInfo& streamInfo, + const std::shared_ptr& streamCustomer, const int streamId, const StreamIntent intent); void GetStreamOpt(); @@ -133,22 +136,23 @@ private: int32_t captureOrientation_ = 0; uint8_t mirrorSwitch_ = 0; std::vector gps_; + CaptureInfo captureInfo_; std::shared_ptr streamCustomerPreview_ = nullptr; std::shared_ptr streamCustomerCapture_ = nullptr; std::shared_ptr streamCustomerVideo_ = nullptr; std::shared_ptr ability_ = nullptr; std::shared_ptr captureSetting_ = nullptr; - std::shared_ptr captureInfo_ = nullptr; std::mutex metaDatalock_; + std::vector cameraAbility_; #ifdef CAMERA_BUILT_ON_OHOS_LITE - std::shared_ptr hostCallback_ = nullptr; + std::shared_ptr hostCallback_ = nullptr; std::shared_ptr streamOperator_ = nullptr; std::shared_ptr demoCameraHost_ = nullptr; std::shared_ptr demoCameraDevice_ = nullptr; #else - OHOS::sptr hostCallback_ = nullptr; + OHOS::sptr hostCallback_ = nullptr; OHOS::sptr streamOperator_ = nullptr; OHOS::sptr demoCameraHost_ = nullptr; OHOS::sptr demoCameraDevice_ = nullptr; @@ -158,14 +162,39 @@ private: #ifdef CAMERA_BUILT_ON_OHOS_LITE #else -class DemoCameraDeviceCallback : public Camera::CameraDeviceCallbackStub { +class DemoCameraDeviceCallback : public ICameraDeviceCallback { public: DemoCameraDeviceCallback() = default; virtual ~DemoCameraDeviceCallback() = default; - void OnError(Camera::ErrorType type, int32_t errorMsg) override; - void OnResult(const uint64_t timestamp, - const std::shared_ptr& result) override; + int32_t OnError(ErrorType type, int32_t errorCode) override; + int32_t OnResult(uint64_t timestamp, const std::vector& result) override; +}; + +class DemoCameraHostCallback : public ICameraHostCallback { +public: + DemoCameraHostCallback() = default; + virtual ~DemoCameraHostCallback() = default; + +public: + int32_t OnCameraStatus(const std::string& cameraId, CameraStatus status) override; + + int32_t OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) override; + + int32_t OnCameraEvent(const std::string& cameraId, CameraEvent event) override; }; + +class DemoStreamOperatorCallback : public IStreamOperatorCallback { +public: + DemoStreamOperatorCallback() = default; + virtual ~DemoStreamOperatorCallback() = default; + +public: + int32_t OnCaptureStarted(int32_t captureId, const std::vector& streamIds) override; + int32_t OnCaptureEnded(int32_t captureId, const std::vector& infos) override; + int32_t OnCaptureError(int32_t captureId, const std::vector& infos) override; + int32_t OnFrameShutter(int32_t captureId, const std::vector& streamIds, uint64_t timestamp) override; +}; + #endif } // namespace OHOS::Camera #endif // OHOS_CAMERA_CAMERA_DEMO_H diff --git a/camera/hal/init/stream_customer.h b/camera/hal/init/stream_customer.h index 3da239046c..ccb8182339 100644 --- a/camera/hal/init/stream_customer.h +++ b/camera/hal/init/stream_customer.h @@ -25,7 +25,7 @@ #include #include "camera_metadata_info.h" #include "ibuffer.h" -#include "ioffline_stream_operator.h" +#include "v1_0/ioffline_stream_operator.h" #include "camera.h" #ifndef CAMERA_BUILT_ON_OHOS_LITE #include "if_system_ability_manager.h" diff --git a/camera/hal/pipeline_core/host_stream/include/host_stream_data_structure.h b/camera/hal/pipeline_core/host_stream/include/host_stream_data_structure.h index ab60535485..172d9014b6 100644 --- a/camera/hal/pipeline_core/host_stream/include/host_stream_data_structure.h +++ b/camera/hal/pipeline_core/host_stream/include/host_stream_data_structure.h @@ -15,9 +15,10 @@ #define HOST_STREAM_DATA_STRUCTURE_ #include #include -#include "types.h" +#include "v1_0/types.h" #include "ibuffer.h" namespace OHOS::Camera { +using namespace OHOS::HDI::Camera::V1_0; struct HostStreamInfo { StreamIntent type_; int32_t streamId_; diff --git a/camera/hal/test/fuzz/BUILD.gn b/camera/hal/test/fuzz/BUILD.gn index ea67e65bec..5af0b929d5 100644 --- a/camera/hal/test/fuzz/BUILD.gn +++ b/camera/hal/test/fuzz/BUILD.gn @@ -68,11 +68,11 @@ ohos_fuzztest("CameraIpcCameraDeviceRemoteFuzzTest") { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] @@ -148,11 +148,11 @@ ohos_fuzztest("CameraIpcCameraHostServiceFuzzTest") { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] @@ -228,11 +228,11 @@ ohos_fuzztest("CameraIpcOfflineFuzzTest") { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] @@ -307,11 +307,11 @@ ohos_fuzztest("CameraIpcStreamOperatorFuzzTest") { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] @@ -389,11 +389,11 @@ ohos_fuzztest("CameraIpcCameraDeviceCallbackFuzzTest") { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] @@ -469,11 +469,11 @@ ohos_fuzztest("CameraIpcCameraHostCallbackFuzzTest") { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] @@ -549,11 +549,11 @@ ohos_fuzztest("CameraIpcStreamOperatorCallbackFuzzTest") { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", ] diff --git a/camera/hal/test/mpi/BUILD.gn b/camera/hal/test/mpi/BUILD.gn index 6cda64b13c..7538508e32 100644 --- a/camera/hal/test/mpi/BUILD.gn +++ b/camera/hal/test/mpi/BUILD.gn @@ -103,7 +103,7 @@ if (defined(ohos_lite)) { deps = [ "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", "$hdf_uhdf_path/utils:libhdf_utils", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", @@ -195,11 +195,11 @@ if (defined(ohos_lite)) { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", "//third_party/googletest:gmock", "//third_party/googletest:gmock_main", diff --git a/camera/hal/test/mpi/dfxShell.sh b/camera/hal/test/mpi/dfxShell.sh index 8e7d181cc7..3c37f0c885 100644 --- a/camera/hal/test/mpi/dfxShell.sh +++ b/camera/hal/test/mpi/dfxShell.sh @@ -25,8 +25,8 @@ echo "libcamera_buffer_manager.z.so(B): "$camera_buffer_manager camera_device_manager=$(stat -c %s "libcamera_device_manager.z.so") echo "libcamera_device_manager.z.so(B): "$camera_device_manager -camera_hdi_impl=$(stat -c %s "libcamera_hdi_impl.z.so") -echo "libcamera_hdi_impl.z.so(B): "$camera_hdi_impl +camera_host_service_1.0=$(stat -c %s "libcamera_host_service_1.0.z.so") +echo "libcamera_host_service_1.0.z.so(B): "$camera_host_service_1.0 camera_pipeline_core=$(stat -c %s "libcamera_pipeline_core.z.so") echo "libcamera_pipeline_core.z.so(B): "$camera_pipeline_core @@ -34,6 +34,6 @@ echo "libcamera_pipeline_core.z.so(B): "$camera_pipeline_core camera_utils=$(stat -c %s "libcamera_utils.z.so") echo "libcamera_utils.z.so(B): "$camera_utils -total=$[libcamera_client+camera_buffer_manager+camera_device_manager+camera_hdi_impl+camera_pipeline_core+camera_utils] +total=$[libcamera_client+camera_buffer_manager+camera_device_manager+camera_host_service_1.0+camera_pipeline_core+camera_utils] echo "so package total(KB)："$(expr $total / 1024) diff --git a/camera/hal/test/v4l2/BUILD.gn b/camera/hal/test/v4l2/BUILD.gn index b299e7d014..c79a7fd52b 100644 --- a/camera/hal/test/v4l2/BUILD.gn +++ b/camera/hal/test/v4l2/BUILD.gn @@ -103,7 +103,7 @@ if (defined(ohos_lite)) { deps = [ "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", "$hdf_uhdf_path/utils:libhdf_utils", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", @@ -190,11 +190,11 @@ if (defined(ohos_lite)) { ] deps = [ - "$camera_path/../interfaces/hdi_ipc/client:libcamera_client", "$camera_path/buffer_manager:camera_buffer_manager", "$camera_path/device_manager:camera_device_manager", - "$camera_path/hdi_impl:camera_hdi_impl", + "$camera_path/hdi_impl:camera_host_service_1.0", "$camera_path/pipeline_core:camera_pipeline_core", + "//drivers/interface/camera/v1_0:libcamera_proxy_1.0", "//drivers/peripheral/camera/interfaces/metadata:metadata", "//third_party/googletest:gmock", "//third_party/googletest:gmock_main", diff --git a/camera/hal/utils/BUILD.gn b/camera/hal/utils/BUILD.gn index 85bbfd6a4a..6a357bc9a8 100644 --- a/camera/hal/utils/BUILD.gn +++ b/camera/hal/utils/BUILD.gn @@ -80,6 +80,7 @@ if (defined(ohos_lite)) { ] include_dirs = [ "//drivers/peripheral/camera/hal/include", + "//drivers/peripheral/camera/interfaces/metadata/include", "//third_party/libexif", "watchdog", "exif", diff --git a/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback.h b/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback.h index ae8f5f6207..1cab913db1 100644 --- a/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback.h +++ b/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback.h @@ -16,17 +16,18 @@ #ifndef HDI_CAMERA_DEVICE_CALLBACK_H #define HDI_CAMERA_DEVICE_CALLBACK_H -#include "camera_device_callback_stub.h" +#include "v1_0/icamera_device_callback.h" namespace OHOS::Camera { -class CameraDeviceCallback : public CameraDeviceCallbackStub { +using namespace OHOS::HDI::Camera::V1_0; +class CameraDeviceCallback : public ICameraDeviceCallback { public: CameraDeviceCallback() = default; virtual ~CameraDeviceCallback() = default; public: - void OnError(ErrorType type, int32_t errorMsg) override; - void OnResult(uint64_t timestamp, const std::shared_ptr &result) override; + int32_t OnError(ErrorType type, int32_t errorCode) override; + int32_t OnResult(uint64_t timestamp, const std::vector& result) override; }; } #endif // HDI_CAMERA_DEVICE_CALLBACK_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_proxy.h b/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_proxy.h deleted file mode 100644 index 04a2dea25b..0000000000 --- a/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_proxy.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2021 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 CAMERA_DEVICE_CALLBACK_CLIENT_H -#define CAMERA_DEVICE_CALLBACK_CLIENT_H - -#include -#include -#include "icamera_device_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class CameraDeviceCallbackProxy : public IRemoteProxy { -public: - explicit CameraDeviceCallbackProxy(const sptr &impl) - : IRemoteProxy(impl) {} - - virtual ~CameraDeviceCallbackProxy() = default; - - void OnError(ErrorType type, int32_t errorMsg) override; - void OnResult(uint64_t timestamp, const std::shared_ptr &result) override; - -private: - static inline BrokerDelegator delegator_; -}; -} -#endif // CAMERA_DEVICE_CALLBACK_CLIENT_H diff --git a/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_stub.h b/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_stub.h deleted file mode 100644 index 199c356e90..0000000000 --- a/camera/interfaces/hdi_ipc/callback/device/include/camera_device_callback_stub.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2021 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 CAMERA_DEVICE_CALLBACK_CLIENT_STUB_H -#define CAMERA_DEVICE_CALLBACK_CLIENT_STUB_H - -#include "icamera_device_callback.h" -#include "iremote_stub.h" -#include "message_parcel.h" -#include "parcel.h" - -namespace OHOS::Camera { -class CameraDeviceCallbackStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) override; -}; -} -#endif // CAMERA_DEVICE_CALLBACK_CLIENT_STUB_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback.cpp b/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback.cpp index a568e3d8dc..9fcd05f2ac 100644 --- a/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback.cpp +++ b/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback.cpp @@ -14,16 +14,19 @@ */ #include +#include #include "camera_device_callback.h" namespace OHOS::Camera { -void CameraDeviceCallback::OnError(ErrorType type, int32_t errorMsg) +int32_t CameraDeviceCallback::OnError(ErrorType type, int32_t errorCode) { HDF_LOGV("%{public}s, enter.", __func__); + return HDF_SUCCESS; } -void CameraDeviceCallback::OnResult(uint64_t timestamp, const std::shared_ptr &result) +int32_t CameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector& result) { HDF_LOGV("%{public}s, enter.", __func__); + return HDF_SUCCESS; } } diff --git a/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_proxy.cpp b/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_proxy.cpp deleted file mode 100644 index 424316cf1e..0000000000 --- a/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_proxy.cpp +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_device_callback_proxy.h" -#include -#include -#include -#include "metadata_utils.h" - -namespace OHOS::Camera { -void CameraDeviceCallbackProxy::OnError(ErrorType type, int32_t errorMsg) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteUint32(type)) { - HDF_LOGE("%{public}s: write error type failed.", __func__); - return; - } - - if (!data.WriteInt32(errorMsg)) { - HDF_LOGE("%{public}s: write error message failed.", __func__); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_DEVICE_CALLBACK_ON_ERROR, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} - -void CameraDeviceCallbackProxy::OnResult(uint64_t timestamp, - const std::shared_ptr &result) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (result == nullptr) { - return; - } - - if (!data.WriteInterfaceToken(CameraDeviceCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteUint64(timestamp)) { - HDF_LOGE("%{public}s: write timestamp failed.", __func__); - return; - } - - if (!MetadataUtils::EncodeCameraMetadata(result, data)) { - HDF_LOGE("%s: write metadata failed", __func__); - return; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_CALLBACK_ON_RESULT, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} -} \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_stub.cpp b/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_stub.cpp deleted file mode 100644 index e7a9b95722..0000000000 --- a/camera/interfaces/hdi_ipc/callback/device/src/camera_device_callback_stub.cpp +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_device_callback_stub.h" -#include -#include -#include -#include "camera_device_callback.h" -#include "metadata_utils.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -int32_t CameraDeviceCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HDF_LOGE("%s: CameraDeviceCallbackStub::OnRemoteRequest entry!", __func__); - switch (code) { - case CMD_CAMERA_DEVICE_CALLBACK_ON_ERROR: { - if (data.ReadInterfaceToken() != CameraDeviceCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - ErrorType type = static_cast(data.ReadUint32()); - int32_t errorMsg = data.ReadInt32(); - OnError(type, errorMsg); - break; - } - case CMD_CAMERA_DEVICE_CALLBACK_ON_RESULT: { - if (data.ReadInterfaceToken() != CameraDeviceCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - uint64_t timestamp = data.ReadUint64(); - std::shared_ptr result = nullptr; - MetadataUtils::DecodeCameraMetadata(data, result); - OnResult(timestamp, result); - break; - } - default: { - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return 0; -} -} diff --git a/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback.h b/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback.h index ff1b2ff647..1384617c4f 100644 --- a/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback.h +++ b/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback.h @@ -16,18 +16,21 @@ #ifndef HDI_CAMERA_HOST_CALLBACK_H #define HDI_CAMERA_HOST_CALLBACK_H -#include "camera_host_callback_stub.h" +#include "v1_0/icamera_host_callback.h" namespace OHOS::Camera { -class CameraHostCallback : public CameraHostCallbackStub { +using namespace OHOS::HDI::Camera::V1_0; +class CameraHostCallback : public ICameraHostCallback { public: CameraHostCallback() = default; virtual ~CameraHostCallback() = default; public: - void OnCameraStatus(const std::string &cameraId, CameraStatus status) override; - void OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) override; - void OnCameraEvent(const std::string &cameraId, CameraEvent event) override; + int32_t OnCameraStatus(const std::string& cameraId, CameraStatus status) override; + + int32_t OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) override; + + int32_t OnCameraEvent(const std::string& cameraId, CameraEvent event) override; }; } #endif // HDI_CAMERA_HOST_CALLBACK_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_proxy.h b/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_proxy.h deleted file mode 100644 index 2526b512dd..0000000000 --- a/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_proxy.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2021 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 CAMERA_HOST_CALLBACK_CLIENT_H -#define CAMERA_HOST_CALLBACK_CLIENT_H - -#include -#include -#include "icamera_host_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class CameraHostCallbackProxy : public IRemoteProxy { -public: - explicit CameraHostCallbackProxy(const sptr &impl) - : IRemoteProxy(impl) {} - - virtual ~CameraHostCallbackProxy() = default; - - virtual void OnCameraStatus(const std::string &cameraId, CameraStatus status); - virtual void OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status); - virtual void OnCameraEvent(const std::string &cameraId, CameraEvent event); -private: - static inline BrokerDelegator delegator_; -}; -} -#endif // CAMERA_HOST_CALLBACK_CLIENT_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_stub.h b/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_stub.h deleted file mode 100644 index 208b6e797c..0000000000 --- a/camera/interfaces/hdi_ipc/callback/host/include/camera_host_callback_stub.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2021 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 CAMERA_HOST_CALLBACK_CLIENT_STUB_H -#define CAMERA_HOST_CALLBACK_CLIENT_STUB_H - -#include "icamera_host_callback.h" -#include "iremote_stub.h" -#include "message_parcel.h" -#include "parcel.h" - -namespace OHOS::Camera { -class CameraHostCallbackStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) override; -}; -} -#endif // CAMERA_HOST_CALLBACK_CLIENT_STUB_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback.cpp b/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback.cpp index d47b2e646d..c1549518af 100644 --- a/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback.cpp +++ b/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback.cpp @@ -14,23 +14,27 @@ */ #include +#include #include "camera_host_callback.h" namespace OHOS::Camera { -void CameraHostCallback::OnCameraStatus(const std::string &cameraId, CameraStatus status) +int32_t CameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status) { HDF_LOGV("%{public}s, enter.", __func__); + return HDF_SUCCESS; } -void CameraHostCallback::OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) +int32_t CameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) { HDF_LOGV("%{public}s, enter. cameraId = %s, status = %d", __func__, cameraId.c_str(), static_cast(status)); + return HDF_SUCCESS; } -void CameraHostCallback::OnCameraEvent(const std::string &cameraId, CameraEvent event) +int32_t CameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event) { HDF_LOGV("%{public}s, enter. cameraId = %s, event = %d", __func__, cameraId.c_str(), static_cast(event)); + return HDF_SUCCESS; } } diff --git a/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_proxy.cpp b/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_proxy.cpp deleted file mode 100644 index 0b22124741..0000000000 --- a/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_proxy.cpp +++ /dev/null @@ -1,105 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_host_callback_proxy.h" -#include -#include -#include - -namespace OHOS::Camera { -void CameraHostCallbackProxy::OnCameraStatus(const std::string &cameraId, CameraStatus status) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteString(cameraId)) { - HDF_LOGE("%{public}s: write cameraId failed.", __func__); - return; - } - - if (!data.WriteInt32(status)) { - HDF_LOGE("%{public}s: write status failed.", __func__); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_CALLBACK_ON_STATUS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} - -void CameraHostCallbackProxy::OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteString(cameraId)) { - HDF_LOGE("%{public}s: write cameraId failed.", __func__); - return; - } - - if (!data.WriteInt32(status)) { - HDF_LOGE("%{public}s: write status failed.", __func__); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_CALLBACK_ON_FLASHLIGHT_STATUS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} - -void CameraHostCallbackProxy::OnCameraEvent(const std::string &cameraId, CameraEvent event) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteString(cameraId)) { - HDF_LOGE("%{public}s: write cameraId failed.", __func__); - return; - } - - if (!data.WriteUint32(event)) { - HDF_LOGE("%{public}s: write event failed.", __func__); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_CALLBACK_ON_CAMERA_EVENT, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} -} \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_stub.cpp b/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_stub.cpp deleted file mode 100644 index 2219876ad6..0000000000 --- a/camera/interfaces/hdi_ipc/callback/host/src/camera_host_callback_stub.cpp +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_host_callback_stub.h" -#include -#include -#include -#include "camera_host_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -int32_t CameraHostCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HDF_LOGE("%s: CameraHostCallbackStub::OnRemoteRequest entry!", __func__); - switch (code) { - case CMD_CAMERA_HOST_CALLBACK_ON_STATUS: { - if (data.ReadInterfaceToken() != CameraHostCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::string cameraId = data.ReadString(); - CameraStatus status = static_cast(data.ReadInt32()); - OnCameraStatus(cameraId, status); - break; - } - case CMD_CAMERA_HOST_CALLBACK_ON_FLASHLIGHT_STATUS: { - if (data.ReadInterfaceToken() != CameraHostCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::string cameraId = data.ReadString(); - FlashlightStatus status = static_cast(data.ReadInt32()); - OnFlashlightStatus(cameraId, status); - break; - } - case CMD_CAMERA_HOST_CALLBACK_ON_CAMERA_EVENT: { - if (data.ReadInterfaceToken() != CameraHostCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::string cameraId = data.ReadString(); - CameraEvent event = static_cast(data.ReadInt32()); - OnCameraEvent(cameraId, event); - break; - } - default: { - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return 0; -} -} diff --git a/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback.h b/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback.h index f0ced46194..b4e4a32ea3 100644 --- a/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback.h +++ b/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback.h @@ -16,22 +16,20 @@ #ifndef HDI_STREAM_OPERATOR_CALLBACK_H #define HDI_STREAM_OPERATOR_CALLBACK_H -#include "stream_operator_callback_stub.h" +#include "v1_0/istream_operator_callback.h" namespace OHOS::Camera { -class StreamOperatorCallback : public StreamOperatorCallbackStub { +using namespace OHOS::HDI::Camera::V1_0; +class StreamOperatorCallback : public IStreamOperatorCallback { public: StreamOperatorCallback() = default; virtual ~StreamOperatorCallback() = default; public: - void OnCaptureStarted(int32_t captureId, const std::vector &streamId) override; - void OnCaptureEnded(int32_t captureId, - const std::vector> &info) override; - void OnCaptureError(int32_t captureId, - const std::vector> &info) override; - void OnFrameShutter(int32_t captureId, - const std::vector &streamId, uint64_t timestamp) override; + int32_t OnCaptureStarted(int32_t captureId, const std::vector& streamIds) override; + int32_t OnCaptureEnded(int32_t captureId, const std::vector& infos) override; + int32_t OnCaptureError(int32_t captureId, const std::vector& infos) override; + int32_t OnFrameShutter(int32_t captureId, const std::vector& streamIds, uint64_t timestamp) override; }; } #endif // HDI_STREAM_OPERATOR_CALLBACK_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_proxy.h b/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_proxy.h deleted file mode 100644 index 0543ca0d73..0000000000 --- a/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_proxy.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2021 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 STREAM_OPERATOR_CALLBACK_CLIENT_PROXY_H -#define STREAM_OPERATOR_CALLBACK_CLIENT_PROXY_H - -#include -#include -#include "istream_operator_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class StreamOperatorCallbackProxy : public IRemoteProxy { -public: - explicit StreamOperatorCallbackProxy(const sptr &impl) - : IRemoteProxy(impl) {} - - virtual ~StreamOperatorCallbackProxy() = default; - - void OnCaptureStarted(int32_t captureId, const std::vector &streamId) override; - void OnCaptureEnded(int32_t captureId, - const std::vector> &info) override; - void OnCaptureError(int32_t captureId, - const std::vector> &info) override; - void OnFrameShutter(int32_t captureId, - const std::vector &streamId, uint64_t timestamp) override; - -private: - static inline BrokerDelegator delegator_; -}; -} -#endif // STREAM_OPERATOR_CALLBACK_CLIENT_PROXY_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_stub.h b/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_stub.h deleted file mode 100644 index 8a5819f5ab..0000000000 --- a/camera/interfaces/hdi_ipc/callback/operator/include/stream_operator_callback_stub.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (c) 2021 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 STREAM_OPERATOR_CALLBACK_CLIENT_STUB_H -#define STREAM_OPERATOR_CALLBACK_CLIENT_STUB_H - -#include "istream_operator_callback.h" -#include "iremote_stub.h" -#include "message_parcel.h" -#include "parcel.h" - -namespace OHOS::Camera { -class StreamOperatorCallbackStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) override; - int32_t OnCaptureStartedStub(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t OnCaptureEndedStub(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t OnCaptureErrorStub(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t OnFrameShutterStub(MessageParcel &data, MessageParcel &reply, MessageOption &option); -}; -} -#endif // STREAM_OPERATOR_CALLBACK_CLIENT_STUB_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback.cpp b/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback.cpp index 2d9ce85741..a1542a22ad 100644 --- a/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback.cpp +++ b/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback.cpp @@ -14,30 +14,32 @@ */ #include +#include #include "stream_operator_callback.h" namespace OHOS::Camera { -void StreamOperatorCallback::OnCaptureStarted(int32_t captureId, - const std::vector &streamId) +int32_t StreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector& streamIds) { HDF_LOGV("%{public}s, enter.", __func__); + return HDF_SUCCESS; } -void StreamOperatorCallback::OnCaptureEnded(int32_t captureId, - const std::vector> &info) +int32_t StreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector& infos) { HDF_LOGV("%{public}s, enter.", __func__); + return HDF_SUCCESS; } -void StreamOperatorCallback::OnCaptureError(int32_t captureId, - const std::vector> &info) +int32_t StreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector& infos) { HDF_LOGV("%{public}s, enter.", __func__); + return HDF_SUCCESS; } -void StreamOperatorCallback::OnFrameShutter(int32_t captureId, - const std::vector &streamId, uint64_t timestamp) +int32_t StreamOperatorCallback::OnFrameShutter(int32_t captureId, + const std::vector& streamIds, uint64_t timestamp) { HDF_LOGV("%{public}s, enter.", __func__); + return HDF_SUCCESS; } } \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_proxy.cpp b/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_proxy.cpp deleted file mode 100644 index 8601eef59d..0000000000 --- a/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_proxy.cpp +++ /dev/null @@ -1,164 +0,0 @@ -/* - * Copyright (c) 2021 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 "stream_operator_callback_proxy.h" -#include -#include -#include - -namespace OHOS::Camera { -void StreamOperatorCallbackProxy::OnCaptureStarted(int32_t captureId, const std::vector &streamId) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteInt32(captureId)) { - HDF_LOGE("%{public}s: write captureId failed.", __func__); - return; - } - - if (!data.WriteInt32Vector(streamId)) { - HDF_LOGE("%{public}s: write streamIds failed.", __func__); - return; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_STARTED, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} - -void StreamOperatorCallbackProxy::OnCaptureEnded(int32_t captureId, - const std::vector> &info) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteInt32(captureId)) { - HDF_LOGE("%{public}s: write captureId failed.", __func__); - return; - } - - size_t size = info.size(); - if (!data.WriteInt32(static_cast(size))) { - HDF_LOGE("%{public}s: write info size failed.", __func__); - return; - } - for (size_t i = 0; i < size; i++) { - auto captureEndInfo = info.at(i); - bool bRet = data.WriteBuffer((void*)captureEndInfo.get(), sizeof(CaptureEndedInfo)); - if (!bRet) { - HDF_LOGE("%{public}s: write info index = %d failed.", __func__, i); - return; - } - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_ENDED, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} - -void StreamOperatorCallbackProxy::OnCaptureError(int32_t captureId, - const std::vector> &info) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteInt32(captureId)) { - HDF_LOGE("%{public}s: write captureId failed.", __func__); - return; - } - - size_t size = info.size(); - if (!data.WriteInt32(static_cast(size))) { - HDF_LOGE("%{public}s: write info size failed.", __func__); - return; - } - for (size_t i = 0; i < size; i++) { - auto captureErrorInfo = info.at(i); - bool bRet = data.WriteBuffer((void*)captureErrorInfo.get(), sizeof(CaptureErrorInfo)); - if (!bRet) { - HDF_LOGE("%{public}s: write info index = %d failed.", __func__, i); - return; - } - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_ERROR, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} - -void StreamOperatorCallbackProxy::OnFrameShutter(int32_t captureId, - const std::vector &streamId, uint64_t timestamp) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - HDF_LOGV("%{public}s: enter OnFrameShutter Callback", __func__); - - if (!data.WriteInterfaceToken(StreamOperatorCallbackProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - if (!data.WriteInt32(captureId)) { - HDF_LOGE("%{public}s: write captureId failed.", __func__); - return; - } - - if (!data.WriteInt32Vector(streamId)) { - HDF_LOGE("%{public}s: write streamId failed.", __func__); - return; - } - - if (!data.WriteUint64(timestamp)) { - HDF_LOGE("%{public}s: write streamId failed.", __func__); - return; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CALLBACK_ON_FRAME_SHUTTER, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return; - } -} -} \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_stub.cpp b/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_stub.cpp deleted file mode 100644 index 9ca821cf80..0000000000 --- a/camera/interfaces/hdi_ipc/callback/operator/src/stream_operator_callback_stub.cpp +++ /dev/null @@ -1,149 +0,0 @@ -/* - * Copyright (c) 2021 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 "stream_operator_callback_stub.h" -#include -#include -#include -#include "stream_operator_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -int32_t StreamOperatorCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HDF_LOGE("%s: StreamOperatorCallbackStub::OnRemoteRequest entry!", __func__); - int32_t ret = HDF_SUCCESS; - switch (code) { - case CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_STARTED: { - ret = OnCaptureStartedStub(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_ENDED: { - ret = OnCaptureEndedStub(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_ERROR: { - ret = OnCaptureErrorStub(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CALLBACK_ON_FRAME_SHUTTER: { - ret = OnFrameShutterStub(data, reply, option); - break; - } - default: { - ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return ret; -} - -int32_t StreamOperatorCallbackStub::OnCaptureStartedStub(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - if (data.ReadInterfaceToken() != StreamOperatorCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t captureId = data.ReadInt32(); - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - HDF_LOGE("%{public}s: OnCaptureStarted read streamIds failed.", __func__); - return HDF_FAILURE; - } - OnCaptureStarted(captureId, streamIds); - - return HDF_SUCCESS; -} - -int32_t StreamOperatorCallbackStub::OnCaptureEndedStub(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - if (data.ReadInterfaceToken() != StreamOperatorCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t captureId = data.ReadInt32(); - int32_t count = data.ReadInt32(); - std::vector> info; - for (int32_t i = 0; i < count; i++) { - const CaptureEndedInfo *pInfo = - reinterpret_cast( - data.ReadBuffer(sizeof(CaptureEndedInfo))); - if (pInfo == nullptr) { - HDF_LOGE("%{public}s: read ended info failed.", __func__); - return HDF_FAILURE; - } - std::shared_ptr captureEndedInfo = std::make_shared(); - captureEndedInfo->streamId_ = pInfo->streamId_; - captureEndedInfo->frameCount_ = pInfo->frameCount_; - info.push_back(captureEndedInfo); - } - OnCaptureEnded(captureId, info); - - return HDF_SUCCESS; -} - -int32_t StreamOperatorCallbackStub::OnCaptureErrorStub(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - if (data.ReadInterfaceToken() != StreamOperatorCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t captureId = data.ReadInt32(); - int32_t count = data.ReadInt32(); - std::vector> info; - for (int32_t i = 0; i < count; i++) { - const CaptureErrorInfo *pInfo = - reinterpret_cast( - data.ReadBuffer(sizeof(CaptureErrorInfo))); - if (pInfo == nullptr) { - HDF_LOGE("%{public}s: read error info failed.", __func__); - return HDF_FAILURE; - } - std::shared_ptr captureErrorInfo = std::make_shared(); - captureErrorInfo->streamId_ = pInfo->streamId_; - captureErrorInfo->error_ = pInfo->error_; - info.push_back(captureErrorInfo); - } - - OnCaptureError(captureId, info); - return HDF_SUCCESS; -} - -int32_t StreamOperatorCallbackStub::OnFrameShutterStub(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - if (data.ReadInterfaceToken() != StreamOperatorCallbackStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t captureId = data.ReadInt32(); - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - HDF_LOGE("%{public}s: read streamIds failed.", __func__); - return HDF_FAILURE; - } - uint64_t timestamp = data.ReadUint64(); - OnFrameShutter(captureId, streamIds, timestamp); - - return HDF_SUCCESS; -} -} diff --git a/camera/interfaces/hdi_ipc/camera_host_driver.cpp b/camera/interfaces/hdi_ipc/camera_host_driver.cpp new file mode 100644 index 0000000000..1c7d2d4a23 --- /dev/null +++ b/camera/interfaces/hdi_ipc/camera_host_driver.cpp @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2021 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 +#include +#include +#include +#include "v1_0/camera_host_stub.h" + +using namespace OHOS::HDI::Camera::V1_0; + +struct HdfCameraHostHost { + struct IDeviceIoService ioService; + OHOS::sptr stub; +}; + +static int32_t CameraHostDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + auto *hdfCameraHostHost = CONTAINER_OF(client->device->service, struct HdfCameraHostHost, ioService); + + OHOS::MessageParcel *dataParcel = nullptr; + OHOS::MessageParcel *replyParcel = nullptr; + OHOS::MessageOption option; + + if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + + return hdfCameraHostHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); +} + +static int HdfCameraHostDriverInit(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfCameraHostDriverInit enter"); + (void)deviceObject; + return HDF_SUCCESS; +} + +static int HdfCameraHostDriverBind(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfCameraHostDriverBind enter"); + + auto *hdfCameraHostHost = new (std::nothrow) HdfCameraHostHost; + if (hdfCameraHostHost == nullptr) { + HDF_LOGE("%{public}s: failed to create create HdfCameraHostHost object", __func__); + return HDF_FAILURE; + } + + hdfCameraHostHost->ioService.Dispatch = CameraHostDriverDispatch; + hdfCameraHostHost->ioService.Open = NULL; + hdfCameraHostHost->ioService.Release = NULL; + + auto serviceImpl = ICameraHost::Get(true); + if (serviceImpl == nullptr) { + HDF_LOGE("%{public}s: failed to get of implement service", __func__); + delete hdfCameraHostHost; + return HDF_FAILURE; + } + + hdfCameraHostHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, + ICameraHost::GetDescriptor()); + if (hdfCameraHostHost->stub == nullptr) { + HDF_LOGE("%{public}s: failed to get stub object", __func__); + delete hdfCameraHostHost; + return HDF_FAILURE; + } + + deviceObject->service = &hdfCameraHostHost->ioService; + return HDF_SUCCESS; +} + +static void HdfCameraHostDriverRelease(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfCameraHostDriverRelease enter"); + if (deviceObject->service == nullptr) { + HDF_LOGE("HdfCameraHostDriverRelease not initted"); + return; + } + + auto *hdfCameraHostHost = CONTAINER_OF(deviceObject->service, struct HdfCameraHostHost, ioService); + delete hdfCameraHostHost; +} + +static struct HdfDriverEntry g_camerahostDriverEntry = { + .moduleVersion = 1, + .moduleName = "camera_service", + .Bind = HdfCameraHostDriverBind, + .Init = HdfCameraHostDriverInit, + .Release = HdfCameraHostDriverRelease, +}; + +#ifndef __cplusplus +extern "C" { +#endif +HDF_INIT(g_camerahostDriverEntry); +#ifndef __cplusplus +} +#endif diff --git a/camera/interfaces/hdi_ipc/client/BUILD.gn b/camera/interfaces/hdi_ipc/client/BUILD.gn deleted file mode 100644 index 2a7433781b..0000000000 --- a/camera/interfaces/hdi_ipc/client/BUILD.gn +++ /dev/null @@ -1,87 +0,0 @@ -# Copyright (c) 2021 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. - -import("//build/ohos.gni") -import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") -group("camera_client") { - deps = [ ":libcamera_client" ] -} - -config("libcamera_client_config") { - visibility = [ ":*" ] - - include_dirs = [ - "//drivers/peripheral/camera/interfaces/include", - "//drivers/peripheral/camera/interfaces/hdi_ipc", - "//drivers/peripheral/camera/interfaces/hdi_ipc/utils/include", - "//drivers/peripheral/camera/interfaces/hdi_ipc/callback/device/include", - "//drivers/peripheral/camera/interfaces/hdi_ipc/callback/operator/include", - "//drivers/peripheral/camera/interfaces/hdi_ipc/callback/host/include", - ] -} - -if (defined(ohos_lite)) { - group("libcamera_client") { - deps = [] - public_configs = [] - } -} else { - ohos_shared_library("libcamera_client") { - include_dirs = [ - "../", - "../server/include", - "./include", - "../../include", - "../utils/include", - "../callback/device/include", - "../callback/host/include", - "../callback/operator/include", - "//drivers/peripheral/camera/interfaces/metadata/include", - ] - public_configs = [ ":libcamera_client_config" ] - - sources = [ - "../callback/device/src/camera_device_callback.cpp", - "../callback/device/src/camera_device_callback_stub.cpp", - "../callback/host/src/camera_host_callback.cpp", - "../callback/host/src/camera_host_callback_stub.cpp", - "../callback/operator/src/stream_operator_callback.cpp", - "../callback/operator/src/stream_operator_callback_stub.cpp", - "../utils/src/utils_data_stub.cpp", - "./src/camera_device_proxy.cpp", - "./src/camera_host_proxy.cpp", - "./src/offline_stream_operator_proxy.cpp", - "./src/stream_operator_proxy.cpp", - ] - - deps = [ "//drivers/peripheral/camera/interfaces/metadata:metadata" ] - - if (is_standard_system) { - external_deps = [ - "graphic_chipsetsdk:surface", - "hdf_core:libhdf_ipc_adapter", - "hdf_core:libhdf_utils", - "hdf_core:libhdi", - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_single", - "utils_base:utils", - ] - } else { - external_deps = [ "hilog:libhilog" ] - } - - install_images = [ chipset_base_dir ] - subsystem_name = "hdf" - part_name = "drivers_peripheral_camera" - } -} diff --git a/camera/interfaces/hdi_ipc/client/include/camera_device_proxy.h b/camera/interfaces/hdi_ipc/client/include/camera_device_proxy.h deleted file mode 100644 index 339b2b54cc..0000000000 --- a/camera/interfaces/hdi_ipc/client/include/camera_device_proxy.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_CAMERA_DEVICE_CLIENT_PROXY_H -#define HDI_CAMERA_DEVICE_CLIENT_PROXY_H - -#include -#include "icamera_device.h" -#include "istream_operator_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class CameraDeviceProxy : public IRemoteProxy { -public: - explicit CameraDeviceProxy(const sptr& impl) : IRemoteProxy(impl) {} - virtual ~CameraDeviceProxy() = default; - - CamRetCode GetStreamOperator( - const OHOS::sptr &callback, - OHOS::sptr &streamOperator) override; - CamRetCode UpdateSettings(const std::shared_ptr &settings) override; - CamRetCode SetResultMode(const ResultCallbackMode &mode) override; - CamRetCode GetEnabledResults(std::vector &results) override; - CamRetCode EnableResult(const std::vector &results) override; - CamRetCode DisableResult(const std::vector &results) override; - void Close() override; - -private: - static inline BrokerDelegator delegator_; -}; -} -#endif // HDI_CAMERA_DEVICE_CLIENT_PROXY_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/client/include/camera_host_proxy.h b/camera/interfaces/hdi_ipc/client/include/camera_host_proxy.h deleted file mode 100644 index 97dd7f63a8..0000000000 --- a/camera/interfaces/hdi_ipc/client/include/camera_host_proxy.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_CAMERA_HOST_CLIENT_PROXY_H -#define HDI_CAMERA_HOST_CLIENT_PROXY_H - -#include -#include "icamera_host.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class ICameraHostCallback; -class CameraHostProxy : public IRemoteProxy { -public: - explicit CameraHostProxy(const sptr& impl) : IRemoteProxy(impl) {} - virtual ~CameraHostProxy() {} - - CamRetCode SetCallback(const OHOS::sptr &callback) override; - CamRetCode GetCameraIds(std::vector &cameraIds) override; - CamRetCode GetCameraAbility(const std::string &cameraId, - std::shared_ptr &ability) override; - CamRetCode OpenCamera(const std::string &cameraId, - const OHOS::sptr &callback, - OHOS::sptr &pDevice) override; - CamRetCode SetFlashlight(const std::string &cameraId, bool &isEnable) override; - -private: - static inline BrokerDelegator delegator_; -}; -} -#endif // HDI_CAMERA_HOST_CLIENT_PROXY_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/client/include/offline_stream_operator_proxy.h b/camera/interfaces/hdi_ipc/client/include/offline_stream_operator_proxy.h deleted file mode 100644 index b5ac475c75..0000000000 --- a/camera/interfaces/hdi_ipc/client/include/offline_stream_operator_proxy.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_OFFLINE_STREAM_OPERATOR_CLIENT_PROXY_H -#define HDI_OFFLINE_STREAM_OPERATOR_CLIENT_PROXY_H - -#include -#include "ioffline_stream_operator.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class OfflineStreamOperatorProxy : public IRemoteProxy { -public: - explicit OfflineStreamOperatorProxy(const sptr& impl) - : IRemoteProxy(impl) {} - virtual ~OfflineStreamOperatorProxy() {} - - CamRetCode CancelCapture(int captureId) override; - CamRetCode ReleaseStreams(const std::vector &streamIds) override; - CamRetCode Release() override; - -private: - static inline BrokerDelegator delegator_; -}; -} -#endif // HDI_OFFLINE_STREAM_OPERATOR_CLIENT_PROXY_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/client/include/stream_operator_proxy.h b/camera/interfaces/hdi_ipc/client/include/stream_operator_proxy.h deleted file mode 100644 index bdaf55891d..0000000000 --- a/camera/interfaces/hdi_ipc/client/include/stream_operator_proxy.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_STREAM_OPERATOR_CLIENT_PROXY_H -#define HDI_STREAM_OPERATOR_CLIENT_PROXY_H - -#include -#include "istream_operator.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class StreamOperatorProxy : public IRemoteProxy { -public: - explicit StreamOperatorProxy(const sptr& impl) : IRemoteProxy(impl) {} - virtual ~StreamOperatorProxy() = default; - - CamRetCode IsStreamsSupported( - OperationMode mode, - const std::shared_ptr &modeSetting, - const std::vector>& pInfo, - StreamSupportType &pType) override; - CamRetCode CreateStreams( - const std::vector> &streamInfos) override; - CamRetCode ReleaseStreams(const std::vector &streamIds) override; - CamRetCode CommitStreams(OperationMode mode, - const std::shared_ptr &modeSetting) override; - CamRetCode GetStreamAttributes( - std::vector> &attributes) override; - CamRetCode AttachBufferQueue(int streamId, - const OHOS::sptr &producer) override; - CamRetCode DetachBufferQueue(int streamId) override; - CamRetCode Capture(int captureId, - const std::shared_ptr &pInfo, bool isStreaming) override; - CamRetCode CancelCapture(int captureId) override; - CamRetCode ChangeToOfflineStream(const std::vector &streamIds, - OHOS::sptr &callback, - OHOS::sptr &offlineOperator) override; - -private: - static inline BrokerDelegator delegator_; -}; -} -#endif // HDI_STREAM_OPERATOR_CLIENT_PROXY_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/client/src/camera_device_proxy.cpp b/camera/interfaces/hdi_ipc/client/src/camera_device_proxy.cpp deleted file mode 100644 index bbc7347137..0000000000 --- a/camera/interfaces/hdi_ipc/client/src/camera_device_proxy.cpp +++ /dev/null @@ -1,215 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_device_proxy.h" -#include -#include -#include -#include "metadata_utils.h" -#include "istream_operator.h" -#include "istream_operator_callback.h" - -namespace OHOS::Camera { -CamRetCode CameraDeviceProxy::GetStreamOperator( - const OHOS::sptr &callback, - OHOS::sptr &streamOperator) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - bool nullFlag = (callback != nullptr); - if (!data.WriteBool(nullFlag)) { - HDF_LOGE("%s: stream operator callback flag write failed!", __func__); - return INVALID_ARGUMENT; - } - - if (nullFlag && !data.WriteRemoteObject(callback->AsObject())) { - HDF_LOGE("%s: write stream operator failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_GET_STREAM_OPERATOR, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - CamRetCode retCode = static_cast(reply.ReadInt32()); - bool flag = reply.ReadBool(); - if (flag) { - sptr remoteStreamOperator = reply.ReadRemoteObject(); - streamOperator = OHOS::iface_cast(remoteStreamOperator); - } - - return retCode; -} - -CamRetCode CameraDeviceProxy::UpdateSettings(const std::shared_ptr &settings) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - bool bRet = MetadataUtils::EncodeCameraMetadata(settings, data); - if (!bRet) { - HDF_LOGE("%s: write metadata failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_UPDATE_SETTINGS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode CameraDeviceProxy::SetResultMode(const ResultCallbackMode &mode) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteInt32(static_cast(mode))) { - HDF_LOGE("%s: write result callback mode failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_SET_RESULT_MODE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode CameraDeviceProxy::GetEnabledResults(std::vector &results) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_GET_ENABLED_RESULTS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - CamRetCode retCode = static_cast(reply.ReadInt32()); - if (!reply.ReadInt32Vector(&results)) { - HDF_LOGE("%s: read results failed", __func__); - return INVALID_ARGUMENT; - } - - return retCode; -} - -CamRetCode CameraDeviceProxy::EnableResult(const std::vector &results) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteInt32Vector(results)) { - HDF_LOGE("%s: write results failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_ENABLE_RESULT, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode CameraDeviceProxy::DisableResult(const std::vector &results) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteInt32Vector(results)) { - HDF_LOGE("%s: write results failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_DISABLE_RESULT, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -void CameraDeviceProxy::Close() -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraDeviceProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_DEVICE_CLOSE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - } -} -} \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/client/src/camera_host_proxy.cpp b/camera/interfaces/hdi_ipc/client/src/camera_host_proxy.cpp deleted file mode 100644 index 43844527f0..0000000000 --- a/camera/interfaces/hdi_ipc/client/src/camera_host_proxy.cpp +++ /dev/null @@ -1,215 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_host_proxy.h" -#include -#include -#include -#include "utils_data_stub.h" -#include "metadata_utils.h" -#include "icamera_device.h" -#include "icamera_host_callback.h" -#include "icamera_device_callback.h" - -namespace OHOS::Camera { -sptr ICameraHost::Get(const char *serviceName) -{ - do { - using namespace OHOS::HDI::ServiceManager::V1_0; - auto servMgr = IServiceManager::Get(); - if (servMgr == nullptr) { - HDF_LOGE("%s: IServiceManager failed!", __func__); - break; - } - - auto remote = servMgr->GetService(serviceName); - if (remote != nullptr) { - sptr hostSptr = iface_cast(remote); - return hostSptr; - } - HDF_LOGE("%s: GetService failed! serviceName = %s", __func__, serviceName); - } while (false); - - HDF_LOGE("%s: get %s failed!", __func__, serviceName); - return nullptr; -} - -CamRetCode CameraHostProxy::SetCallback(const OHOS::sptr &callback) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - bool callbackFlag = (callback != nullptr); - if (!data.WriteBool(callbackFlag)) { - HDF_LOGE("%s: set callback flag failed!", __func__); - return INVALID_ARGUMENT; - } - - if (callbackFlag && !data.WriteRemoteObject(callback->AsObject())) { - HDF_LOGE("%s: set callback write remote obj failed!", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_SET_CALLBACK, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode CameraHostProxy::GetCameraIds(std::vector &cameraIds) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_GET_CAMERAID, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - CamRetCode retCode = static_cast(reply.ReadInt32()); - - if (!reply.ReadStringVector(&cameraIds)) { - HDF_LOGE("%{public}s: read cameraids failed.", __func__); - return INVALID_ARGUMENT; - } - - return retCode; -} - -CamRetCode CameraHostProxy::GetCameraAbility(const std::string &cameraId, - std::shared_ptr &ability) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteString(cameraId)) { - HDF_LOGE("%{public}s: write cameraId failed!", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_CAMERA_HOST_GET_CAMERA_ABILITY, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - CamRetCode retCode = static_cast(reply.ReadInt32()); - MetadataUtils::DecodeCameraMetadata(reply, ability); - - return retCode; -} - -CamRetCode CameraHostProxy::OpenCamera(const std::string &cameraId, - const OHOS::sptr &callback, - OHOS::sptr &pDevice) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteString(cameraId)) { - HDF_LOGE("%{public}s: write cameraId failed!", __func__); - return INVALID_ARGUMENT; - } - - bool callbackFlag = (callback != nullptr); - if (!data.WriteBool(callbackFlag)) { - HDF_LOGE("%s: write camera callback flag failed", __func__); - return INVALID_ARGUMENT; - } - - if (callbackFlag && !data.WriteRemoteObject(callback->AsObject())) { - HDF_LOGE("%s: write camera device callback failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_OPEN_CAMERA, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - CamRetCode retCode = static_cast(reply.ReadInt32()); - bool flag = reply.ReadBool(); - if (flag) { - sptr remoteCameraDevice = reply.ReadRemoteObject(); - if (remoteCameraDevice == nullptr) { - HDF_LOGE("%{public}s: CameraHostProxy remoteCameraDevice is null", __func__); - return INVALID_ARGUMENT; - } - pDevice = OHOS::iface_cast(remoteCameraDevice); - } - - return retCode; -} - -CamRetCode CameraHostProxy::SetFlashlight(const std::string &cameraId, bool &isEnable) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(CameraHostProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteString(cameraId)) { - HDF_LOGE("%{public}s: write cameraId failed!", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteBool(isEnable)) { - HDF_LOGE("%{public}s: write isEnable failed!", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_SET_FLASH_LIGHT, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} -} \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/client/src/offline_stream_operator_proxy.cpp b/camera/interfaces/hdi_ipc/client/src/offline_stream_operator_proxy.cpp deleted file mode 100644 index 72b46c2bc1..0000000000 --- a/camera/interfaces/hdi_ipc/client/src/offline_stream_operator_proxy.cpp +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (c) 2021 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 "offline_stream_operator_proxy.h" -#include -#include -#include - -namespace OHOS::Camera { -CamRetCode OfflineStreamOperatorProxy::CancelCapture(int captureId) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(OfflineStreamOperatorProxy::GetDescriptor()) || - !data.WriteInt32(static_cast(captureId))) { - HDF_LOGE("%s: write captureId obj failed!", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest(CMD_OFFLINE_STREAM_OPERATOR_CANCEL_CAPTURE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - int32_t result = reply.ReadInt32(); - HDF_LOGE("%s: CameraHostProxy::return entry! result = %d", __func__, result); - - return static_cast(result); -} - -CamRetCode OfflineStreamOperatorProxy::ReleaseStreams(const std::vector &streamIds) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - std::vector pxyStreamIds = streamIds; - if (!data.WriteInterfaceToken(OfflineStreamOperatorProxy::GetDescriptor()) || - !data.WriteInt32Vector(pxyStreamIds)) { - HDF_LOGE("%s: write streamIds obj failed!", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest(CMD_OFFLINE_STREAM_OPERATOR_RELEASE_STREAMS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - int32_t result = reply.ReadInt32(); - HDF_LOGE("%s: CameraHostProxy::return entry! result = %d", __func__, result); - - return static_cast(result); -} - -CamRetCode OfflineStreamOperatorProxy::Release() -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!data.WriteInterfaceToken(OfflineStreamOperatorProxy::GetDescriptor())) { - return INVALID_ARGUMENT; - } - int32_t ret = Remote()->SendRequest(CMD_OFFLINE_STREAM_OPERATOR_RELEASE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - int32_t result = reply.ReadInt32(); - HDF_LOGE("%s: CameraHostProxy::return entry! result = %d", __func__, result); - - return static_cast(result); -} -} \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/client/src/stream_operator_proxy.cpp b/camera/interfaces/hdi_ipc/client/src/stream_operator_proxy.cpp deleted file mode 100644 index 699469ce13..0000000000 --- a/camera/interfaces/hdi_ipc/client/src/stream_operator_proxy.cpp +++ /dev/null @@ -1,407 +0,0 @@ -/* - * Copyright (c) 2021 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 "stream_operator_proxy.h" -#include -#include -#include -#include -#include "istream_operator_callback.h" -#include "ioffline_stream_operator.h" -#include "camera_metadata_info.h" -#include "utils_data_stub.h" -#include "metadata_utils.h" - -namespace OHOS::Camera { -CamRetCode StreamOperatorProxy::IsStreamsSupported( - OperationMode mode, - const std::shared_ptr &modeSetting, - const std::vector> &pInfo, - StreamSupportType &pType) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - // stub operation mode - if (!data.WriteInt32(mode)) { - HDF_LOGE("%s: write operation mode failed", __func__); - return INVALID_ARGUMENT; - } - - bool nullFlag = (modeSetting != nullptr); - if (!data.WriteBool(nullFlag)) { - HDF_LOGE("%s: write mode nullflag failed", __func__); - return INVALID_ARGUMENT; - } - - // stub metadata - if (nullFlag && !MetadataUtils::EncodeCameraMetadata(modeSetting, data)) { - HDF_LOGE("%s: write metadata failed", __func__); - return INVALID_ARGUMENT; - } - - size_t count = pInfo.size(); - if (!data.WriteInt32(static_cast(count))) { - HDF_LOGE("%s: write pInfo count failed", __func__); - return INVALID_ARGUMENT; - } - - bool bRet = true; - for (size_t i = 0; i < count; i++) { - std::shared_ptr streamInfo = pInfo.at(i); - bRet = UtilsDataStub::EncodeStreamInfo(streamInfo, data); - if (!bRet) { - HDF_LOGE("%s: write streamInfo failed. index = %zu", __func__, i); - return INVALID_ARGUMENT; - } - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_IS_STREAMS_SUPPORTED, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - CamRetCode retCode = static_cast(reply.ReadInt32()); - pType = static_cast(reply.ReadInt32()); - - return retCode; -} - -CamRetCode StreamOperatorProxy::CreateStreams( - const std::vector> &streamInfos) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - size_t count = streamInfos.size(); - if (!data.WriteInt32(static_cast(count))) { - HDF_LOGE("%s: write streamInfos count failed", __func__); - return INVALID_ARGUMENT; - } - - bool bRet = true; - for (size_t i = 0; i < count; i++) { - std::shared_ptr streamInfo = streamInfos.at(i); - bRet = UtilsDataStub::EncodeStreamInfo(streamInfo, data); - if (!bRet) { - HDF_LOGE("%s: write streamInfo failed. index = %zu", __func__, i); - return INVALID_ARGUMENT; - } - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CREATE_STREAMS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode StreamOperatorProxy::ReleaseStreams(const std::vector &streamIds) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - std::vector pxyStreamIds = streamIds; - if (!data.WriteInt32Vector(pxyStreamIds)) { - HDF_LOGE("%s: write streamIds failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_RELEASE_STREAMS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode StreamOperatorProxy::CommitStreams(OperationMode mode, - const std::shared_ptr &modeSetting) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteInt32(mode)) { - HDF_LOGE("%s: write operation mode failed", __func__); - return INVALID_ARGUMENT; - } - - bool bRet = MetadataUtils::EncodeCameraMetadata(modeSetting, data); - if (!bRet) { - HDF_LOGE("%s: write metadata failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_COMMIT_STREAMS, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode StreamOperatorProxy::GetStreamAttributes( - std::vector> &attributes) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_GET_STREAM_ATTRIBUTES, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - int32_t retCode = reply.ReadInt32(); - int32_t count = reply.ReadInt32(); - for (int i = 0; i < count; i++) { - const uint8_t *buffer = data.ReadBuffer(sizeof(StreamAttribute)); - std::shared_ptr attribute = std::make_shared(); - if (memcpy_s(attribute.get(), sizeof(StreamAttribute), buffer, sizeof(StreamAttribute)) != EOK) { - return INVALID_ARGUMENT; - } - attributes.push_back(attribute); - } - - return static_cast(retCode); -} - -CamRetCode StreamOperatorProxy::AttachBufferQueue(int streamId, const OHOS::sptr &producer) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (producer == nullptr) { - HDF_LOGE("%s: producer is NULL", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteInt32(static_cast(streamId))) { - HDF_LOGE("%s: write streamId failed", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteRemoteObject(producer->AsObject())) { - HDF_LOGE("%s: write buffer producer failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_ATTACH_BUFFER_QUEUE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode StreamOperatorProxy::DetachBufferQueue(int streamId) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteInt32(static_cast(streamId))) { - HDF_LOGE("%s: write streamId failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_DETACH_BUFFER_QUEUE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode StreamOperatorProxy::Capture(int captureId, - const std::shared_ptr &pInfo, bool isStreaming) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (pInfo == nullptr) { - return INVALID_ARGUMENT; - } - - // stub captureId - if (!data.WriteInt32(static_cast(captureId))) { - HDF_LOGE("%s: write captureId failed", __func__); - return INVALID_ARGUMENT; - } - - // stub CaptureInfo - std::vector pxyStreamIds = pInfo->streamIds_; - if (!data.WriteInt32Vector(pxyStreamIds)) { - HDF_LOGE("%s: write streamIds failed", __func__); - return INVALID_ARGUMENT; - } - - bool bRet = MetadataUtils::EncodeCameraMetadata(pInfo->captureSetting_, data); - if (!bRet) { - HDF_LOGE("%s: write metadata failed", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteBool(pInfo->enableShutterCallback_)) { - HDF_LOGE("%s: write enableShutterCallback_ failed", __func__); - return INVALID_ARGUMENT; - } - - // stub isStreaming - if (!data.WriteBool(isStreaming)) { - HDF_LOGE("%s: write isStreaming failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CAPTURE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode StreamOperatorProxy::CancelCapture(int captureId) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteInt32(static_cast(captureId))) { - HDF_LOGE("%s: write captureId failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CANCEL_CAPTURE, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - return static_cast(reply.ReadInt32()); -} - -CamRetCode StreamOperatorProxy::ChangeToOfflineStream( - const std::vector &streamIds, - OHOS::sptr &callback, - OHOS::sptr &offlineOperator) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(StreamOperatorProxy::GetDescriptor())) { - HDF_LOGE("%{public}s: write interface descriptor failed.", __func__); - return INVALID_ARGUMENT; - } - - if (callback == nullptr) { - return INVALID_ARGUMENT; - } - - std::vector pxyStreamIds = streamIds; - if (!data.WriteInt32Vector(pxyStreamIds)) { - HDF_LOGE("%s: write streamIds failed", __func__); - return INVALID_ARGUMENT; - } - - if (!data.WriteRemoteObject(callback->AsObject())) { - HDF_LOGE("%s: write offline stream operator callback failed", __func__); - return INVALID_ARGUMENT; - } - - int32_t ret = Remote()->SendRequest( - CMD_STREAM_OPERATOR_CHANGE_TO_OFFLINE_STREAM, data, reply, option); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret); - return INVALID_ARGUMENT; - } - - CamRetCode retCode = static_cast(reply.ReadInt32()); - sptr remoteObj = reply.ReadRemoteObject(); - offlineOperator = OHOS::iface_cast(remoteObj); - - return retCode; -} -} diff --git a/camera/interfaces/hdi_ipc/server/include/camera_device_stub.h b/camera/interfaces/hdi_ipc/server/include/camera_device_stub.h deleted file mode 100644 index b67fcb5406..0000000000 --- a/camera/interfaces/hdi_ipc/server/include/camera_device_stub.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_CAMERA_DEVICE_SERVICE_STUB_INF_H -#define HDI_CAMERA_DEVICE_SERVICE_STUB_INF_H - -#include -#include -#include -#include "iremote_stub.h" -#include "icamera_device.h" -#include "camera.h" - -namespace OHOS::Camera { -class CameraDeviceStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) override; - - int32_t CameraDeviceStubGetStreamOperator(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraDeviceStubUpdateSettings(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraDeviceStubSetResultMode(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraDeviceStubGetEnabledReuslts(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraDeviceStubEnableResult(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraDeviceStubDisableResult(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraDeviceStubClose(MessageParcel& data, MessageParcel& reply, MessageOption& option); -}; -} -#endif // HDI_CAMERA_DEVICE_SERVICE_STUB_INF_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/server/include/camera_host_stub.h b/camera/interfaces/hdi_ipc/server/include/camera_host_stub.h deleted file mode 100644 index bbf55ec77d..0000000000 --- a/camera/interfaces/hdi_ipc/server/include/camera_host_stub.h +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_CAMERA_HOST_SERVICE_STUB_INF_H -#define HDI_CAMERA_HOST_SERVICE_STUB_INF_H - -#include -#include -#include -#include "icamera_host_callback.h" -#include "icamera_device_callback.h" -#include "camera_host.h" -#include "types.h" -#include "camera.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -class CameraHostStub { -public: - CameraHostStub(); - virtual ~CameraHostStub() {} - RetCode Init(); - int32_t CameraHostStubSetCallback(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraHostStubGetCameraIds(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraHostStubGetCameraAbility(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraHostStubOpenCamera(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t CameraHostStubSetFlashlight(MessageParcel& data, MessageParcel& reply, MessageOption& option); - static inline const std::u16string metaDescriptor_ = u"HDI.Camera.V1_0.Host"; - static inline const std::u16string &GetDescriptor() - { - return metaDescriptor_; - } - - int32_t CameraHostServiceStubOnRemoteRequest(int cmdId, - MessageParcel& data, MessageParcel& reply, MessageOption& option); - -private: - std::shared_ptr cameraHost_ = nullptr; -}; -} - -void *CameraHostStubInstance(void); - -void DestroyCameraHostStub(void *obj); - -int32_t CameraHostServiceOnRemoteRequest(void *stub, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply); - -#endif // HDI_CAMERA_HOST_SERVICE_STUB_INF_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/server/include/offline_stream_operator_stub.h b/camera/interfaces/hdi_ipc/server/include/offline_stream_operator_stub.h deleted file mode 100644 index 9c72093702..0000000000 --- a/camera/interfaces/hdi_ipc/server/include/offline_stream_operator_stub.h +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_OFFLINE_STREAM_OPERATOR_SERVICE_STUB_INF_H -#define HDI_OFFLINE_STREAM_OPERATOR_SERVICE_STUB_INF_H - -#include -#include -#include -#include "iremote_stub.h" -#include "ioffline_stream_operator.h" -#include "camera.h" - -namespace OHOS::Camera { -class OfflineStreamOperatorStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, - MessageParcel &data, MessageParcel &reply, MessageOption &option) override; - - int32_t OfflineStreamOperatorStubCancelCapture(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t OfflineStreamOperatorStubReleaseStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t OfflineStreamOperatorStubRelease(MessageParcel &data, MessageParcel &reply, MessageOption &option); -}; -} -#endif // HDI_OFFLINE_STREAM_OPERATOR_SERVICE_STUB_INF_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/server/include/stream_operator_stub.h b/camera/interfaces/hdi_ipc/server/include/stream_operator_stub.h deleted file mode 100644 index 80ec6dc87e..0000000000 --- a/camera/interfaces/hdi_ipc/server/include/stream_operator_stub.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_STREAM_OPERATOR_SERVICE_STUB_INF_H -#define HDI_STREAM_OPERATOR_SERVICE_STUB_INF_H - -#include -#include -#include -#include "iremote_stub.h" -#include "istream_operator.h" -#include "camera.h" - -namespace OHOS::Camera { -class StreamOperatorStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) override; - - int32_t StreamOperatorStubIsStreamsSupported(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubCreateStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubReleaseStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubCommitStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubGetStreamAttributes(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubAttachBufferQueue(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubDetachBufferQueue(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubCapture(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubCancelCapture(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t StreamOperatorStubChangeToOfflineStream(MessageParcel &data, MessageParcel &reply, MessageOption &option); - - std::shared_ptr pInfo_ = nullptr; - std::mutex metaDatalock_; -}; -} -#endif // HDI_STREAM_OPERATOR_SERVICE_STUB_INF_H \ No newline at end of file diff --git a/camera/interfaces/hdi_ipc/server/src/camera_device_stub.cpp b/camera/interfaces/hdi_ipc/server/src/camera_device_stub.cpp deleted file mode 100644 index 53c3c6e23f..0000000000 --- a/camera/interfaces/hdi_ipc/server/src/camera_device_stub.cpp +++ /dev/null @@ -1,243 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_device_stub.h" -#include -#include -#include -#include "metadata_utils.h" -#include "istream_operator.h" -#include "istream_operator_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -int32_t CameraDeviceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HDF_LOGE("%s: CameraDeviceStub::OnRemoteRequest entry!", __func__); - int32_t ret = HDF_SUCCESS; - switch (code) { - case CMD_CAMERA_DEVICE_GET_STREAM_OPERATOR: { - ret = CameraDeviceStubGetStreamOperator(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_UPDATE_SETTINGS: { - ret = CameraDeviceStubUpdateSettings(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_SET_RESULT_MODE: { - ret = CameraDeviceStubSetResultMode(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_GET_ENABLED_RESULTS: { - ret = CameraDeviceStubGetEnabledReuslts(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_ENABLE_RESULT: { - ret = CameraDeviceStubEnableResult(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_DISABLE_RESULT: { - ret = CameraDeviceStubDisableResult(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_CLOSE: { - ret = CameraDeviceStubClose(data, reply, option); - break; - } - default: { - ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return ret; -} - -int32_t CameraDeviceStub::CameraDeviceStubGetStreamOperator( - MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraDeviceStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - sptr spStreamOperatorCallback = nullptr; - bool flag = data.ReadBool(); - if (flag) { - sptr remoteObj = data.ReadRemoteObject(); - spStreamOperatorCallback = OHOS::iface_cast(remoteObj); - if (spStreamOperatorCallback == nullptr) { - HDF_LOGE("%s: read operator callback failed", __func__); - return HDF_FAILURE; - } - } - - OHOS::sptr streamOperator = nullptr; - CamRetCode ret = GetStreamOperator(spStreamOperatorCallback, streamOperator); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: get stream operator failed", __func__); - return HDF_FAILURE; - } - - bool nullFlag = (streamOperator != nullptr); - if (!reply.WriteBool(nullFlag)) { - HDF_LOGE("%s: stream operator flag write failed!", __func__); - return INVALID_ARGUMENT; - } - - if (nullFlag && !reply.WriteRemoteObject(streamOperator->AsObject())) { - HDF_LOGE("%s: write stream operator failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraDeviceStub::CameraDeviceStubUpdateSettings( - MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraDeviceStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::shared_ptr metadata = nullptr; - MetadataUtils::DecodeCameraMetadata(data, metadata); - - CamRetCode ret = UpdateSettings(metadata); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: get stream operator failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraDeviceStub::CameraDeviceStubSetResultMode( - MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraDeviceStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - ResultCallbackMode mode = static_cast(data.ReadInt32()); - CamRetCode ret = SetResultMode(mode); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraDeviceStub::CameraDeviceStubGetEnabledReuslts( - MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraDeviceStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::vector results; - CamRetCode ret = GetEnabledResults(results); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - if (!reply.WriteInt32Vector(results)) { - HDF_LOGE("%s: write results failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraDeviceStub::CameraDeviceStubEnableResult( - MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraDeviceStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::vector results; - if (!data.ReadInt32Vector(&results)) { - HDF_LOGE("%s: read results failed", __func__); - return HDF_FAILURE; - } - - CamRetCode ret = EnableResult(results); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - if (!reply.WriteInt32Vector(results)) { - HDF_LOGE("%s: write results failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraDeviceStub::CameraDeviceStubDisableResult( - MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraDeviceStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::vector results; - if (!data.ReadInt32Vector(&results)) { - HDF_LOGE("%s: read results failed", __func__); - return HDF_FAILURE; - } - - CamRetCode ret = DisableResult(results); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - if (!reply.WriteInt32Vector(results)) { - HDF_LOGE("%s: write results failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraDeviceStub::CameraDeviceStubClose( - MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - (void)reply; - (void)option; - if (data.ReadInterfaceToken() != CameraDeviceStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - Close(); - return HDF_SUCCESS; -} -} diff --git a/camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp b/camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp deleted file mode 100644 index 1d97226c18..0000000000 --- a/camera/interfaces/hdi_ipc/server/src/camera_host_driver.cpp +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright (c) 2021 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 -#include -#include -#include -#include "camera_host_stub.h" - -#ifdef HDF_LOG_TAG -#undef HDF_LOG_TAG -#endif -#define HDF_LOG_TAG camera_service - -struct HdfCameraService { - struct IDeviceIoService ioservice; - void *instance = nullptr; -}; - -static int32_t CameraServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, - struct HdfSBuf *data, struct HdfSBuf *reply) -{ - HdfCameraService *hdfCameraService = CONTAINER_OF(client->device->service, HdfCameraService, ioservice); - return CameraHostServiceOnRemoteRequest(hdfCameraService->instance, cmdId, data, reply); -} - -int HdfCameraHostDriverInit(struct HdfDeviceObject *deviceObject) -{ - (void)deviceObject; - return HDF_SUCCESS; -} - -int HdfCameraHostDriverBind(HdfDeviceObject *deviceObject) -{ - HDF_LOGI("HdfCameraHostDriverBind enter!"); - if (deviceObject == nullptr) { - HDF_LOGE("HdfCameraHostDriverBind: HdfDeviceObject is NULL !"); - return HDF_FAILURE; - } - - HdfCameraService *hdfCameraService = - reinterpret_cast(OsalMemAlloc(sizeof(HdfCameraService))); - if (hdfCameraService == nullptr) { - HDF_LOGE("HdfCameraHostDriverBind OsalMemAlloc HdfCameraService failed!"); - return HDF_FAILURE; - } - - hdfCameraService->ioservice.Dispatch = CameraServiceDispatch; - hdfCameraService->ioservice.Open = nullptr; - hdfCameraService->ioservice.Release = nullptr; - hdfCameraService->instance = CameraHostStubInstance(); - - deviceObject->service = &hdfCameraService->ioservice; - return HDF_SUCCESS; -} - -void HdfCameraHostDriverRelease(HdfDeviceObject *deviceObject) -{ - if (deviceObject == nullptr || deviceObject->service == nullptr) { - HDF_LOGE("%{public}s deviceObject or deviceObject->service is NULL!", __FUNCTION__); - return; - } - HdfCameraService *hdfCameraService = CONTAINER_OF(deviceObject->service, HdfCameraService, ioservice); - if (hdfCameraService == nullptr) { - HDF_LOGE("%{public}s hdfCameraService is NULL!", __FUNCTION__); - return; - } - OsalMemFree(hdfCameraService); -} - -struct HdfDriverEntry g_cameraHostDriverEntry = { - .moduleVersion = 1, - .moduleName = "camera_service", - .Bind = HdfCameraHostDriverBind, - .Init = HdfCameraHostDriverInit, - .Release = HdfCameraHostDriverRelease, -}; - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -HDF_INIT(g_cameraHostDriverEntry); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ diff --git a/camera/interfaces/hdi_ipc/server/src/camera_host_stub.cpp b/camera/interfaces/hdi_ipc/server/src/camera_host_stub.cpp deleted file mode 100644 index 34ecede386..0000000000 --- a/camera/interfaces/hdi_ipc/server/src/camera_host_stub.cpp +++ /dev/null @@ -1,266 +0,0 @@ -/* - * Copyright (c) 2021 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 "camera_host_stub.h" -#include -#include -#include -#include "metadata_utils.h" -#include "icamera_device.h" -#include "icamera_host_callback.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -CameraHostStub::CameraHostStub() -{ -} - -RetCode CameraHostStub::Init() -{ - cameraHost_ = CameraHost::CreateCameraHost(); - if (cameraHost_ == nullptr) { - HDF_LOGE("%s: camera host service start failed", __func__); - return RC_ERROR; - } - return RC_OK; -} - -int32_t CameraHostStub::CameraHostStubSetCallback( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - bool flag = data.ReadBool(); - sptr hostCallback = nullptr; - if (flag) { - sptr remoteObj = data.ReadRemoteObject(); - hostCallback = OHOS::iface_cast(remoteObj); - } - CamRetCode ret = cameraHost_->SetCallback(hostCallback); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraHostStub::CameraHostStubGetCameraIds( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (cameraHost_ == nullptr) { - return HDF_FAILURE; - } - - if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - std::vector cameraIds; - CamRetCode ret = cameraHost_->GetCameraIds(cameraIds); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - if (!reply.WriteStringVector(cameraIds)) { - HDF_LOGE("%s: write cameraIds failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraHostStub::CameraHostStubGetCameraAbility( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - const std::string cameraId = data.ReadString(); - if (cameraId.empty()) { - HDF_LOGE("%s: read input param is empty", __func__); - return HDF_ERR_INVALID_PARAM; - } - - std::shared_ptr ability = nullptr; - CamRetCode ret = cameraHost_->GetCameraAbility(cameraId, ability); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - bool bRet = MetadataUtils::EncodeCameraMetadata(ability, reply); - if (!bRet) { - HDF_LOGE("%s: write ability failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraHostStub::CameraHostStubOpenCamera( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - const std::string cameraId = data.ReadString(); - if (cameraId.empty()) { - HDF_LOGE("%s: read input param is empty", __func__); - return HDF_ERR_INVALID_PARAM; - } - - bool flag = data.ReadBool(); - OHOS::sptr deviceCallback = nullptr; - if (flag) { - OHOS::sptr remoteCallback = data.ReadRemoteObject(); - deviceCallback = OHOS::iface_cast(remoteCallback); - } - - OHOS::sptr cameraDevice = nullptr; - CamRetCode ret = cameraHost_->OpenCamera(cameraId, deviceCallback, cameraDevice); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: get stream operator failed", __func__); - return HDF_FAILURE; - } - - bool deviceFlag = (cameraDevice != nullptr); - if (!reply.WriteBool(deviceFlag)) { - HDF_LOGE("%s: write camera device flag failed", __func__); - return HDF_FAILURE; - } - - if (deviceFlag && !reply.WriteRemoteObject(cameraDevice->AsObject())) { - HDF_LOGE("%s: write camera device failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraHostStub::CameraHostStubSetFlashlight( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - if (cameraHost_ == nullptr) { - HDF_LOGE("%s: camera host is null", __func__); - return HDF_FAILURE; - } - - std::string cameraId = data.ReadString(); - bool isEnable = data.ReadBool(); - CamRetCode ret = cameraHost_->SetFlashlight(cameraId, isEnable); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CameraHostStub::CameraHostServiceStubOnRemoteRequest(int cmdId, MessageParcel &data, - MessageParcel &reply, MessageOption &option) -{ - switch (cmdId) { - case CMD_CAMERA_HOST_SET_CALLBACK: { - return CameraHostStubSetCallback(data, reply, option); - } - case CMD_CAMERA_HOST_GET_CAMERAID: { - return CameraHostStubGetCameraIds(data, reply, option); - } - case CMD_CAMERA_HOST_GET_CAMERA_ABILITY: { - return CameraHostStubGetCameraAbility(data, reply, option); - } - case CMD_CAMERA_HOST_OPEN_CAMERA: { - return CameraHostStubOpenCamera(data, reply, option); - } - case CMD_CAMERA_HOST_SET_FLASH_LIGHT: { - return CameraHostStubSetFlashlight(data, reply, option); - } - default: { - HDF_LOGE("%s: not support cmd %d", __func__, cmdId); - return HDF_ERR_INVALID_PARAM; - } - } - return HDF_SUCCESS; -} -} - -void *CameraHostStubInstance() -{ - OHOS::Camera::CameraHostStub *stub = - new (std::nothrow) OHOS::Camera::CameraHostStub(); - if (stub == nullptr) { - HDF_LOGE("%s: camera host stub create failed.", __func__); - return nullptr; - } - - OHOS::Camera::RetCode ret = stub->Init(); - if (ret != OHOS::Camera::RC_OK) { - delete stub; - stub = nullptr; - return nullptr; - } - - return reinterpret_cast(stub); -} - -void DestroyCameraHostStub(void *stubObj) -{ - delete reinterpret_cast(stubObj); -} - -int32_t CameraHostServiceOnRemoteRequest(void *stub, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) -{ - if (stub == nullptr) { - HDF_LOGE("%s:stub is null", __func__); - return HDF_FAILURE; - } - - OHOS::Camera::CameraHostStub *cameraHostStub = - reinterpret_cast(stub); - OHOS::MessageParcel *dataParcel = nullptr; - OHOS::MessageParcel *replyParcel = nullptr; - - if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { - HDF_LOGE("%s:invalid reply sbuf object to dispatch", __func__); - return HDF_ERR_INVALID_PARAM; - } - - if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { - HDF_LOGE("%s:invalid data sbuf object to dispatch", __func__); - return HDF_ERR_INVALID_PARAM; - } - - OHOS::MessageOption option; - return cameraHostStub->CameraHostServiceStubOnRemoteRequest(cmdId, *dataParcel, *replyParcel, option); -} diff --git a/camera/interfaces/hdi_ipc/server/src/offline_stream_operator_stub.cpp b/camera/interfaces/hdi_ipc/server/src/offline_stream_operator_stub.cpp deleted file mode 100644 index 575e345b96..0000000000 --- a/camera/interfaces/hdi_ipc/server/src/offline_stream_operator_stub.cpp +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright (c) 2021 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 "offline_stream_operator_stub.h" -#include -#include -#include -#include "cmd_common.h" - -namespace OHOS::Camera { -int32_t OfflineStreamOperatorStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HDF_LOGE("%s: CameraDeviceStub::OnRemoteRequest entry!", __func__); - (void)option; - int32_t ret = HDF_SUCCESS; - switch (code) { - case CMD_OFFLINE_STREAM_OPERATOR_CANCEL_CAPTURE: { - if (data.ReadInterfaceToken() != OfflineStreamOperatorStub::GetDescriptor()) { - ret = HDF_ERR_INVALID_PARAM; - break; - } - ret = OfflineStreamOperatorStubCancelCapture(data, reply, option); - break; - } - case CMD_OFFLINE_STREAM_OPERATOR_RELEASE_STREAMS: { - if (data.ReadInterfaceToken() != OfflineStreamOperatorStub::GetDescriptor()) { - ret = HDF_ERR_INVALID_PARAM; - break; - } - ret = OfflineStreamOperatorStubReleaseStreams(data, reply, option); - break; - } - case CMD_OFFLINE_STREAM_OPERATOR_RELEASE: { - if (data.ReadInterfaceToken() != OfflineStreamOperatorStub::GetDescriptor()) { - ret = HDF_ERR_INVALID_PARAM; - break; - } - ret = OfflineStreamOperatorStubRelease(data, reply, option); - break; - } - default: { - ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return ret; -} - -int32_t OfflineStreamOperatorStub::OfflineStreamOperatorStubCancelCapture( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - int32_t captureId = data.ReadInt32(); - CamRetCode ret = CancelCapture(captureId); - if (reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t OfflineStreamOperatorStub::OfflineStreamOperatorStubReleaseStreams( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - HDF_LOGE("%s: read streamIds failed", __func__); - return HDF_FAILURE; - } - - CamRetCode ret = ReleaseStreams(streamIds); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t OfflineStreamOperatorStub::OfflineStreamOperatorStubRelease( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)data; - (void)option; - CamRetCode ret = Release(); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} -} diff --git a/camera/interfaces/hdi_ipc/server/src/stream_operator_stub.cpp b/camera/interfaces/hdi_ipc/server/src/stream_operator_stub.cpp deleted file mode 100644 index 88dbdce963..0000000000 --- a/camera/interfaces/hdi_ipc/server/src/stream_operator_stub.cpp +++ /dev/null @@ -1,366 +0,0 @@ -/* - * Copyright (c) 2021 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 "stream_operator_stub.h" -#include -#include -#include -#include "utils_data_stub.h" -#include "metadata_utils.h" -#include "istream_operator_callback.h" -#include "ioffline_stream_operator.h" -#include "cmd_common.h" - -namespace OHOS::Camera { -int32_t StreamOperatorStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HDF_LOGE("%{public}s: CameraDeviceStub::OnRemoteRequest entry!", __func__); - int32_t ret = HDF_SUCCESS; - switch (code) { - case CMD_STREAM_OPERATOR_IS_STREAMS_SUPPORTED: { - ret = StreamOperatorStubIsStreamsSupported(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CREATE_STREAMS: { - ret = StreamOperatorStubCreateStreams(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_RELEASE_STREAMS: { - ret = StreamOperatorStubReleaseStreams(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_COMMIT_STREAMS: { - ret = StreamOperatorStubCommitStreams(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_GET_STREAM_ATTRIBUTES: { - ret = StreamOperatorStubGetStreamAttributes(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_ATTACH_BUFFER_QUEUE: { - ret = StreamOperatorStubAttachBufferQueue(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_DETACH_BUFFER_QUEUE: { - ret = StreamOperatorStubDetachBufferQueue(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CAPTURE: { - ret = StreamOperatorStubCapture(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CANCEL_CAPTURE: { - ret = StreamOperatorStubCancelCapture(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CHANGE_TO_OFFLINE_STREAM: { - ret = StreamOperatorStubChangeToOfflineStream(data, reply, option); - break; - } - default: { - ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return ret; -} - -int32_t StreamOperatorStub::StreamOperatorStubIsStreamsSupported( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - OperationMode operationMode = static_cast(data.ReadInt32()); - - std::shared_ptr metadata = nullptr; - bool nullFlag = data.ReadBool(); - if (nullFlag) { - MetadataUtils::DecodeCameraMetadata(data, metadata); - } - - int32_t count = data.ReadInt32(); - std::vector> streamInfos; - for (int i = 0; i < count; i++) { - std::shared_ptr streamInfo = std::make_shared(); - UtilsDataStub::DecodeStreamInfo(data, streamInfo); - streamInfos.push_back(streamInfo); - } - - StreamSupportType streamSupportType; - CamRetCode ret = IsStreamsSupported(operationMode, metadata, streamInfos, streamSupportType); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}: write retcode failed", __func__); - return HDF_FAILURE; - } - - if (!reply.WriteInt32(static_cast(streamSupportType))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubCreateStreams( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t count = data.ReadInt32(); - std::vector> streamInfos; - for (int i = 0; i < count; i++) { - std::shared_ptr streamInfo = std::make_shared(); - UtilsDataStub::DecodeStreamInfo(data, streamInfo); - streamInfos.push_back(streamInfo); - } - - CamRetCode ret = CreateStreams(streamInfos); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubReleaseStreams( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - HDF_LOGE("%{public}s: read streamIds failed", __func__); - return HDF_FAILURE; - } - - CamRetCode ret = ReleaseStreams(streamIds); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubCommitStreams( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - OperationMode mode = static_cast(data.ReadInt32()); - - std::shared_ptr metadata = nullptr; - MetadataUtils::DecodeCameraMetadata(data, metadata); - - CamRetCode ret = CommitStreams(mode, metadata); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubGetStreamAttributes( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::vector> attributes; - CamRetCode ret = GetStreamAttributes(attributes); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - size_t count = attributes.size(); - if (!reply.WriteInt32(static_cast(count))) { - HDF_LOGE("%{public}s: write attributes count failed", __func__); - return HDF_FAILURE; - } - - for (size_t i = 0; i < count; i++) { - if (!reply.WriteBuffer((void*)(attributes[i].get()), sizeof(StreamAttribute))) { - HDF_LOGE("%{public}s: write attribute failed. index = %d", __func__, i); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubAttachBufferQueue( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t streamId = data.ReadInt32(); - sptr remoteObj = data.ReadRemoteObject(); - const sptr bufferProducer = - OHOS::iface_cast(remoteObj); - - CamRetCode ret = AttachBufferQueue(streamId, bufferProducer); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubDetachBufferQueue( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t streamId = data.ReadInt32(); - CamRetCode ret = DetachBufferQueue(streamId); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubCapture( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int captureId = static_cast(data.ReadInt32()); - - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - HDF_LOGE("%{public}s: write streamIds failed", __func__); - return HDF_FAILURE; - } - - std::shared_ptr metadata = nullptr; - MetadataUtils::DecodeCameraMetadata(data, metadata); - - bool enableShutterCallback = data.ReadBool(); - std::lock_guard lock(metaDatalock_); - pInfo_ = std::make_shared(); - pInfo_->streamIds_ = streamIds; - pInfo_->captureSetting_ = metadata; - pInfo_->enableShutterCallback_ = enableShutterCallback; - - bool isStreaming = data.ReadBool(); - - CamRetCode ret = Capture(captureId, pInfo_, isStreaming); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubCancelCapture( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - int32_t captureId = data.ReadInt32(); - CamRetCode ret = CancelCapture(captureId); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t StreamOperatorStub::StreamOperatorStubChangeToOfflineStream( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - (void)option; - if (data.ReadInterfaceToken() != StreamOperatorStub::GetDescriptor()) { - HDF_LOGE("%{public}s: invalid interface descriptor.", __func__); - return INVALID_ARGUMENT; - } - - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - HDF_LOGE("%{public}s: read streamIds failed", __func__); - return HDF_FAILURE; - } - - sptr remoteObj = data.ReadRemoteObject(); - sptr spStreamOperatorCallback = - OHOS::iface_cast(remoteObj); - if (spStreamOperatorCallback == nullptr) { - HDF_LOGE("%{public}s: read operator callback failed", __func__); - return HDF_FAILURE; - } - - OHOS::sptr offlineOperator = nullptr; - CamRetCode ret = ChangeToOfflineStream(streamIds, spStreamOperatorCallback, offlineOperator); - if (!reply.WriteInt32(static_cast(ret))) { - HDF_LOGE("%{public}s: write retcode failed", __func__); - return HDF_FAILURE; - } - - if (offlineOperator == nullptr) { - HDF_LOGE("%{public}s, change to offline stream failed, offlineOperator is null.", __func__); - return HDF_FAILURE; - } - - if (!reply.WriteRemoteObject(offlineOperator->AsObject())) { - HDF_LOGE("%{public}s: write offline stream operator failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} -} diff --git a/camera/interfaces/hdi_ipc/utils/include/utils_data_stub.h b/camera/interfaces/hdi_ipc/utils/include/utils_data_stub.h index 2dfec27200..f088d411e8 100644 --- a/camera/interfaces/hdi_ipc/utils/include/utils_data_stub.h +++ b/camera/interfaces/hdi_ipc/utils/include/utils_data_stub.h @@ -21,10 +21,11 @@ #include #include #include -#include "types.h" +#include "v1_0/types.h" #include "camera_metadata_info.h" namespace OHOS::Camera { +using namespace OHOS::HDI::Camera::V1_0; class UtilsDataStub { public: static bool EncodeCameraMetadata(const std::shared_ptr &metadata, @@ -32,11 +33,44 @@ public: static void DecodeCameraMetadata(MessageParcel &data, std::shared_ptr &metadata); static bool EncodeStreamInfo(const std::shared_ptr &pInfo, MessageParcel &parcel); static void DecodeStreamInfo(MessageParcel &parcel, std::shared_ptr &pInfo); + static bool ConvertMetadataToVec(const std::shared_ptr &metadata, + std::vector& cameraAbility); + static void ConvertVecToMetadata(const std::vector& cameraAbility, + std::shared_ptr &metadata); + private: static int32_t GetDataSize(uint8_t type); static bool WriteMetadata(const camera_metadata_item_t &entry, MessageParcel &data); static bool ReadMetadata(camera_metadata_item_t &entry, MessageParcel &data); static void EntryDataToBuffer(const camera_metadata_item_t &entry, void **buffer); + static bool WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector& cameraAbility); + static bool ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry, + const std::vector& cameraAbility); + template static void WriteData(T data, std::vector& cameraAbility); + template static void ReadData(T &data, int32_t &index, const std::vector& cameraAbility); }; + +template +void UtilsDataStub::WriteData(T data, std::vector& cameraAbility) +{ + T dataTemp = data; + uint8_t *dataPtr = (uint8_t *)&dataTemp; + for (size_t j = 0; j < sizeof(T); j++) { + cameraAbility.push_back(*(dataPtr + j)); + } +} + +template +void UtilsDataStub::ReadData(T &data, int32_t &index, const std::vector& cameraAbility) +{ + constexpr uint32_t typeLen = sizeof(T); + uint8_t array[typeLen] = {0}; + T *ptr = nullptr; + for (size_t j = 0; j < sizeof(T); j++) { + array[j] = cameraAbility.at(index++); + } + ptr = (T *)array; + data = *ptr; +} } #endif // HDI_UTILS_DATA_STUB_INF_H diff --git a/camera/interfaces/hdi_ipc/utils/src/utils_data_stub.cpp b/camera/interfaces/hdi_ipc/utils/src/utils_data_stub.cpp index 6c32911733..873cadefdb 100644 --- a/camera/interfaces/hdi_ipc/utils/src/utils_data_stub.cpp +++ b/camera/interfaces/hdi_ipc/utils/src/utils_data_stub.cpp @@ -16,6 +16,74 @@ #include "utils_data_stub.h" namespace OHOS::Camera { +bool UtilsDataStub::WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector& cameraAbility) +{ + if (entry.data_type == META_TYPE_BYTE) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.u8 + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_INT32) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.i32 + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_FLOAT) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.f + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_INT64) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.i64 + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_DOUBLE) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.d + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_RATIONAL) { + for (size_t i = 0; i < entry.count; i++) { + WriteData((*(entry.data.r + i)).numerator, cameraAbility); + WriteData((*(entry.data.r + i)).denominator, cameraAbility); + } + } + + return true; +} + +bool UtilsDataStub::ConvertMetadataToVec(const std::shared_ptr &metadata, + std::vector& cameraAbility) +{ + if (metadata == nullptr) { + return false; + } + + bool bRet = true; + uint32_t tagCount = 0; + common_metadata_header_t *meta = metadata->get(); + if (meta != nullptr) { + tagCount = GetCameraMetadataItemCount(meta); + WriteData(tagCount, cameraAbility); + WriteData(GetCameraMetadataItemCapacity(meta), cameraAbility); + WriteData(GetCameraMetadataDataSize(meta), cameraAbility); + for (uint32_t i = 0; i < tagCount; i++) { + camera_metadata_item_t item; + int ret = GetCameraMetadataItem(meta, i, &item); + if (ret != CAM_META_SUCCESS) { + return false; + } + + WriteData(item.index, cameraAbility); + WriteData(item.item, cameraAbility); + WriteData(item.data_type, cameraAbility); + WriteData(item.count, cameraAbility); + + bRet = WriteMetadataDataToVec(item, cameraAbility); + } + } else { + cameraAbility.push_back(tagCount); + } + + return bRet; +} + bool UtilsDataStub::EncodeCameraMetadata(const std::shared_ptr &metadata, MessageParcel &data) { @@ -49,6 +117,109 @@ bool UtilsDataStub::EncodeCameraMetadata(const std::shared_ptr & return bRet; } +bool UtilsDataStub::ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry, + const std::vector& cameraAbility) +{ + if (entry.data_type == META_TYPE_BYTE) { + entry.data.u8 = new(std::nothrow) uint8_t[entry.count]; + if (entry.data.u8 != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.u8[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_INT32) { + entry.data.i32 = new(std::nothrow) int32_t[entry.count]; + if (entry.data.i32 != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.i32[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_FLOAT) { + entry.data.f = new(std::nothrow) float[entry.count]; + if (entry.data.f != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.f[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_INT64) { + entry.data.i64 = new(std::nothrow) int64_t[entry.count]; + if (entry.data.i64 != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.i64[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_DOUBLE) { + entry.data.d = new(std::nothrow) double[entry.count]; + if (entry.data.d != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.d[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_RATIONAL) { + entry.data.r = new(std::nothrow) camera_rational_t[entry.count]; + if (entry.data.r != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.r[i].numerator, index, cameraAbility); + ReadData(entry.data.r[i].denominator, index, cameraAbility); + } + } + } + + return true; +} + +void UtilsDataStub::ConvertVecToMetadata(const std::vector& cameraAbility, + std::shared_ptr &metadata) +{ + int32_t index = 0; + uint32_t tagCount = 0; + uint32_t itemCapacity = 0; + uint32_t dataCapacity = 0; + constexpr uint32_t MAX_SUPPORTED_TAGS = 1000; + constexpr uint32_t MAX_SUPPORTED_ITEMS = 1000; + constexpr uint32_t MAX_ITEM_CAPACITY = (1000 * 10); + constexpr uint32_t MAX_DATA_CAPACITY = (1000 * 10 * 10); + + ReadData(tagCount, index, cameraAbility); + if (tagCount > MAX_SUPPORTED_TAGS) { + tagCount = MAX_SUPPORTED_TAGS; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value"); + } + ReadData(itemCapacity, index, cameraAbility); + if (itemCapacity > MAX_ITEM_CAPACITY) { + itemCapacity = MAX_ITEM_CAPACITY; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata itemCapacity is more than supported value"); + } + ReadData(dataCapacity, index, cameraAbility); + if (dataCapacity > MAX_DATA_CAPACITY) { + dataCapacity = MAX_DATA_CAPACITY; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata dataCapacity is more than supported value"); + } + + std::vector items; + for (int32_t i = 0; i < tagCount; i++) { + camera_metadata_item_t item; + ReadData(item.index, index, cameraAbility); + ReadData(item.item, index, cameraAbility); + ReadData(item.data_type, index, cameraAbility); + ReadData(item.count, index, cameraAbility); + if (item.count > MAX_SUPPORTED_ITEMS) { + item.count = MAX_SUPPORTED_ITEMS; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata item.count is more than supported value"); + } + ReadMetadataDataFromVec(index, item, cameraAbility); + items.push_back(item); + } + + metadata = std::make_shared(itemCapacity, dataCapacity); + common_metadata_header_t *meta = metadata->get(); + for (auto &item_ : items) { + void *buffer = nullptr; + MetadataUtils::ItemDataToBuffer(item_, &buffer); + (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count); + } +} + void UtilsDataStub::DecodeCameraMetadata(MessageParcel &data, std::shared_ptr &metadata) { int32_t tagCount = data.ReadInt32(); @@ -90,10 +261,10 @@ bool UtilsDataStub::EncodeStreamInfo(const std::shared_ptr &pInfo, M bRet = (bRet && parcel.WriteInt32(static_cast(pInfo->format_))); bRet = (bRet = (bRet && parcel.WriteInt32(pInfo->intent_))); bRet = (bRet && parcel.WriteBool(pInfo->tunneledMode_)); - bool bufferQueueFlag = (pInfo->bufferQueue_ != nullptr) ? true : false; + bool bufferQueueFlag = (pInfo->bufferQueue_->producer_ != nullptr) ? true : false; bRet = (bRet && parcel.WriteBool(bufferQueueFlag)); if (bufferQueueFlag) { - bRet = (bRet && parcel.WriteRemoteObject(pInfo->bufferQueue_->AsObject())); + bRet = (bRet && parcel.WriteRemoteObject(pInfo->bufferQueue_->producer_->AsObject())); } bRet = (bRet && parcel.WriteInt32(static_cast(pInfo->minFrameDuration_))); bRet = (bRet && parcel.WriteInt32(pInfo->encodeType_)); @@ -111,7 +282,7 @@ void UtilsDataStub::DecodeStreamInfo(MessageParcel &parcel, std::shared_ptr remoteBufferProducer = parcel.ReadRemoteObject(); - pInfo->bufferQueue_ = OHOS::iface_cast(remoteBufferProducer); + pInfo->bufferQueue_->producer_ = OHOS::iface_cast(remoteBufferProducer); } pInfo->minFrameDuration_ = static_cast(parcel.ReadInt32()); pInfo->encodeType_ = static_cast(parcel.ReadInt32()); diff --git a/camera/interfaces/include/icamera_device.h b/camera/interfaces/include/icamera_device.h deleted file mode 100644 index b3ed900df6..0000000000 --- a/camera/interfaces/include/icamera_device.h +++ /dev/null @@ -1,136 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file icamera_device.h - * - * @brief Declares APIs for camera device operations. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef HDI_CAMERA_DEVICE_CLIENT_INF_H -#define HDI_CAMERA_DEVICE_CLIENT_INF_H - -#include -#include -#include -#include "types.h" -#include "icamera_device_callback.h" -#include "istream_operator.h" -#include "istream_operator_callback.h" -#include "icamera_interface.h" - -namespace OHOS::Camera { -class ICameraDevice : public ICameraInterface { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"HDI.Camera.V1_0.Device"); - virtual ~ICameraDevice() {} - - /** - * @brief Obtains the stream operation handle. - * - * @param callback Indicates a stream callback. For details, see {@link IStreamOperatorCallback}. - * {@link OnCaptureStarted} and {@link OnCaptureEnded} are used to report the start and end of capture, - * and {@link OnCaptureError} is used to report a capture error. - * - * @param streamOperator Indicates the stream operation handle. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode GetStreamOperator( - const OHOS::sptr &callback, - OHOS::sptr &streamOperator) = 0; - - /** - * @brief Updates camera device control parameters. - * - * @param settings Indicates the camera parameters, including the sensor frame rate and 3A parameters. 3A stands for automatic focus (AF), automatic exposure (AE), and automatic white-balance (​AWB). - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode UpdateSettings(const std::shared_ptr &settings) = 0; - - /** - * @brief Sets the metadata reporting mode. - * - * @param mode Indicates the metadata reporting mode to set, which can be frame-by-frame reporting or reporting upon device status change. For details, see {@link ResultCallbackMode}. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode SetResultMode(const ResultCallbackMode &mode) = 0; - - /** - * @brief Obtains enabled metadata. - * - * Metadata to be reported is enabled by calling {@link EnableResult}. - * - * @param results Indicates all enabled metadata. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode GetEnabledResults(std::vector &results) = 0; - - /** - * @brief Enables metadata reporting. - * - * Only metadata that is enabled can be reported by using {@link OnResult}. - * - * @param results Indicates the metadata for which reporting is to be enabled. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode EnableResult(const std::vector &results) = 0; - - /** - * @brief Disables metadata reporting. - * - * After metadata reporting is disabled, the metadata is not reported by calling {@link OnResult}. To enable metadata reporting, you must call {@link EnableResult}. - * - * @param results Indicates the metadata for which reporting is to be disabled. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode DisableResult(const std::vector &results) = 0; - - /** - * @brief Closes the camera device. - * - * @since 1.0 - * @version 1.0 - */ - virtual void Close() = 0; -}; -} -#endif // HDI_CAMERA_DEVICE_CLIENT_INF_H \ No newline at end of file diff --git a/camera/interfaces/include/icamera_device_callback.h b/camera/interfaces/include/icamera_device_callback.h deleted file mode 100644 index 65db5711b5..0000000000 --- a/camera/interfaces/include/icamera_device_callback.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file icamera_device_callback.h - * - * @brief Declares callbacks for reporting camera device errors and metadata. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef HDI_CAMERA_DEVICE_CALLBACK_SERVER_H -#define HDI_CAMERA_DEVICE_CALLBACK_SERVER_H - -#include -#include -#include -#include "types.h" -#include "icamera_interface.h" - -namespace OHOS::Camera { -class ICameraDeviceCallback : public ICameraInterface { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"HDI.Camera.V1_0.DeviceCallback"); - virtual ~ICameraDeviceCallback() {} - -public: - /** - * @brief Called when an error occurs on the camera device. The caller needs to implement this function. - * - * @param type Indicates the error type. For details, see {@link ErrorType}. - * @param errorCode Indicates the error code. This parameter is not used currently. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnError(ErrorType type, int32_t errorCode) = 0; - - /** - * @brief Called to report metadata related to the camera device. - * For details about the reporting mode, see {@link SetResultMode}. - * - * @param timestamp Indicates the timestamp when the metadata is reported. - * @param result Indicates the metadata reported. The reported metadata is specified by {@link EnableResult}. - * You can call {@link GetEnabledResults} to obtain enabled metadata and - * call {@link DisableResult} to disable metadata reporting. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnResult(uint64_t timestamp, const std::shared_ptr &result) = 0; -}; -} -#endif // HDI_CAMERA_DEVICE_CALLBACK_SERVER_H \ No newline at end of file diff --git a/camera/interfaces/include/icamera_host.h b/camera/interfaces/include/icamera_host.h deleted file mode 100644 index 05a9f677fe..0000000000 --- a/camera/interfaces/include/icamera_host.h +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file icamera_host.h - * - * @brief Management class of the camera service that provides Hardware Driver Interfaces (HDIs) for the upper layer. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef HDI_CAMERA_HOST_CLIENT_INF_H -#define HDI_CAMERA_HOST_CLIENT_INF_H - -#include -#include -#include -#include "icamera_device_callback.h" -#include "types.h" -#include "icamera_interface.h" - -namespace OHOS::Camera { -class ICameraDevice; -class ICameraHostCallback; -class ICameraDeviceCallback; -class ICameraHost : public ICameraInterface { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"HDI.Camera.V1_0.Host"); - virtual ~ICameraHost() {} - /** - * @brief Obtains an ICameraHost instance. - * - * This function provides the entry to the camera service. You must use this function to obtain an ICameraHost instance before performing other operations. - * - * @param serviceName Indicates the name of the ICameraHost instance to obtain. Currently, the name is fixed at camera_service. - * - * @return Returns the ICameraHost instance if the operation is successful; returns nullptr otherwise. - * - * @since 1.0 - * @version 1.0 - */ - static sptr Get(const char *serviceName); - - /** - * @brief Sets callbacks. For details about the callbacks, see {@link ICameraHostCallback}. - * - * @param callback Indicates the callbacks to set. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode SetCallback(const OHOS::sptr &callback) = 0; - - /** - * @brief Obtains the IDs of available camera devices. - * - * @param cameraIds Indicates the IDs of available camera devices. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode GetCameraIds(std::vector &cameraIds) = 0; - - /** - * @brief Obtains the abilities of a camera device. - * - * @param cameraId Indicates the ID of the camera device, which can be obtained by calling {@link GetCameraIds}. - * - * @param ability Returns the abilities of the camera device. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode GetCameraAbility(const std::string &cameraId, - std::shared_ptr &ability) = 0; - - /** - * @brief Opens a camera device. - * - * By calling this function, you can obtain the ICameraDevice instance and operate the specific camera device mapping to the instance. - * - * @param cameraId Indicates the ID of the camera device, which can be obtained by calling {@link GetCameraIds}. - * @param callback Indicates the callback related to the camera. For details, see {@link ICameraDeviceCallback}. - * @param device Indicates the ICameraDevice instance corresponding to the ID of the camera device. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode OpenCamera(const std::string &cameraId, - const OHOS::sptr &callback, - OHOS::sptr &device) = 0; - - /** - * @brief Turns on or off the flash. - * - * This function can be used only by the caller who has opened the camera device specified by cameraId. - * - * @param cameraId Indicates the ID of the camera whose flash is to be turned on or off. - * @param isEnable Specifies whether to turn on or off the flash. The value true means to turn on the flash, and false means the opposite. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode SetFlashlight(const std::string &cameraId, bool &isEnable) = 0; -}; -} -#endif // HDI_CAMERA_HOST_CLIENT_INF_H \ No newline at end of file diff --git a/camera/interfaces/include/icamera_host_callback.h b/camera/interfaces/include/icamera_host_callback.h deleted file mode 100644 index 8bd3f54cdc..0000000000 --- a/camera/interfaces/include/icamera_host_callback.h +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file icamera_host_callback.h - * - * @brief Declares callbacks for status changes of cameras and flashes. The caller needs to implement the callbacks. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef HDI_CAMERA_HOST_CALLBACK_SERVER_H -#define HDI_CAMERA_HOST_CALLBACK_SERVER_H - -#include -#include -#include -#include "types.h" -#include "icamera_interface.h" - -namespace OHOS::Camera { -class ICameraHostCallback : public ICameraInterface { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"HDI.Camera.V1_0.HostCallback"); - virtual ~ICameraHostCallback() {} - -public: - /** - * @brief Called when the camera status changes to report the latest status. - * - * @param cameraId Indicates the ID of the camera whose status changes. - * @param status Indicates the latest status of the camera. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnCameraStatus(const std::string &cameraId, CameraStatus status) = 0; - - /** - * @brief Called when the flash status changes to report the latest status. - * - * @param cameraId Indicates the ID of the camera to which the flash whose status changes is bound. - * @param status Indicates the latest status of the flash. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) = 0; - - /** - * @brief Called when the camera event occurs. - * - * @param cameraId Indicates the ID of the camera to which the camera event is bound. - * @param event Indicates the camera event type. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnCameraEvent(const std::string &cameraId, CameraEvent event) = 0; -}; -} -#endif // HDI_CAMERA_HOST_CALLBACK_SERVER_H \ No newline at end of file diff --git a/camera/interfaces/include/ioffline_stream_operator.h b/camera/interfaces/include/ioffline_stream_operator.h deleted file mode 100644 index a6e70901d1..0000000000 --- a/camera/interfaces/include/ioffline_stream_operator.h +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file ioffline_stream_operator.h - * - * @brief Declares APIs for offline stream operations. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef HDI_OFFLINE_STREAM_OPERATOR_CLIENT_INF_H -#define HDI_OFFLINE_STREAM_OPERATOR_CLIENT_INF_H - -#include -#include -#include -#include "types.h" -#include "icamera_interface.h" - -namespace OHOS::Camera { -class IOfflineStreamOperator : public ICameraInterface { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"HDI.Camera.V1_0.OfflineStreamOperator"); - - virtual ~IOfflineStreamOperator() {} - - /** - * @brief Cancels a capture request. - * - * @param captureId Indicates the ID of the capture request to cancel. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode CancelCapture(int captureId) = 0; - - /** - * @brief Releases offline streams. - * - * @param streamIds Indicates the IDs of the offline streams to release. - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode ReleaseStreams(const std::vector &streamIds) = 0; - - /** - * @brief Releases all offline streams. - * - * - * @return Returns NO_ERROR if the operation is successful; returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode Release() = 0; -}; -} -#endif // HDI_OFFLINE_STREAM_OPERATOR_CLIENT_INF_H \ No newline at end of file diff --git a/camera/interfaces/include/istream_operator.h b/camera/interfaces/include/istream_operator.h deleted file mode 100644 index f833f881f5..0000000000 --- a/camera/interfaces/include/istream_operator.h +++ /dev/null @@ -1,258 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file istream_operator.h - * - * @brief Declares APIs for stream operations. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef HDI_STREAM_OPERATOR_CLIENT_INF_H -#define HDI_STREAM_OPERATOR_CLIENT_INF_H - -#include -#include -#include -#include "istream_operator_callback.h" -#include "ioffline_stream_operator.h" -#include "types.h" -#include "icamera_interface.h" - -namespace OHOS::Camera { -class IBufferProducer; -class IStreamOperator : public ICameraInterface { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"HDI.Camera.V1_0.StreamOperator"); - - virtual ~IStreamOperator() {} - - /** - * @brief Checks whether a specific stream can be dynamically created. - * - * A stream is a sequence of data elements output from a bottom-layer device, processed by the current module, - * and then transmitted to an upper-layer service or application. - * The current module supports preview streams, video streams, photographing streams, and the like. - * For details, see {@link StreamIntent}. - * - * This function is used to check whether a stream or streams can be dynamically created based on the - * operation mode, configuration information, and existing streams in the current module. - * If the streams can be created without stopping the existing streams or making the upper-layer service or - * application unaware of the stopping of the existing streams, - * type is set to DYNAMIC_SUPPORTED so that the upper-layer service or application - * can directly add the new stream. - * If the streams can be created only after the upper-layer service or application stops capturing all streams, - * type is set to RE_CONFIGURED_REQUIRED. - * If the streams are not supported, type is set to NOT_SUPPORTED. - * This function must be called prior to {@link CreateStreams}. - * - * @param mode Indicates the operation mode of the streams. For details, see {@link OperationMode}. - * @param modeSetting Indicates the stream configuration parameters, including the frame rate and 3A. - * 3A stands for automatic focus (AF), automatic exposure (AE), and automatic white-balance (AWB). - * @param info Indicates the stream configuration information. For details, see {@link StreamInfo}. - * @param type Indicates the support type of the dynamically created stream. - * The supported types are defined in {@link StreamSupportType}. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode IsStreamsSupported( - OperationMode mode, - const std::shared_ptr &modeSetting, - const std::vector> &info, - StreamSupportType &type) = 0; - - /** - * @brief Creates streams. - * - * Before calling this function, you must use {@link IsStreamsSupported} to check whether the hardware - * abstraction layer (HAL) supports the streams to create. - * - * @param streamInfos Indicates the list of stream information, which is defined by {@link StreamInfo}. - * The passed stream information may be changed. Therefore, you can run {@link GetStreamAttributes} to - * obtain the latest stream attributes after the stream is created. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode CreateStreams(const std::vector> &streamInfos) = 0; - - /** - * @brief Releases streams. - * - * @param streamIds Indicates the IDs of the streams to release. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode ReleaseStreams(const std::vector &streamIds) = 0; - - /** - * @brief Configures a stream. - * - * This function must be called after {@link CreateStreams}. - * - * @param mode Indicates the operation mode of the stream. For details, see {@link OperationMode}. - * @param modeSetting Indicates the stream configuration parameters, including the frame rate and zoom information. - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode CommitStreams(OperationMode mode, - const std::shared_ptr &modeSetting) = 0; - - /** - * @brief Obtains stream attributes. - * - * @param attributes Indicates the obtained stream attributes. - * Stream information passed by the streamInfos parameter in {@link CreateStreams} - * may be overridden. Therefore, the stream attributes obtained by using this function may be - * different from the stream information passed in {@link CreateStreams}. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode GetStreamAttributes( - std::vector> &attributes) = 0; - - /** - * @brief Attaches a producer handle to a stream. - * - * If a producer handle has been specified during stream creation (by {@link CreateStreams}), - * you do not need to call this function. If you want to attach a new procedure handle, - * call {@link DetachBufferQueue} to detach the existing procedure handle and then - * call this function to attach the new one. - * You do not need to attach a procedure handle for IoT devices that do not support or require - * image data caching and transferring of preview streams. - * In this case, set bufferQueue_ in the {@link StreamInfo} parameter of {@link CreateStreams} - * to null, - * and set tunneledMode_ to false. - * - * @param streamId Indicates the ID of the stream to which the procedure handle is to be attached. - * @param producer Indicates the producer handle to be attached. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode AttachBufferQueue(int streamId, const OHOS::sptr &producer) = 0; - - /** - * @brief Detaches the producer handle from a stream. - * - * @param streamId Indicates the ID of the stream from which the procedure handle is to be detached. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode DetachBufferQueue(int streamId) = 0; - - /** - * @brief Captures an image. - * - * This function must be called after {@link CommitStreams}. - * There are two image capture modes: continuous capture and single capture. - * A continuous capture is performed inside the module after being triggered, - * and the consumer can continuously receive captured image data after calling this function only once. - * If this function is called again, the current capture is stopped, the capture request configuration is updated, - * and a new capture is performed. - * This mode is mainly used in preview, video recording, or continuous shooting scenarios. - * After a single capture is triggered, only one frame of image data is captured. - * This mode applies to the single shooting scenario. - * When the capture is started, {@link OnCaptureStarted} is called to notify of the start. - * To stop a continuous capture, call {@link CancelCapture}. - * When the capture ends, {@link OnCaptureEnded} is called to notify the caller of the information - * such as the number of captured frames. - * enableShutterCallback_ in {@link CaptureInfo} is used to enable the callback for each capture. - * After the callback is enabled, {@link OnFrameShutter} is called upon each capture. - * In the scenario where multiple streams are captured at the same time, this module ensures that - * the captured data of multiple streams is reported simultaneously. - * - * @param captureId Indicates the ID of the capture request. You must ensure that the ID of the - * capture request is unique when the camera is started. - * @param info Indicates the capture request configuration information. For details, see {@link CaptureInfo}. - * @param isStreaming Specifies whether to continuously capture images. - * The value true means to continuously capture images, and false means the opposite. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode Capture(int captureId, - const std::shared_ptr &info, bool isStreaming) = 0; - - /** - * @brief Cancels a capture. - * - * {@link OnCaptureEnded} is called when a continuous capture is canceled. - * - * @param captureId Indicates the ID of the capture request to cancel. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode CancelCapture(int captureId) = 0; - - /** - * @brief Converts a specific stream to an offline stream. - * - * Only photographing streams can be converted into offline streams. - * Due to the limited processing capability, some devices may spend a long period of time on - * algorithm processing during photographing, causing the capture requests to stack in the module. - * Converting to an offline stream enables the bottom-layer device to close and - * the offline stream to take over for subsequent processing. - * - * @param streamIds Indicates the IDs of the streams to be converted. - * @param callback Indicates the callback for conversion to offline streams. - * @param offlineOperator Indicates the offline stream after conversion. - * - * @return Returns NO_ERROR if the operation is successful; - * returns an error code defined in {@link CamRetCode} otherwise. - * - * @since 1.0 - * @version 1.0 - */ - virtual CamRetCode ChangeToOfflineStream(const std::vector &streamIds, - OHOS::sptr &callback, - OHOS::sptr &offlineOperator) = 0; -}; -} -#endif // HDI_STREAM_OPERATOR_CLIENT_INF_H \ No newline at end of file diff --git a/camera/interfaces/include/istream_operator_callback.h b/camera/interfaces/include/istream_operator_callback.h deleted file mode 100644 index c74810adb7..0000000000 --- a/camera/interfaces/include/istream_operator_callback.h +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file istream_operator_callback.h - * - * @brief Declares callbacks related to {@link IStreamOperator}. The caller needs to implement these callbacks. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef HDI_STREAM_OPERATOR_CALLBACK_SERVER_H -#define HDI_STREAM_OPERATOR_CALLBACK_SERVER_H - -#include -#include -#include -#include "types.h" -#include "icamera_interface.h" - -namespace OHOS::Camera { -class IStreamOperatorCallback : public ICameraInterface { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"HDI.Camera.V1_0.StreamOperatorCallback"); - virtual ~IStreamOperatorCallback() {} - -public: - /** - * @brief Called when the capture starts. - * - * @param captureId Indicates the ID of the capture request corresponding to the callback. - * @param streamIds Indicates the IDs of the streams corresponding to the callback. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnCaptureStarted(int32_t captureId, const std::vector &streamIds) = 0; - - /** - * @brief Called when the capture ends. - * - * @param captureId Indicates the ID of the capture request corresponding to the callback. - * @param infos Indicates information related to the capture when it ends. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnCaptureEnded(int32_t captureId, - const std::vector> &infos) = 0; - - /** - * @brief Called when an error occurs during the capture. - * - * @param captureId Indicates the ID of the capture request corresponding to the callback. - * @param infos Indicates a list of capture error messages. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnCaptureError(int32_t captureId, - const std::vector> &infos) = 0; - - /** - * @brief Called when a frame is captured. - * - * This callback is enabled by using enableShutterCallback_ in the {@link CaptureInfo} parameter of {@link Capture}. - * When enableShutterCallback_ is set to true, - * this callback is triggered each time a frame is captured. - * - * @param captureId Indicates the ID of the capture request corresponding to the callback. - * @param streamIds Indicates the IDs of the streams corresponding to the callback. - * @param timestamp Indicates the timestamp when the callback is invoked. - * - * @since 1.0 - * @version 1.0 - */ - virtual void OnFrameShutter(int32_t captureId, - const std::vector &streamIds, uint64_t timestamp) = 0; -}; -} -#endif // HDI_STREAM_OPERATOR_CALLBACK_SERVER_H diff --git a/camera/interfaces/include/types.h b/camera/interfaces/include/types.h deleted file mode 100644 index 06fdb30de1..0000000000 --- a/camera/interfaces/include/types.h +++ /dev/null @@ -1,467 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -/** - * @file types.h - * - * @brief Declares data types - * used by the Hardware Driver Interfaces (HDIs) of this module. - * - * @since 1.0 - * @version 1.0 - */ - -#ifndef CAMERA_DEVICE_DRIVER_TYPES_H -#define CAMERA_DEVICE_DRIVER_TYPES_H - -#include -#include -#include -#include -#include -#include "camera_metadata_info.h" -#include "type_common.h" - -namespace OHOS::Camera { -using CameraAbility = CameraMetadata; -using CameraSetting = CameraMetadata; - -/** - * @brief Enumerates return values of the HDIs. - */ -enum CamRetCode : int32_t { - /** - * Successful call. - */ - NO_ERROR = 0, - - /** - * The camera device is busy. - */ - CAMERA_BUSY = -1, - - /** - * Insufficient resources. - */ - INSUFFICIENT_RESOURCES = -2, - - /** - * Invalid parameters. - */ - INVALID_ARGUMENT = -3, - - /** - * Unsupported function. - */ - METHOD_NOT_SUPPORTED = -4, - - /** - * The camera device is closed. - */ - CAMERA_CLOSED = -5, - - /** - * A critical error occurs at the driver layer. - */ - DEVICE_ERROR = -6, - - /** - * No permission to access the camera device. - */ - NO_PERMISSION = -7, -}; - -/** - * @brief Enumerates metadata reporting modes. - */ -enum ResultCallbackMode : int32_t { - /** - * Frame-by-frame reporting - */ - PER_FRAME, - - /** - * Reporting upon device status change - */ - ON_CHANGED -}; - -/** - * @brief Enumerates stream operation modes. - */ -enum OperationMode : int32_t { - /** - * Normal - */ - NORMAL = 0, -}; - -/** - * @brief Enumerates stream types. - */ -enum StreamIntent : int32_t { - /** - * Preview streams, indicating that stream data is used for preview - */ - PREVIEW = 0, - - /** - * Video streams, indicating that stream data is used to encode and generate videos - */ - VIDEO = 1, - - /** - * Photographing streams, indicating that stream data is used to encode and generate images - */ - STILL_CAPTURE = 2, - - /** - * Stream data that is used to store thumbnails - */ - POST_VIEW = 3, - - /** - * Stream data that is used for image analysis - */ - ANALYZE = 4, - - /** - * Custom type - */ - CUSTOM = 5, -}; - -/** - * @brief Enumerates encoding types of stream data. - */ -enum EncodeType : int32_t { - /** - * Unspecified - */ - ENCODE_TYPE_NULL = 0, - - /** - * H.264 - */ - ENCODE_TYPE_H264 = 1, - - /** - * H.265 - */ - ENCODE_TYPE_H265 = 2, - - /** - * JPEG - */ - ENCODE_TYPE_JPEG = 3, -}; - -/** - * @brief Defines the stream information, which is used to pass configuration parameters during stream creation. - */ -struct StreamInfo { - /** - * Stream ID, which uniquely identifies a stream on a camera device. - */ - int streamId_; - - /** - * Image width. - */ - int width_; - - /** - * Image height. - */ - int height_; - - /** - * Image format. - */ - int format_; - - /** - * Image color space. - */ - int dataspace_; - - /** - * Stream type. - */ - StreamIntent intent_; - - /** - * Tunnel mode. The value true means that the tunnel mode is enabled, and false means the opposite. - * - * After the tunnel mode is enabled, - * the hardware abstraction layer (HAL) does not directly interact with the upper layer. - * Instead, it uses the producer handle provided by the graphics layer to transfer frame data. - * You need to disable the tunnel mode for IoT devices that do not support - * or require image data caching and forwarding of preview streams. - */ - bool tunneledMode_; - - /** - * Producer handle provided by the graphics layer. - */ - OHOS::sptr bufferQueue_; - - /** - * Minimum frame interval. - */ - int minFrameDuration_; - - /** - * Encoding type. - */ - EncodeType encodeType_; -}; - -/** - * @brief Enumerates the support types of the stream. For details about the application scenario, - * see {@link IsStreamsSupported}. - */ -enum StreamSupportType : int32_t { - /** - * The stream can be dynamically created, and the corresponding stream parameters take effect directly. - */ - DYNAMIC_SUPPORTED, - - /** - * The stream cannot be dynamically created, - * and the corresponding parameters take effect only after the existing stream is stopped and reconfigured. - */ - RE_CONFIGURED_REQUIRED, - - /** - * The stream cannot be dynamically created. - */ - NOT_SUPPORTED, -}; - -/** - * @brief Defines the stream attributes. - */ -struct StreamAttribute { - /** - * Stream ID, which uniquely identifies a stream on a camera device. - */ - int streamId_; - - /** - * Image width. - */ - int width_; - - /** - * Image height. - */ - int height_; - - /** - * New image format. - */ - int overrideFormat_; - - /** - * New image color space. - */ - int overrideDataspace_; - - /** - * New procedure usage. - */ - int producerUsage_; - - /** - * New number of produce buffers. - */ - int producerBufferCount_; - - /** - * Maximum number of frames that can be captured in a continuous capture. - */ - int maxBatchCaptureCount_; - - /** - * Maximum number of concurrent capture requests. The default value is 1. - */ - int maxCaptureCount_; -}; - -/** - * @brief Defines the information about a capture request. - */ -struct CaptureInfo { - /** - * IDs of captured streams. - */ - std::vector streamIds_; - - /** - * Captured configuration information. - */ - std::shared_ptr captureSetting_; - - /** - * Whether to enable callback for each capture. If enabled, {@link OnFrameShutter} is called upon each capture. - */ - bool enableShutterCallback_; -}; - -/** - * @brief Enumerates camera device statuses. - */ -enum CameraStatus { - /** - * The camera device is not in position or is unavailable. - */ - UN_AVAILABLE = 0, - - /** - * The camera device is available. - */ - AVAILABLE = 1, -}; - -/** - * @brief Enumerates flash statuses. - */ -enum FlashlightStatus : uint32_t { - /** - * The flash is off. - */ - FLASHLIGHT_OFF = 0, - - /** - * The flash is on. - */ - FLASHLIGHT_ON = 1, - - /** - * The flash is unavailable. - */ - FLASHLIGHT_UNAVAILABLE = 2, -}; - -/** - * @brief Camera event. - */ -enum CameraEvent : uint32_t { - /** - * Camera device add event. - */ - CAMERA_EVENT_DEVICE_ADD = 0, - - /** - * Camera device remove event. - */ - CAMERA_EVENT_DEVICE_RMV = 1, -}; - -/** - * @brief Enumerates camera device error types, which are used by {@link OnError}. - */ -enum ErrorType : uint32_t { - /** - * A critical error occurs. The camera device needs to be closed. - */ - FATAL_ERROR = 0, - - /** - * A request timeout occurs. The camera device needs to be closed. - */ - REQUEST_TIMEOUT = 1, - - /** - * An error occurred int the driver. - */ - DRIVER_ERROR = 2, - - /** - * The device is preempted. - */ - DEVICE_PREEMPT = 3, - - /** - * Device disconnected. - */ - DEVICE_DISCONNECT = 4, - - /** - * The distributed camera error type starts, - * and all subsequent error types are distributed camera-specific. - */ - DCAMERA_ERROR_BEGIN = 1024, - - /** - * The distributed camera device is busy. - */ - DCAMERA_ERROR_DEVICE_IN_USE = DCAMERA_ERROR_BEGIN, - - /** - * No permission to access the distributed camera device. - */ - DCAMERA_ERROR_NO_PERMISSION, -}; - -/** - * @brief Defines the information about the end of packet capture, which is used by {@link OnCaptureEnded}. - */ -struct CaptureEndedInfo { - /** - * ID of a captured stream. - */ - int streamId_; - - /** - * Number of frames that have been captured when the capture ends. - */ - int frameCount_; -}; - -/** - * @brief Enumerates stream error types, which are used by {@link CaptureErrorInfo}. - */ -enum StreamError { - /** - * Unknown error - */ - UNKNOWN_ERROR = 0, - - /** - * Packet loss - */ - BUFFER_LOST = 1, -}; - -/** - * @brief Defines the stream error information, which is used by {@link OnCaptureError}. - */ -struct CaptureErrorInfo { - /** - * Stream ID - */ - int streamId_; - - /** - * Error type - */ - StreamError error_; -}; - -using MetaType = int32_t; -} -#endif /* CAMERA_DEVICE_DRIVER_TYPES_H */ diff --git a/camera/interfaces/metadata/include/metadata_utils.h b/camera/interfaces/metadata/include/metadata_utils.h index 9ffd9b3c7f..36f28737a2 100644 --- a/camera/interfaces/metadata/include/metadata_utils.h +++ b/camera/interfaces/metadata/include/metadata_utils.h @@ -33,11 +33,42 @@ public: static std::string EncodeToString(std::shared_ptr metadata); static std::shared_ptr DecodeFromString(std::string setting); - + static bool ConvertMetadataToVec(const std::shared_ptr &metadata, + std::vector& cameraAbility); + static void ConvertVecToMetadata(const std::vector& cameraAbility, + std::shared_ptr &metadata); private: static bool WriteMetadata(const camera_metadata_item_t &item, MessageParcel &data); static bool ReadMetadata(camera_metadata_item_t &item, MessageParcel &data); static void ItemDataToBuffer(const camera_metadata_item_t &item, void **buffer); + static bool WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector& cameraAbility); + static bool ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry, + const std::vector& cameraAbility); + template static void WriteData(T data, std::vector& cameraAbility); + template static void ReadData(T &data, int32_t &index, const std::vector& cameraAbility); }; + +template +void MetadataUtils::WriteData(T data, std::vector& cameraAbility) +{ + T dataTemp = data; + uint8_t *dataPtr = (uint8_t *)&dataTemp; + for (size_t j = 0; j < sizeof(T); j++) { + cameraAbility.push_back(*(dataPtr + j)); + } +} + +template +void MetadataUtils::ReadData(T &data, int32_t &index, const std::vector& cameraAbility) +{ + constexpr uint32_t typeLen = sizeof(T); + uint8_t array[typeLen] = {0}; + T *ptr = nullptr; + for (size_t j = 0; j < sizeof(T); j++) { + array[j] = cameraAbility.at(index++); + } + ptr = (T *)array; + data = *ptr; +} } // namespace Camera #endif // OHOS_CAMERA_METADATA_UTILS_H diff --git a/camera/interfaces/metadata/src/metadata_utils.cpp b/camera/interfaces/metadata/src/metadata_utils.cpp index d391bc3421..687efb3fdc 100644 --- a/camera/interfaces/metadata/src/metadata_utils.cpp +++ b/camera/interfaces/metadata/src/metadata_utils.cpp @@ -18,6 +18,74 @@ #include "metadata_log.h" namespace OHOS::Camera { +bool MetadataUtils::WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector& cameraAbility) +{ + if (entry.data_type == META_TYPE_BYTE) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.u8 + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_INT32) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.i32 + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_FLOAT) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.f + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_INT64) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.i64 + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_DOUBLE) { + for (size_t i = 0; i < entry.count; i++) { + WriteData(*(entry.data.d + i), cameraAbility); + } + } else if (entry.data_type == META_TYPE_RATIONAL) { + for (size_t i = 0; i < entry.count; i++) { + WriteData((*(entry.data.r + i)).numerator, cameraAbility); + WriteData((*(entry.data.r + i)).denominator, cameraAbility); + } + } + + return true; +} + +bool MetadataUtils::ConvertMetadataToVec(const std::shared_ptr &metadata, + std::vector& cameraAbility) +{ + if (metadata == nullptr) { + return false; + } + + bool bRet = true; + uint32_t tagCount = 0; + common_metadata_header_t *meta = metadata->get(); + if (meta != nullptr) { + tagCount = GetCameraMetadataItemCount(meta); + WriteData(tagCount, cameraAbility); + WriteData(GetCameraMetadataItemCapacity(meta), cameraAbility); + WriteData(GetCameraMetadataDataSize(meta), cameraAbility); + for (uint32_t i = 0; i < tagCount; i++) { + camera_metadata_item_t item; + int ret = GetCameraMetadataItem(meta, i, &item); + if (ret != CAM_META_SUCCESS) { + return false; + } + + WriteData(item.index, cameraAbility); + WriteData(item.item, cameraAbility); + WriteData(item.data_type, cameraAbility); + WriteData(item.count, cameraAbility); + + bRet = WriteMetadataDataToVec(item, cameraAbility); + } + } else { + cameraAbility.push_back(tagCount); + } + + return bRet; +} + bool MetadataUtils::EncodeCameraMetadata(const std::shared_ptr &metadata, MessageParcel &data) { @@ -52,6 +120,109 @@ bool MetadataUtils::EncodeCameraMetadata(const std::shared_ptr & return bRet; } +bool MetadataUtils::ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry, + const std::vector& cameraAbility) +{ + if (entry.data_type == META_TYPE_BYTE) { + entry.data.u8 = new(std::nothrow) uint8_t[entry.count]; + if (entry.data.u8 != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.u8[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_INT32) { + entry.data.i32 = new(std::nothrow) int32_t[entry.count]; + if (entry.data.i32 != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.i32[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_FLOAT) { + entry.data.f = new(std::nothrow) float[entry.count]; + if (entry.data.f != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.f[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_INT64) { + entry.data.i64 = new(std::nothrow) int64_t[entry.count]; + if (entry.data.i64 != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.i64[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_DOUBLE) { + entry.data.d = new(std::nothrow) double[entry.count]; + if (entry.data.d != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.d[i], index, cameraAbility); + } + } + } else if (entry.data_type == META_TYPE_RATIONAL) { + entry.data.r = new(std::nothrow) camera_rational_t[entry.count]; + if (entry.data.r != nullptr) { + for (size_t i = 0; i < entry.count; i++) { + ReadData(entry.data.r[i].numerator, index, cameraAbility); + ReadData(entry.data.r[i].denominator, index, cameraAbility); + } + } + } + + return true; +} + +void MetadataUtils::ConvertVecToMetadata(const std::vector& cameraAbility, + std::shared_ptr &metadata) +{ + int32_t index = 0; + uint32_t tagCount = 0; + uint32_t itemCapacity = 0; + uint32_t dataCapacity = 0; + constexpr uint32_t MAX_SUPPORTED_TAGS = 1000; + constexpr uint32_t MAX_SUPPORTED_ITEMS = 1000; + constexpr uint32_t MAX_ITEM_CAPACITY = (1000 * 10); + constexpr uint32_t MAX_DATA_CAPACITY = (1000 * 10 * 10); + + ReadData(tagCount, index, cameraAbility); + if (tagCount > MAX_SUPPORTED_TAGS) { + tagCount = MAX_SUPPORTED_TAGS; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value"); + } + ReadData(itemCapacity, index, cameraAbility); + if (itemCapacity > MAX_ITEM_CAPACITY) { + itemCapacity = MAX_ITEM_CAPACITY; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata itemCapacity is more than supported value"); + } + ReadData(dataCapacity, index, cameraAbility); + if (dataCapacity > MAX_DATA_CAPACITY) { + dataCapacity = MAX_DATA_CAPACITY; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata dataCapacity is more than supported value"); + } + + std::vector items; + for (uint32_t i = 0; i < tagCount; i++) { + camera_metadata_item_t item; + ReadData(item.index, index, cameraAbility); + ReadData(item.item, index, cameraAbility); + ReadData(item.data_type, index, cameraAbility); + ReadData(item.count, index, cameraAbility); + if (item.count > MAX_SUPPORTED_ITEMS) { + item.count = MAX_SUPPORTED_ITEMS; + METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata item.count is more than supported value"); + } + ReadMetadataDataFromVec(index, item, cameraAbility); + items.push_back(item); + } + + metadata = std::make_shared(itemCapacity, dataCapacity); + common_metadata_header_t *meta = metadata->get(); + for (auto &item_ : items) { + void *buffer = nullptr; + MetadataUtils::ItemDataToBuffer(item_, &buffer); + (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count); + } +} + void MetadataUtils::DecodeCameraMetadata(MessageParcel &data, std::shared_ptr &metadata) { uint32_t tagCount = data.ReadUint32(); diff --git a/distributed_camera/hdi_service/BUILD.gn b/distributed_camera/hdi_service/BUILD.gn index b7640ac2c9..49af4296d5 100644 --- a/distributed_camera/hdi_service/BUILD.gn +++ b/distributed_camera/hdi_service/BUILD.gn @@ -37,49 +37,23 @@ ohos_shared_library("libdistributed_camera_provider_config") { ohos_shared_library("libdistributed_camera_host_config") { include_dirs = [ - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/host", - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/device", - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/operator", - "${distributedcamera_hdf_path}/hdi_service/include/dcamera_host", "${distributedcamera_hdf_path}/hdi_service/include/dcamera_device", + "${distributedcamera_hdf_path}/hdi_service/include/dcamera_host", "${distributedcamera_hdf_path}/hdi_service/include/dstream_operator", "${distributedcamera_hdf_path}/hdi_service/include/utils", - "//utils/native/base/include", - "//utils/system/safwk/native/include", - "${camera_hdf_path}/camera/interfaces/include", - "${camera_hdf_path}/camera/interfaces/hdi_ipc", - "${hdf_framework_path}/include/utils", - "${hdf_framework_path}/include/core", - "${hdf_framework_path}/include/osal", - "${hdf_uhdf_path}/include/hdi", - "${hdf_uhdf_path}/osal/include", - "${hdf_uhdf_path}/ipc/include", - "${hdf_uhdf_path}/include/host", "//drivers/peripheral/camera/interfaces/metadata/include", "//third_party/jsoncpp/include", ] - sources = [ "./src/config/dcamera_host_config.cpp" ] - - deps = [ - "${distributedcamera_hdf_path}/hdi_service:libdistributed_camera_hdf_service_1.0", - "//utils/native/base:utils", - ] - - public_deps = [ "//drivers/interface/distributed_camera/v1_0:libdistributed_camera_provider_stub_1.0" ] - - defines = [ - "HI_LOG_ENABLE", - "DH_LOG_TAG=\"distributedcamerahdf\"", - "LOG_DOMAIN=0xD004100", - ] + deps = [ "${distributedcamera_hdf_path}/hdi_service:libdistributed_camera_hdf_service_1.0" ] external_deps = [ - "graphic_chipsetsdk:buffer_handle", - "graphic_chipsetsdk:surface", "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", "ipc:ipc_single", + "utils_base:utils", ] install_images = [ chipset_base_dir ] @@ -94,10 +68,6 @@ ohos_shared_library("libdistributed_camera_hdf_service_1.0") { "include/dcamera_provider", "include/dstream_operator", "include/utils", - "../interfaces/hdi_ipc", - "../interfaces/hdi_ipc/server/device", - "../interfaces/hdi_ipc/server/host", - "../interfaces/hdi_ipc/server/operator", "//utils/native/base/include", "//utils/system/safwk/native/include", "${display_hdf_path}/interfaces/include", @@ -110,18 +80,9 @@ ohos_shared_library("libdistributed_camera_hdf_service_1.0") { "${hdf_uhdf_path}/include/host", "//third_party/jsoncpp/include", "//drivers/peripheral/camera/interfaces/metadata/include", - "${camera_hdf_path}/camera/interfaces/include", - "${camera_hdf_path}/camera/interfaces/hdi_ipc", ] sources = [ - "../interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.cpp", - "../interfaces/hdi_ipc/server/device/dcamera_device_stub.cpp", - "../interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.cpp", - "../interfaces/hdi_ipc/server/host/dcamera_host_stub.cpp", - "../interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.cpp", - "../interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.cpp", - "../interfaces/hdi_ipc/server/operator/dstream_operator_stub.cpp", "src/dcamera_device/dcamera_device.cpp", "src/dcamera_device/dmetadata_processor.cpp", "src/dcamera_host/dcamera_host.cpp", @@ -136,7 +97,10 @@ ohos_shared_library("libdistributed_camera_hdf_service_1.0") { "src/utils/dh_log.cpp", ] - public_deps = [ "//drivers/interface/distributed_camera/v1_0:libdistributed_camera_provider_stub_1.0" ] + public_deps = [ + "//drivers/interface/camera/v1_0:libcamera_stub_1.0", + "//drivers/interface/distributed_camera/v1_0:libdistributed_camera_provider_stub_1.0", + ] deps = [ "//drivers/hdf_core/adapter/uhdf2/ipc:libhdf_ipc_adapter", diff --git a/distributed_camera/hdi_service/include/dcamera_device/dcamera_device.h b/distributed_camera/hdi_service/include/dcamera_device/dcamera_device.h index 64e08ee986..ed0f440811 100644 --- a/distributed_camera/hdi_service/include/dcamera_device/dcamera_device.h +++ b/distributed_camera/hdi_service/include/dcamera_device/dcamera_device.h @@ -18,16 +18,18 @@ #include #include -#include "dcamera_device_stub.h" #include "dmetadata_processor.h" #include "dstream_operator.h" -#include "icamera_device_callback.h" -#include "types.h" + +#include "v1_0/icamera_device.h" +#include "v1_0/icamera_device_callback.h" #include "v1_0/id_camera_provider_callback.h" +#include "v1_0/types.h" namespace OHOS { namespace DistributedHardware { -class DCameraDevice : public DCameraDeviceStub { +using namespace OHOS::HDI::Camera::V1_0; +class DCameraDevice : public ICameraDevice { public: DCameraDevice(const DHBase &dhBase, const std::string &abilityInfo); DCameraDevice() = default; @@ -38,14 +40,14 @@ public: DCameraDevice& operator=(DCameraDevice &&other) = delete; public: - CamRetCode GetStreamOperator(const OHOS::sptr &callback, - OHOS::sptr &streamOperator) override; - CamRetCode UpdateSettings(const std::shared_ptr &settings) override; - CamRetCode SetResultMode(const ResultCallbackMode &mode) override; - CamRetCode GetEnabledResults(std::vector &results) override; - CamRetCode EnableResult(const std::vector &results) override; - CamRetCode DisableResult(const std::vector &results) override; - void Close() override; + int32_t GetStreamOperator(const sptr &callbackObj, + sptr &streamOperator) override; + int32_t UpdateSettings(const std::vector &settings) override; + int32_t SetResultMode(ResultCallbackMode mode) override; + int32_t GetEnabledResults(std::vector &results) override; + int32_t EnableResult(const std::vector &results) override; + int32_t DisableResult(const std::vector &results) override; + int32_t Close() override; CamRetCode OpenDCamera(const OHOS::sptr &callback); CamRetCode GetDCameraAbility(std::shared_ptr &ability); diff --git a/distributed_camera/hdi_service/include/dcamera_device/dmetadata_processor.h b/distributed_camera/hdi_service/include/dcamera_device/dmetadata_processor.h index 01fb4e65df..85ef239ecc 100644 --- a/distributed_camera/hdi_service/include/dcamera_device/dmetadata_processor.h +++ b/distributed_camera/hdi_service/include/dcamera_device/dmetadata_processor.h @@ -22,13 +22,13 @@ #include #include "constants.h" #include "dcamera.h" -#include "v1_0/dcamera_types.h" -#include +#include "v1_0/dcamera_types.h" +#include "v1_0/types.h" namespace OHOS { namespace DistributedHardware { -using namespace OHOS::Camera; +using namespace OHOS::HDI::Camera::V1_0; using namespace OHOS::HDI::DistributedCamera::V1_0; class DMetadataProcessor { public: @@ -49,7 +49,7 @@ public: DCamRetCode ResetEnableResults(); DCamRetCode SaveResultMetadata(std::string resultStr); void UpdateResultMetadata(const uint64_t &resultTimestamp); - void SetResultCallback(std::function)> &resultCbk); + void SetResultCallback(std::function)> &resultCbk); void PrintDCameraMetadata(const common_metadata_header_t *metadata); private: @@ -58,7 +58,7 @@ private: DCamRetCode AddAbilityEntry(uint32_t tag, const void *data, size_t size); DCamRetCode UpdateAbilityEntry(uint32_t tag, const void *data, size_t size); void ConvertToCameraMetadata(common_metadata_header_t *&input, - std::shared_ptr &output); + std::shared_ptr &output); void ResizeMetadataHeader(common_metadata_header_t *&header, uint32_t itemCapacity, uint32_t dataCapacity); void UpdateAllResult(const uint64_t &resultTimestamp); void UpdateOnChanged(const uint64_t &resultTimestamp); @@ -68,7 +68,7 @@ private: void InitDcameraBaseAbility(); private: - std::function)> resultCallback_; + std::function)> resultCallback_; std::shared_ptr dCameraAbility_; std::string protocolVersion_; std::string dCameraPosition_; @@ -80,10 +80,10 @@ private: std::mutex producerMutex_; // The latest result metadata that received from the sink device. - std::shared_ptr latestProducerMetadataResult_; + std::shared_ptr latestProducerMetadataResult_; // The latest result metadata that replied to the camera service. - std::shared_ptr latestConsumerMetadataResult_; + std::shared_ptr latestConsumerMetadataResult_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h b/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h index af435fe49d..fec52a3dab 100644 --- a/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h +++ b/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h @@ -16,20 +16,19 @@ #ifndef DISTRIBUTED_CAMERA_HOST_H #define DISTRIBUTED_CAMERA_HOST_H -#include "dcamera.h" #include "dcamera_base.h" #include "dcamera_device.h" -#include "icamera_device.h" -#include "icamera_host_callback.h" -#include "icamera_device_callback.h" -#include "v1_0/dcamera_types.h" -#include +#include "v1_0/icamera_host.h" +#include "v1_0/icamera_host_callback.h" +#include "v1_0/dcamera_types.h" +#include "v1_0/types.h" namespace OHOS { namespace DistributedHardware { using namespace OHOS::HDI::DistributedCamera::V1_0; -class DCameraHost { +using namespace OHOS::HDI::Camera::V1_0; +class DCameraHost : public ICameraHost { public: DCameraHost() = default; virtual ~DCameraHost() = default; @@ -39,13 +38,13 @@ public: DCameraHost& operator=(DCameraHost &&other) = delete; public: - static std::shared_ptr GetInstance(); - CamRetCode SetCallback(const OHOS::sptr &callback); - CamRetCode GetCameraIds(std::vector &cameraIds); - CamRetCode GetCameraAbility(const std::string &cameraId, std::shared_ptr &ability); - CamRetCode OpenCamera(const std::string &cameraId, const OHOS::sptr &callback, - OHOS::sptr &pDevice); - CamRetCode SetFlashlight(const std::string &cameraId, bool &isEnable); + static OHOS::sptr GetInstance(); + int32_t SetCallback(const sptr &callbackObj) override; + int32_t GetCameraIds(std::vector &cameraIds) override; + int32_t GetCameraAbility(const std::string &cameraId, std::vector &cameraAbility) override; + int32_t OpenCamera(const std::string &cameraId, const sptr &callbackObj, + sptr &device) override; + int32_t SetFlashlight(const std::string &cameraId, bool isEnable) override; DCamRetCode AddDCameraDevice(const DHBase &dhBase, const std::string &abilityInfo, const sptr &callback); @@ -69,7 +68,7 @@ private: } }; static AutoRelease autoRelease_; - static std::shared_ptr instance_; + static OHOS::sptr instance_; OHOS::sptr dCameraHostCallback_; std::map dhBaseHashDCamIdMap_; diff --git a/distributed_camera/hdi_service/include/dstream_operator/dcamera_stream.h b/distributed_camera/hdi_service/include/dstream_operator/dcamera_stream.h index 967e95ea84..0dc24bbff2 100644 --- a/distributed_camera/hdi_service/include/dstream_operator/dcamera_stream.h +++ b/distributed_camera/hdi_service/include/dstream_operator/dcamera_stream.h @@ -19,14 +19,14 @@ #include "surface.h" #include "dimage_buffer.h" #include "dbuffer_manager.h" -#include "v1_0/dcamera_types.h" -#include +#include "v1_0/dcamera_types.h" +#include "v1_0/types.h" namespace OHOS { namespace DistributedHardware { using namespace std; -using namespace OHOS::Camera; +using namespace OHOS::HDI::Camera::V1_0; using namespace OHOS::HDI::DistributedCamera::V1_0; class DCameraStream { public: @@ -38,11 +38,11 @@ public: DCameraStream &operator=(DCameraStream &&other) = delete; public: - DCamRetCode InitDCameraStream(const shared_ptr &info); + DCamRetCode InitDCameraStream(const StreamInfo &info); DCamRetCode GetDCameraStreamInfo(shared_ptr &info); - DCamRetCode SetDCameraBufferQueue(const OHOS::sptr producer); + DCamRetCode SetDCameraBufferQueue(const OHOS::sptr &producer); DCamRetCode ReleaseDCameraBufferQueue(); - DCamRetCode GetDCameraStreamAttribute(shared_ptr &attribute); + DCamRetCode GetDCameraStreamAttribute(StreamAttribute &attribute); DCamRetCode GetDCameraBuffer(DCameraBuffer &buffer); DCamRetCode ReturnDCameraBuffer(const DCameraBuffer &buffer); DCamRetCode FlushDCameraBuffer(); @@ -58,7 +58,7 @@ private: int32_t index_ = -1; int dcStreamId_; shared_ptr dcStreamInfo_ = nullptr; - shared_ptr dcStreamAttribute_ = nullptr; + StreamAttribute dcStreamAttribute_; shared_ptr dcStreamBufferMgr_ = nullptr; OHOS::sptr dcStreamProducer_ = nullptr; map, tuple, int, int>> bufferConfigMap_; diff --git a/distributed_camera/hdi_service/include/dstream_operator/dimage_buffer.h b/distributed_camera/hdi_service/include/dstream_operator/dimage_buffer.h index 207e4c440d..452b009a37 100644 --- a/distributed_camera/hdi_service/include/dstream_operator/dimage_buffer.h +++ b/distributed_camera/hdi_service/include/dstream_operator/dimage_buffer.h @@ -17,7 +17,9 @@ #define DISTRIBUTED_CAMERA_IMAGE_BUFFER_H #include + #include "constants.h" +#include "v1_0/dcamera_types.h" namespace OHOS { namespace DistributedHardware { diff --git a/distributed_camera/hdi_service/include/dstream_operator/doffline_stream_operator.h b/distributed_camera/hdi_service/include/dstream_operator/doffline_stream_operator.h index 62c6d624f2..f042016a8b 100644 --- a/distributed_camera/hdi_service/include/dstream_operator/doffline_stream_operator.h +++ b/distributed_camera/hdi_service/include/dstream_operator/doffline_stream_operator.h @@ -16,12 +16,12 @@ #ifndef DISTRIBUTED_CAMERA_OFFLINE_STREAM_OPERATOR_H #define DISTRIBUTED_CAMERA_OFFLINE_STREAM_OPERATOR_H -#include "doffline_stream_operator_stub.h" -#include "dcamera.h" +#include "v1_0/ioffline_stream_operator.h" namespace OHOS { namespace DistributedHardware { -class DOfflineStreamOperator : public DOfflineStreamOperatorStub { +using namespace OHOS::HDI::Camera::V1_0; +class DOfflineStreamOperator : public IOfflineStreamOperator { public: DOfflineStreamOperator() = default; virtual ~DOfflineStreamOperator() = default; @@ -31,9 +31,9 @@ public: DOfflineStreamOperator& operator=(DOfflineStreamOperator &&other) = delete; public: - virtual CamRetCode CancelCapture(int captureId) override; - virtual CamRetCode ReleaseStreams(const std::vector& streamIds) override; - virtual CamRetCode Release() override; + int32_t CancelCapture(int32_t captureId) override; + int32_t ReleaseStreams(const std::vector& streamIds) override; + int32_t Release() override; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h b/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h index 5683d892b3..51414fdb45 100644 --- a/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h +++ b/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h @@ -19,21 +19,22 @@ #include #include #include -#include "istream_operator.h" -#include "dstream_operator_stub.h" -#include "dcamera.h" -#include "dmetadata_processor.h" -#include "types.h" + #include "constants.h" +#include "dcamera.h" #include "dcamera_stream.h" +#include "dmetadata_processor.h" #include "json/json.h" +#include "v1_0/istream_operator.h" +#include "v1_0/types.h" namespace OHOS { namespace DistributedHardware { using namespace std; +using namespace OHOS::HDI::Camera::V1_0; class DCameraProvider; -class DStreamOperator : public DStreamOperatorStub { +class DStreamOperator : public IStreamOperator { public: explicit DStreamOperator(std::shared_ptr &dMetadataProcessor); DStreamOperator() = default; @@ -44,31 +45,32 @@ public: DStreamOperator& operator=(DStreamOperator &&other) = delete; public: - CamRetCode IsStreamsSupported(OperationMode mode, const std::shared_ptr &modeSetting, - const std::vector> &info, StreamSupportType &type) override; - CamRetCode CreateStreams(const std::vector>& streamInfos) override; - CamRetCode ReleaseStreams(const std::vector& streamIds) override; - CamRetCode CommitStreams(OperationMode mode, const std::shared_ptr& modeSetting) override; - CamRetCode GetStreamAttributes(std::vector>& attributes) override; - CamRetCode AttachBufferQueue(int streamId, const OHOS::sptr& producer) override; - CamRetCode DetachBufferQueue(int streamId) override; - CamRetCode Capture(int captureId, const std::shared_ptr& captureInfo, bool isStreaming) override; - CamRetCode CancelCapture(int captureId) override; - CamRetCode ChangeToOfflineStream(const std::vector& streamIds, OHOS::sptr& callback, - OHOS::sptr& offlineOperator) override; + int32_t IsStreamsSupported(OperationMode mode, const std::vector &modeSetting, + const std::vector &infos, StreamSupportType &type) override; + int32_t CreateStreams(const std::vector &streamInfos) override; + int32_t ReleaseStreams(const std::vector &streamIds) override; + int32_t CommitStreams(OperationMode mode, const std::vector &modeSetting) override; + int32_t GetStreamAttributes(std::vector &attributes) override; + int32_t AttachBufferQueue(int32_t streamId, const sptr &bufferProducer) override; + int32_t DetachBufferQueue(int32_t streamId) override; + int32_t Capture(int32_t captureId, const CaptureInfo &info, bool isStreaming) override; + int32_t CancelCapture(int32_t captureId) override; + int32_t ChangeToOfflineStream(const std::vector &streamIds, + const sptr &callbackObj, sptr &offlineOperator) override; + DCamRetCode InitOutputConfigurations(const DHBase &dhBase, const std::string &abilityInfo); DCamRetCode AcquireBuffer(int streamId, DCameraBuffer &buffer); DCamRetCode ShutterBuffer(int streamId, const DCameraBuffer &buffer); DCamRetCode SetCallBack(OHOS::sptr const &callback); DCamRetCode SetDeviceCallback(function &errorCbk, - function)> &resultCbk); + function)> &resultCbk); void Release(); std::vector GetStreamIds(); private: bool IsCapturing(); void SetCapturing(bool isCapturing); - DCamRetCode NegotiateSuitableCaptureInfo(const std::shared_ptr& srcCaptureInfo, bool isStreaming); + DCamRetCode NegotiateSuitableCaptureInfo(const CaptureInfo& srcCaptureInfo, bool isStreaming); void ChooseSuitableFormat(std::vector> &streamInfo, std::shared_ptr &captureInfo); void ChooseSuitableResolution(std::vector> &streamInfo, @@ -77,16 +79,16 @@ private: std::shared_ptr &captureInfo); void ChooseSuitableEncodeType(std::vector> &streamInfo, std::shared_ptr &captureInfo); - void ConvertStreamInfo(std::shared_ptr &srcInfo, std::shared_ptr &dstInfo); + void ConvertStreamInfo(const StreamInfo &srcInfo, std::shared_ptr &dstInfo); DCEncodeType ConvertDCEncodeType(std::string &srcEncodeType); - std::shared_ptr BuildSuitableCaptureInfo(const shared_ptr& srcCaptureInfo, + std::shared_ptr BuildSuitableCaptureInfo(const CaptureInfo& srcCaptureInfo, std::vector> &srcStreamInfo); void SnapShotStreamOnCaptureEnded(int32_t captureId, int streamId); bool HasContinuousCaptureInfo(int captureId); void ExtractStreamInfo(DCStreamInfo &dstStreamInfo, const std::shared_ptr &srcStreamInfo); void ExtractCaptureInfo(std::vector &captureInfos); void ExtractCameraAttr(Json::Value &rootValue, std::set &allFormats, std::vector &photoFormats); - DCamRetCode GetInputCaptureInfo(const std::shared_ptr& srcCaptureInfo, bool isStreaming, + DCamRetCode GetInputCaptureInfo(const CaptureInfo& srcCaptureInfo, bool isStreaming, std::shared_ptr& inputCaptureInfo); private: @@ -110,7 +112,7 @@ private: bool isCapturing_ = false; std::mutex isCapturingLock_; OperationMode currentOperMode_ = OperationMode::NORMAL; - std::shared_ptr latestStreamSetting_; + std::shared_ptr latestStreamSetting_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/distributed_camera/hdi_service/include/utils/constants.h b/distributed_camera/hdi_service/include/utils/constants.h index b022c0e2fc..6ff64dce30 100644 --- a/distributed_camera/hdi_service/include/utils/constants.h +++ b/distributed_camera/hdi_service/include/utils/constants.h @@ -16,8 +16,8 @@ #ifndef DISTRIBUTED_CONSTANTS_H #define DISTRIBUTED_CONSTANTS_H +#include #include -#include "types.h" namespace OHOS { namespace DistributedHardware { @@ -95,22 +95,6 @@ enum DCameraBufferUsage : uint64_t { CAMERA_USAGE_MEM_DMA = (1 << 2), }; -/* Each virtual camera must include these default resolution. */ -const std::vector> DEFAULT_FMT_VEC { -/* - pair(320, 240), - pair(480, 360), - pair(640, 360), - pair(640, 480), - pair(720, 540), - pair(960, 540), - pair(960, 720), - pair(1280, 720), - pair(1440, 1080), - pair(1920, 1080) -*/ -}; - using DCSceneType = enum _DCSceneType : int32_t { PREVIEW = 0, VIDEO = 1, diff --git a/distributed_camera/hdi_service/include/utils/dcamera.h b/distributed_camera/hdi_service/include/utils/dcamera.h index e38ab8570e..9798789c22 100644 --- a/distributed_camera/hdi_service/include/utils/dcamera.h +++ b/distributed_camera/hdi_service/include/utils/dcamera.h @@ -16,13 +16,17 @@ #ifndef DISTRIBUTED_CAMERA_H #define DISTRIBUTED_CAMERA_H -#include +#include "camera_metadata_info.h" + #include "v1_0/dcamera_types.h" +#include "v1_0/types.h" namespace OHOS { namespace DistributedHardware { -using namespace OHOS::Camera; +using namespace OHOS::HDI::Camera::V1_0; using namespace OHOS::HDI::DistributedCamera::V1_0; +using CameraAbility = OHOS::Camera::CameraMetadata; +using CameraSetting = OHOS::Camera::CameraMetadata; using RetCode = uint32_t; using MetaType = int32_t; const std::string BASE_64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; diff --git a/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp b/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp index 3392848a34..6e22d923e2 100644 --- a/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp +++ b/distributed_camera/hdi_service/src/config/dcamera_host_config.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 @@ -16,90 +16,111 @@ #include #include #include -#include +#include -#include "dcamera_host_stub.h" +#include "dcamera_host.h" +#include "v1_0/camera_host_stub.h" -struct HdfDCameraService { - struct IDeviceIoService ioservice; - void *instance; +using namespace OHOS::HDI::Camera::V1_0; + +struct HdfCameraHostHost { + struct IDeviceIoService ioService; + OHOS::sptr stub; }; -static int32_t DCameraServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, - struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t CameraHostDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, + struct HdfSBuf *reply) { - HdfDCameraService *service = CONTAINER_OF(client->device->service, HdfDCameraService, ioservice); - if (service == nullptr) { - HDF_LOGE("HdfDCameraService CONTAINER_OF failed!"); - return HDF_FAILURE; + auto *hdfCameraHostHost = CONTAINER_OF(client->device->service, struct HdfCameraHostHost, ioService); + + OHOS::MessageParcel *dataParcel = nullptr; + OHOS::MessageParcel *replyParcel = nullptr; + OHOS::MessageOption option; + + if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; } - return DCHostServiceOnRemoteRequest(service->instance, cmdId, data, reply); + if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + + return hdfCameraHostHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); } -static int HdfDCameraHostDriverInit(struct HdfDeviceObject *deviceObject) +static int HdfCameraHostDriverInit(struct HdfDeviceObject *deviceObject) { + HDF_LOGI("HdfCameraHostDriverInit enter"); if (deviceObject == nullptr) { - HDF_LOGE("HdfDCameraHostDriverInit:: HdfDeviceObject is NULL !"); + HDF_LOGE("HdfCameraHostDriverInit:: HdfDeviceObject is NULL !"); return HDF_FAILURE; } if (!HdfDeviceSetClass(deviceObject, DEVICE_CLASS_CAMERA)) { - HDF_LOGE("HdfDCameraHostDriverInit set camera class failed"); + HDF_LOGE("HdfCameraHostDriverInit set camera class failed"); return HDF_FAILURE; } return HDF_SUCCESS; } -static int HdfDCameraHostDriverBind(HdfDeviceObject *deviceObject) +static int HdfCameraHostDriverBind(struct HdfDeviceObject *deviceObject) { - HDF_LOGI("HdfDCameraHostDriverBind enter!"); - if (deviceObject == nullptr) { - HDF_LOGE("HdfDCameraHostDriverBind: HdfDeviceObject is NULL !"); + HDF_LOGI("HdfCameraHostDriverBind enter"); + + auto *hdfCameraHostHost = new (std::nothrow) HdfCameraHostHost; + if (hdfCameraHostHost == nullptr) { + HDF_LOGE("%{public}s: failed to create create HdfCameraHostHost object", __func__); return HDF_FAILURE; } - HdfDCameraService *service = reinterpret_cast(malloc(sizeof(HdfDCameraService))); - if (service == nullptr) { - HDF_LOGE("HdfDCameraHostDriverBind malloc HdfDCameraService failed!"); + hdfCameraHostHost->ioService.Dispatch = CameraHostDriverDispatch; + hdfCameraHostHost->ioService.Open = NULL; + hdfCameraHostHost->ioService.Release = NULL; + + auto serviceImpl = OHOS::DistributedHardware::DCameraHost::GetInstance(); + if (serviceImpl == nullptr) { + HDF_LOGE("%{public}s: failed to get of implement service", __func__); + delete hdfCameraHostHost; return HDF_FAILURE; } - service->ioservice.Dispatch = DCameraServiceDispatch; - service->ioservice.Open = nullptr; - service->ioservice.Release = nullptr; - service->instance = DCameraHostStubInstance(); + hdfCameraHostHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, + ICameraHost::GetDescriptor()); + if (hdfCameraHostHost->stub == nullptr) { + HDF_LOGE("%{public}s: failed to get stub object", __func__); + delete hdfCameraHostHost; + return HDF_FAILURE; + } - deviceObject->service = &service->ioservice; + deviceObject->service = &hdfCameraHostHost->ioService; return HDF_SUCCESS; } -static void HdfDCameraHostDriverRelease(HdfDeviceObject *deviceObject) +static void HdfCameraHostDriverRelease(struct HdfDeviceObject *deviceObject) { + HDF_LOGI("HdfCameraHostDriverRelease enter"); if (deviceObject == nullptr || deviceObject->service == nullptr) { - HDF_LOGE("HdfDCameraHostDriverRelease: deviceObject or deviceObject->service is NULL!"); - return; - } - HdfDCameraService *service = CONTAINER_OF(deviceObject->service, HdfDCameraService, ioservice); - if (service == nullptr) { - HDF_LOGE("HdfDCameraHostDriverRelease: service is NULL!"); + HDF_LOGE("HdfCameraHostDriverRelease not initted"); return; } - free(service); + auto *hdfCameraHostHost = CONTAINER_OF(deviceObject->service, struct HdfCameraHostHost, ioService); + delete hdfCameraHostHost; } -static struct HdfDriverEntry g_dCameraHostDriverEntry = { +static struct HdfDriverEntry g_camerahostDriverEntry = { .moduleVersion = 1, .moduleName = "distributed_camera_service", - .Bind = HdfDCameraHostDriverBind, - .Init = HdfDCameraHostDriverInit, - .Release = HdfDCameraHostDriverRelease, + .Bind = HdfCameraHostDriverBind, + .Init = HdfCameraHostDriverInit, + .Release = HdfCameraHostDriverRelease, }; #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ -HDF_INIT(g_dCameraHostDriverEntry); +HDF_INIT(g_camerahostDriverEntry); #ifdef __cplusplus } diff --git a/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp b/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp index ab275ee2ad..24923a21aa 100644 --- a/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp +++ b/distributed_camera/hdi_service/src/config/dcamera_provider_config.cpp @@ -53,12 +53,12 @@ static int HdfDCameraProviderDriverInit(struct HdfDeviceObject *deviceObject) { HDF_LOGI("HdfDCameraProviderDriverInit enter"); if (deviceObject == nullptr) { - HDF_LOGE("HdfDCameraHostDriverInit:: HdfDeviceObject is NULL !"); + HDF_LOGE("HdfDCameraProviderDriverInit:: HdfDeviceObject is NULL !"); return HDF_FAILURE; } if (!HdfDeviceSetClass(deviceObject, DEVICE_CLASS_CAMERA)) { - HDF_LOGE("HdfDCameraHostDriverInit set camera class failed"); + HDF_LOGE("HdfDCameraProviderDriverInit set camera class failed"); return HDF_FAILURE; } return HDF_SUCCESS; diff --git a/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp b/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp index 665890007a..f727496e27 100644 --- a/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp +++ b/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp @@ -26,7 +26,7 @@ namespace OHOS { namespace DistributedHardware { using ErrorCallback = std::function; -using ResultCallback = std::function)>; +using ResultCallback = std::function)>; DCameraDevice::DCameraDevice(const DHBase &dhBase, const std::string &abilityInfo) : isOpened_(false), dCameraId_(GenerateCameraId(dhBase)), @@ -72,10 +72,12 @@ DCamRetCode DCameraDevice::CreateDStreamOperator() } }; ResultCallback onResultCallback = - [this](uint64_t timestamp, const std::shared_ptr &result) -> void { + [this](uint64_t timestamp, const std::shared_ptr &result) -> void { if (dCameraDeviceCallback_) { DHLOGI("DCameraDevice onResultCallback timestamp: %llu", timestamp); - dCameraDeviceCallback_->OnResult(timestamp, result); + std::vector metadata; + OHOS::Camera::MetadataUtils::ConvertMetadataToVec(result, metadata); + dCameraDeviceCallback_->OnResult(timestamp, metadata); } }; dCameraStreamOperator_->SetDeviceCallback(onErrorCallback, onResultCallback); @@ -83,22 +85,22 @@ DCamRetCode DCameraDevice::CreateDStreamOperator() return ret; } -CamRetCode DCameraDevice::GetStreamOperator(const OHOS::sptr &callback, - OHOS::sptr &streamOperator) +int32_t DCameraDevice::GetStreamOperator(const sptr &callbackObj, + sptr &streamOperator) { if (dCameraStreamOperator_ == nullptr) { DHLOGE("Distributed camera stream operator not init."); return CamRetCode::DEVICE_ERROR; } - if (callback == nullptr) { - DHLOGE("Input callback is null."); + if (callbackObj == nullptr) { + DHLOGE("Input callbackObj is null."); return CamRetCode::INVALID_ARGUMENT; } - DCamRetCode ret = dCameraStreamOperator_->SetCallBack(callback); + DCamRetCode ret = dCameraStreamOperator_->SetCallBack(callbackObj); if (ret != SUCCESS) { - DHLOGE("Set stream operator callback failed, ret=%d.", ret); + DHLOGE("Set stream operator callbackObj failed, ret=%d.", ret); return MapToExternalRetCode(ret); } @@ -106,9 +108,9 @@ CamRetCode DCameraDevice::GetStreamOperator(const OHOS::sptr &settings) +int32_t DCameraDevice::UpdateSettings(const std::vector& settings) { - if (settings == nullptr) { + if (settings.empty()) { DHLOGE("DCameraDevice::UpdateSettings, input settings is null."); return CamRetCode::INVALID_ARGUMENT; } @@ -118,7 +120,9 @@ CamRetCode DCameraDevice::UpdateSettings(const std::shared_ptr &s return CamRetCode::CAMERA_CLOSED; } - std::string abilityString = Camera::MetadataUtils::EncodeToString(settings); + std::shared_ptr updateSettings = nullptr; + OHOS::Camera::MetadataUtils::ConvertVecToMetadata(settings, updateSettings); + std::string abilityString = OHOS::Camera::MetadataUtils::EncodeToString(updateSettings); std::string encodeString = Base64Encode(reinterpret_cast(abilityString.c_str()), abilityString.length()); @@ -139,7 +143,7 @@ CamRetCode DCameraDevice::UpdateSettings(const std::shared_ptr &s return MapToExternalRetCode(static_cast(ret)); } -CamRetCode DCameraDevice::SetResultMode(const ResultCallbackMode &mode) +int32_t DCameraDevice::SetResultMode(ResultCallbackMode mode) { if (dMetadataProcessor_ == nullptr) { DHLOGE("Metadata processor not init."); @@ -153,7 +157,7 @@ CamRetCode DCameraDevice::SetResultMode(const ResultCallbackMode &mode) return MapToExternalRetCode(ret); } -CamRetCode DCameraDevice::GetEnabledResults(std::vector &results) +int32_t DCameraDevice::GetEnabledResults(std::vector &results) { if (dMetadataProcessor_ == nullptr) { DHLOGE("Metadata processor not init."); @@ -167,7 +171,7 @@ CamRetCode DCameraDevice::GetEnabledResults(std::vector &results) return MapToExternalRetCode(ret); } -CamRetCode DCameraDevice::EnableResult(const std::vector &results) +int32_t DCameraDevice::EnableResult(const std::vector &results) { if (dMetadataProcessor_ == nullptr) { DHLOGE("Metadata processor not init."); @@ -197,7 +201,7 @@ CamRetCode DCameraDevice::EnableResult(const std::vector &results) return MapToExternalRetCode(static_cast(retProv)); } -CamRetCode DCameraDevice::DisableResult(const std::vector &results) +int32_t DCameraDevice::DisableResult(const std::vector &results) { if (dMetadataProcessor_ == nullptr) { DHLOGE("Metadata processor not init."); @@ -227,7 +231,7 @@ CamRetCode DCameraDevice::DisableResult(const std::vector &results) return MapToExternalRetCode(static_cast(retProv)); } -void DCameraDevice::Close() +int32_t DCameraDevice::Close() { DHLOGI("DCameraDevice::Close distributed camera: %s", GetAnonyString(dCameraId_).c_str()); @@ -249,6 +253,7 @@ void DCameraDevice::Close() dCameraDeviceCallback_ = nullptr; isOpenSessFailed_ = false; isOpened_ = false; + return CamRetCode::NO_ERROR; } CamRetCode DCameraDevice::OpenDCamera(const OHOS::sptr &callback) diff --git a/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp b/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp index 87df9d8f7b..b99c97f5ec 100644 --- a/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp +++ b/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp @@ -41,7 +41,7 @@ DCamRetCode DMetadataProcessor::InitDCameraAbility(const std::string &abilityInf std::string decodeString = Base64Decode(metadataStr); DHLOGI("Decode distributed camera metadata from string, hash: %zu, length: %zu", h(decodeString), decodeString.length()); - dCameraAbility_ = Camera::MetadataUtils::DecodeFromString(decodeString); + dCameraAbility_ = OHOS::Camera::MetadataUtils::DecodeFromString(decodeString); DHLOGI("Decode distributed camera metadata from string success."); } } @@ -52,7 +52,7 @@ DCamRetCode DMetadataProcessor::InitDCameraAbility(const std::string &abilityInf dCameraAbility_ = std::make_shared(DEFAULT_ENTRY_CAPACITY, DEFAULT_DATA_CAPACITY); } - if (Camera::GetCameraMetadataItemCount(dCameraAbility_->get()) <= 0) { + if (OHOS::Camera::GetCameraMetadataItemCount(dCameraAbility_->get()) <= 0) { DCamRetCode ret = InitDCameraDefaultAbilityKeys(abilityInfo); if (ret != SUCCESS) { DHLOGE("Init distributed camera defalult abilily keys failed."); @@ -68,7 +68,7 @@ DCamRetCode DMetadataProcessor::InitDCameraAbility(const std::string &abilityInf return ret; } - camera_metadata_item_entry_t* itemEntry = Camera::GetMetadataItems(dCameraAbility_->get()); + camera_metadata_item_entry_t* itemEntry = OHOS::Camera::GetMetadataItems(dCameraAbility_->get()); uint32_t count = dCameraAbility_->get()->item_count; for (uint32_t i = 0; i < count; i++, itemEntry++) { allResultSet_.insert((MetaType)(itemEntry->item)); @@ -255,7 +255,7 @@ DCamRetCode DMetadataProcessor::AddAbilityEntry(uint32_t tag, const void *data, } camera_metadata_item_t item; - int ret = Camera::FindCameraMetadataItem(dCameraAbility_->get(), tag, &item); + int ret = OHOS::Camera::FindCameraMetadataItem(dCameraAbility_->get(), tag, &item); if (ret) { if (!dCameraAbility_->addEntry(tag, data, size)) { DHLOGE("Add tag %u failed.", tag); @@ -273,7 +273,7 @@ DCamRetCode DMetadataProcessor::UpdateAbilityEntry(uint32_t tag, const void *dat } camera_metadata_item_t item; - int ret = Camera::FindCameraMetadataItem(dCameraAbility_->get(), tag, &item); + int ret = OHOS::Camera::FindCameraMetadataItem(dCameraAbility_->get(), tag, &item); if (ret) { if (!dCameraAbility_->addEntry(tag, data, size)) { DHLOGE("Add tag %u failed.", tag); @@ -385,18 +385,19 @@ void DMetadataProcessor::UpdateResultMetadata(const uint64_t &resultTimestamp) } void DMetadataProcessor::SetResultCallback( - std::function)> &resultCbk) + std::function)> &resultCbk) { resultCallback_ = resultCbk; } void DMetadataProcessor::UpdateAllResult(const uint64_t &resultTimestamp) { - uint32_t itemCap = Camera::GetCameraMetadataItemCapacity(latestProducerMetadataResult_->get()); - uint32_t dataSize = Camera::GetCameraMetadataDataSize(latestProducerMetadataResult_->get()); + uint32_t itemCap = OHOS::Camera::GetCameraMetadataItemCapacity(latestProducerMetadataResult_->get()); + uint32_t dataSize = OHOS::Camera::GetCameraMetadataDataSize(latestProducerMetadataResult_->get()); DHLOGD("DMetadataProcessor::UpdateAllResult itemCapacity: %u, dataSize: %u", itemCap, dataSize); - std::shared_ptr result = std::make_shared(itemCap, dataSize); - int32_t ret = Camera::CopyCameraMetadataItems(result->get(), latestProducerMetadataResult_->get()); + std::shared_ptr result = + std::make_shared(itemCap, dataSize); + int32_t ret = OHOS::Camera::CopyCameraMetadataItems(result->get(), latestProducerMetadataResult_->get()); if (ret != CAM_META_SUCCESS) { DHLOGE("DMetadataProcessor::UpdateAllResult copy metadata item failed, ret: %d", ret); return; @@ -407,17 +408,18 @@ void DMetadataProcessor::UpdateAllResult(const uint64_t &resultTimestamp) void DMetadataProcessor::UpdateOnChanged(const uint64_t &resultTimestamp) { bool needReturn = false; - uint32_t itemCap = Camera::GetCameraMetadataItemCapacity(latestProducerMetadataResult_->get()); - uint32_t dataSize = Camera::GetCameraMetadataDataSize(latestProducerMetadataResult_->get()); + uint32_t itemCap = OHOS::Camera::GetCameraMetadataItemCapacity(latestProducerMetadataResult_->get()); + uint32_t dataSize = OHOS::Camera::GetCameraMetadataDataSize(latestProducerMetadataResult_->get()); DHLOGD("DMetadataProcessor::UpdateOnChanged itemCapacity: %u, dataSize: %u", itemCap, dataSize); - std::shared_ptr result = std::make_shared(itemCap, dataSize); + std::shared_ptr result = + std::make_shared(itemCap, dataSize); DHLOGD("DMetadataProcessor::UpdateOnChanged enabledResultSet size: %d", enabledResultSet_.size()); for (auto tag : enabledResultSet_) { DHLOGD("DMetadataProcessor::UpdateOnChanged cameta device metadata tag: %d", tag); camera_metadata_item_t item; camera_metadata_item_t anoItem; - int ret1 = Camera::FindCameraMetadataItem(latestProducerMetadataResult_->get(), tag, &item); - int ret2 = Camera::FindCameraMetadataItem(latestConsumerMetadataResult_->get(), tag, &anoItem); + int ret1 = OHOS::Camera::FindCameraMetadataItem(latestProducerMetadataResult_->get(), tag, &item); + int ret2 = OHOS::Camera::FindCameraMetadataItem(latestConsumerMetadataResult_->get(), tag, &anoItem); DHLOGD("DMetadataProcessor::UpdateOnChanged find metadata item ret: %d, %d", ret1, ret2); if (ret1 != CAM_META_SUCCESS) { continue; @@ -460,13 +462,13 @@ DCamRetCode DMetadataProcessor::SaveResultMetadata(std::string resultStr) std::string metadataStr = Base64Decode(resultStr); std::lock_guard autoLock(producerMutex_); latestConsumerMetadataResult_ = latestProducerMetadataResult_; - latestProducerMetadataResult_ = Camera::MetadataUtils::DecodeFromString(metadataStr); + latestProducerMetadataResult_ = OHOS::Camera::MetadataUtils::DecodeFromString(metadataStr); if (latestProducerMetadataResult_ == nullptr) { DHLOGE("Failed to decode metadata setting from string."); return DCamRetCode::INVALID_ARGUMENT; } - if (!Camera::GetCameraMetadataItemCount(latestProducerMetadataResult_->get())) { + if (!OHOS::Camera::GetCameraMetadataItemCount(latestProducerMetadataResult_->get())) { DHLOGE("Input result metadata item is empty."); return DCamRetCode::INVALID_ARGUMENT; } @@ -482,7 +484,7 @@ DCamRetCode DMetadataProcessor::SaveResultMetadata(std::string resultStr) return SUCCESS; } - camera_metadata_item_entry_t* itemEntry = Camera::GetMetadataItems(latestProducerMetadataResult_->get()); + camera_metadata_item_entry_t* itemEntry = OHOS::Camera::GetMetadataItems(latestProducerMetadataResult_->get()); uint32_t count = latestProducerMetadataResult_->get()->item_count; for (uint32_t i = 0; i < count; i++, itemEntry++) { enabledResultSet_.insert((MetaType)(itemEntry->item)); @@ -492,9 +494,9 @@ DCamRetCode DMetadataProcessor::SaveResultMetadata(std::string resultStr) } void DMetadataProcessor::ConvertToCameraMetadata(common_metadata_header_t *&input, - std::shared_ptr &output) + std::shared_ptr &output) { - auto ret = Camera::CopyCameraMetadataItems(output->get(), input); + auto ret = OHOS::Camera::CopyCameraMetadataItems(output->get(), input); if (ret != CAM_META_SUCCESS) { DHLOGE("Failed to copy the old metadata to new metadata."); output = nullptr; @@ -505,9 +507,9 @@ void DMetadataProcessor::ResizeMetadataHeader(common_metadata_header_t *&header, uint32_t itemCapacity, uint32_t dataCapacity) { if (header) { - Camera::FreeCameraMetadataBuffer(header); + OHOS::Camera::FreeCameraMetadataBuffer(header); } - header = Camera::AllocateCameraMetadataBuffer(itemCapacity, dataCapacity); + header = OHOS::Camera::AllocateCameraMetadataBuffer(itemCapacity, dataCapacity); } uint32_t DMetadataProcessor::GetDataSize(uint32_t type) @@ -650,16 +652,16 @@ void DMetadataProcessor::PrintDCameraMetadata(const common_metadata_header_t *me return; } - uint32_t tagCount = Camera::GetCameraMetadataItemCount(metadata); + uint32_t tagCount = OHOS::Camera::GetCameraMetadataItemCount(metadata); DHLOGD("DMetadataProcessor::PrintDCameraMetadata, input metadata item count = %d.", tagCount); for (uint32_t i = 0; i < tagCount; i++) { camera_metadata_item_t item; - int ret = Camera::GetCameraMetadataItem(metadata, i, &item); + int ret = OHOS::Camera::GetCameraMetadataItem(metadata, i, &item); if (ret != 0) { continue; } - const char *name = Camera::GetCameraMetadataItemName(item.item); + const char *name = OHOS::Camera::GetCameraMetadataItemName(item.item); if (item.data_type == META_TYPE_BYTE) { for (size_t k = 0; k < item.count; k++) { DHLOGI("tag index:%d, name:%s, value:%d", item.index, name, (uint8_t)(item.data.u8[k])); diff --git a/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp b/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp index 26eac7956a..f0552f2322 100644 --- a/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp +++ b/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp @@ -14,18 +14,25 @@ */ #include "dcamera_host.h" + #include "anonymous_string.h" #include "distributed_hardware_log.h" +#include "metadata_utils.h" namespace OHOS { namespace DistributedHardware { -std::shared_ptr DCameraHost::instance_ = nullptr; +OHOS::sptr DCameraHost::instance_ = nullptr; DCameraHost::AutoRelease DCameraHost::autoRelease_; -std::shared_ptr DCameraHost::GetInstance() +extern "C" ICameraHost *CameraHostImplGetInstance(void) +{ + return static_cast(DCameraHost::GetInstance().GetRefPtr()); +} + +OHOS::sptr DCameraHost::GetInstance() { if (instance_ == nullptr) { - instance_ = std::make_shared(); + instance_ = new DCameraHost(); if (instance_ == nullptr) { DHLOGE("Get distributed camera host instance failed."); return nullptr; @@ -34,17 +41,17 @@ std::shared_ptr DCameraHost::GetInstance() return instance_; } -CamRetCode DCameraHost::SetCallback(const OHOS::sptr &callback) +int32_t DCameraHost::SetCallback(const sptr &callbackObj) { - if (callback == nullptr) { + if (callbackObj == nullptr) { DHLOGE("DCameraHost::SetCallback, camera host callback is null."); return CamRetCode::INVALID_ARGUMENT; } - dCameraHostCallback_ = callback; + dCameraHostCallback_ = callbackObj; return CamRetCode::NO_ERROR; } -CamRetCode DCameraHost::GetCameraIds(std::vector &cameraIds) +int32_t DCameraHost::GetCameraIds(std::vector &cameraIds) { auto iter = dhBaseHashDCamIdMap_.begin(); while (iter != dhBaseHashDCamIdMap_.end()) { @@ -56,8 +63,7 @@ CamRetCode DCameraHost::GetCameraIds(std::vector &cameraIds) return CamRetCode::NO_ERROR; } -CamRetCode DCameraHost::GetCameraAbility(const std::string &cameraId, - std::shared_ptr &ability) +int32_t DCameraHost::GetCameraAbility(const std::string &cameraId, std::vector &cameraAbility) { DHLOGE("DCameraHost::GetCameraAbility for cameraId: %s", GetAnonyString(cameraId).c_str()); @@ -67,14 +73,24 @@ CamRetCode DCameraHost::GetCameraAbility(const std::string &cameraId, } auto iter = dCameraDeviceMap_.find(cameraId); - CamRetCode retCode = (iter->second)->GetDCameraAbility(ability); + std::shared_ptr ability = nullptr; + int32_t ret = (iter->second)->GetDCameraAbility(ability); + if (ret != CamRetCode::NO_ERROR) { + DHLOGE("DCameraHost::GetCameraAbility, GetDCameraAbility failed, ret: %d.", ret); + return ret; + } + bool retBool = OHOS::Camera::MetadataUtils::ConvertMetadataToVec(ability, cameraAbility); + if (!retBool) { + DHLOGE("DCameraHost::GetCameraAbility, ConvertMetadataToVec failed."); + return CamRetCode::INVALID_ARGUMENT; + } do { camera_metadata_item_t item; constexpr uint32_t WIDTH_OFFSET = 1; constexpr uint32_t HEIGHT_OFFSET = 2; constexpr uint32_t UNIT_LENGTH = 3; - int32_t ret = Camera::FindCameraMetadataItem(ability->get(), + int32_t ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item); DHLOGI("FindCameraMetadataItem item=%u, count=%u, dataType=%u", item.item, item.count, item.data_type); if (ret != CAM_META_SUCCESS) { @@ -92,17 +108,15 @@ CamRetCode DCameraHost::GetCameraAbility(const std::string &cameraId, DHLOGD("format: %d, width: %d, height: %d", format, width, height); } } while (0); - - return retCode; + return CamRetCode::NO_ERROR; } -CamRetCode DCameraHost::OpenCamera(const std::string &cameraId, - const OHOS::sptr &callback, - OHOS::sptr &pDevice) +int32_t DCameraHost::OpenCamera(const std::string &cameraId, const sptr &callbackObj, + sptr &device) { DHLOGI("DCameraHost::OpenCamera for cameraId: %s", GetAnonyString(cameraId).c_str()); - if (IsCameraIdInvalid(cameraId) || callback == nullptr) { + if (IsCameraIdInvalid(cameraId) || callbackObj == nullptr) { DHLOGE("DCameraHost::OpenCamera, open camera id is empty or callback is null."); return CamRetCode::INVALID_ARGUMENT; } @@ -124,18 +138,18 @@ CamRetCode DCameraHost::OpenCamera(const std::string &cameraId, return CamRetCode::CAMERA_BUSY; } - CamRetCode ret = dcameraDevice->OpenDCamera(callback); + CamRetCode ret = dcameraDevice->OpenDCamera(callbackObj); if (ret != CamRetCode::NO_ERROR) { DHLOGE("DCameraHost::OpenCamera, open camera failed."); return ret; } - pDevice = dcameraDevice; + device = dcameraDevice; DHLOGI("DCameraHost::OpenCamera, open camera %s success.", GetAnonyString(cameraId).c_str()); return CamRetCode::NO_ERROR; } -CamRetCode DCameraHost::SetFlashlight(const std::string &cameraId, bool &isEnable) +int32_t DCameraHost::SetFlashlight(const std::string &cameraId, bool isEnable) { (void)cameraId; (void)isEnable; diff --git a/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp b/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp index 4e586ca451..d2987c39e0 100644 --- a/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp +++ b/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp @@ -61,7 +61,7 @@ int32_t DCameraProvider::EnableDCameraDevice(const DHBase& dhBase, const std::st return DCamRetCode::INVALID_ARGUMENT; } - std::shared_ptr dCameraHost = DCameraHost::GetInstance(); + OHOS::sptr dCameraHost = DCameraHost::GetInstance(); if (dCameraHost == nullptr) { DHLOGE("DCameraProvider::EnableDCameraDevice, dcamera host is null."); return DCamRetCode::DEVICE_NOT_INIT; @@ -84,7 +84,7 @@ int32_t DCameraProvider::DisableDCameraDevice(const DHBase& dhBase) return DCamRetCode::INVALID_ARGUMENT; } - std::shared_ptr dCameraHost = DCameraHost::GetInstance(); + OHOS::sptr dCameraHost = DCameraHost::GetInstance(); if (dCameraHost == nullptr) { DHLOGE("DCameraProvider::DisableDCameraDevice, dcamera host is null."); return DCamRetCode::DEVICE_NOT_INIT; @@ -100,7 +100,7 @@ int32_t DCameraProvider::DisableDCameraDevice(const DHBase& dhBase) int32_t DCameraProvider::AcquireBuffer(const DHBase& dhBase, int32_t streamId, DCameraBuffer& buffer) { - DHLOGI("DCameraProvider::AcquireBuffer for {devId: %s, dhId: %s}, streamId: %d.", + DHLOGD("DCameraProvider::AcquireBuffer for {devId: %s, dhId: %s}, streamId: %d.", GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str(), streamId); OHOS::sptr device = GetDCameraDevice(dhBase); @@ -309,7 +309,7 @@ sptr DCameraProvider::GetCallbackBydhBase(const DHBase OHOS::sptr DCameraProvider::GetDCameraDevice(const DHBase &dhBase) { - std::shared_ptr dCameraHost = DCameraHost::GetInstance(); + OHOS::sptr dCameraHost = DCameraHost::GetInstance(); if (dCameraHost == nullptr) { DHLOGE("DCameraProvider::GetDCameraDevice, dcamera host is null."); return nullptr; diff --git a/distributed_camera/hdi_service/src/dstream_operator/dcamera_stream.cpp b/distributed_camera/hdi_service/src/dstream_operator/dcamera_stream.cpp index af3b51964c..86558e905a 100644 --- a/distributed_camera/hdi_service/src/dstream_operator/dcamera_stream.cpp +++ b/distributed_camera/hdi_service/src/dstream_operator/dcamera_stream.cpp @@ -22,41 +22,35 @@ namespace OHOS { namespace DistributedHardware { -DCamRetCode DCameraStream::InitDCameraStream(const shared_ptr &info) +DCamRetCode DCameraStream::InitDCameraStream(const StreamInfo &info) { - if ((info->streamId_ < 0) || (info->width_ < 0) || (info->height_ < 0) || - (info->format_ < 0) || (info->dataspace_ < 0)) { + if ((info.streamId_ < 0) || (info.width_ < 0) || (info.height_ < 0) || + (info.format_ < 0) || (info.dataspace_ < 0)) { DHLOGE("Stream info is invalid."); return DCamRetCode::INVALID_ARGUMENT; } - dcStreamId_ = info->streamId_; + dcStreamId_ = info.streamId_; dcStreamInfo_ = std::make_shared(); - dcStreamInfo_->streamId_ = info->streamId_; - dcStreamInfo_->width_ = info->width_; - dcStreamInfo_->height_ = info->height_; - dcStreamInfo_->format_ = info->format_; - dcStreamInfo_->dataspace_ = info->dataspace_; - dcStreamInfo_->intent_ = info->intent_; - dcStreamInfo_->tunneledMode_ = info->tunneledMode_; - dcStreamInfo_->bufferQueue_ = info->bufferQueue_; - dcStreamInfo_->minFrameDuration_ = info->minFrameDuration_; - - if (dcStreamAttribute_ == nullptr) { - dcStreamAttribute_ = std::make_shared(); - if (dcStreamAttribute_ == nullptr) { - return DCamRetCode::FAILED; - } - } - dcStreamAttribute_->streamId_ = dcStreamInfo_->streamId_; - dcStreamAttribute_->width_ = dcStreamInfo_->width_; - dcStreamAttribute_->height_ = dcStreamInfo_->height_; - dcStreamAttribute_->overrideFormat_ = dcStreamInfo_->format_; - dcStreamAttribute_->overrideDataspace_ = dcStreamInfo_->dataspace_; - dcStreamAttribute_->producerUsage_ = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA; - - dcStreamAttribute_->producerBufferCount_ = BUFFER_QUEUE_SIZE; - dcStreamAttribute_->maxBatchCaptureCount_ = BUFFER_QUEUE_SIZE; - dcStreamAttribute_->maxCaptureCount_ = 1; + dcStreamInfo_->streamId_ = info.streamId_; + dcStreamInfo_->width_ = info.width_; + dcStreamInfo_->height_ = info.height_; + dcStreamInfo_->format_ = info.format_; + dcStreamInfo_->dataspace_ = info.dataspace_; + dcStreamInfo_->intent_ = info.intent_; + dcStreamInfo_->tunneledMode_ = info.tunneledMode_; + dcStreamInfo_->bufferQueue_ = info.bufferQueue_; + dcStreamInfo_->minFrameDuration_ = info.minFrameDuration_; + + dcStreamAttribute_.streamId_ = dcStreamInfo_->streamId_; + dcStreamAttribute_.width_ = dcStreamInfo_->width_; + dcStreamAttribute_.height_ = dcStreamInfo_->height_; + dcStreamAttribute_.overrideFormat_ = dcStreamInfo_->format_; + dcStreamAttribute_.overrideDataspace_ = dcStreamInfo_->dataspace_; + dcStreamAttribute_.producerUsage_ = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA; + + dcStreamAttribute_.producerBufferCount_ = BUFFER_QUEUE_SIZE; + dcStreamAttribute_.maxBatchCaptureCount_ = BUFFER_QUEUE_SIZE; + dcStreamAttribute_.maxCaptureCount_ = 1; DCamRetCode ret = DCamRetCode::SUCCESS; if (dcStreamInfo_->bufferQueue_ != nullptr) { @@ -75,8 +69,8 @@ DCamRetCode DCameraStream::InitDCameraBufferManager() return DCamRetCode::INVALID_ARGUMENT; } - if (dcStreamInfo_->bufferQueue_ != nullptr) { - dcStreamProducer_ = OHOS::Surface::CreateSurfaceAsProducer(dcStreamInfo_->bufferQueue_); + if (dcStreamInfo_->bufferQueue_ != nullptr && dcStreamInfo_->bufferQueue_->producer_ != nullptr) { + dcStreamProducer_ = OHOS::Surface::CreateSurfaceAsProducer(dcStreamInfo_->bufferQueue_->producer_); } if (dcStreamProducer_ == nullptr) { DHLOGE("Distributed camera stream producer is invalid."); @@ -101,7 +95,7 @@ DCamRetCode DCameraStream::GetDCameraStreamInfo(shared_ptr &info) return DCamRetCode::SUCCESS; } -DCamRetCode DCameraStream::SetDCameraBufferQueue(const OHOS::sptr producer) +DCamRetCode DCameraStream::SetDCameraBufferQueue(const OHOS::sptr &producer) { if (dcStreamInfo_->bufferQueue_) { DHLOGE("Stream [%d] has already have bufferQueue.", dcStreamId_); @@ -123,6 +117,9 @@ DCamRetCode DCameraStream::ReleaseDCameraBufferQueue() DHLOGE("Release distributed camera buffer queue failed."); return ret; } + if (dcStreamInfo_->bufferQueue_ != nullptr) { + dcStreamInfo_->bufferQueue_->producer_ = nullptr; + } dcStreamInfo_->bufferQueue_ = nullptr; dcStreamProducer_ = nullptr; dcStreamBufferMgr_ = nullptr; @@ -130,12 +127,9 @@ DCamRetCode DCameraStream::ReleaseDCameraBufferQueue() return DCamRetCode::SUCCESS; } -DCamRetCode DCameraStream::GetDCameraStreamAttribute(shared_ptr &attribute) +DCamRetCode DCameraStream::GetDCameraStreamAttribute(StreamAttribute &attribute) { attribute = dcStreamAttribute_; - if (attribute == nullptr) { - return DCamRetCode::INVALID_ARGUMENT; - } return DCamRetCode::SUCCESS; } diff --git a/distributed_camera/hdi_service/src/dstream_operator/doffline_stream_operator.cpp b/distributed_camera/hdi_service/src/dstream_operator/doffline_stream_operator.cpp index fc3c721f81..7384048ad7 100644 --- a/distributed_camera/hdi_service/src/dstream_operator/doffline_stream_operator.cpp +++ b/distributed_camera/hdi_service/src/dstream_operator/doffline_stream_operator.cpp @@ -18,19 +18,19 @@ namespace OHOS { namespace DistributedHardware { -CamRetCode DOfflineStreamOperator::CancelCapture(int captureId) +int32_t DOfflineStreamOperator::CancelCapture(int32_t captureId) { (void)captureId; return CamRetCode::METHOD_NOT_SUPPORTED; } -CamRetCode DOfflineStreamOperator::ReleaseStreams(const std::vector& streamIds) +int32_t DOfflineStreamOperator::ReleaseStreams(const std::vector& streamIds) { (void)streamIds; return CamRetCode::METHOD_NOT_SUPPORTED; } -CamRetCode DOfflineStreamOperator::Release() +int32_t DOfflineStreamOperator::Release() { return CamRetCode::METHOD_NOT_SUPPORTED; } diff --git a/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp b/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp index 7063e0e8c8..102b3ebc62 100644 --- a/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp +++ b/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp @@ -28,22 +28,15 @@ DStreamOperator::DStreamOperator(std::shared_ptr &dMetadataP DHLOGI("DStreamOperator::ctor, instance = %p", this); } -CamRetCode DStreamOperator::IsStreamsSupported(OperationMode mode, - const std::shared_ptr &modeSetting, - const std::vector> &info, - StreamSupportType &type) +int32_t DStreamOperator::IsStreamsSupported(OperationMode mode, const std::vector &modeSetting, + const std::vector &infos, StreamSupportType &type) { (void)mode; - type = Camera::DYNAMIC_SUPPORTED; + (void)modeSetting; + type = DYNAMIC_SUPPORTED; - if (modeSetting == nullptr) { - DHLOGE("Input invalid argument: modeSetting:%p.", - modeSetting.get()); - return CamRetCode::INVALID_ARGUMENT; - } - - for (auto it : info) { - int id = it->streamId_; + for (const auto &it : infos) { + int id = it.streamId_; if (halStreamMap_.find(id) != halStreamMap_.end()) { DHLOGE("Repeat streamId."); return CamRetCode::INVALID_ARGUMENT; @@ -52,7 +45,7 @@ CamRetCode DStreamOperator::IsStreamsSupported(OperationMode mode, return CamRetCode::NO_ERROR; } -CamRetCode DStreamOperator::CreateStreams(const std::vector>& streamInfos) +int32_t DStreamOperator::CreateStreams(const std::vector &streamInfos) { DHLOGI("DStreamOperator::CreateStreams, input stream info size=%d.", streamInfos.size()); if (streamInfos.empty()) { @@ -60,14 +53,14 @@ CamRetCode DStreamOperator::CreateStreams(const std::vectorstreamId_, info->intent_, info->width_, info->height_, info->format_, - info->dataspace_, info->encodeType_); - if (halStreamMap_.find(info->streamId_) != halStreamMap_.end()) { + "dataspace=%d, encodeType=%d", info.streamId_, info.intent_, info.width_, info.height_, info.format_, + info.dataspace_, info.encodeType_); + if (halStreamMap_.find(info.streamId_) != halStreamMap_.end()) { return CamRetCode::INVALID_ARGUMENT; } - if (!info->tunneledMode_) { + if (!info.tunneledMode_) { return CamRetCode::METHOD_NOT_SUPPORTED; } @@ -77,11 +70,11 @@ CamRetCode DStreamOperator::CreateStreams(const std::vectorstreamId_] = dcStream; + halStreamMap_[info.streamId_] = dcStream; std::shared_ptr dcStreamInfo = std::make_shared(); ConvertStreamInfo(info, dcStreamInfo); - dcStreamInfoMap_[info->streamId_] = dcStreamInfo; + dcStreamInfoMap_[info.streamId_] = dcStreamInfo; DHLOGI("DStreamOperator::CreateStreams, dcStreamInfo: id=%d, type=%d, width=%d, height=%d, format=%d, " + "dataspace=%d, encodeType=%d", dcStreamInfo->streamId_, dcStreamInfo->type_, dcStreamInfo->width_, dcStreamInfo->height_, dcStreamInfo->format_, dcStreamInfo->dataspace_, dcStreamInfo->encodeType_); @@ -90,7 +83,7 @@ CamRetCode DStreamOperator::CreateStreams(const std::vector& streamIds) +int32_t DStreamOperator::ReleaseStreams(const std::vector &streamIds) { DHLOGI("DStreamOperator::ReleaseStreams, input stream id list size=%d.", streamIds.size()); if (IsCapturing()) { @@ -146,8 +139,7 @@ void DStreamOperator::ExtractStreamInfo(DCStreamInfo &dstStreamInfo, dstStreamInfo.type_ = srcStreamInfo->type_; } -CamRetCode DStreamOperator::CommitStreams(OperationMode mode, - const std::shared_ptr& modeSetting) +int32_t DStreamOperator::CommitStreams(OperationMode mode, const std::vector &modeSetting) { DHLOGI("DStreamOperator::CommitStreams, input operation mode=%d.", mode); if (IsCapturing()) { @@ -158,10 +150,13 @@ CamRetCode DStreamOperator::CommitStreams(OperationMode mode, if (currentOperMode_ != mode) { currentOperMode_ = mode; } - if (modeSetting == nullptr || modeSetting.get() == nullptr) { + + std::shared_ptr setting = nullptr; + OHOS::Camera::MetadataUtils::ConvertVecToMetadata(modeSetting, setting); + if (setting == nullptr || setting.get() == nullptr) { DHLOGE("Input stream mode setting is invalid."); } else { - latestStreamSetting_ = modeSetting; + latestStreamSetting_ = setting; } if (dcStreamInfoMap_.size() == 0) { @@ -202,11 +197,11 @@ CamRetCode DStreamOperator::CommitStreams(OperationMode mode, return CamRetCode::NO_ERROR; } -CamRetCode DStreamOperator::GetStreamAttributes(std::vector>& attributes) +int32_t DStreamOperator::GetStreamAttributes(std::vector &attributes) { attributes.clear(); - for (auto stream : halStreamMap_) { - std::shared_ptr attribute; + for (const auto &stream : halStreamMap_) { + StreamAttribute attribute; DCamRetCode ret = stream.second->GetDCameraStreamAttribute(attribute); if (ret != SUCCESS) { DHLOGE("Get distributed camera stream attribute failed."); @@ -218,7 +213,7 @@ CamRetCode DStreamOperator::GetStreamAttributes(std::vector& producer) +int32_t DStreamOperator::AttachBufferQueue(int32_t streamId, const sptr &bufferProducer) { if (IsCapturing()) { DHLOGE("Can not attach buffer queue when capture."); @@ -227,7 +222,7 @@ CamRetCode DStreamOperator::AttachBufferQueue(int streamId, const OHOS::sptrsecond->SetDCameraBufferQueue(producer); + DCamRetCode ret = iter->second->SetDCameraBufferQueue(bufferProducer); if (ret != SUCCESS) { DHLOGE("Attach distributed camera buffer queue failed."); } @@ -238,7 +233,7 @@ CamRetCode DStreamOperator::AttachBufferQueue(int streamId, const OHOS::sptr &captureInfo } } -CamRetCode DStreamOperator::Capture(int captureId, const std::shared_ptr& captureInfo, bool isStreaming) +int32_t DStreamOperator::Capture(int32_t captureId, const CaptureInfo &info, bool isStreaming) { if (captureId < 0 || halCaptureInfoMap_.find(captureId) != halCaptureInfoMap_.end()) { DHLOGE("Input captureId %d is exist.", captureId); return CamRetCode::INVALID_ARGUMENT; } - if (!captureInfo) { - DHLOGE("Input capture info is null."); - return CamRetCode::INVALID_ARGUMENT; - } - - for (auto &id : captureInfo->streamIds_) { + for (const auto &id : info.streamIds_) { auto iter = halStreamMap_.find(id); if (iter == halStreamMap_.end()) { DHLOGE("Invalid stream id %d", id); @@ -298,11 +288,11 @@ CamRetCode DStreamOperator::Capture(int captureId, const std::shared_ptrfirst); return CamRetCode::INVALID_ARGUMENT; } - enableShutterCbkMap_[id] = captureInfo->enableShutterCallback_; + enableShutterCbkMap_[id] = info.enableShutterCallback_; DHLOGI("DStreamOperator::Capture info: captureId=%d, streamId=%d, isStreaming=%d", captureId, id, isStreaming); } - DCamRetCode ret = NegotiateSuitableCaptureInfo(captureInfo, isStreaming); + DCamRetCode ret = NegotiateSuitableCaptureInfo(info, isStreaming); if (ret != SUCCESS) { DHLOGE("Negotiate suitable capture info failed."); return MapToExternalRetCode(ret); @@ -320,10 +310,14 @@ CamRetCode DStreamOperator::Capture(int captureId, const std::shared_ptr(retProv)); } + std::shared_ptr captureInfo = std::make_shared(); + captureInfo->streamIds_.assign(info.streamIds_.begin(), info.streamIds_.end()); + captureInfo->captureSetting_.assign(info.captureSetting_.begin(), info.captureSetting_.end()); + captureInfo->enableShutterCallback_ = info.enableShutterCallback_; halCaptureInfoMap_[captureId] = captureInfo; if (dcStreamOperatorCallback_) { - dcStreamOperatorCallback_->OnCaptureStarted(captureId, captureInfo->streamIds_); + dcStreamOperatorCallback_->OnCaptureStarted(captureId, info.streamIds_); } SetCapturing(true); DHLOGI("DStreamOperator::Capture, start distributed camera capture success."); @@ -331,7 +325,7 @@ CamRetCode DStreamOperator::Capture(int captureId, const std::shared_ptr(ret)); } - std::vector> info; + std::vector info; for (auto id : halCaptureInfoMap_[captureId]->streamIds_) { auto iter = halStreamMap_.find(id); if (iter != halStreamMap_.end()) { iter->second->FlushDCameraBuffer(); } - std::shared_ptr tmp = std::make_shared(); - tmp->frameCount_ = acceptedBufferNum_[std::make_pair(captureId, id)]; - tmp->streamId_ = id; + CaptureEndedInfo tmp; + tmp.frameCount_ = acceptedBufferNum_[std::make_pair(captureId, id)]; + tmp.streamId_ = id; info.push_back(tmp); acceptedBufferNum_.erase(std::make_pair(captureId, id)); } @@ -402,11 +396,11 @@ bool DStreamOperator::HasContinuousCaptureInfo(int captureId) return flag; } -CamRetCode DStreamOperator::ChangeToOfflineStream(const std::vector& streamIds, - OHOS::sptr& callback, OHOS::sptr& offlineOperator) +int32_t DStreamOperator::ChangeToOfflineStream(const std::vector &streamIds, + const sptr &callbackObj, sptr &offlineOperator) { (void)streamIds; - (void)callback; + (void)callbackObj; offlineOperator = nullptr; return CamRetCode::METHOD_NOT_SUPPORTED; } @@ -586,7 +580,7 @@ DCamRetCode DStreamOperator::SetCallBack(OHOS::sptr con DCamRetCode DStreamOperator::SetDeviceCallback( std::function &errorCbk, - std::function)> &resultCbk) + std::function)> &resultCbk) { errorCallback_ = errorCbk; dMetadataProcessor_->SetResultCallback(resultCbk); @@ -605,10 +599,10 @@ void DStreamOperator::SnapShotStreamOnCaptureEnded(int32_t captureId, int stream if (dcStreamOperatorCallback_ == nullptr) { return; } - std::vector> info; - std::shared_ptr tmp = std::make_shared(); - tmp->frameCount_ = acceptedBufferNum_[std::make_pair(captureId, streamId)]; - tmp->streamId_ = streamId; + std::vector info; + CaptureEndedInfo tmp; + tmp.frameCount_ = acceptedBufferNum_[std::make_pair(captureId, streamId)]; + tmp.streamId_ = streamId; info.push_back(tmp); dcStreamOperatorCallback_->OnCaptureEnded(captureId, info); DHLOGD("snapshot stream successfully reported captureId = %d streamId = %d.", captureId, streamId); @@ -662,16 +656,16 @@ void DStreamOperator::SetCapturing(bool isCapturing) isCapturing_ = isCapturing; } -void DStreamOperator::ConvertStreamInfo(std::shared_ptr &srcInfo, std::shared_ptr &dstInfo) +void DStreamOperator::ConvertStreamInfo(const StreamInfo &srcInfo, std::shared_ptr &dstInfo) { - dstInfo->streamId_ = srcInfo->streamId_; - dstInfo->width_ = srcInfo->width_; - dstInfo->stride_ = srcInfo->width_; - dstInfo->height_ = srcInfo->height_; - dstInfo->dataspace_ = srcInfo->dataspace_; - dstInfo->encodeType_ = (DCEncodeType)srcInfo->encodeType_; + dstInfo->streamId_ = srcInfo.streamId_; + dstInfo->width_ = srcInfo.width_; + dstInfo->stride_ = srcInfo.width_; + dstInfo->height_ = srcInfo.height_; + dstInfo->dataspace_ = srcInfo.dataspace_; + dstInfo->encodeType_ = (DCEncodeType)srcInfo.encodeType_; - if ((srcInfo->intent_ == STILL_CAPTURE) || (srcInfo->intent_ == POST_VIEW)) { + if ((srcInfo.intent_ == STILL_CAPTURE) || (srcInfo.intent_ == POST_VIEW)) { dstInfo->type_ = DCStreamType::SNAPSHOT_FRAME; if (dstInfo->encodeType_ == DCEncodeType::ENCODE_TYPE_JPEG) { dstInfo->format_ = OHOS_CAMERA_FORMAT_JPEG; @@ -683,14 +677,13 @@ void DStreamOperator::ConvertStreamInfo(std::shared_ptr &srcInfo, st dstInfo->encodeType_ = DCEncodeType::ENCODE_TYPE_NULL; dstInfo->type_ = DCStreamType::CONTINUOUS_FRAME; dstInfo->format_ = - static_cast(DBufferManager::PixelFormatToDCameraFormat(static_cast(srcInfo->format_))); + static_cast(DBufferManager::PixelFormatToDCameraFormat(static_cast(srcInfo.format_))); } } -DCamRetCode DStreamOperator::NegotiateSuitableCaptureInfo(const std::shared_ptr& srcCaptureInfo, - bool isStreaming) +DCamRetCode DStreamOperator::NegotiateSuitableCaptureInfo(const CaptureInfo& srcCaptureInfo, bool isStreaming) { - for (auto streamId : srcCaptureInfo->streamIds_) { + for (auto streamId : srcCaptureInfo.streamIds_) { DHLOGI("DStreamOperator::NegotiateSuitableCaptureInfo, streamId=%d, isStreaming=%d", streamId, isStreaming); } @@ -744,11 +737,11 @@ DCamRetCode DStreamOperator::NegotiateSuitableCaptureInfo(const std::shared_ptr< return SUCCESS; } -DCamRetCode DStreamOperator::GetInputCaptureInfo(const std::shared_ptr& srcCaptureInfo, bool isStreaming, +DCamRetCode DStreamOperator::GetInputCaptureInfo(const CaptureInfo& srcCaptureInfo, bool isStreaming, std::shared_ptr& inputCaptureInfo) { std::vector> srcStreamInfo; - for (auto &id : srcCaptureInfo->streamIds_) { + for (auto &id : srcCaptureInfo.streamIds_) { auto iter = dcStreamInfoMap_.find(id); if (iter != dcStreamInfoMap_.end()) { srcStreamInfo.push_back(iter->second); @@ -766,7 +759,7 @@ DCamRetCode DStreamOperator::GetInputCaptureInfo(const std::shared_ptr DStreamOperator::BuildSuitableCaptureInfo(const shared_ptr& srcCaptureInfo, +std::shared_ptr DStreamOperator::BuildSuitableCaptureInfo(const CaptureInfo& srcCaptureInfo, std::vector> &srcStreamInfo) { std::shared_ptr captureInfo = std::make_shared(); @@ -778,7 +771,9 @@ std::shared_ptr DStreamOperator::BuildSuitableCaptureInfo(const s DCameraSettings dcSetting; dcSetting.type_ = DCSettingsType::UPDATE_METADATA; - std::string settingStr = Camera::MetadataUtils::EncodeToString(srcCaptureInfo->captureSetting_); + std::shared_ptr captureSetting = nullptr; + OHOS::Camera::MetadataUtils::ConvertVecToMetadata(srcCaptureInfo.captureSetting_, captureSetting); + std::string settingStr = OHOS::Camera::MetadataUtils::EncodeToString(captureSetting); dcSetting.value_ = Base64Encode(reinterpret_cast(settingStr.c_str()), settingStr.length()); captureInfo->captureSettings_.push_back(dcSetting); diff --git a/distributed_camera/hdi_service/test/BUILD.gn b/distributed_camera/hdi_service/test/BUILD.gn index 66a78a926e..8bd239160a 100644 --- a/distributed_camera/hdi_service/test/BUILD.gn +++ b/distributed_camera/hdi_service/test/BUILD.gn @@ -24,12 +24,6 @@ ohos_executable("dcamera_hdi_sample") { ] include_dirs = [ - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/client/device", - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/client/host", - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/client/operator", - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/device", - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/host", - "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/operator", "${distributedcamera_hdf_path}/hdi_service/include/dcamera_device", "${distributedcamera_hdf_path}/hdi_service/include/dcamera_host", "${distributedcamera_hdf_path}/hdi_service/include/dcamera_provider", @@ -46,8 +40,6 @@ ohos_executable("dcamera_hdi_sample") { "//drivers/peripheral/camera/interfaces/metadata/include", - "${camera_hdf_path}/camera/interfaces/include", - "${camera_hdf_path}/camera/interfaces/hdi_ipc", "${innerkits_path}/native_cpp/camera_source/include", "${innerkits_path}/native_cpp/camera_source/include/callback", "${fwk_common_path}/utils/include", diff --git a/distributed_camera/hdi_service/test/common.cpp b/distributed_camera/hdi_service/test/common.cpp index b349d84c8f..32a594d71e 100644 --- a/distributed_camera/hdi_service/test/common.cpp +++ b/distributed_camera/hdi_service/test/common.cpp @@ -17,6 +17,69 @@ namespace OHOS { namespace DistributedHardware { +class DCameraHostCallback : public ICameraHostCallback { +public: + DCameraHostCallback() = default; + virtual ~DCameraHostCallback() = default; + + int32_t OnCameraStatus(const std::string& cameraId, CameraStatus status) + { + return 0; + } + + int32_t OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) + { + return 0; + } + + int32_t OnCameraEvent(const std::string& cameraId, CameraEvent event) + { + return 0; + } +}; + +class DCameraDeviceCallback : public ICameraDeviceCallback { +public: + DCameraDeviceCallback() = default; + virtual ~DCameraDeviceCallback() = default; + + int32_t OnError(ErrorType type, int32_t errorCode) + { + return 0; + } + + int32_t OnResult(uint64_t timestamp, const std::vector& result) + { + return 0; + } +}; + +class DStreamOperatorCallback : public IStreamOperatorCallback { +public: + DStreamOperatorCallback() = default; + virtual ~DStreamOperatorCallback() = default; + + int32_t OnCaptureStarted(int32_t captureId, const std::vector& streamIds) + { + return 0; + } + + int32_t OnCaptureEnded(int32_t captureId, const std::vector& infos) + { + return 0; + } + + int32_t OnCaptureError(int32_t captureId, const std::vector& infos) + { + return 0; + } + + int32_t OnFrameShutter(int32_t captureId, const std::vector& streamIds, uint64_t timestamp) + { + return 0; + } +}; + uint64_t Test::GetCurrentLocalTimeStamp() { std::chrono::time_point tp = @@ -117,11 +180,11 @@ void Test::Init() service->SetCallback(hostCallback); } -std::shared_ptr Test::GetCameraAbility() +std::vector Test::GetCameraAbility() { if (cameraDevice == nullptr) { rc = service->GetCameraIds(cameraIds); - if (rc != Camera::NO_ERROR) { + if (rc != NO_ERROR) { std::cout << "==========[test log]GetCameraIds failed." << std::endl; return ability; } else { @@ -139,12 +202,14 @@ std::shared_ptr Test::GetCameraAbility() void Test::GetCameraMetadata() { rc = service->GetCameraAbility(cameraIds.front(), ability); - if (rc != Camera::NO_ERROR) { + if (rc != NO_ERROR) { std::cout << "==========[test log]GetCameraAbility failed, rc = " << rc << std::endl; } - common_metadata_header_t* data = ability->get(); + std::shared_ptr abililyMeta = nullptr; + OHOS::Camera::MetadataUtils::ConvertVecToMetadata(abilily, abililyMeta); + common_metadata_header_t* data = abililyMeta->get(); camera_metadata_item_t entry; - int ret = Camera::FindCameraMetadataItem(data, OHOS_CONTROL_AE_AVAILABLE_MODES, &entry); + int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_CONTROL_AE_AVAILABLE_MODES, &entry); if (ret == 0) { std::cout << "==========[test log] get OHOS_CONTROL_AE_AVAILABLE_MODES success" << std::endl; } @@ -161,7 +226,7 @@ void Test::Open() GetCameraMetadata(); deviceCallback = new DCameraDeviceCallback(); rc = service->OpenCamera(cameraIds.front(), deviceCallback, cameraDevice); - if (rc != Camera::NO_ERROR || cameraDevice == nullptr) { + if (rc != NO_ERROR || cameraDevice == nullptr) { std::cout << "==========[test log]OpenCamera failed, rc = " << rc << std::endl; return; } @@ -178,84 +243,94 @@ void Test::Close() } consumerMap_.clear(); if (hostCallback != nullptr) { - delete hostCallback; hostCallback = nullptr; } if (deviceCallback != nullptr) { - delete deviceCallback; deviceCallback = nullptr; } if (streamOperatorCallback != nullptr) { - delete streamOperatorCallback; streamOperatorCallback = nullptr; } } void Test::SetPreviewStreamInfo() { - streamInfo_pre->streamId_ = streamId_preview; - streamInfo_pre->width_ = preview_width; - streamInfo_pre->height_ = preview_height; - streamInfo_pre->format_ = preview_format; - streamInfo_pre->dataspace_ = dataspace; - streamInfo_pre->intent_ = PREVIEW; - streamInfo_pre->tunneledMode_ = tunneledMode; + int dataspace = 8; + int tunneledMode = 5; + int bufferQueueSize = 8; + streamInfo_pre.streamId_ = streamId_preview; + streamInfo_pre.width_ = preview_width; + streamInfo_pre.height_ = preview_height; + streamInfo_pre.format_ = preview_format; + streamInfo_pre.dataspace_ = dataspace; + streamInfo_pre.intent_ = PREVIEW; + streamInfo_pre.tunneledMode_ = tunneledMode; std::shared_ptr consumer_pre = std::make_shared(); std::cout << "==========[test log]received a preview buffer ... 0" << std::endl; - streamInfo_pre->bufferQueue_ = consumer_pre->CreateProducer([this](void* addr, uint32_t size) { + streamInfo_pre.bufferQueue_ = new BufferProducerSequenceable(); + streamInfo_pre.bufferQueue_->producer_ = consumer_pre->CreateProducer([this](void* addr, uint32_t size) { SaveYUV("preview", addr, size); }); - streamInfo_pre->bufferQueue_->SetQueueSize(bufferQueueSize); + streamInfo_pre.bufferQueue_->producer_->SetQueueSize(bufferQueueSize); consumerMap_[intent] = consumer_pre; streamInfos.push_back(streamInfo_pre); } void Test::SetVideoStreamInfo() { - streamInfo_video->streamId_ = streamId_video; - streamInfo_video->width_ = video_width; - streamInfo_video->height_ = video_height; - streamInfo_video->format_ = video_format; - streamInfo_video->dataspace_ = dataspace; - streamInfo_video->intent_ = intent; - streamInfo_video->encodeType_ = OHOS::Camera::ENCODE_TYPE_H265; - streamInfo_video->tunneledMode_ = tunneledMode; + int dataspace = 8; + int tunneledMode = 5; + int bufferQueueSize = 8; + streamInfo_video.streamId_ = streamId_video; + streamInfo_video.width_ = video_width; + streamInfo_video.height_ = video_height; + streamInfo_video.format_ = video_format; + streamInfo_video.dataspace_ = dataspace; + streamInfo_video.intent_ = VIDEO; + streamInfo_video.encodeType_ = OHOS::HDI::Camera::V1_0::ENCODE_TYPE_H265; + streamInfo_video.tunneledMode_ = tunneledMode; std::shared_ptr consumer_video = std::make_shared(); std::cout << "==========[test log]received a video buffer ... 1" << std::endl; SaveVideoFile("video", nullptr, 0, 0); - streamInfo_video->bufferQueue_ = consumer_video->CreateProducer([this](void* addr, uint32_t size) { + streamInfo_video.bufferQueue_ = new BufferProducerSequenceable(); + streamInfo_video.bufferQueue_->producer_ = consumer_video->CreateProducer([this](void* addr, uint32_t size) { SaveVideoFile("video", addr, size, 1); }); - streamInfo_video->bufferQueue_->SetQueueSize(bufferQueueSize); + streamInfo_video.bufferQueue_->producer_->SetQueueSize(bufferQueueSize); consumerMap_[intent] = consumer_video; streamInfos.push_back(streamInfo_video); } void Test::SetPhotoStreamInfo() { - streamInfo_capture->streamId_ = streamId_capture; - streamInfo_capture->width_ = snapshot_width; - streamInfo_capture->height_ = snapshot_height; - streamInfo_capture->format_ = snapshot_format; - streamInfo_capture->dataspace_ = dataspace; - streamInfo_capture->intent_ = intent; - streamInfo_capture->encodeType_ = OHOS::Camera::ENCODE_TYPE_JPEG; - streamInfo_capture->tunneledMode_ = tunneledMode; + int dataspace = 8; + int tunneledMode = 5; + int bufferQueueSize = 8; + streamInfo_capture.streamId_ = streamId_capture; + streamInfo_capture.width_ = snapshot_width; + streamInfo_capture.height_ = snapshot_height; + streamInfo_capture.format_ = snapshot_format; + streamInfo_capture.dataspace_ = dataspace; + streamInfo_capture.intent_ = STILL_CAPTURE; + streamInfo_capture.encodeType_ = OHOS::HDI::Camera::V1_0::ENCODE_TYPE_JPEG; + streamInfo_capture.tunneledMode_ = tunneledMode; std::shared_ptr consumer_capture = std::make_shared(); std::cout << "==========[test log]received a capture buffer ... 2" << std::endl; - streamInfo_capture->bufferQueue_ = consumer_capture->CreateProducer([this](void* addr, uint32_t size) { - SaveYUV("capture", addr, size); + streamInfo_capture.bufferQueue_ = new BufferProducerSequenceable(); + streamInfo_capture.bufferQueue_->producer_ = + consumer_capture->CreateProducer([this](void* addr, uint32_t size) { + SaveYUV("capture", addr, size); }); - streamInfo_capture->bufferQueue_->SetQueueSize(bufferQueueSize); + streamInfo_capture.bufferQueue_->producer_->SetQueueSize(bufferQueueSize); consumerMap_[intent] = consumer_capture; streamInfos.push_back(streamInfo_capture); } -void Test::StartStream(std::vector intents) +void Test::StartStream(std::vector intents) { streamOperatorCallback = new DStreamOperatorCallback(); rc = cameraDevice->GetStreamOperator(streamOperatorCallback, streamOperator); - if (rc == Camera::NO_ERROR) { + if (rc == NO_ERROR) { std::cout << "==========[test log]GetStreamOperator success." << std::endl; } else { std::cout << "==========[test log]GetStreamOperator fail, rc = " << rc << std::endl; @@ -263,9 +338,6 @@ void Test::StartStream(std::vector intents) int dataspace = 8; int tunneledMode = 5; int bufferQueueSize = 8; - streamInfo_pre = std::make_shared(); - streamInfo_video = std::make_shared(); - streamInfo_capture = std::make_shared(); for (auto& intent : intents) { if (intent == 0) { SetPreviewStreamInfo(); @@ -277,30 +349,29 @@ void Test::StartStream(std::vector intents) } rc = streamOperator->CreateStreams(streamInfos); - if (rc == Camera::NO_ERROR) { + if (rc == NO_ERROR) { std::cout << "==========[test log]CreateStreams success." << std::endl; } else { std::cout << "==========[test log]CreateStreams fail, rc = " << rc << std::endl; } - rc = streamOperator->CommitStreams(Camera::NORMAL, ability); - if (rc == Camera::NO_ERROR) { + rc = streamOperator->CommitStreams(NORMAL, ability); + if (rc == NO_ERROR) { std::cout << "==========[test log]CommitStreams success." << std::endl; } else { std::cout << "==========[test log]CommitStreams fail, rc = " << rc << std::endl; } unsigned int sleepSeconds = 2; sleep(sleepSeconds); - std::vector>().swap(streamInfos); + std::vector>().swap(streamInfos); } void Test::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming) { - captureInfo = std::make_shared(); - captureInfo->streamIds_ = {streamId}; - captureInfo->captureSetting_ = ability; - captureInfo->enableShutterCallback_ = shutterCallback; + captureInfo.streamIds_ = { streamId }; + captureInfo.captureSetting_ = ability; + captureInfo.enableShutterCallback_ = shutterCallback; rc = streamOperator->Capture(captureId, captureInfo, isStreaming); - if (rc == Camera::NO_ERROR) { + if (rc == NO_ERROR) { std::cout << "==========[test log]check Capture: Capture success, " << captureId << std::endl; } else { std::cout << "==========[test log]check Capture: Capture fail, rc = " << rc << std::endl; @@ -314,7 +385,7 @@ void Test::StopStream(std::vector& captureIds, std::vector& streamIds) if (sizeof(captureIds) > 0) { for (auto &captureId : captureIds) { rc = streamOperator->CancelCapture(captureId); - if (rc == Camera::NO_ERROR) { + if (rc == NO_ERROR) { std::cout << "==========[test log]check Capture: CancelCapture success," << captureId << std::endl; } else { std::cout << "==========[test log]check Capture: CancelCapture fail, rc = " << rc; @@ -326,7 +397,7 @@ void Test::StopStream(std::vector& captureIds, std::vector& streamIds) SaveVideoFile("video", nullptr, 0, operationMode); if (sizeof(streamIds) > 0) { rc = streamOperator->ReleaseStreams(streamIds); - if (rc == Camera::NO_ERROR) { + if (rc == NO_ERROR) { std::cout << "==========[test log]check Capture: ReleaseStreams success." << std::endl; } else { std::cout << "==========[test log]check Capture: ReleaseStreams fail, rc = " << rc << std::endl; @@ -337,14 +408,14 @@ void Test::StopStream(std::vector& captureIds, std::vector& streamIds) void Test::StopOfflineStream(int captureId) { rc = offlineStreamOperator->CancelCapture(captureId); - if (rc == Camera::NO_ERROR) { + if (rc == NO_ERROR) { std::cout << "==========[test log]check offline: CancelCapture success," << captureId << std::endl; } else { std::cout << "==========[test log]check offline: CancelCapture fail, rc = " << rc; std::cout << "captureId = " << captureId << std::endl; } rc = offlineStreamOperator->Release(); - if (rc == Camera::NO_ERROR) { + if (rc == NO_ERROR) { std::cout << "==========[test log]Check offline stream: offline Release success." << std::endl; } else { std::cout << "==========[test log]Check offline stream: offline Release fail, rc = " << rc << std::endl; diff --git a/distributed_camera/hdi_service/test/common.h b/distributed_camera/hdi_service/test/common.h index 1fed4e4709..5aff688935 100644 --- a/distributed_camera/hdi_service/test/common.h +++ b/distributed_camera/hdi_service/test/common.h @@ -32,28 +32,25 @@ #include "camera_metadata_info.h" #include "display_type.h" #include "distributed_hardware_log.h" -#include "drivers/peripheral/camera/interfaces/include/types.h" -#include "icamera_device.h" -#include "icamera_host.h" #include "idistributed_hardware_source.h" -#include "ioffline_stream_operator.h" #include "iservice_registry.h" -#include "istream_operator.h" #include "securec.h" #include "surface.h" #include "constants.h" #include "dcamera.h" -#include "dcamera_device_callback.h" #include "dcamera_host.h" -#include "dcamera_host_callback.h" -#include "dcamera_host_proxy.h" -#include "dstream_operator_callback.h" #include "v1_0/dcamera_types.h" +#include "v1_0/icamera_device.h" +#include "v1_0/icamera_host.h" +#include "v1_0/ioffline_stream_operator.h" +#include "v1_0/istream_operator.h" +#include "v1_0/types.h" namespace OHOS { namespace DistributedHardware { using namespace OHOS::HDI::DistributedCamera::V1_0; +using namespace OHOS::HDI::Camera::V1_0; class Test { public: void Init(); @@ -63,7 +60,7 @@ public: uint64_t GetCurrentLocalTimeStamp(); int32_t SaveYUV(const char* type, const void* buffer, int32_t size); int32_t SaveVideoFile(const char* type, const void* buffer, int32_t size, int32_t operationMode); - void StartStream(std::vector intents); + void StartStream(std::vector intents); void StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming); void StopStream(std::vector& captureIds, std::vector& streamIds); void StopOfflineStream(int captureId); @@ -77,15 +74,13 @@ public: OHOS::sptr hostCallback = nullptr; OHOS::sptr deviceCallback = nullptr; OHOS::sptr streamOperator = nullptr; - OHOS::sptr offlineStreamOperator = nullptr; + OHOS::sptr offlineStreamOperator = nullptr; OHOS::sptr offlineStreamOperatorCallback = nullptr; - std::shared_ptr captureInfo = nullptr; - std::vector> streamInfos; - std::shared_ptr streamInfo = nullptr; - std::shared_ptr streamInfo2 = nullptr; - std::shared_ptr streamInfo_pre = nullptr; - std::shared_ptr streamInfo_video = nullptr; - std::shared_ptr streamInfo_capture = nullptr; + CaptureInfo captureInfo; + std::vector streamInfos; + StreamInfo streamInfo_pre; + StreamInfo streamInfo_video; + StreamInfo streamInfo_capture; std::vector cameraIds; int streamId_preview = 1000; int streamId_preview_double = 1001; @@ -106,16 +101,16 @@ public: int video_height = 1080; std::vector captureIds; std::vector streamIds; - std::vector intents; - OHOS::Camera::CamRetCode rc; - OHOS::sptr service = nullptr; - std::shared_ptr ability = nullptr; + std::vector intents; + OHOS::HDI::Camera::V1_0::CamRetCode rc; + OHOS::sptr service = nullptr; + std::vector ability; OHOS::sptr cameraDevice = nullptr; bool status; int previewBufCnt = 0; int32_t videoFd = -1; class StreamConsumer; - std::map> consumerMap_ = {}; + std::map> consumerMap_ = {}; class TestBufferConsumerListener : public IBufferConsumerListener { public: diff --git a/distributed_camera/hdi_service/test/dcamera_hdi_sample.cpp b/distributed_camera/hdi_service/test/dcamera_hdi_sample.cpp index 5f14c958dd..07fa854dfd 100644 --- a/distributed_camera/hdi_service/test/dcamera_hdi_sample.cpp +++ b/distributed_camera/hdi_service/test/dcamera_hdi_sample.cpp @@ -61,7 +61,7 @@ int main() std::cout << "==========[test log]Preview stream, 640*480, expected success." << std::endl; // 启动流 - test->intents = {OHOS::Camera::PREVIEW}; + test->intents = {OHOS::HDI::Camera::V1_0::PREVIEW}; test->StartStream(test->intents); sleepSeconds = 1; sleep(sleepSeconds); diff --git a/distributed_camera/interfaces/hdi_ipc/ipc_data_utils.h b/distributed_camera/interfaces/hdi_ipc/ipc_data_utils.h deleted file mode 100644 index 9fc2412250..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/ipc_data_utils.h +++ /dev/null @@ -1,104 +0,0 @@ -/* - * Copyright (c) 2021 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 HDI_IPC_DATA_UTILS_H -#define HDI_IPC_DATA_UTILS_H - -#include -#include -#include -#include -#include -#include -#include "camera_metadata_info.h" -#include "v1_0/dcamera_types.h" - -#include - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::HDI::DistributedCamera::V1_0; -class IpcDataUtils { -static const uint32_t RATIONAL_TYPE_STEP = 2; -public: - static bool EncodeStreamInfo(const std::shared_ptr &pInfo, MessageParcel &parcel) - { - bool bRet = true; - bRet = (bRet && parcel.WriteInt32(static_cast(pInfo->streamId_))); - bRet = (bRet && parcel.WriteInt32(static_cast(pInfo->width_))); - bRet = (bRet && parcel.WriteInt32(static_cast(pInfo->height_))); - bRet = (bRet && parcel.WriteInt32(static_cast(pInfo->format_))); - bRet = (bRet && parcel.WriteInt32(pInfo->intent_)); - bRet = (bRet && parcel.WriteBool(pInfo->tunneledMode_)); - bool bufferQueueFlag = (pInfo->bufferQueue_ != nullptr) ? true : false; - bRet = (bRet && parcel.WriteBool(bufferQueueFlag)); - if (bufferQueueFlag) { - bRet = (bRet && parcel.WriteRemoteObject(pInfo->bufferQueue_->AsObject())); - } - bRet = (bRet && parcel.WriteInt32(static_cast(pInfo->minFrameDuration_))); - bRet = (bRet && parcel.WriteInt32(pInfo->encodeType_)); - return bRet; - } - - static void DecodeStreamInfo(MessageParcel &parcel, std::shared_ptr &pInfo) - { - pInfo->streamId_ = static_cast(parcel.ReadInt32()); - pInfo->width_ = static_cast(parcel.ReadInt32()); - pInfo->height_ = static_cast(parcel.ReadInt32()); - pInfo->format_ = static_cast(parcel.ReadInt32()); - pInfo->intent_ = static_cast(parcel.ReadInt32()); - pInfo->tunneledMode_ = parcel.ReadBool(); - bool bufferQueueFlag = parcel.ReadBool(); - if (bufferQueueFlag) { - sptr remoteBufferProducer = parcel.ReadRemoteObject(); - pInfo->bufferQueue_ = OHOS::iface_cast(remoteBufferProducer); - } - pInfo->minFrameDuration_ = static_cast(parcel.ReadInt32()); - pInfo->encodeType_ = static_cast(parcel.ReadInt32()); - } - - static bool EncodeDCameraSettings(const std::shared_ptr &pSettings, MessageParcel &parcel) - { - bool bRet = true; - bRet = (bRet && parcel.WriteInt32(pSettings->type_)); - bRet = (bRet && parcel.WriteString(pSettings->value_)); - return bRet; - } - - static void DecodeDCameraSettings(MessageParcel &parcel, std::shared_ptr &pSettings) - { - pSettings->type_ = (DCSettingsType)(parcel.ReadInt32()); - pSettings->value_ = parcel.ReadString(); - } - - static bool EncodeDCameraHDFEvent(const std::shared_ptr &pEvent, MessageParcel &parcel) - { - bool bRet = true; - bRet = (bRet && parcel.WriteInt32(pEvent->type_)); - bRet = (bRet && parcel.WriteInt32(pEvent->result_)); - bRet = (bRet && parcel.WriteString(pEvent->content_)); - return bRet; - } - - static void DecodeDCameraHDFEvent(MessageParcel &parcel, std::shared_ptr &pEvent) - { - pEvent->type_ = parcel.ReadInt32(); - pEvent->result_ = parcel.ReadInt32(); - pEvent->content_ = parcel.ReadString(); - } -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // HDI_IPC_DATA_UTILS_H diff --git a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.cpp b/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.cpp deleted file mode 100644 index 8a47104d5d..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.cpp +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (c) 2021 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 "dcamera_device_callback_proxy.h" - -#include -#include - -#include "cmd_common.h" -#include "distributed_hardware_log.h" -#include "ipc_data_utils.h" -#include "metadata_utils.h" - -namespace OHOS { -namespace DistributedHardware { -void DCameraDeviceCallbackProxy::OnError(ErrorType type, int32_t errorMsg) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DCameraDeviceCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteUint32(type)) { - DHLOGE("Write error type failed."); - return; - } - - if (!data.WriteInt32(errorMsg)) { - DHLOGE("Write error message failed."); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_DEVICE_CALLBACK_ON_ERROR, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - } -} - -void DCameraDeviceCallbackProxy::OnResult(uint64_t timestamp, - const std::shared_ptr &result) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DCameraDeviceCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (result == nullptr) { - return; - } - - if (!data.WriteUint64(timestamp)) { - DHLOGE("Write timestamp failed."); - return; - } - - if (!Camera::MetadataUtils::EncodeCameraMetadata(result, data)) { - DHLOGE("Write metadata failed."); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_DEVICE_CALLBACK_ON_RESULT, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - return; - } -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.h b/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.h deleted file mode 100644 index 505feda0c2..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_callback_proxy.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) 2021 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 DISTRIBUTED_CAMERA_DEVICE_CALLBACK_PROXY_H -#define DISTRIBUTED_CAMERA_DEVICE_CALLBACK_PROXY_H - -#include "iremote_proxy.h" -#include "icamera_device_callback.h" - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::Camera; -class DCameraDeviceCallbackProxy : public IRemoteProxy { -public: - explicit DCameraDeviceCallbackProxy(const sptr &impl) - : IRemoteProxy(impl) {} - - virtual ~DCameraDeviceCallbackProxy() = default; - - virtual void OnError(ErrorType type, int32_t errorMsg) override; - virtual void OnResult(uint64_t timestamp, const std::shared_ptr &result) override; - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // DISTRIBUTED_CAMERA_DEVICE_CALLBACK_PROXY_H diff --git a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.cpp b/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.cpp deleted file mode 100644 index 9315851a81..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.cpp +++ /dev/null @@ -1,235 +0,0 @@ -/* - * Copyright (c) 2021 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 "dcamera_device_stub.h" - -#include -#include - -#include "cmd_common.h" -#include "distributed_hardware_log.h" -#include "ipc_data_utils.h" -#include "istream_operator.h" -#include "istream_operator_callback.h" -#include "metadata_utils.h" - -namespace OHOS { -namespace DistributedHardware { -int32_t DCameraDeviceStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, - MessageOption& option) -{ - int32_t ret = HDF_SUCCESS; - switch (code) { - case CMD_CAMERA_DEVICE_GET_STREAM_OPERATOR: { - ret = DCDeviceStubGetStreamOperator(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_UPDATE_SETTINGS: { - ret = DCDeviceStubUpdateSettings(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_SET_RESULT_MODE: { - ret = DCDeviceStubSetResultMode(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_GET_ENABLED_RESULTS: { - ret = DCDeviceStubGetEnabledReuslts(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_ENABLE_RESULT: { - ret = DCDeviceStubEnableResult(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_DISABLE_RESULT: { - ret = DCDeviceStubDisableResult(data, reply, option); - break; - } - case CMD_CAMERA_DEVICE_CLOSE: { - ret = DCDeviceStubClose(data, reply, option); - break; - } - default: { - ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return ret; -} - -int32_t DCameraDeviceStub::DCDeviceStubGetStreamOperator(MessageParcel& data, MessageParcel& reply, - MessageOption& option) -{ - DHLOGI("DCameraDeviceStub::DCDeviceStubGetStreamOperator entry."); - if (data.ReadInterfaceToken() != DCameraDeviceStub::GetDescriptor()) { - DHLOGE("Invalid token."); - return HDF_FAILURE; - } - - sptr spStreamOperatorCallback = nullptr; - bool flag = data.ReadBool(); - if (flag) { - sptr remoteObj = data.ReadRemoteObject(); - spStreamOperatorCallback = OHOS::iface_cast(remoteObj); - if (spStreamOperatorCallback == nullptr) { - DHLOGE("Read operator callback failed."); - return HDF_FAILURE; - } - } - - OHOS::sptr streamOperator = nullptr; - CamRetCode ret = GetStreamOperator(spStreamOperatorCallback, streamOperator); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Get stream operator failed."); - return HDF_FAILURE; - } - - bool nullFlag = (streamOperator != nullptr); - if (!reply.WriteBool(nullFlag)) { - DHLOGE("Write stream operator flag failed."); - return HDF_FAILURE; - } - - if (nullFlag && !reply.WriteRemoteObject(streamOperator->AsObject())) { - DHLOGE("Write stream operator failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraDeviceStub::DCDeviceStubUpdateSettings(MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - DHLOGI("DCameraDeviceStub::DCDeviceStubUpdateSettings entry."); - if (data.ReadInterfaceToken() != DCameraDeviceStub::GetDescriptor()) { - DHLOGE("Invalid token."); - return HDF_FAILURE; - } - - std::shared_ptr metadata = nullptr; - Camera::MetadataUtils::DecodeCameraMetadata(data, metadata); - - CamRetCode ret = UpdateSettings(metadata); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Get stream operator failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraDeviceStub::DCDeviceStubSetResultMode(MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - DHLOGI("DCameraDeviceStub::DCDeviceStubSetResultMode entry."); - if (data.ReadInterfaceToken() != DCameraDeviceStub::GetDescriptor()) { - DHLOGE("Invalid token."); - return HDF_FAILURE; - } - - ResultCallbackMode mode = static_cast(data.ReadInt32()); - CamRetCode ret = SetResultMode(mode); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraDeviceStub::DCDeviceStubGetEnabledReuslts(MessageParcel& data, MessageParcel& reply, - MessageOption& option) -{ - DHLOGI("DCameraDeviceStub::DCDeviceStubGetEnabledReuslts entry."); - if (data.ReadInterfaceToken() != DCameraDeviceStub::GetDescriptor()) { - DHLOGE("Invalid token."); - return HDF_FAILURE; - } - - std::vector results; - CamRetCode ret = GetEnabledResults(results); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - - if (!reply.WriteInt32Vector(results)) { - DHLOGE("Write results failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraDeviceStub::DCDeviceStubEnableResult(MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - DHLOGI("DCameraDeviceStub::DCDeviceStubEnableResult entry."); - if (data.ReadInterfaceToken() != DCameraDeviceStub::GetDescriptor()) { - DHLOGE("Invalid token."); - return HDF_FAILURE; - } - - std::vector results; - if (!data.ReadInt32Vector(&results)) { - DHLOGE("Read results failed."); - return HDF_FAILURE; - } - - CamRetCode ret = EnableResult(results); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - - if (!reply.WriteInt32Vector(results)) { - DHLOGE("Write results failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraDeviceStub::DCDeviceStubDisableResult(MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - DHLOGI("DCameraDeviceStub::DCDeviceStubDisableResult entry."); - if (data.ReadInterfaceToken() != DCameraDeviceStub::GetDescriptor()) { - DHLOGE("Invalid token."); - return HDF_FAILURE; - } - - std::vector results; - if (!data.ReadInt32Vector(&results)) { - DHLOGE("Read results failed."); - return HDF_FAILURE; - } - - CamRetCode ret = DisableResult(results); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - - if (!reply.WriteInt32Vector(results)) { - DHLOGE("Write results failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraDeviceStub::DCDeviceStubClose(MessageParcel& data, MessageParcel& reply, MessageOption& option) -{ - DHLOGI("DCameraDeviceStub::DCDeviceStubClose entry."); - if (data.ReadInterfaceToken() != DCameraDeviceStub::GetDescriptor()) { - DHLOGE("Invalid token."); - return HDF_FAILURE; - } - - Close(); - return HDF_SUCCESS; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.h b/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.h deleted file mode 100644 index ab4fa7f848..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/device/dcamera_device_stub.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2021 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 DISTRIBUTED_CAMERA_DEVICE_SERVER_STUB_H -#define DISTRIBUTED_CAMERA_DEVICE_SERVER_STUB_H - -#include -#include -#include -#include "icamera_device.h" -#include "iremote_stub.h" - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::Camera; -class DCameraDeviceStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, - MessageOption& option) override; - -private: - int32_t DCDeviceStubGetStreamOperator(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCDeviceStubUpdateSettings(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCDeviceStubSetResultMode(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCDeviceStubGetEnabledReuslts(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCDeviceStubEnableResult(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCDeviceStubDisableResult(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCDeviceStubClose(MessageParcel& data, MessageParcel& reply, MessageOption& option); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // DISTRIBUTED_CAMERA_DEVICE_SERVER_STUB_H \ No newline at end of file diff --git a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.cpp b/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.cpp deleted file mode 100644 index 8c74fe68b0..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.cpp +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright (c) 2021 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 "dcamera_host_callback_proxy.h" - -#include -#include - -#include "cmd_common.h" -#include "distributed_hardware_log.h" - -namespace OHOS { -namespace DistributedHardware { -void DCameraHostCallbackProxy::OnCameraStatus(const std::string &cameraId, CameraStatus status) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DCameraHostCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteString(cameraId)) { - DHLOGE("Write cameraId failed."); - return; - } - - if (!data.WriteInt32(status)) { - DHLOGE("Write status failed."); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_CALLBACK_ON_STATUS, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - } -} - -void DCameraHostCallbackProxy::OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DCameraHostCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteString(cameraId)) { - DHLOGE("Write cameraId failed."); - return; - } - - if (!data.WriteInt32(status)) { - DHLOGE("Write status failed."); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_CALLBACK_ON_FLASHLIGHT_STATUS, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - } -} - -void DCameraHostCallbackProxy::OnCameraEvent(const std::string &cameraId, CameraEvent event) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DCameraHostCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteString(cameraId)) { - DHLOGE("Write cameraId failed."); - return; - } - - if (!data.WriteInt32(event)) { - DHLOGE("Write event failed."); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_CAMERA_HOST_CALLBACK_ON_CAMERA_EVENT, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - } -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.h b/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.h deleted file mode 100644 index 4b3267c2a8..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_callback_proxy.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2021 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 DISTRIBUTED_CAMERA_HOST_CALLBACK_PROXY_H -#define DISTRIBUTED_CAMERA_HOST_CALLBACK_PROXY_H - -#include "iremote_proxy.h" -#include "icamera_host_callback.h" - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::Camera; -class DCameraHostCallbackProxy : public IRemoteProxy { -public: - explicit DCameraHostCallbackProxy(const sptr &impl) - : IRemoteProxy(impl) {} - - virtual ~DCameraHostCallbackProxy() = default; - - virtual void OnCameraStatus(const std::string &cameraId, CameraStatus status); - virtual void OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status); - virtual void OnCameraEvent(const std::string &cameraId, CameraEvent event); - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // DISTRIBUTED_CAMERA_HOST_CALLBACK_PROXY_H diff --git a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.cpp b/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.cpp deleted file mode 100644 index e756636865..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.cpp +++ /dev/null @@ -1,262 +0,0 @@ -/* - * Copyright (c) 2021 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 "dcamera_host_stub.h" - -#include -#include -#include - -#include "cmd_common.h" -#include "distributed_hardware_log.h" -#include "icamera_device.h" -#include "icamera_host_callback.h" -#include "ipc_data_utils.h" -#include "metadata_utils.h" - -namespace OHOS { -namespace DistributedHardware { -DCameraHostStub::DCameraHostStub() -{ -} - -int32_t DCameraHostStub::Init() -{ - dcameraHost_ = DCameraHost::GetInstance(); - if (dcameraHost_ == nullptr) { - DHLOGE("Distributed camera host service start failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraHostStub::DCHostStubSetCallback(MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - if (data.ReadInterfaceToken() != DCameraHostStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - bool flag = data.ReadBool(); - sptr hostCallback = nullptr; - if (flag) { - sptr remoteObj = data.ReadRemoteObject(); - hostCallback = OHOS::iface_cast(remoteObj); - } - CamRetCode ret = dcameraHost_->SetCallback(hostCallback); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraHostStub::DCHostStubGetCameraIds(MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - if (data.ReadInterfaceToken() != DCameraHostStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - if (dcameraHost_ == nullptr) { - return HDF_FAILURE; - } - - std::vector cameraIds; - CamRetCode ret = dcameraHost_->GetCameraIds(cameraIds); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - - if (ret == CamRetCode::NO_ERROR) { - if (!reply.WriteStringVector(cameraIds)) { - DHLOGE("Write cameraIds failed."); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -int32_t DCameraHostStub::DCHostStubGetCameraAbility(MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - if (data.ReadInterfaceToken() != DCameraHostStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - const std::string cameraId = data.ReadString(); - if (cameraId.empty()) { - DHLOGE("Read input param is empty."); - return HDF_ERR_INVALID_PARAM; - } - - std::shared_ptr ability = nullptr; - CamRetCode ret = dcameraHost_->GetCameraAbility(cameraId, ability); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - - if (ret == CamRetCode::NO_ERROR) { - bool bRet = Camera::MetadataUtils::EncodeCameraMetadata(ability, reply); - if (!bRet) { - DHLOGE("Write ability failed."); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -int32_t DCameraHostStub::DCHostStubOpenCamera(MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - if (data.ReadInterfaceToken() != DCameraHostStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - const std::string cameraId = data.ReadString(); - if (cameraId.empty()) { - DHLOGE("Read input param is empty."); - return HDF_ERR_INVALID_PARAM; - } - - bool flag = data.ReadBool(); - OHOS::sptr deviceCallback = nullptr; - if (flag) { - OHOS::sptr remoteCallback = data.ReadRemoteObject(); - deviceCallback = OHOS::iface_cast(remoteCallback); - } - - OHOS::sptr cameraDevice = nullptr; - CamRetCode ret = dcameraHost_->OpenCamera(cameraId, deviceCallback, cameraDevice); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Get stream operator failed."); - return HDF_FAILURE; - } - - if (ret == CamRetCode::NO_ERROR) { - bool deviceFlag = (cameraDevice != nullptr); - if (!reply.WriteBool(deviceFlag)) { - DHLOGE("Write camera device flag failed."); - return HDF_FAILURE; - } - - if (deviceFlag && !reply.WriteRemoteObject(cameraDevice->AsObject())) { - DHLOGE("Write camera device failed."); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -int32_t DCameraHostStub::DCHostStubSetFlashlight(MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - if (data.ReadInterfaceToken() != DCameraHostStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - if (dcameraHost_ == nullptr) { - DHLOGE("Camera host is null."); - return HDF_FAILURE; - } - - std::string cameraId = data.ReadString(); - bool isEnable = data.ReadBool(); - CamRetCode ret = dcameraHost_->SetFlashlight(cameraId, isEnable); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DCameraHostStub::OnRemoteRequest(int cmdId, MessageParcel &data, - MessageParcel &reply, MessageOption &option) -{ - switch (cmdId) { - case CMD_CAMERA_HOST_SET_CALLBACK: { - return DCHostStubSetCallback(data, reply, option); - } - case CMD_CAMERA_HOST_GET_CAMERAID: { - return DCHostStubGetCameraIds(data, reply, option); - } - case CMD_CAMERA_HOST_GET_CAMERA_ABILITY: { - return DCHostStubGetCameraAbility(data, reply, option); - } - case CMD_CAMERA_HOST_OPEN_CAMERA: { - return DCHostStubOpenCamera(data, reply, option); - } - case CMD_CAMERA_HOST_SET_FLASH_LIGHT: { - return DCHostStubSetFlashlight(data, reply, option); - } - default: { - DHLOGE("Not support cmd %d.", cmdId); - return HDF_ERR_INVALID_PARAM; - } - } - return HDF_SUCCESS; -} -} // namespace DistributedHardware -} // namespace OHOS - -void *DCameraHostStubInstance() -{ - OHOS::DistributedHardware::DCameraHostStub *stub = new (std::nothrow) OHOS::DistributedHardware::DCameraHostStub(); - if (stub == nullptr) { - HDF_LOGE("%{public}s: camera host stub create failed.", __func__); - return nullptr; - } - - int32_t ret = stub->Init(); - if (ret != HDF_SUCCESS) { - delete stub; - stub = nullptr; - return nullptr; - } - return reinterpret_cast(stub); -} - -void DestroyDCameraHostStub(void *stubObj) -{ - delete reinterpret_cast(stubObj); -} - -int32_t DCHostServiceOnRemoteRequest(void *stub, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) -{ - if (stub == nullptr) { - HDF_LOGE("%{public}s:stub is null", __func__); - return HDF_FAILURE; - } - - OHOS::DistributedHardware::DCameraHostStub *dcameraHostStub = - reinterpret_cast(stub); - OHOS::MessageParcel *dataParcel = nullptr; - OHOS::MessageParcel *replyParcel = nullptr; - - if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { - HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); - return HDF_ERR_INVALID_PARAM; - } - - if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { - HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); - return HDF_ERR_INVALID_PARAM; - } - - OHOS::MessageOption option; - return dcameraHostStub->OnRemoteRequest(cmdId, *dataParcel, *replyParcel, option); -} diff --git a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.h b/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.h deleted file mode 100644 index 465c0a4ada..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/host/dcamera_host_stub.h +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) 2021 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 DISTRIBUTED_CAMERA_HOST_SERVER_STUB_H -#define DISTRIBUTED_CAMERA_HOST_SERVER_STUB_H - -#include -#include -#include -#include -#include "dcamera_host.h" -#include "icamera_device_callback.h" -#include "icamera_host_callback.h" - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::Camera; -enum { - CMD_CAMERA_HOST_SET_CALLBACK = 0, - CMD_CAMERA_HOST_GET_CAMERAID, - CMD_CAMERA_HOST_GET_CAMERA_ABILITY, - CMD_CAMERA_HOST_OPEN_CAMERA, - CMD_CAMERA_HOST_SET_FLASH_LIGHT, -}; - -class DCameraHostStub { -public: - DCameraHostStub(); - virtual ~DCameraHostStub() {} - int32_t Init(); - int32_t OnRemoteRequest(int cmdId, MessageParcel& data, MessageParcel& reply, MessageOption& option); - -private: - int32_t DCHostStubSetCallback(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCHostStubGetCameraIds(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCHostStubGetCameraAbility(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCHostStubOpenCamera(MessageParcel& data, MessageParcel& reply, MessageOption& option); - int32_t DCHostStubSetFlashlight(MessageParcel& data, MessageParcel& reply, MessageOption& option); - static inline const std::u16string metaDescriptor_ = u"HDI.Camera.V1_0.Host"; - static inline const std::u16string &GetDescriptor() - { - return metaDescriptor_; - } - -private: - std::shared_ptr dcameraHost_ = nullptr; -}; -} // namespace DistributedHardware -} // namespace OHOS - -void* DCameraHostStubInstance(); - -void DestroyDCameraHostStub(void* stubObj); - -int32_t DCHostServiceOnRemoteRequest(void* stub, int cmdId, struct HdfSBuf* data, struct HdfSBuf* reply); - -#endif // DISTRIBUTED_CAMERA_HOST_SERVER_STUB_H \ No newline at end of file diff --git a/distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.cpp b/distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.cpp deleted file mode 100644 index 1f9530936e..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.cpp +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright (c) 2021 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 "doffline_stream_operator_stub.h" - -#include - -#include "cmd_common.h" -#include "distributed_hardware_log.h" - -namespace OHOS { -namespace DistributedHardware { -int32_t DOfflineStreamOperatorStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - int32_t ret = HDF_SUCCESS; - switch (code) { - case CMD_OFFLINE_STREAM_OPERATOR_CANCEL_CAPTURE: { - ret = DOfflineStreamOperatorStubCancelCapture(data, reply, option); - break; - } - case CMD_OFFLINE_STREAM_OPERATOR_RELEASE_STREAMS: { - ret = DOfflineStreamOperatorStubReleaseStreams(data, reply, option); - break; - } - case CMD_OFFLINE_STREAM_OPERATOR_RELEASE: { - ret = DOfflineStreamOperatorStubRelease(data, reply, option); - break; - } - default: { - ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return ret; -} - -int32_t DOfflineStreamOperatorStub::DOfflineStreamOperatorStubCancelCapture(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DOfflineStreamOperatorStub::DOfflineStreamOperatorStubCancelCapture entry."); - if (data.ReadInterfaceToken() != DOfflineStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - int32_t captureId = data.ReadInt32(); - CamRetCode ret = CancelCapture(captureId); - if (reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DOfflineStreamOperatorStub::DOfflineStreamOperatorStubReleaseStreams(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DOfflineStreamOperatorStub::DOfflineStreamOperatorStubReleaseStreams entry."); - if (data.ReadInterfaceToken() != DOfflineStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - DHLOGE("Read streamIds failed."); - return HDF_FAILURE; - } - - CamRetCode ret = ReleaseStreams(streamIds); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DOfflineStreamOperatorStub::DOfflineStreamOperatorStubRelease(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DOfflineStreamOperatorStub::DOfflineStreamOperatorStubRelease entry."); - if (data.ReadInterfaceToken() != DOfflineStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - CamRetCode ret = Release(); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.h b/distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.h deleted file mode 100644 index 5f5ad7f741..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/operator/doffline_stream_operator_stub.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2021 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 DISTRIBUTED_OFFLINE_STREAM_OPERATOR_SERVER_STUB_H -#define DISTRIBUTED_OFFLINE_STREAM_OPERATOR_SERVER_STUB_H - -#include -#include -#include -#include "ioffline_stream_operator.h" -#include "iremote_stub.h" - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::Camera; -class DOfflineStreamOperatorStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, - MessageParcel &data, MessageParcel &reply, MessageOption &option) override; - - int32_t DOfflineStreamOperatorStubCancelCapture(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DOfflineStreamOperatorStubReleaseStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DOfflineStreamOperatorStubRelease(MessageParcel &data, MessageParcel &reply, MessageOption &option); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // DISTRIBUTED_OFFLINE_STREAM_OPERATOR_SERVER_STUB_H \ No newline at end of file diff --git a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.cpp b/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.cpp deleted file mode 100644 index 5438957192..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.cpp +++ /dev/null @@ -1,162 +0,0 @@ -/* - * Copyright (c) 2021 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 "dstream_operator_callback_proxy.h" - -#include -#include - -#include "cmd_common.h" -#include "distributed_hardware_log.h" - -namespace OHOS { -namespace DistributedHardware { -void DStreamOperatorCallbackProxy::OnCaptureStarted(int32_t captureId, const std::vector &streamId) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DStreamOperatorCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteInt32(captureId)) { - DHLOGE("Write captureId failed."); - return; - } - - if (!data.WriteInt32Vector(streamId)) { - DHLOGE("Write streamIds failed."); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_STARTED, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - } -} - -void DStreamOperatorCallbackProxy::OnCaptureEnded(int32_t captureId, - const std::vector> &info) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DStreamOperatorCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteInt32(captureId)) { - DHLOGE("Write captureId failed."); - return; - } - - size_t size = info.size(); - if (!data.WriteInt32(static_cast(size))) { - DHLOGE("Write info size failed."); - return; - } - for (size_t i = 0; i < size; i++) { - auto captureEndInfo = info.at(i); - bool bRet = data.WriteBuffer((void *)captureEndInfo.get(), sizeof(CaptureEndedInfo)); - if (!bRet) { - DHLOGE("Write info index = %zu failed.", i); - return; - } - } - - int32_t ret = Remote()->SendRequest(CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_ENDED, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - return; - } -} - -void DStreamOperatorCallbackProxy::OnCaptureError(int32_t captureId, - const std::vector> &info) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DStreamOperatorCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteInt32(captureId)) { - DHLOGE("Write captureId failed."); - return; - } - - size_t size = info.size(); - if (!data.WriteInt32(static_cast(size))) { - DHLOGE("Write info size failed."); - return; - } - for (size_t i = 0; i < size; i++) { - auto captureErrorInfo = info.at(i); - bool bRet = data.WriteBuffer((void *)captureErrorInfo.get(), sizeof(CaptureErrorInfo)); - if (!bRet) { - DHLOGE("Write info index = %zu failed.", i); - return; - } - } - - int32_t ret = Remote()->SendRequest(CMD_STREAM_OPERATOR_CALLBACK_ON_CAPTURE_ERROR, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - return; - } -} - -void DStreamOperatorCallbackProxy::OnFrameShutter(int32_t captureId, - const std::vector &streamId, uint64_t timestamp) -{ - MessageParcel data; - MessageParcel reply; - MessageOption option; - - if (!data.WriteInterfaceToken(DStreamOperatorCallbackProxy::GetDescriptor())) { - DHLOGE("Write token failed."); - return; - } - - if (!data.WriteInt32(captureId)) { - DHLOGE("Write captureId failed."); - return; - } - - if (!data.WriteInt32Vector(streamId)) { - DHLOGE("Write streamId failed."); - return; - } - - if (!data.WriteUint64(timestamp)) { - DHLOGE("Write streamId failed."); - return; - } - - int32_t ret = Remote()->SendRequest(CMD_STREAM_OPERATOR_CALLBACK_ON_FRAME_SHUTTER, data, reply, option); - if (ret != HDF_SUCCESS) { - DHLOGE("SendRequest failed, error code is %d.", ret); - } -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.h b/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.h deleted file mode 100644 index 2c8e169aef..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_callback_proxy.h +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright (c) 2021 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 DISTRIBUTED_STREAM_OPERATOR_CALLBACK_PROXY_H -#define DISTRIBUTED_STREAM_OPERATOR_CALLBACK_PROXY_H - -#include "iremote_proxy.h" -#include "istream_operator_callback.h" - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::Camera; -class DStreamOperatorCallbackProxy : public IRemoteProxy { -public: - explicit DStreamOperatorCallbackProxy(const sptr &impl) - : IRemoteProxy(impl) {} - - virtual ~DStreamOperatorCallbackProxy() = default; - - virtual void OnCaptureStarted(int32_t captureId, const std::vector &streamId) override; - virtual void OnCaptureEnded(int32_t captureId, - const std::vector> &info) override; - virtual void OnCaptureError(int32_t captureId, - const std::vector> &info) override; - virtual void OnFrameShutter(int32_t captureId, - const std::vector &streamId, uint64_t timestamp) override; - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // DISTRIBUTED_STREAM_OPERATOR_CALLBACK_PROXY_H \ No newline at end of file diff --git a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.cpp b/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.cpp deleted file mode 100644 index c3aa1f5ad7..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.cpp +++ /dev/null @@ -1,355 +0,0 @@ -/* - * Copyright (c) 2021 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 "dstream_operator_stub.h" - -#include - -#include "cmd_common.h" -#include "distributed_hardware_log.h" -#include "ioffline_stream_operator.h" -#include "ipc_data_utils.h" -#include "istream_operator_callback.h" -#include "metadata_utils.h" - -namespace OHOS { -namespace DistributedHardware { -int32_t DStreamOperatorStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - int32_t ret = HDF_SUCCESS; - switch (code) { - case CMD_STREAM_OPERATOR_IS_STREAMS_SUPPORTED: { - ret = DStreamOperatorStubIsStreamsSupported(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CREATE_STREAMS: { - ret = DStreamOperatorStubCreateStreams(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_RELEASE_STREAMS: { - ret = DStreamOperatorStubReleaseStreams(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_COMMIT_STREAMS: { - ret = DStreamOperatorStubCommitStreams(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_GET_STREAM_ATTRIBUTES: { - ret = DStreamOperatorStubGetStreamAttributes(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_ATTACH_BUFFER_QUEUE: { - ret = DStreamOperatorStubAttachBufferQueue(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_DETACH_BUFFER_QUEUE: { - ret = DStreamOperatorStubDetachBufferQueue(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CAPTURE: { - ret = DStreamOperatorStubCapture(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CANCEL_CAPTURE: { - ret = DStreamOperatorStubCancelCapture(data, reply, option); - break; - } - case CMD_STREAM_OPERATOR_CHANGE_TO_OFFLINE_STREAM: { - ret = DStreamOperatorStubChangeToOfflineStream(data, reply, option); - break; - } - default: { - ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - } - return ret; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubIsStreamsSupported(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubIsStreamsSupported entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - OperationMode operationMode = static_cast(data.ReadInt32()); - - std::shared_ptr metadata = nullptr; - bool nullFlag = data.ReadBool(); - if (nullFlag) { - Camera::MetadataUtils::DecodeCameraMetadata(data, metadata); - } - - int32_t count = data.ReadInt32(); - std::vector> streamInfos; - for (int i = 0; i < count; i++) { - std::shared_ptr streamInfo = std::make_shared(); - IpcDataUtils::DecodeStreamInfo(data, streamInfo); - streamInfos.push_back(streamInfo); - } - - StreamSupportType streamSupportType; - CamRetCode ret = IsStreamsSupported(operationMode, metadata, streamInfos, streamSupportType); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - - if (!reply.WriteInt32(static_cast(streamSupportType))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubCreateStreams(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubCreateStreams entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - int32_t count = data.ReadInt32(); - std::vector> streamInfos; - for (int i = 0; i < count; i++) { - std::shared_ptr streamInfo = std::make_shared(); - IpcDataUtils::DecodeStreamInfo(data, streamInfo); - streamInfos.push_back(streamInfo); - } - - CamRetCode ret = CreateStreams(streamInfos); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubReleaseStreams(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubReleaseStreams entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - DHLOGE("Read streamIds failed."); - return HDF_FAILURE; - } - - CamRetCode ret = ReleaseStreams(streamIds); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubCommitStreams(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubCommitStreams entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - OperationMode mode = static_cast(data.ReadInt32()); - - std::shared_ptr metadata = nullptr; - Camera::MetadataUtils::DecodeCameraMetadata(data, metadata); - - CamRetCode ret = CommitStreams(mode, metadata); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubGetStreamAttributes(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubGetStreamAttributes entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - std::vector> attributes; - CamRetCode ret = GetStreamAttributes(attributes); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - - size_t count = attributes.size(); - if (!reply.WriteInt32(static_cast(count))) { - DHLOGE("Write attributes count failed."); - return HDF_FAILURE; - } - - for (size_t i = 0; i < count; i++) { - if (!reply.WriteBuffer((void *)(attributes[i].get()), sizeof(StreamAttribute))) { - DHLOGE("Write attribute failed. index = %d.", i); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubAttachBufferQueue(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubAttachBufferQueue entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - int32_t streamId = data.ReadInt32(); - sptr remoteObj = data.ReadRemoteObject(); - const sptr bufferProducer = OHOS::iface_cast(remoteObj); - - CamRetCode ret = AttachBufferQueue(streamId, bufferProducer); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubDetachBufferQueue( - MessageParcel &data, MessageParcel &reply, MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubDetachBufferQueue entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - int32_t streamId = data.ReadInt32(); - CamRetCode ret = DetachBufferQueue(streamId); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubCapture(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubCapture entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - int captureId = static_cast(data.ReadInt32()); - - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - DHLOGE("Write streamIds failed."); - return HDF_FAILURE; - } - - std::shared_ptr metadata = nullptr; - Camera::MetadataUtils::DecodeCameraMetadata(data, metadata); - - bool enableShutterCallback = data.ReadBool(); - std::shared_ptr pInfo = std::make_shared(); - pInfo->streamIds_ = streamIds; - pInfo->captureSetting_ = metadata; - pInfo->enableShutterCallback_ = enableShutterCallback; - - bool isStreaming = data.ReadBool(); - - CamRetCode ret = Capture(captureId, pInfo, isStreaming); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubCancelCapture(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubCancelCapture entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - int32_t captureId = data.ReadInt32(); - CamRetCode ret = CancelCapture(captureId); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("Write retcode failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t DStreamOperatorStub::DStreamOperatorStubChangeToOfflineStream(MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - DHLOGI("DStreamOperatorStub::DStreamOperatorStubChangeToOfflineStream entry."); - if (data.ReadInterfaceToken() != DStreamOperatorStub::GetDescriptor()) { - DHLOGE("invalid token."); - return HDF_FAILURE; - } - - std::vector streamIds; - if (!data.ReadInt32Vector(&streamIds)) { - DHLOGE("Read streamIds failed."); - return HDF_FAILURE; - } - - sptr remoteObj = data.ReadRemoteObject(); - sptr spStreamOperatorCallback = OHOS::iface_cast(remoteObj); - if (spStreamOperatorCallback == nullptr) { - DHLOGE("Read operator callback failed."); - return HDF_FAILURE; - } - - OHOS::sptr offlineOperator = nullptr; - CamRetCode ret = ChangeToOfflineStream(streamIds, spStreamOperatorCallback, offlineOperator); - if (!reply.WriteInt32(static_cast(ret))) { - DHLOGE("write retcode failed."); - return HDF_FAILURE; - } - - if (offlineOperator == nullptr) { - DHLOGE("Change to offline stream failed, offlineOperator is null."); - return HDF_FAILURE; - } - - if (!reply.WriteRemoteObject(offlineOperator->AsObject())) { - DHLOGE("Write offline stream operator failed."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.h b/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.h deleted file mode 100644 index f8bd5b72c7..0000000000 --- a/distributed_camera/interfaces/hdi_ipc/server/operator/dstream_operator_stub.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (c) 2021 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 DISTRIBUTED_STREAM_OPERATOR_SERVER_STUB_H -#define DISTRIBUTED_STREAM_OPERATOR_SERVER_STUB_H - -#include -#include -#include -#include "iremote_stub.h" -#include "istream_operator.h" - -namespace OHOS { -namespace DistributedHardware { -using namespace OHOS::Camera; -class DStreamOperatorStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) override; - -private: - int32_t DStreamOperatorStubIsStreamsSupported(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubCreateStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubReleaseStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubCommitStreams(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubGetStreamAttributes(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubAttachBufferQueue(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubDetachBufferQueue(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubCapture(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubCancelCapture(MessageParcel &data, MessageParcel &reply, MessageOption &option); - int32_t DStreamOperatorStubChangeToOfflineStream(MessageParcel &data, MessageParcel &reply, MessageOption &option); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // DISTRIBUTED_STREAM_OPERATOR_SERVER_STUB_H \ No newline at end of file -- Gitee From fde2272b850d57c57b616351a836231a6c8f6268 Mon Sep 17 00:00:00 2001 From: yichengzhao Date: Tue, 7 Jun 2022 19:02:59 +0800 Subject: [PATCH 11/33] add partitionslot Signed-off-by: yichengzhao Change-Id: I5dfb95421c849221aa213218ce33efbd029e63fe --- partitionslot/BUILD.gn | 16 ++ partitionslot/bundle.json | 47 ++++++ partitionslot/hal/BUILD.gn | 37 +++++ .../hal/src/partitionslot_manager.cpp | 152 ++++++++++++++++++ partitionslot/hdi_service/BUILD.gn | 72 +++++++++ .../hdi_service/include/partitionslot_impl.h | 38 +++++ .../hdi_service/src/partition_slot_driver.cpp | 115 +++++++++++++ .../hdi_service/src/partitionslot_impl.cpp | 60 +++++++ .../innerkits/partitionslot_manager.h | 45 ++++++ partitionslot/test/BUILD.gn | 37 +++++ .../test/unittest/hdf_partitionslot_test.cpp | 68 ++++++++ 11 files changed, 687 insertions(+) create mode 100644 partitionslot/BUILD.gn create mode 100644 partitionslot/bundle.json create mode 100644 partitionslot/hal/BUILD.gn create mode 100644 partitionslot/hal/src/partitionslot_manager.cpp create mode 100644 partitionslot/hdi_service/BUILD.gn create mode 100644 partitionslot/hdi_service/include/partitionslot_impl.h create mode 100644 partitionslot/hdi_service/src/partition_slot_driver.cpp create mode 100644 partitionslot/hdi_service/src/partitionslot_impl.cpp create mode 100644 partitionslot/interfaces/innerkits/partitionslot_manager.h create mode 100644 partitionslot/test/BUILD.gn create mode 100644 partitionslot/test/unittest/hdf_partitionslot_test.cpp diff --git a/partitionslot/BUILD.gn b/partitionslot/BUILD.gn new file mode 100644 index 0000000000..2317b59ca0 --- /dev/null +++ b/partitionslot/BUILD.gn @@ -0,0 +1,16 @@ +# Copyright (c) 2022 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. + +group("partitionslot_entry") { + deps = [ "./hdi_service:hdf_partitionslot_service" ] +} diff --git a/partitionslot/bundle.json b/partitionslot/bundle.json new file mode 100644 index 0000000000..71c95f0f86 --- /dev/null +++ b/partitionslot/bundle.json @@ -0,0 +1,47 @@ +{ + "name": "drivers_peripheral_partitionslot", + "description": "partitionslot hdf", + "version": "3.1", + "license": "Apache License 2.0", + "component": { + "name": "drivers_peripheral_partitionslot", + "subsystem": "hdf", + "syscap": [ "" ], + "adapter_system_type": ["standard", "small"], + "rom": "600KB", + "ram": "7400KB", + "deps": { + "components": [ + "ipc", + "utils_base", + "base", + "hdf_core", + "libhilog", + "ipc_single", + "init" + ], + "third_part": [ + "gmock_main", + "gtest_main", + "jsoncpp" + ] + }, + "build": { + "sub_component": [ + "//drivers/peripheral/partitionslot:partitionslot_entry" + ], + "test": [ + "//drivers/peripheral/partitionslot/test:partitionslot_unittest" + ], + "inner_kits": [ + { + "name": "//drivers/peripheral/partitionslot/hal:libpartition_slot_manager", + "header": { + "header_files": [ "partitionslot_manager.h" ], + "header_base": "//drivers/peripheral/partitionslot/interfaces/innerkits" + } + } + ] + } + } +} diff --git a/partitionslot/hal/BUILD.gn b/partitionslot/hal/BUILD.gn new file mode 100644 index 0000000000..1b511fa712 --- /dev/null +++ b/partitionslot/hal/BUILD.gn @@ -0,0 +1,37 @@ +# Copyright (c) 2022 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. + +import("//build/ohos.gni") + +config("exported_header_files") { + visibility = [ ":*" ] + include_dirs = [ "//drivers/peripheral/partitionslot/interfaces/innerkits" ] +} + +ohos_shared_library("libpartition_slot_manager") { + include_dirs = [ + "//drivers/peripheral/partitionslot/interfaces/innerkits", + "//drivers/peripheral/partitionslot/hdi_service/include", + ] + sources = [ "src/partitionslot_manager.cpp" ] + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "init:libbegetutil", + "utils_base:utils", + ] + + public_configs = [ ":exported_header_files" ] + + subsystem_name = "hdf" + part_name = "drivers_peripheral_partitionslot" +} diff --git a/partitionslot/hal/src/partitionslot_manager.cpp b/partitionslot/hal/src/partitionslot_manager.cpp new file mode 100644 index 0000000000..c37b2cebbe --- /dev/null +++ b/partitionslot/hal/src/partitionslot_manager.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2022 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 "partitionslot_manager.h" + +#include +#include +#include "param_wrapper.h" +#include "fs_manager.h" +#include "hilog/log.h" + +namespace OHOS { +namespace HDI { +namespace Partitionslot { +namespace V1_0 { +#define HILOG_LOG_TAG hdf_partitionslot_manager + +constexpr int32_t UPDATE_PARTITION_B = 2; + +constexpr off_t MISC_PARTITION_ACTIVE_SLOT_OFFSET = 1400; +constexpr off_t MISC_PARTITION_ACTIVE_SLOT_SIZE = 4; + +constexpr off_t MISC_PARTITION_UNBOOT_SLOT_OFFSET = MISC_PARTITION_ACTIVE_SLOT_OFFSET + MISC_PARTITION_ACTIVE_SLOT_SIZE; +constexpr off_t MISC_PARTITION_UNBOOT_SLOT_SIZE = 4; + +int32_t PartitionSlotManager::GetCurrentSlot(int32_t& numOfSlots) +{ + HILOG_DEBUG(LOG_CORE, "%{public}s called!", __func__); + numOfSlots = system::GetIntParameter("ohos.boot.bootslot", 1); + char miscDev[PATH_MAX] = { 0 }; + int ret = GetBlockDevicePath("/misc", miscDev, PATH_MAX); + if (ret != 0) { + HILOG_ERROR(LOG_CORE, "GetBlockDevicePath failed"); + return -1; + } + std::string miscDevice = std::string(miscDev); + if (miscDevice.empty()) { + HILOG_ERROR(LOG_CORE, "miscDevice is empty"); + return -1; + } + int32_t currentSlot = ReadMisc(miscDevice, MISC_PARTITION_ACTIVE_SLOT_OFFSET, MISC_PARTITION_ACTIVE_SLOT_SIZE); + HILOG_INFO(LOG_CORE, "current slot is %{public}d, numOfSlots is %{public}d", currentSlot, numOfSlots); + return currentSlot; +} + +int32_t PartitionSlotManager::GetSlotSuffix(int32_t slot, std::string& suffix) +{ + HILOG_DEBUG(LOG_CORE, "%{public}s called!", __func__); + if (slot == UPDATE_PARTITION_B) { + suffix = "_b"; + } else { + suffix = ""; + } + HILOG_INFO(LOG_CORE, "suffix is %{public}s", suffix.c_str()); + return 0; +} + +int32_t PartitionSlotManager::SetActiveSlot(int32_t slot) +{ + HILOG_DEBUG(LOG_CORE, "%{public}s called!, slot is %{public}d", __func__, slot); + return WriteSlotToMisc(slot, MISC_PARTITION_ACTIVE_SLOT_OFFSET, MISC_PARTITION_ACTIVE_SLOT_SIZE); +} + +int32_t PartitionSlotManager::SetSlotUnbootable(int32_t slot) +{ + HILOG_DEBUG(LOG_CORE, "%{public}s called!, slot is %{public}d", __func__, slot); + return WriteSlotToMisc(slot, MISC_PARTITION_UNBOOT_SLOT_OFFSET, MISC_PARTITION_UNBOOT_SLOT_SIZE); +} + +int32_t PartitionSlotManager::WriteSlot(int fd, int32_t slot, off_t offset, off_t size) +{ + if (lseek(fd, offset, SEEK_SET) < 0) { + HILOG_ERROR(LOG_CORE, "Failed lseek slot %{public}d errno %{public}d", slot, errno); + return -1; + } + + if (write(fd, &slot, size) != size) { + HILOG_ERROR(LOG_CORE, "Write slot failed "); + return -1; + } + return 0; +} + +int PartitionSlotManager::ReadMisc(const std::string &miscDevice, off_t offset, off_t size) +{ + int fd = open(miscDevice.c_str(), O_RDWR | O_CLOEXEC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); + if (fd < 0) { + return -1; + } + if (lseek(fd, offset, SEEK_SET) < 0) { + HILOG_ERROR(LOG_CORE, "Failed lseek miscDevice errno %{public}d ", errno); + close(fd); + return -1; + } + int32_t slot = 0; + if (read(fd, &slot, size) != size) { + HILOG_ERROR(LOG_CORE, "Failed read migic miscDevice errno %{public}d ", errno); + close(fd); + return -1; + } + HILOG_INFO(LOG_CORE, "Read slot %{public}d", slot); + close(fd); + return slot; +} + +int PartitionSlotManager::WriteSlotToMisc(int32_t slot, off_t offset, off_t size) +{ + if (slot < 0) { + HILOG_ERROR(LOG_CORE, "Invalid slot : %{public}d", slot); + return -1; + } + char miscDev[PATH_MAX] = { 0 }; + int ret = GetBlockDevicePath("/misc", miscDev, PATH_MAX); + if (ret != 0) { + return -1; + } + std::string miscDevice = std::string(miscDev); + if (miscDevice.empty()) { + HILOG_ERROR(LOG_CORE, "miscDevice is empty"); + return -1; + } + HILOG_INFO(LOG_CORE, "WriteSlotToMisc miscDevice %{public}s ", miscDevice.c_str()); + int fd = open(miscDevice.c_str(), O_RDWR | O_CLOEXEC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); + if (fd < 0) { + HILOG_ERROR(LOG_CORE, "Failed to open miscDevice %{public}s errno %{public}d ", miscDevice.c_str(), errno); + return -1; + } + + if (WriteSlot(fd, slot, offset, size) < 0) { + HILOG_ERROR(LOG_CORE, "Failed to WriteSlot miscDevice %{public}d errno %{public}d ", slot, errno); + close(fd); + return -1; + } + close(fd); + return 0; +} +} // V1_0 +} // Partitionslot +} // HDI +} // OHOS diff --git a/partitionslot/hdi_service/BUILD.gn b/partitionslot/hdi_service/BUILD.gn new file mode 100644 index 0000000000..e1fb9951fd --- /dev/null +++ b/partitionslot/hdi_service/BUILD.gn @@ -0,0 +1,72 @@ +# Copyright (c) 2022 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. + +import("//build/ohos.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") + +ohos_shared_library("libpartition_slot_service_1.0") { + include_dirs = [ + "include", + "//base/user_iam/user_auth/common/logs", + ] + sources = [ "src/partitionslot_impl.cpp" ] + public_deps = [ + "//drivers/interface/partitionslot/v1_0:libpartitionslot_stub_1.0", + "//drivers/peripheral/partitionslot/hal:libpartition_slot_manager", + ] + external_deps = [ + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + "init:libbegetutil", + "ipc:ipc_single", + "utils_base:utils", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_partitionslot" +} + +ohos_shared_library("libpartitionslot_driver") { + include_dirs = [ + "include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//base/user_iam/user_auth/common/logs", + ] + sources = [ "src/partition_slot_driver.cpp" ] + deps = [ + ":libpartition_slot_service_1.0", + "//drivers/interface/partitionslot/v1_0:libpartitionslot_stub_1.0", + ] + + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + "utils_base:utils", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_partitionslot" +} + +group("hdf_partitionslot_service") { + deps = [ + ":libpartition_slot_service_1.0", + ":libpartitionslot_driver", + ] +} diff --git a/partitionslot/hdi_service/include/partitionslot_impl.h b/partitionslot/hdi_service/include/partitionslot_impl.h new file mode 100644 index 0000000000..a7ffb94f3c --- /dev/null +++ b/partitionslot/hdi_service/include/partitionslot_impl.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2022 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 OHOS_HDI_PARTITIONSLOT_V1_0_PARTITIONSLOTIMPL_H +#define OHOS_HDI_PARTITIONSLOT_V1_0_PARTITIONSLOTIMPL_H + +#include "v1_0/ipartition_slot.h" + +namespace OHOS { +namespace HDI { +namespace Partitionslot { +namespace V1_0 { +class PartitionSlotImpl : public IPartitionSlot { +public: + virtual ~PartitionSlotImpl() {} + int32_t GetCurrentSlot(int32_t& numOfSlots) override; + int32_t GetSlotSuffix(int32_t slot, std::string& suffix) override; + int32_t SetActiveSlot(int32_t slot) override; + int32_t SetSlotUnbootable(int32_t slot) override; +}; +} // V1_0 +} // Partitionslot +} // HDI +} // OHOS + +#endif // OHOS_HDI_PARTITIONSLOT_V1_0_PARTITIONSLOTIMPL_H \ No newline at end of file diff --git a/partitionslot/hdi_service/src/partition_slot_driver.cpp b/partitionslot/hdi_service/src/partition_slot_driver.cpp new file mode 100644 index 0000000000..32afb46805 --- /dev/null +++ b/partitionslot/hdi_service/src/partition_slot_driver.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2022 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 +#include +#include +#include +#include "v1_0/partition_slot_stub.h" + +using namespace OHOS::HDI::Partitionslot::V1_0; + +struct HdfPartitionSlotHost { + struct IDeviceIoService ioService; + OHOS::sptr stub; +}; + +static int32_t PartitionSlotDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + auto *hdfPartitionSlotHost = CONTAINER_OF(client->device->service, struct HdfPartitionSlotHost, ioService); + + OHOS::MessageParcel *dataParcel = nullptr; + OHOS::MessageParcel *replyParcel = nullptr; + OHOS::MessageOption option; + + if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + + return hdfPartitionSlotHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); +} + +static int HdfPartitionSlotDriverInit(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfPartitionSlotDriverInit enter"); + return HDF_SUCCESS; +} + +static int HdfPartitionSlotDriverBind(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfPartitionSlotDriverBind enter"); + + auto *hdfPartitionSlotHost = new (std::nothrow) HdfPartitionSlotHost; + if (hdfPartitionSlotHost == nullptr) { + HDF_LOGE("%{public}s: failed to create create HdfPartitionSlotHost object", __func__); + return HDF_FAILURE; + } + + hdfPartitionSlotHost->ioService.Dispatch = PartitionSlotDriverDispatch; + hdfPartitionSlotHost->ioService.Open = NULL; + hdfPartitionSlotHost->ioService.Release = NULL; + + auto serviceImpl = IPartitionSlot::Get(true); + if (serviceImpl == nullptr) { + HDF_LOGE("%{public}s: failed to get of implement service", __func__); + delete hdfPartitionSlotHost; + return HDF_FAILURE; + } + + hdfPartitionSlotHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, + IPartitionSlot::GetDescriptor()); + if (hdfPartitionSlotHost->stub == nullptr) { + HDF_LOGE("%{public}s: failed to get stub object", __func__); + delete hdfPartitionSlotHost; + return HDF_FAILURE; + } + + deviceObject->service = &hdfPartitionSlotHost->ioService; + return HDF_SUCCESS; +} + +static void HdfPartitionSlotDriverRelease(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfPartitionSlotDriverRelease enter"); + if (deviceObject->service == nullptr) { + HDF_LOGE("HdfPartitionSlotDriverRelease not initted"); + return; + } + + auto *hdfPartitionSlotHost = CONTAINER_OF(deviceObject->service, struct HdfPartitionSlotHost, ioService); + delete hdfPartitionSlotHost; +} + +static struct HdfDriverEntry g_partitionslotDriverEntry = { + .moduleVersion = 1, + .moduleName = "partitionslot_interface_service", + .Bind = HdfPartitionSlotDriverBind, + .Init = HdfPartitionSlotDriverInit, + .Release = HdfPartitionSlotDriverRelease, +}; + +#ifndef __cplusplus +extern "C" { +#endif +HDF_INIT(g_partitionslotDriverEntry); +#ifndef __cplusplus +} +#endif diff --git a/partitionslot/hdi_service/src/partitionslot_impl.cpp b/partitionslot/hdi_service/src/partitionslot_impl.cpp new file mode 100644 index 0000000000..cf29e2e0fa --- /dev/null +++ b/partitionslot/hdi_service/src/partitionslot_impl.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2022 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 "partitionslot_impl.h" + +#include +#include +#include "partitionslot_manager.h" + +namespace OHOS { +namespace HDI { +namespace Partitionslot { +namespace V1_0 { +#define HDF_LOG_TAG hdf_partitionslot_impl + +extern "C" IPartitionSlot *PartitionSlotImplGetInstance(void) +{ + return new (std::nothrow) PartitionSlotImpl(); +} + +int32_t PartitionSlotImpl::GetCurrentSlot(int32_t& numOfSlots) +{ + HDF_LOGD("%{public}s called!", __func__); + int currentSlot = PartitionSlotManager::GetInstance()->GetCurrentSlot(numOfSlots); + return currentSlot; +} + +int32_t PartitionSlotImpl::GetSlotSuffix(int32_t slot, std::string& suffix) +{ + HDF_LOGD("%{public}s called!", __func__); + return PartitionSlotManager::GetInstance()->GetSlotSuffix(slot, suffix); +} + +int32_t PartitionSlotImpl::SetActiveSlot(int32_t slot) +{ + HDF_LOGD("%{public}s called!, slot is %{public}d", __func__, slot); + return PartitionSlotManager::GetInstance()->SetActiveSlot(slot); +} + +int32_t PartitionSlotImpl::SetSlotUnbootable(int32_t slot) +{ + HDF_LOGD("%{public}s called!, slot is %{public}d", __func__, slot); + return PartitionSlotManager::GetInstance()->SetSlotUnbootable(slot); +} +} // V1_0 +} // Partitionslot +} // HDI +} // OHOS diff --git a/partitionslot/interfaces/innerkits/partitionslot_manager.h b/partitionslot/interfaces/innerkits/partitionslot_manager.h new file mode 100644 index 0000000000..c4e0a07911 --- /dev/null +++ b/partitionslot/interfaces/innerkits/partitionslot_manager.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2022 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 OHOS_HDI_PARTITIONSLOT_PARTITIONSLOT_MANAGER_H +#define OHOS_HDI_PARTITIONSLOT_PARTITIONSLOT_MANAGER_H + +#include +#include + +#include "singleton.h" + +namespace OHOS { +namespace HDI { +namespace Partitionslot { +namespace V1_0 { +class PartitionSlotManager : public DelayedSingleton { +public: + int32_t GetCurrentSlot(int32_t& numOfSlots); + int32_t GetSlotSuffix(int32_t slot, std::string& suffix); + int32_t SetActiveSlot(int32_t slot); + int32_t SetSlotUnbootable(int32_t slot); + +private: + int32_t WriteSlot(int fd, int32_t slot, off_t offset, off_t size); + int ReadMisc(const std::string &miscDevice, off_t offset, off_t size); + int WriteSlotToMisc(int32_t slot, off_t offset, off_t size); +}; +} // V1_0 +} // Partitionslot +} // HDI +} // OHOS + +#endif // OHOS_HDI_PARTITIONSLOT_PARTITIONSLOT_MANAGER_H \ No newline at end of file diff --git a/partitionslot/test/BUILD.gn b/partitionslot/test/BUILD.gn new file mode 100644 index 0000000000..f1fbc88d2d --- /dev/null +++ b/partitionslot/test/BUILD.gn @@ -0,0 +1,37 @@ +# Copyright (c) 2021 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. +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") + +module_output_path = "partitionslot/" + +ohos_unittest("partitionslot_hdi_1.0_test") { + module_out_path = module_output_path + sources = [ "unittest/hdf_partitionslot_test.cpp" ] + + deps = [ "//utils/native/base:utils" ] + + external_deps = [ + "drivers_peripheral_partitionslot:libpartition_slot_manager", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hiviewdfx_hilog_native:libhilog", + ] +} + +group("partitionslot_unittest") { + testonly = true + deps = [ ":partitionslot_hdi_1.0_test" ] +} diff --git a/partitionslot/test/unittest/hdf_partitionslot_test.cpp b/partitionslot/test/unittest/hdf_partitionslot_test.cpp new file mode 100644 index 0000000000..c6325e53e5 --- /dev/null +++ b/partitionslot/test/unittest/hdf_partitionslot_test.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2022 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 +#include +#include +#include "hdf_log.h" +#include "partitionslot_manager.h" + +namespace OHOS { +namespace PartitionSlot { +using namespace testing; +using namespace testing::ext; +using namespace OHOS::HDI::Partitionslot::V1_0; + +class HDFPartitionSlotTest : public testing::Test { +public: + static void SetUpTestCase() {} + static void TearDownTestCase() {} + void SetUp() {} + void TearDown() {} +}; + +HWTEST_F(HDFPartitionSlotTest, HdfPartitionSlotTest_001, TestSize.Level1) +{ + printf("begin get currentslot by service \n"); + int numOfSlots = 0; + int currentSlot = -1; + currentSlot = PartitionSlotManager::GetInstance()->GetCurrentSlot(numOfSlots); + ASSERT_TRUE(currentSlot != -1); +} + +HWTEST_F(HDFPartitionSlotTest, HdfPartitionSlotTest_002, TestSize.Level1) +{ + printf("begin get suffix by service \n"); + std::string suffix = ""; + int slot = 2; + ASSERT_TRUE(PartitionSlotManager::GetInstance()->GetSlotSuffix(slot, suffix) == 0); +} + +HWTEST_F(HDFPartitionSlotTest, HdfPartitionSlotTest_003, TestSize.Level1) +{ + printf("begin set active slot by service \n"); + int numOfSlots = 0; + int currentSlot = PartitionSlotManager::GetInstance()->GetCurrentSlot(numOfSlots); + ASSERT_TRUE(PartitionSlotManager::GetInstance()->SetActiveSlot(2) == 0); + PartitionSlotManager::GetInstance()->SetActiveSlot(currentSlot); +} + +HWTEST_F(HDFPartitionSlotTest, HdfPartitionSlotTest_004, TestSize.Level1) +{ + printf("begin set unbootable slot by service \n"); + ASSERT_TRUE(PartitionSlotManager::GetInstance()->SetSlotUnbootable(2) == 0); +} +} // PartitionSlot +} // OHOS -- Gitee From b9921daf56060ba44f27e66056cf62e84587db57 Mon Sep 17 00:00:00 2001 From: shijie Date: Fri, 29 Jul 2022 17:36:15 +0800 Subject: [PATCH 12/33] fix:put the charger's file into the vendor path and optimize the name Signed-off-by: shijie --- battery/charger/BUILD.gn | 3 +- battery/charger/resources/BUILD.gn | 207 ++++++++++++------ .../{init.charge.cfg => init.charger.cfg} | 0 battery/charger/sa_profile/BUILD.gn | 3 +- battery/charger/src/charger_thread.cpp | 4 +- battery/charger/ui/src/text_label.cpp | 8 +- .../hdi_service/src/battery_config.cpp | 2 +- .../test/unittest/src/hdi_service_test.cpp | 6 +- 8 files changed, 151 insertions(+), 82 deletions(-) rename battery/charger/resources/{init.charge.cfg => init.charger.cfg} (100%) diff --git a/battery/charger/BUILD.gn b/battery/charger/BUILD.gn index dcf4279a44..123ecc7d85 100644 --- a/battery/charger/BUILD.gn +++ b/battery/charger/BUILD.gn @@ -60,6 +60,7 @@ ohos_executable("charger") { "utils_base:utils", ] + install_images = [ chipset_base_dir ] part_name = "drivers_peripheral_battery" } @@ -73,6 +74,7 @@ group("led_service") { group("resources_service") { deps = [ + "resources:init.charger.cfg", "resources:resources_config", "resources:resources_config1", "resources:resources_config10", @@ -136,7 +138,6 @@ group("resources_service") { "resources:resources_config63", "resources:resources_config64", "resources:resources_config65", - "resources:resources_config66", "resources:resources_config7", "resources:resources_config8", "resources:resources_config9", diff --git a/battery/charger/resources/BUILD.gn b/battery/charger/resources/BUILD.gn index 394ce2691c..daa001b84a 100644 --- a/battery/charger/resources/BUILD.gn +++ b/battery/charger/resources/BUILD.gn @@ -13,471 +13,538 @@ import("//build/ohos.gni") -## Install resources to /system/etc/resources +## Install resources to /vendor/etc/resources ohos_prebuilt_etc("resources_config") { source = "font.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config1") { source = "icon_error.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config2") { source = "loop00000.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config3") { source = "loop00001.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config4") { source = "loop00002.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config5") { source = "loop00003.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config6") { source = "loop00004.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config7") { source = "loop00005.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config8") { source = "loop00006.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config9") { source = "loop00007.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config10") { source = "loop00008.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config11") { source = "loop00009.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config12") { source = "loop00010.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config13") { source = "loop00011.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config14") { source = "loop00012.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config15") { source = "loop00013.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config16") { source = "loop00014.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config17") { source = "loop00015.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config18") { source = "loop00016.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config19") { source = "loop00017.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config20") { source = "loop00018.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config21") { source = "loop00019.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config22") { source = "loop00020.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config23") { source = "loop00021.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config24") { source = "loop00022.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config25") { source = "loop00023.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config26") { source = "loop00024.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config27") { source = "loop00025.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config28") { source = "loop00026.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config29") { source = "loop00027.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config30") { source = "loop00028.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config31") { source = "loop00029.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config32") { source = "loop00030.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config33") { source = "loop00031.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config34") { source = "loop00032.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config35") { source = "loop00033.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config36") { source = "loop00034.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config37") { source = "loop00035.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config38") { source = "loop00036.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config39") { source = "loop00037.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config40") { source = "loop00038.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config41") { source = "loop00039.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config42") { source = "loop00040.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config43") { source = "loop00041.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config44") { source = "loop00042.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config45") { source = "loop00043.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config46") { source = "loop00044.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config47") { source = "loop00045.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config48") { source = "loop00046.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config49") { source = "loop00047.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config50") { source = "loop00048.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config51") { source = "loop00049.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config52") { source = "loop00050.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config53") { source = "loop00051.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config54") { source = "loop00052.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config55") { source = "loop00053.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config56") { source = "loop00054.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config57") { source = "loop00055.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config58") { source = "loop00056.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config59") { source = "loop00057.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config60") { source = "loop00058.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config61") { source = "loop00059.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config62") { source = "loop00060.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config63") { source = "loop00061.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config64") { source = "progress_empty.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } ohos_prebuilt_etc("resources_config65") { source = "progress_fill.png" - relative_install_dir = "resources" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger/resources" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } -ohos_prebuilt_etc("resources_config66") { - source = "init.charge.cfg" - relative_install_dir = "charge" +ohos_prebuilt_etc("init.charger.cfg") { + source = "init.charger.cfg" + install_images = [ chipset_base_dir ] + relative_install_dir = "charger" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" } diff --git a/battery/charger/resources/init.charge.cfg b/battery/charger/resources/init.charger.cfg similarity index 100% rename from battery/charger/resources/init.charge.cfg rename to battery/charger/resources/init.charger.cfg diff --git a/battery/charger/sa_profile/BUILD.gn b/battery/charger/sa_profile/BUILD.gn index 88cad854d9..bc007d479c 100644 --- a/battery/charger/sa_profile/BUILD.gn +++ b/battery/charger/sa_profile/BUILD.gn @@ -13,9 +13,10 @@ import("//build/ohos.gni") -## Install led_config.json to /system/etc/ledconfig/led_config.json +## Install led_config.json to /vendor/etc/ledconfig/led_config.json ohos_prebuilt_etc("led_config") { source = "led_config.json" + install_images = [ chipset_base_dir ] relative_install_dir = "ledconfig" part_name = "drivers_peripheral_battery" subsystem_name = "hdf" diff --git a/battery/charger/src/charger_thread.cpp b/battery/charger/src/charger_thread.cpp index 1c6ad79b8e..3806eeefbb 100644 --- a/battery/charger/src/charger_thread.cpp +++ b/battery/charger/src/charger_thread.cpp @@ -134,13 +134,13 @@ void ChargerThread::LoadImages(AnimationLabel* animationLabel) if (i < LOOP_TOP_PICTURES) { if (snprintf_s(nameBuf, MAX_IMG_NAME_SIZE, MAX_IMG_NAME_SIZE - 1, - "/system/etc/resources/loop0000%d.png", i) == -1) { + "/vendor/etc/charger/resources/loop0000%d.png", i) == -1) { BATTERY_HILOGW(FEATURE_CHARGING, "snprintf_s failed, index=%{public}d", i); return; } } else { if (snprintf_s(nameBuf, MAX_IMG_NAME_SIZE, MAX_IMG_NAME_SIZE - 1, - "/system/etc/resources/loop000%d.png", i) == -1) { + "/vendor/etc/charger/resources/loop000%d.png", i) == -1) { BATTERY_HILOGW(FEATURE_CHARGING, "snprintf_s failed, index=%{public}d", i); return; } diff --git a/battery/charger/ui/src/text_label.cpp b/battery/charger/ui/src/text_label.cpp index 96c0eaa1c0..7b50e9a1f4 100644 --- a/battery/charger/ui/src/text_label.cpp +++ b/battery/charger/ui/src/text_label.cpp @@ -126,14 +126,14 @@ void TextLabel::InitFont() switch (fontType_) { case FontType::DEFAULT_FONT: if (snprintf_s(resPath, sizeof(resPath), sizeof(resPath) - 1, - "/system/etc/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { + "/vendor/etc/charger/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { BATTERY_HILOGW(FEATURE_CHARGING, "snprintf_s font failed."); return; } break; default: if (snprintf_s(resPath, sizeof(resPath), sizeof(resPath) - 1, - "/system/etc/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { + "/vendor/etc/charger/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { BATTERY_HILOGW(FEATURE_CHARGING, "snprintf_s font failed."); return; } @@ -196,14 +196,14 @@ FILE* TextLabel::InitFontType() switch (fontType_) { case FontType::DEFAULT_FONT: if (snprintf_s(resPath, sizeof(resPath), sizeof(resPath) - 1, - "/system/etc/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { + "/vendor/etc/charger/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { BATTERY_HILOGW(FEATURE_CHARGING, "snprintf_s font fail."); return nullptr; } break; default: if (snprintf_s(resPath, sizeof(resPath), sizeof(resPath) - 1, - "/system/etc/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { + "/vendor/etc/charger/resources/%s.png", DEFAULT_FONT_NAME.c_str()) == -1) { BATTERY_HILOGW(FEATURE_CHARGING, "snprintf_s font fail."); return nullptr; } diff --git a/battery/interfaces/hdi_service/src/battery_config.cpp b/battery/interfaces/hdi_service/src/battery_config.cpp index 5af5f118a4..0a115c1bc1 100644 --- a/battery/interfaces/hdi_service/src/battery_config.cpp +++ b/battery/interfaces/hdi_service/src/battery_config.cpp @@ -22,7 +22,7 @@ namespace HDI { namespace Battery { namespace V1_1 { namespace { -const std::string CONFIG_FILE = "/system/etc/ledconfig/led_config.json"; +const std::string CONFIG_FILE = "/vendor/etc/ledconfig/led_config.json"; constexpr int32_t DEFAULT_CAPACITY_CONF = 3; constexpr int32_t DEFAULT_UPPER_TEMP_CONF = 600; constexpr int32_t DEFAULT_LOWER_TEMP_CONF = -100; diff --git a/battery/interfaces/hdi_service/test/unittest/src/hdi_service_test.cpp b/battery/interfaces/hdi_service/test/unittest/src/hdi_service_test.cpp index a78d974917..4038e63be2 100644 --- a/battery/interfaces/hdi_service/test/unittest/src/hdi_service_test.cpp +++ b/battery/interfaces/hdi_service/test/unittest/src/hdi_service_test.cpp @@ -1162,7 +1162,7 @@ HWTEST_F (HdiServiceTest, HdiService016, TestSize.Level1) */ HWTEST_F (HdiServiceTest, HdiService017, TestSize.Level1) { - std::string filename = "error_path/system/etc/ledconfig/led_config.json"; + std::string filename = "error_path/vendor/etc/ledconfig/led_config.json"; BatteryConfig bc; ParseConfigTest(filename, bc); @@ -1178,7 +1178,7 @@ HWTEST_F (HdiServiceTest, HdiService017, TestSize.Level1) */ HWTEST_F (HdiServiceTest, HdiService018, TestSize.Level1) { - std::string filename = "error_path/system/etc/ledconfig/led_config.json"; + std::string filename = "error_path/vendor/etc/ledconfig/led_config.json"; BatteryConfig bc; ParseConfigTest(filename, bc); @@ -1196,7 +1196,7 @@ HWTEST_F (HdiServiceTest, HdiService018, TestSize.Level1) */ HWTEST_F (HdiServiceTest, HdiService019, TestSize.Level1) { - std::string filename = "error_path/system/etc/ledconfig/led_config.json"; + std::string filename = "error_path/vendor/etc/ledconfig/led_config.json"; BatteryConfig bc; ParseConfigTest(filename, bc); -- Gitee From df244e0cd56f30595a15cd105573eafba5f8e45b Mon Sep 17 00:00:00 2001 From: zenglifeng Date: Tue, 2 Aug 2022 11:13:32 +0800 Subject: [PATCH 13/33] test:part9 add audio testcase of hdi_service Signed-off-by: zenglifeng --- audio/test/systemtest/BUILD.gn | 1 + .../src/audio_adm_interface_test.cpp | 6 +- .../src/audio_threshold_report_test.cpp | 2 + .../include/hdi_service_common.h | 2 +- .../src/hdi_service_common.cpp | 24 +- .../src/audio_hdirender_volume_test.cpp | 2 +- ...io_hdicapture_hardware_dependence_test.cpp | 12 +- audio/test/systemtest/hdi_service/BUILD.gn | 30 + .../systemtest/hdi_service/common/BUILD.gn | 26 + ...idl_hdirender_hardware_dependence_test.cpp | 1047 +++++++++++++++++ .../systemtest/hdi_service/rk3568/BUILD.gn | 24 + .../hdi_service/rk3568/capture/BUILD.gn | 48 + .../hdi_service/rk3568/render/BUILD.gn | 46 + .../capture/src/audio_libcapture_test.cpp | 16 + .../render/src/audio_librender_test.cpp | 25 +- 15 files changed, 1296 insertions(+), 15 deletions(-) create mode 100644 audio/test/systemtest/hdi_service/BUILD.gn create mode 100644 audio/test/systemtest/hdi_service/common/BUILD.gn create mode 100644 audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp create mode 100644 audio/test/systemtest/hdi_service/rk3568/BUILD.gn create mode 100644 audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn create mode 100644 audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn diff --git a/audio/test/systemtest/BUILD.gn b/audio/test/systemtest/BUILD.gn index f612dc9a79..d87a07f7a3 100644 --- a/audio/test/systemtest/BUILD.gn +++ b/audio/test/systemtest/BUILD.gn @@ -32,6 +32,7 @@ if (defined(ohos_lite)) { deps = [ "hdi:hdi", + "hdi_service:hdi_service_st", "supportlibs:supportlibs", #"audio_adapter:audio_adapter", diff --git a/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp b/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp index 7329565421..dc8ec3ce0d 100644 --- a/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp +++ b/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp @@ -1274,7 +1274,7 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostWrite_0001, TestSize.Level1) HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRead_0001, TestSize.Level1) { int32_t tryNumReply = 100; - int32_t buffStatus = 0; + uint32_t buffStatus = 0; uint32_t readSize = 0; struct HdfIoService *service = nullptr; struct HdfSBuf *sBufTStop = nullptr; @@ -1295,8 +1295,8 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRead_0001, TestSize.Level1) do { ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_READ, nullptr, reply); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GE(HdfSbufReadInt32(reply, &buffStatus), HDF_SUCCESS); - if (buffStatus != CIR_BUFF_NORMAL) { + EXPECT_GE(HdfSbufReadUint32(reply, &buffStatus), HDF_SUCCESS); + if ((int32_t)buffStatus != CIR_BUFF_NORMAL) { int32_t ms = buffStatus >= 0 ? buffStatus : WAITE_TIME; tryNumReply--; HdfSbufFlush(reply); diff --git a/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp b/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp index e68049c4d8..862a6415ff 100644 --- a/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp +++ b/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp @@ -17,6 +17,7 @@ #include "hdf_io_service_if.h" #include "hdf_service_status.h" #include "ioservstat_listener.h" +#include "servstat_listener_hdi.h" #include "svcmgr_ioservice.h" #include "audio_events.h" #include "audio_hdi_common.h" @@ -87,6 +88,7 @@ void AudioThresholdReportTest::TearDownTestCase(void) GetAudioManager = nullptr; } (void)servmgr->UnregisterServiceStatusListener(servmgr, listener); + (void)HdiServiceStatusListenerFree(listener); listener = nullptr; (void)SvcMgrIoserviceRelease(servmgr); servmgr = nullptr; diff --git a/audio/test/systemtest/common/hdi_service_common/include/hdi_service_common.h b/audio/test/systemtest/common/hdi_service_common/include/hdi_service_common.h index 864784e57b..b311b361b6 100644 --- a/audio/test/systemtest/common/hdi_service_common/include/hdi_service_common.h +++ b/audio/test/systemtest/common/hdi_service_common/include/hdi_service_common.h @@ -37,7 +37,7 @@ namespace OHOS { namespace Audio { -#ifdef AUDIO_ADM_SO +#ifdef AUDIO_ADM_PASSTHROUGH const std::string RESOLVED_PATH = HDF_LIBRARY_FULL_PATH("libhdi_audio_passthrough"); const int IS_ADM = true; #endif diff --git a/audio/test/systemtest/common/hdi_service_common/src/hdi_service_common.cpp b/audio/test/systemtest/common/hdi_service_common/src/hdi_service_common.cpp index 2308e1f2e0..819da33d31 100644 --- a/audio/test/systemtest/common/hdi_service_common/src/hdi_service_common.cpp +++ b/audio/test/systemtest/common/hdi_service_common/src/hdi_service_common.cpp @@ -209,11 +209,33 @@ int32_t WavHeadAnalysis(struct AudioHeadInfo &wavHeadInfo, FILE *file, struct Au } return HDF_SUCCESS; } + +static void TestAudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf) +{ + if (dataBlock == NULL) { + return; + } + + if (dataBlock->adapterName != NULL) { + OsalMemFree(dataBlock->adapterName); + dataBlock->adapterName = NULL; + } + + if (dataBlock->ports != NULL) { + OsalMemFree(dataBlock->ports); + dataBlock->ports = NULL; + } + + if (freeSelf) { + OsalMemFree(dataBlock); + } +} + void TestReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen) { if (descsLen > 0 && descs != nullptr && (*descs) != nullptr) { for (uint32_t i = 0; i < descsLen; i++) { - AudioAdapterDescriptorFree(&(*descs)[i], false); + TestAudioAdapterDescriptorFree(&(*descs)[i], false); } OsalMemFree(*descs); *descs = nullptr; diff --git a/audio/test/systemtest/hdi/common/render/src/audio_hdirender_volume_test.cpp b/audio/test/systemtest/hdi/common/render/src/audio_hdirender_volume_test.cpp index 38815130cd..9da5702d5d 100644 --- a/audio/test/systemtest/hdi/common/render/src/audio_hdirender_volume_test.cpp +++ b/audio/test/systemtest/hdi/common/render/src/audio_hdirender_volume_test.cpp @@ -513,7 +513,7 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0001, TestSi int32_t ret = -1; bool muteTrue = true; bool muteFalse = false; -#ifdef PRODUCT_RK3568 +#ifdef ALSA_LIB_MODE bool defaultmute = false; #else bool defaultmute = true; diff --git a/audio/test/systemtest/hdi/hardwaredependence/capture/src/audio_hdicapture_hardware_dependence_test.cpp b/audio/test/systemtest/hdi/hardwaredependence/capture/src/audio_hdicapture_hardware_dependence_test.cpp index bc5a1b1fdd..c20f238d36 100644 --- a/audio/test/systemtest/hdi/hardwaredependence/capture/src/audio_hdicapture_hardware_dependence_test.cpp +++ b/audio/test/systemtest/hdi/hardwaredependence/capture/src/audio_hdicapture_hardware_dependence_test.cpp @@ -161,7 +161,7 @@ HWTEST_F(AudioHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_AudioCaptureSetSam * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; * attrs.format = AUDIO_FORMAT_PCM_16_BIT; -* attrs.sampleRate = BROADCAST_FM_RATE; +* attrs.sampleRate = SAMPLE_RATE_22050; * attrs.channelCount = 1; * @tc.author: ZHANGHAILIN */ @@ -176,7 +176,7 @@ HWTEST_F(AudioHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_AudioCaptureSetSam TestAudioManager* manager = GetAudioManager(); ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture); ASSERT_EQ(AUDIO_HAL_SUCCESS, ret); - InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, BROADCAST_FM_RATE); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, SAMPLE_RATE_22050); ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); #ifdef PRODUCT_RK3568 @@ -185,7 +185,7 @@ HWTEST_F(AudioHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_AudioCaptureSetSam EXPECT_EQ(AUDIO_HAL_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); - EXPECT_EQ(BROADCAST_FM_RATE, attrsValue.sampleRate); + EXPECT_EQ(SAMPLE_RATE_22050, attrsValue.sampleRate); EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); #endif @@ -565,7 +565,7 @@ HWTEST_F(AudioHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_AudioCaptureSetSam #else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret); #endif - InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, SINGLE_CHANNEL_COUNT, BROADCAST_FM_RATE); + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_22050); ret = capture->attr.SetSampleAttributes(capture, &attrs3); EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret); @@ -709,8 +709,8 @@ HWTEST_F(AudioHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_AudioCaptureSetSam * attrs.type = AUDIO_IN_MEDIA; * attrs.format = AUDIO_FORMAT_PCM_16_BIT * attrs.sampleRate = SAMPLE_RATE_8000; -* attrs.channelCount = 5; -* silenceThreshold = 4*1024 "the value of silenceThreshold is less than requested"; +* attrs.channelCount = 2; +* silenceThreshold = 2*1024 "the value of silenceThreshold is less than requested"; * @tc.author: ZENG LIFENG */ HWTEST_F(AudioHdiCaptureHardwareDependenceTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_019, TestSize.Level1) diff --git a/audio/test/systemtest/hdi_service/BUILD.gn b/audio/test/systemtest/hdi_service/BUILD.gn new file mode 100644 index 0000000000..77335eddc4 --- /dev/null +++ b/audio/test/systemtest/hdi_service/BUILD.gn @@ -0,0 +1,30 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/hdi.gni") +import("//drivers/peripheral/audio/audio.gni") + +group("hdi_service_st") { + testonly = true + deps = [ "common:hdi_service_common" ] + if ("${product_name}" == "hispark_taurus_standard") { + deps += [ "hispark_taurus_standard:hdi_service_hardwaredependence" ] + } + if ("${product_name}" == "rk3568") { + deps += [ "rk3568:hdi_service_hardwaredependence" ] + } + if (drivers_peripheral_audio_alsa_lib == false) { + deps += [ "hdiperformace:hdf_audio_idlhdi_performace_test" ] + } +} diff --git a/audio/test/systemtest/hdi_service/common/BUILD.gn b/audio/test/systemtest/hdi_service/common/BUILD.gn new file mode 100644 index 0000000000..26191ef5e1 --- /dev/null +++ b/audio/test/systemtest/hdi_service/common/BUILD.gn @@ -0,0 +1,26 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +group("hdi_service_common") { + testonly = true + deps = [ + "adapter:hdf_audio_idlhdi_adapter_test", + "capture:hdf_audio_idlhdi_capture_test", + "manager:hdf_audio_idlhdi_manager_test", + "render:hdf_audio_idlhdi_render_test", + ] +} diff --git a/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp b/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp new file mode 100644 index 0000000000..bdb24b2b9c --- /dev/null +++ b/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp @@ -0,0 +1,1047 @@ +/* + * Copyright (c) 2022 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 "hdi_service_common.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS::Audio; + +namespace { +class AudioIdlHdiRenderHardwareDependenceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + static TestAudioManager *(*GetAudioManager)(const char *); + static TestAudioManager *manager; + static void *handle; + static void (*AudioManagerRelease)(struct AudioManager *); + static void (*AudioAdapterRelease)(struct AudioAdapter *); + static void (*AudioRenderRelease)(struct AudioRender *); + void ReleaseAudioSource(void); +}; + +using THREAD_FUNC = void *(*)(void *); +TestAudioManager *(*AudioIdlHdiRenderHardwareDependenceTest::GetAudioManager)(const char *) = nullptr; +TestAudioManager *AudioIdlHdiRenderHardwareDependenceTest::manager = nullptr; +void *AudioIdlHdiRenderHardwareDependenceTest::handle = nullptr; +void (*AudioIdlHdiRenderHardwareDependenceTest::AudioManagerRelease)(struct AudioManager *) = nullptr; +void (*AudioIdlHdiRenderHardwareDependenceTest::AudioAdapterRelease)(struct AudioAdapter *) = nullptr; +void (*AudioIdlHdiRenderHardwareDependenceTest::AudioRenderRelease)(struct AudioRender *) = nullptr; + +void AudioIdlHdiRenderHardwareDependenceTest::SetUpTestCase(void) +{ + char absPath[PATH_MAX] = {0}; + char *path = realpath(RESOLVED_PATH.c_str(), absPath); + ASSERT_NE(nullptr, path); + handle = dlopen(absPath, RTLD_LAZY); + ASSERT_NE(nullptr, handle); + GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); + ASSERT_NE(nullptr, GetAudioManager); + manager = GetAudioManager(IDL_SERVER_NAME.c_str()); + ASSERT_NE(nullptr, manager); + AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); + ASSERT_NE(nullptr, AudioManagerRelease); + AudioAdapterRelease = (void (*)(struct AudioAdapter *))(dlsym(handle, "AudioAdapterRelease")); + ASSERT_NE(nullptr, AudioAdapterRelease); + AudioRenderRelease = (void (*)(struct AudioRender *))(dlsym(handle, "AudioRenderRelease")); + ASSERT_NE(nullptr, AudioRenderRelease); +} + +void AudioIdlHdiRenderHardwareDependenceTest::TearDownTestCase(void) +{ + if (AudioManagerRelease !=nullptr) { + AudioManagerRelease(manager); + manager = nullptr; + } + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; + } + if (handle != nullptr) { + dlclose(handle); + handle = nullptr; + } +} + +void AudioIdlHdiRenderHardwareDependenceTest::SetUp(void) +{ + int32_t ret; + ASSERT_NE(nullptr, manager); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); +} + +void AudioIdlHdiRenderHardwareDependenceTest::TearDown(void) +{ + ReleaseAudioSource(); +} + +void AudioIdlHdiRenderHardwareDependenceTest::ReleaseAudioSource(void) +{ + int32_t ret; + if (render != nullptr && AudioRenderRelease != nullptr) { + ret = adapter->DestroyRender(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + AudioRenderRelease(render); + render = nullptr; + } + if (adapter != nullptr && AudioAdapterRelease != nullptr) { + ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str()); + EXPECT_EQ(HDF_SUCCESS, ret); + AudioAdapterRelease(adapter); + adapter = nullptr; + } +} +/** + * @tc.name Test RenderGetFrameSize API via define format to different values + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_004 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define format as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameSize_004, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = render->GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); +} +/** + * @tc.name Test RenderGetFrameSize API via define sampleRate to different values + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_005 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define sampleRate as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameSize_005, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = render->GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); +} +/** + * @tc.name Test RenderGetFrameSize API via define channelCount to different values + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_006 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define channelCount as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameSize_006, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_44100, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = render->GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); +} +/** + * @tc.name Test RenderGetFrameSize API via define sampleRate to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_007 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define sampleRate as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameSize_007, TestSize.Level1) +{ + int32_t ret; + uint64_t size = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, SAMPLE_RATE_48000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = render->GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); +} +/** + * @tc.name Test RenderGetFrameCount API via define channelCount to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_004 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameCount_004, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_8000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetFrameCount(render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = render->Stop(render); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test RenderGetFrameCount API via define format to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_005 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define format as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameCount_005, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_8000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetFrameCount(render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = render->Stop(render); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test RenderGetFrameCount API via define channelCount to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_006 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount to different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameCount_006, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_44100, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetFrameCount(render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + render->Stop(render); +} +/** + * @tc.name Test RenderGetFrameCount API via define format to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_007 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define format as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetFrameCount_007, TestSize.Level1) +{ + int32_t ret; + uint64_t count = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_32000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_32000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); + + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetFrameCount(render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + render->Stop(render); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_001 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = AUDIO_SAMPLE_RATE_MASK_8000; +* attrs.channelCount = 1; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_001, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioSampleAttributes attrsValue = {}; + ret = render->GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_8000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_002 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_11025; +* attrs.channelCount = 2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_002, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_11025); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_11025, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_003 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_22050; +* attrs.channelCount = 1; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_003, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_22050); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_22050, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_004 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_32000; +* attrs.channelCount = 2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_004, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_32000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_32000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_005 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_44100; +* attrs.channelCount = 1; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_005, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_44100, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_COMMUNICATION; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_48000; +* attrs.channelCount = 2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_006, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_008 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_12000; +* attrs.channelCount = 1; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_008, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_12000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_12000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_009 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_16000; +* attrs.channelCount = 1; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_009, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_16000); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_16000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_010 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_24000; +* attrs.channelCount = 2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_010, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_24000); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_24000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_011 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_64000; +* attrs.channelCount = 2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_011, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_64000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_64000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_012 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = SAMPLE_RATE_96000; +* attrs.channelCount = 1; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_012, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_96000); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_96000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** +* @tc.name Test RenderSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_013 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 0xFFFFFFFFu; +* attrs.channelCount = 2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_013, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, DOUBLE_CHANNEL_COUNT, 0xFFFFFFFFu); + + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); +} +/** +* @tc.name Test RenderSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_014 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN; +* attrs.sampleRate = SAMPLE_RATE_8000/SAMPLE_RATE_11025/SAMPLE_RATE_22050; +* attrs.channelCount = 1/2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_014, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + struct AudioSampleAttributes attrs3 = {}; + ASSERT_NE(nullptr, render); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_PCM_8_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + ret = render->SetSampleAttributes(render, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_PCM_32_BIT, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_11025); + ret = render->SetSampleAttributes(render, &attrs2); +#ifdef ALSA_LIB_MODE + EXPECT_EQ(HDF_SUCCESS, ret); +#else + EXPECT_EQ(HDF_FAILURE, ret); +#endif + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_22050); + ret = render->SetSampleAttributes(render, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test RenderSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_015 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD; +* attrs.sampleRate = SAMPLE_RATE_32000/SAMPLE_RATE_44100/SAMPLE_RATE_48000; +* attrs.channelCount = 1/2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_015, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + struct AudioSampleAttributes attrs3 = {}; + ASSERT_NE(nullptr, render); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_32000); + ret = render->SetSampleAttributes(render, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + ret = render->SetSampleAttributes(render, &attrs2); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_48000); + ret = render->SetSampleAttributes(render, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test RenderSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_016 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2 +* attrs.sampleRate = SAMPLE_RATE_8000/SAMPLE_RATE_44100; +* attrs.channelCount = 1/2; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_016, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + ASSERT_NE(nullptr, render); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + ret = render->SetSampleAttributes(render, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, DOUBLE_CHANNEL_COUNT, SAMPLE_RATE_44100); + ret = render->SetSampleAttributes(render, &attrs2); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test RenderSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_RenderSetSampleAttributes_017 +* @tc.desc Test RenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT +* attrs.sampleRate = SAMPLE_RATE_8000; +* attrs.channelCount = 5; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetSampleAttributes_017, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, render); + uint32_t silenceThreshold = 5; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, silenceThreshold, SAMPLE_RATE_8000); + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); +} +/** +* @tc.name Test RenderGetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_RenderGetSampleAttributes_001 +* @tc.desc Test RenderGetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = SAMPLE_RATE_8000; +* attrs.channelCount = 1; +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetSampleAttributes_001, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, render); + + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_8000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); +} +/** + * @tc.name Test GetCurrentChannelId API via get channelId to 1 and set channelCount to 1 + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_003 + * @tc.desc Test GetCurrentChannelId interface,return 0 if get channelId to 1 and set channelCount to 1 + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetCurrentChannelId_002, TestSize.Level1) +{ + int32_t ret; + uint32_t channelId = 0; + uint32_t channelIdExp = 1; + uint32_t channelCountExp = 1; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + + ASSERT_NE(nullptr, render); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_32000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelCountExp, attrs.channelCount); + + ret = render->GetCurrentChannelId(render, &channelId); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelIdExp, channelId); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via define format to AUDIO_FORMAT_PCM_16_BIT + * @tc.number SUB_Audio_HDI_RenderGetRenderPosition_009 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetRenderPosition_009, TestSize.Level1) +{ + int32_t ret; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + + ASSERT_NE(nullptr, render); + InitAttrs(attrs); + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_16_BIT; + attrs.sampleRate = SAMPLE_RATE_48000; + attrs.channelCount = 2; + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + render->Stop(render); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via define format to AUDIO_FORMAT_PCM_24_BIT + * @tc.number SUB_Audio_HDI_RenderGetRenderPosition_010 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetRenderPosition_010, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + + ASSERT_NE(nullptr, render); + InitAttrs(attrs); + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_24_BIT; + attrs.sampleRate = SAMPLE_RATE_48000; + attrs.channelCount = 2; + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(DOUBLE_CHANNEL_COUNT, attrsValue.channelCount); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + render->Stop(render); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via define sampleRate and channelCount to different value + * @tc.number SUB_Audio_HDI_RenderGetRenderPosition_011 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define channelCount as different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetRenderPosition_011, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + + ASSERT_NE(nullptr, render); + InitAttrs(attrs); + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_16_BIT; + attrs.sampleRate = SAMPLE_RATE_48000; + attrs.channelCount = 1; + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + render->Stop(render); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via define sampleRate and channelCount to 1 + * @tc.number SUB_Audio_HDI_RenderGetRenderPosition_012 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define channelCount to 1 + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetRenderPosition_012, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + + ASSERT_NE(nullptr, render); + InitAttrs(attrs); + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_24_BIT; + attrs.sampleRate = SAMPLE_RATE_48000; + attrs.channelCount = 1; + ret = render->SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(SAMPLE_RATE_48000, attrsValue.sampleRate); + EXPECT_EQ(SINGLE_CHANNEL_COUNT, attrsValue.channelCount); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + render->Stop(render); +} +/** +* @tc.name Test GetMmapPosition API via SetSampleAttributes and Getting position is normal. +* @tc.number SUB_Audio_HDI_RenderGetMmapPosition_002 +* @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully. +* @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderGetMmapPosition_002, TestSize.Level1) +{ + int32_t ret; + uint64_t frames = 0; + int64_t timeExp = 0; + ASSERT_NE(nullptr, render); + struct PrepareAudioPara audiopara = { + .path = LOW_LATENCY_AUDIO_FILE.c_str(), .render = render + }; + InitAttrs(audiopara.attrs); + audiopara.attrs.format = AUDIO_FORMAT_PCM_24_BIT; + audiopara.attrs.channelCount = 1; + ret = audiopara.render->SetSampleAttributes(audiopara.render, &(audiopara.attrs)); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + void *result = nullptr; + pthread_join(audiopara.tids, &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + ret = audiopara.render->GetMmapPosition(audiopara.render, &frames, &(audiopara.time)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + audiopara.render->Stop(audiopara.render); +} +/** + * @tc.name Test SetChannelMode API via setting channel mode to different enumeration values + * @tc.number SUB_Audio_HDI_RenderSetChannelMode_001 + * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different enumeration values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetChannelMode_001, TestSize.Level1) +{ + int32_t ret; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetChannelMode(render, mode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); +#ifndef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); + AudioChannelMode modeOne = AUDIO_CHANNEL_BOTH_LEFT; + AudioChannelMode modeSec = AUDIO_CHANNEL_BOTH_RIGHT; + AudioChannelMode modeTrd = AUDIO_CHANNEL_EXCHANGE; + ret = render->SetChannelMode(render, modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_BOTH_LEFT, modeOne); + ret = render->SetChannelMode(render, modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, modeSec); + ret = render->SetChannelMode(render, modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_EXCHANGE, modeTrd); +#endif + render->Stop(render); +} +#ifndef ALSA_LIB_MODE +/** + * @tc.name Test SetChannelMode API via setting channel mode to different values + * @tc.number SUB_Audio_HDI_RenderSetChannelMode_002 + * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different values + * @tc.author: liweiming +*/ +HWTEST_F(AudioIdlHdiRenderHardwareDependenceTest, SUB_Audio_HDI_RenderSetChannelMode_002, TestSize.Level1) +{ + int32_t ret; + AudioChannelMode mode = AUDIO_CHANNEL_MIX; + AudioChannelMode modeOne = AUDIO_CHANNEL_LEFT_MUTE; + AudioChannelMode modeSec = AUDIO_CHANNEL_RIGHT_MUTE; + AudioChannelMode modeTrd = AUDIO_CHANNEL_BOTH_MUTE; + ASSERT_NE(nullptr, render); + ret = AudioRenderStartAndOneFrame(render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetChannelMode(render, mode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_MIX, mode); + ret = render->SetChannelMode(render, modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_LEFT_MUTE, modeOne); + ret = render->SetChannelMode(render, modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, modeSec); + ret = render->SetChannelMode(render, modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, modeTrd); + render->Stop(render); +} +#endif +} diff --git a/audio/test/systemtest/hdi_service/rk3568/BUILD.gn b/audio/test/systemtest/hdi_service/rk3568/BUILD.gn new file mode 100644 index 0000000000..1bb4e92412 --- /dev/null +++ b/audio/test/systemtest/hdi_service/rk3568/BUILD.gn @@ -0,0 +1,24 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +group("hdi_service_hardwaredependence") { + testonly = true + deps = [ + "capture:hdf_audio_idlhdi_capture_hardware_dependence_test", + "render:hdf_audio_idlhdi_render_hardware_dependence_test", + ] +} diff --git a/audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn b/audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn new file mode 100644 index 0000000000..ff40313be5 --- /dev/null +++ b/audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn @@ -0,0 +1,48 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/hdi.gni") +import("//drivers/peripheral/audio/audio.gni") + +module_output_path = "drivers_peripheral_audio/audio" + +ohos_systemtest("hdf_audio_idlhdi_capture_hardware_dependence_test") { + module_out_path = module_output_path + public_deps = [ "//drivers/interface/audio/v1_0:audio_idl_headers" ] + sources = [ + "../../../common/hdi_service_common/src/hdi_service_common.cpp", + "src/audio_idl_hdicapture_hardware_dependence_test.cpp", + ] + include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] + external_deps = [ + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + ] + + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_passthrough) { + defines += [ "AUDIO_ADM_PASSTHROUGH" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + + if (drivers_peripheral_audio_alsa_lib) { + defines += [ "ALSA_LIB_MODE" ] + } +} diff --git a/audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn b/audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn new file mode 100644 index 0000000000..f81dbe601c --- /dev/null +++ b/audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn @@ -0,0 +1,46 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/hdi.gni") +import("//drivers/peripheral/audio/audio.gni") + +module_output_path = "drivers_peripheral_audio/audio" + +ohos_systemtest("hdf_audio_idlhdi_render_hardware_dependence_test") { + module_out_path = module_output_path + public_deps = [ "//drivers/interface/audio/v1_0:audio_idl_headers" ] + sources = [ + "../../../common/hdi_service_common/src/hdi_service_common.cpp", + "src/audio_idl_hdirender_hardware_dependence_test.cpp", + ] + include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] + external_deps = [ + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_passthrough) { + defines += [ "AUDIO_ADM_PASSTHROUGH" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (drivers_peripheral_audio_alsa_lib) { + defines += [ "ALSA_LIB_MODE" ] + } +} diff --git a/audio/test/systemtest/supportlibs/common/capture/src/audio_libcapture_test.cpp b/audio/test/systemtest/supportlibs/common/capture/src/audio_libcapture_test.cpp index 04a3ca0934..24583df21d 100644 --- a/audio/test/systemtest/supportlibs/common/capture/src/audio_libcapture_test.cpp +++ b/audio/test/systemtest/supportlibs/common/capture/src/audio_libcapture_test.cpp @@ -345,6 +345,8 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_HwParams_001, EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); hwCapture = nullptr; @@ -370,6 +372,8 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Prepare_001, EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); hwCapture = nullptr; @@ -397,6 +401,10 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Start_001, Te EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); hwCapture = nullptr; @@ -525,6 +533,10 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Pause_001, Tes hwCapture->captureParam.captureMode.ctlParam.pause = 1; ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); hwCapture = nullptr; @@ -554,6 +566,10 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Resume_001, Te hwCapture->captureParam.captureMode.ctlParam.pause = 0; ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); hwCapture = nullptr; diff --git a/audio/test/systemtest/supportlibs/common/render/src/audio_librender_test.cpp b/audio/test/systemtest/supportlibs/common/render/src/audio_librender_test.cpp index a5bd9d9f62..15cf56bb71 100644 --- a/audio/test/systemtest/supportlibs/common/render/src/audio_librender_test.cpp +++ b/audio/test/systemtest/supportlibs/common/render/src/audio_librender_test.cpp @@ -449,9 +449,12 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_HwParams_0001, T ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr)); ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle); ASSERT_EQ(HDF_SUCCESS, ret); - + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); hwRender = nullptr; @@ -470,11 +473,14 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Prepare_0001, Te ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr)); ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle); ASSERT_EQ(HDF_SUCCESS, ret); - + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); hwRender = nullptr; @@ -493,13 +499,18 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Start_0001, Test ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr)); ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle); ASSERT_EQ(HDF_SUCCESS, ret); - + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); hwRender = nullptr; @@ -629,6 +640,10 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Pause_0001, Test hwRender->renderParam.renderMode.ctlParam.pause = 1; ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); hwRender = nullptr; @@ -652,6 +667,10 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Resume_0001, Tes hwRender->renderParam.renderMode.ctlParam.pause = 0; ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); hwRender = nullptr; -- Gitee From 99479fb6a0a52cdf2607a222b7ffd140b329896e Mon Sep 17 00:00:00 2001 From: zhangguorong Date: Wed, 3 Aug 2022 10:31:49 +0800 Subject: [PATCH 14/33] fix: xts unit test failed Signed-off-by: zhangguorong --- codec/test/demo/adapter/src/codec_hdi_adapter_decode.cpp | 2 +- codec/test/demo/v1.0/codec_decode_test_ipc.c | 2 +- codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/codec/test/demo/adapter/src/codec_hdi_adapter_decode.cpp b/codec/test/demo/adapter/src/codec_hdi_adapter_decode.cpp index 0359e8689e..85743f8c9d 100644 --- a/codec/test/demo/adapter/src/codec_hdi_adapter_decode.cpp +++ b/codec/test/demo/adapter/src/codec_hdi_adapter_decode.cpp @@ -185,7 +185,7 @@ int32_t CodecHdiAdapterDecode::ConfigMppPassthrough() int32_t needDefault = 1; param.val = &needDefault; param.size = sizeof(int32_t); - ret = client_->SetParameter(client_, OMX_IndexParamPassthrough, (int8_t *)¶m, sizeof(param)); + ret = client_->GetParameter(client_, OMX_IndexParamPassthrough, (int8_t *)¶m, sizeof(param)); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s errNo[%{public}d] key is KEY_EXT_DEFAULT_CFG_RK", __func__, ret); return ret; diff --git a/codec/test/demo/v1.0/codec_decode_test_ipc.c b/codec/test/demo/v1.0/codec_decode_test_ipc.c index 1b0226d0d3..b5ac01125c 100644 --- a/codec/test/demo/v1.0/codec_decode_test_ipc.c +++ b/codec/test/demo/v1.0/codec_decode_test_ipc.c @@ -280,7 +280,7 @@ int32_t SetDecParameter(void) int32_t needDefault = 1; param.val = &needDefault; param.size = sizeof(int32_t); - ret = g_codecProxy->CodecSetParameter(g_codecProxy, (CODEC_HANDLETYPE)g_handle, ¶m, paramCnt); + ret = g_codecProxy->CodecGetParameter(g_codecProxy, (CODEC_HANDLETYPE)g_handle, ¶m, paramCnt); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: CodecSetParameter failed", __func__); return HDF_FAILURE; diff --git a/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp b/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp index 84b389aec5..5bb92fc0b4 100644 --- a/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp +++ b/codec/test/unittest/hdi_v1.0/codec_proxy_test.cpp @@ -210,7 +210,7 @@ HWTEST_F(CodecProxyTest, HdfCodecHdiV1GetDefaultCfgTest_008, TestSize.Level1) params->val = nullptr; params->size = 0; - int32_t errorCode = g_codecObj->CodecSetParameter(g_codecObj, g_handle, params, paramCnt); + int32_t errorCode = g_codecObj->CodecGetParameter(g_codecObj, g_handle, params, paramCnt); OsalMemFree(params); ASSERT_EQ(errorCode, HDF_SUCCESS); } -- Gitee From dab54e8a4c5950bf2d1ec526f77106a6ad173034 Mon Sep 17 00:00:00 2001 From: yanchenyang Date: Fri, 5 Aug 2022 15:30:44 +0800 Subject: [PATCH 15/33] fix: solve xxx build audio demo fail Signed-off-by: yanchenyang --- audio/BUILD.gn | 3 --- 1 file changed, 3 deletions(-) diff --git a/audio/BUILD.gn b/audio/BUILD.gn index c432a14794..7c4372e430 100644 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -73,7 +73,4 @@ group("audio_sample_client") { "sample:audio_sample_render", ] } - if (!defined(ohos_lite)) { - deps += [ "sample:audio_sample_event" ] - } } -- Gitee From 9a7d2f6bbc511c654ba297e4353088caf3220d44 Mon Sep 17 00:00:00 2001 From: wangyeyu Date: Thu, 4 Aug 2022 16:43:24 +0800 Subject: [PATCH 16/33] fix:Mutex range minimization processing Signed-off-by: wangyeyu --- .../server/src/hdf_audio_server_common.c | 17 +---------------- .../server/src/hdf_audio_server_render.c | 9 +++++++++ .../src/audio_interface_lib_render.c | 6 ------ 3 files changed, 10 insertions(+), 22 deletions(-) diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c b/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c index 3391bcaaa8..494b9fbd43 100644 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c @@ -23,7 +23,6 @@ #include "hdf_audio_server_render.h" #include "hdf_device_object.h" #include "osal_mem.h" -#include "osal_mutex.h" #define HDF_LOG_TAG HDF_AUDIO_HAL_STUB @@ -35,7 +34,6 @@ struct AudioManager *g_serverManager = NULL; int32_t g_serverAdapterNum = 0; struct AudioInfoInAdapter *g_renderAndCaptureManage = NULL; -struct OsalMutex g_serverLock; static struct AudioEvent g_audioEventPnp = { .eventType = HDF_AUDIO_EVENT_UNKOWN, @@ -117,7 +115,6 @@ void AdaptersServerManageRelease( return; } - OsalMutexDestroy(&g_serverLock); num = (num > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : num; for (i = 0; i < num; i++) { if (adaptersManage[i].adapterName != NULL) { @@ -163,7 +160,6 @@ int32_t AdaptersServerManageInit(const struct AudioAdapterDescriptor *descs, int } g_serverAdapterNum = num; g_renderAndCaptureManage = adaptersManage; - OsalMutexInit(&g_serverLock); return HDF_SUCCESS; } @@ -1686,7 +1682,7 @@ static struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleCapLi {AUDIO_HDI_CAPTURE_DEV_DUMP, HdiServiceCaptureDevDump}, }; -int32_t AudioDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, +int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { unsigned int i; @@ -1722,14 +1718,3 @@ int32_t AudioDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBu } return AUDIO_HAL_ERR_INTERNAL; } - -int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, - struct HdfSBuf *reply) -{ - int32_t ret; - (void)OsalMutexLock(&g_serverLock); - ret = AudioDispatch(client, cmdId, data, reply); - (void)OsalMutexUnlock(&g_serverLock); - - return ret; -} diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c index ff5f8d8bfd..8b98fec006 100644 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c @@ -15,8 +15,10 @@ #include "hdf_audio_server_render.h" #include "audio_uhdf_log.h" #include "hdf_audio_server_common.h" +#include "osal_mutex.h" #define HDF_LOG_TAG HDF_AUDIO_HAL_STUB +struct OsalMutex g_renderLock; int32_t GetInitRenderParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs) { @@ -151,6 +153,7 @@ int32_t HdiServiceCreatRender(const struct HdfDeviceIoClient *client, adapter->DestroyRender(adapter, render); return AUDIO_HAL_ERR_INTERNAL; } + OsalMutexInit(&g_renderLock); return AUDIO_HAL_SUCCESS; } @@ -164,6 +167,8 @@ int32_t HdiServiceRenderDestory(const struct HdfDeviceIoClient *client, struct AudioRender *render = NULL; const char *adapterName = NULL; uint32_t pid = 0; + + OsalMutexDestroy(&g_renderLock); if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { return AUDIO_HAL_ERR_INTERNAL; } @@ -626,7 +631,9 @@ int32_t HdiServiceRenderRenderFrame(const struct HdfDeviceIoClient *client, return AUDIO_HAL_ERR_INTERNAL; } AudioSetRenderStatus(adapterName, true); + (void)OsalMutexLock(&g_renderLock); ret = render->RenderFrame((AudioHandle)render, (const void *)frame, (uint64_t)requestBytes, &replyBytes); + (void)OsalMutexUnlock(&g_renderLock); AudioSetRenderStatus(adapterName, false); if (ret < 0) { AUDIO_FUNC_LOGE("HdiServiceRenderRenderFrame fail"); @@ -648,7 +655,9 @@ int32_t HdiServiceRenderGetRenderPosition(const struct HdfDeviceIoClient *client if (ret < 0) { return ret; } + (void)OsalMutexLock(&g_renderLock); ret = render->GetRenderPosition((AudioHandle)render, &frames, &time); + (void)OsalMutexUnlock(&g_renderLock); if (ret < 0) { return ret; } diff --git a/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c b/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c index 6adc012644..c6699fc849 100644 --- a/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c +++ b/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c @@ -17,7 +17,6 @@ #include "audio_common.h" #include "audio_uhdf_log.h" #include "osal_mem.h" -#include "osal_mutex.h" #include "osal_mem.h" #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB @@ -26,7 +25,6 @@ /* Out Put Render */ static struct AudioPcmHwParams g_hwParams; -static struct OsalMutex g_renderMutex; int32_t SetHwParams(const struct AudioHwRenderParam *handleData) { @@ -1327,7 +1325,6 @@ int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle, return HDF_FAILURE; } int32_t ret; - (void)OsalMutexLock(&g_renderMutex); switch (cmdId) { case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: ret = AudioOutputRenderHwParams(handle, cmdId, handleData); @@ -1360,7 +1357,6 @@ int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle, ret = HDF_FAILURE; break; } - (void)OsalMutexUnlock(&g_renderMutex); return ret; } @@ -1411,7 +1407,6 @@ struct DevHandle *AudioBindServiceRender(const char *name) AudioMemFree((void **)&handle); return NULL; } - OsalMutexInit(&g_renderMutex); AUDIO_FUNC_LOGI("BIND SERVICE SUCCESS!"); return handle; } @@ -1422,7 +1417,6 @@ void AudioCloseServiceRender(const struct DevHandle *handle) AUDIO_FUNC_LOGE("Render handle or handle->object is NULL"); return; } - OsalMutexDestroy(&g_renderMutex); struct HdfIoService *service = (struct HdfIoService *)handle->object; HdfIoServiceRecycle(service); AudioMemFree((void **)&handle); -- Gitee From 5544bf908cc54deddbda4c9d60b17e684a16150a Mon Sep 17 00:00:00 2001 From: zenglifeng Date: Wed, 3 Aug 2022 09:51:26 +0800 Subject: [PATCH 17/33] feat:audio ut part1 Signed-off-by: zenglifeng --- audio/test/unittest/BUILD.gn | 7 +- .../hdi/adapter/include/audio_adapter_test.h | 19 - .../hdi/capture/include/audio_capture_test.h | 20 - .../adapter/src/audio_proxy_adapter_test.cpp | 387 ++++++++++++++++++ .../test/unittest/hdi/client/common/BUILD.gn | 47 +++ .../include/audio_proxy_common_fun_test.h | 69 ++++ .../src/audio_proxy_common_fun_test.cpp | 242 +++++++++++ .../common/src/audio_proxy_common_test.cpp | 227 ++++++++++ .../test/unittest/hdi/client/manager/BUILD.gn | 50 +++ .../manager/src/audio_proxy_manager_test.cpp | 153 +++++++ .../hdi/manager/include/audio_manager_test.h | 19 - .../unittest/hdi/{ => passthrough}/BUILD.gn | 19 +- .../hdi/{ => passthrough}/adapter/BUILD.gn | 42 +- .../adapter/src/audio_adapter_test.cpp | 70 ++-- .../hdi/{ => passthrough}/capture/BUILD.gn | 47 +-- .../capture/src/audio_capture_test.cpp | 335 +++++++++++++-- .../common/include/audio_common_test.h | 3 + .../common/src/audio_common_test.cpp | 0 .../hdi/{ => passthrough}/manager/BUILD.gn | 35 +- .../manager/src/audio_manager_test.cpp | 16 +- .../hdi/{ => passthrough}/render/BUILD.gn | 47 +-- .../render/src/audio_render_test.cpp | 290 ++++++++++--- .../hdi/render/include/audio_render_test.h | 19 - 23 files changed, 1827 insertions(+), 336 deletions(-) delete mode 100644 audio/test/unittest/hdi/adapter/include/audio_adapter_test.h delete mode 100644 audio/test/unittest/hdi/capture/include/audio_capture_test.h create mode 100644 audio/test/unittest/hdi/client/adapter/src/audio_proxy_adapter_test.cpp create mode 100644 audio/test/unittest/hdi/client/common/BUILD.gn create mode 100644 audio/test/unittest/hdi/client/common/include/audio_proxy_common_fun_test.h create mode 100644 audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp create mode 100644 audio/test/unittest/hdi/client/common/src/audio_proxy_common_test.cpp create mode 100644 audio/test/unittest/hdi/client/manager/BUILD.gn create mode 100644 audio/test/unittest/hdi/client/manager/src/audio_proxy_manager_test.cpp delete mode 100644 audio/test/unittest/hdi/manager/include/audio_manager_test.h rename audio/test/unittest/hdi/{ => passthrough}/BUILD.gn (69%) rename audio/test/unittest/hdi/{ => passthrough}/adapter/BUILD.gn (72%) rename audio/test/unittest/hdi/{ => passthrough}/adapter/src/audio_adapter_test.cpp (95%) rename audio/test/unittest/hdi/{ => passthrough}/capture/BUILD.gn (72%) rename audio/test/unittest/hdi/{ => passthrough}/capture/src/audio_capture_test.cpp (75%) rename audio/test/unittest/hdi/{ => passthrough}/common/include/audio_common_test.h (95%) rename audio/test/unittest/hdi/{ => passthrough}/common/src/audio_common_test.cpp (100%) rename audio/test/unittest/hdi/{ => passthrough}/manager/BUILD.gn (78%) rename audio/test/unittest/hdi/{ => passthrough}/manager/src/audio_manager_test.cpp (94%) rename audio/test/unittest/hdi/{ => passthrough}/render/BUILD.gn (73%) rename audio/test/unittest/hdi/{ => passthrough}/render/src/audio_render_test.cpp (81%) delete mode 100644 audio/test/unittest/hdi/render/include/audio_render_test.h diff --git a/audio/test/unittest/BUILD.gn b/audio/test/unittest/BUILD.gn index 5436c8adef..1e02904889 100644 --- a/audio/test/unittest/BUILD.gn +++ b/audio/test/unittest/BUILD.gn @@ -26,15 +26,12 @@ group("audiotest") { # hal ut deps = [ - "hdi:hdi", + "hdi/passthrough:hdi_passthrough", "lib:lib", ] # adm + driver ut if (drivers_peripheral_audio_full_test_suite) { - deps += [ - "adm:khdf_audio_adm_test", - "driver:khdf_audio_driver_test", - ] + deps += [ "adm:khdf_audio_adm_test" ] } } diff --git a/audio/test/unittest/hdi/adapter/include/audio_adapter_test.h b/audio/test/unittest/hdi/adapter/include/audio_adapter_test.h deleted file mode 100644 index ae60d738da..0000000000 --- a/audio/test/unittest/hdi/adapter/include/audio_adapter_test.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (c) 2021 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_ADAPTER_TEST_H -#define AUDIO_ADAPTER_TEST_H - -#endif diff --git a/audio/test/unittest/hdi/capture/include/audio_capture_test.h b/audio/test/unittest/hdi/capture/include/audio_capture_test.h deleted file mode 100644 index f5ba4fd48c..0000000000 --- a/audio/test/unittest/hdi/capture/include/audio_capture_test.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (c) 2021 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_CAPTURE_TEST_H -#define AUDIO_CAPTURE_TEST_H - -#endif - diff --git a/audio/test/unittest/hdi/client/adapter/src/audio_proxy_adapter_test.cpp b/audio/test/unittest/hdi/client/adapter/src/audio_proxy_adapter_test.cpp new file mode 100644 index 0000000000..ce198a73ae --- /dev/null +++ b/audio/test/unittest/hdi/client/adapter/src/audio_proxy_adapter_test.cpp @@ -0,0 +1,387 @@ +/* + * Copyright (c) 2022 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 +#include +#include "audio_proxy_common_fun_test.h" +#include "audio_proxy_internal.h" + +using namespace std; +using namespace comfun; +using namespace testing::ext; +namespace { +class AudioProxyAdapterTest : public testing::Test { +public: + struct AudioManager *managerFuncs = nullptr; + struct AudioManager *(*getAudioManager)(void) = NULL; + struct AudioAdapterDescriptor *descs = nullptr; + struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + struct AudioCapture *capture = nullptr; + void *clientHandle = nullptr; + struct AudioDeviceDescriptor devDescRender = {}; + struct AudioSampleAttributes attrsRender = {}; + struct AudioDeviceDescriptor devDescCapture = {}; + struct AudioSampleAttributes attrsCapture = {}; + virtual void SetUp(); + virtual void TearDown(); +}; + +void AudioProxyAdapterTest::SetUp() +{ + clientHandle = GetDynamicLibHandle(RESOLVED_PATH); + ASSERT_NE(clientHandle, nullptr); + getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str())); + ASSERT_NE(getAudioManager, nullptr); + managerFuncs = getAudioManager(); + ASSERT_NE(managerFuncs, nullptr); + int32_t size = 0; + ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size)); + desc = &descs[0]; + ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter)); + ASSERT_NE(adapter, nullptr); + ASSERT_EQ(HDF_SUCCESS, InitDevDesc(devDescRender)); + ASSERT_EQ(HDF_SUCCESS, InitAttrs(attrsRender)); + ASSERT_EQ(HDF_SUCCESS, adapter->CreateRender(adapter, &devDescRender, &attrsRender, &render)); + + ASSERT_EQ(HDF_SUCCESS, InitDevDescCapture(devDescCapture)); + ASSERT_EQ(HDF_SUCCESS, InitAttrsCapture(attrsCapture)); + ASSERT_EQ(HDF_SUCCESS, adapter->CreateCapture(adapter, &devDescCapture, &attrsCapture, &capture)); +} + +void AudioProxyAdapterTest::TearDown() +{ + if (adapter != nullptr) { + adapter->DestroyRender(adapter, render); + render = nullptr; + adapter->DestroyCapture(adapter, capture); + capture = nullptr; + } + if (managerFuncs != nullptr) { + managerFuncs->UnloadAdapter(managerFuncs, adapter); + adapter = nullptr; + managerFuncs->ReleaseAudioManagerObject(managerFuncs); + managerFuncs = nullptr; + } + if (clientHandle != nullptr) { + dlclose(clientHandle); + clientHandle = nullptr; + } +} + +HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterInitAllPorts(nullptr)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + const char *tempPtr = hwAdapter->adapterDescriptor.adapterName; + hwAdapter->adapterDescriptor.adapterName = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterInitAllPorts(adapter)); + hwAdapter->adapterDescriptor.adapterName = tempPtr; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_003, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + struct AudioPort *ports = hwAdapter->adapterDescriptor.ports; + hwAdapter->adapterDescriptor.ports = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterInitAllPorts(adapter)); + hwAdapter->adapterDescriptor.ports = ports; + ports = nullptr; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_004, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + uint32_t portNum = hwAdapter->adapterDescriptor.portNum; + hwAdapter->adapterDescriptor.portNum = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterInitAllPorts(adapter)); + hwAdapter->adapterDescriptor.portNum = portNum; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_005, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterInitAllPorts(adapter)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterCreateRender_001, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioRender *render = nullptr; + const struct AudioDeviceDescriptor *descTemp = nullptr; + const struct AudioSampleAttributes *attrsTemp = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(nullptr, descTemp, attrsTemp, &render)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, nullptr, attrsTemp, &render)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, descTemp, nullptr, &render)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, descTemp, attrsTemp, nullptr)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterCreateRender_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle; + hwAdapter->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, &devDescRender, &attrsRender, + &render)); + hwAdapter->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterDestroyRender_001, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioRender render; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyRender(nullptr, &render)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyRender(adapter, nullptr)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterDestroyRender_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyRender(adapter, render)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterDestroyRender_003, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterDestroyRender(adapter, render)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterCreateCapture_001, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioCapture *capture = nullptr; + const struct AudioDeviceDescriptor *descTemp = nullptr; + const struct AudioSampleAttributes *attrsTemp = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(nullptr, descTemp, attrsTemp, &capture)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, nullptr, attrsTemp, &capture)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, descTemp, nullptr, &capture)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, descTemp, attrsTemp, nullptr)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterCreateCapture_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle; + hwAdapter->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, &devDescCapture, &attrsCapture, + &capture)); + hwAdapter->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterDestroyCapture_001, TestSize.Level1) +{ + struct AudioAdapter adapter; + struct AudioCapture capture; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyCapture(nullptr, &capture)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyCapture(&adapter, nullptr)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterDestroyCapture_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyCapture(adapter, capture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterDestroyCapture_003, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterDestroyCapture(adapter, capture)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_001, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + const struct AudioPort *port = nullptr; + struct AudioPortCapability capability; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPortCapability(nullptr, port, &capability)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPortCapability(adapter, nullptr, &capability)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPortCapability(adapter, port, nullptr)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + struct AudioPortCapability capability; + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle; + hwAdapter->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPortCapability(adapter, &port, &capability)); + hwAdapter->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_003, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + struct AudioPortCapability capability; + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys; + hwAdapter->portCapabilitys = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPortCapability(adapter, &port, &capability)); + hwAdapter->portCapabilitys = hwAdapterPortCapabilitys; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_004, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + struct AudioPortCapability capability; + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + hwAdapter->adapterDescriptor.portNum = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPortCapability(adapter, &port, &capability)); + hwAdapter->adapterDescriptor.portNum = portNum; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_001, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + int32_t ret = AudioProxyAdapterSetPassthroughMode(nullptr, &port, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); + ret = AudioProxyAdapterSetPassthroughMode(adapter, nullptr, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); + port.portName = nullptr; + ret = AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + port.dir = PORT_IN; + port.portName = nullptr; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterSetPassthroughMode(adapter, &port, mode)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_003, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + port.dir = PORT_OUT; + port.portId = 0; + port.portName = "AOP"; + int32_t ret = AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_004, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + port.dir = PORT_OUT; + port.portId = 1; + port.portName = "abc"; + int32_t ret = AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_005, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + port.dir = PORT_OUT; + port.portId = 1; + port.portName = "AOP"; + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle; + hwAdapter->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM)); + hwAdapter->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_001, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(nullptr, &port, nullptr)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(adapter, nullptr, nullptr)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(adapter, &port, nullptr)); + port.portName = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(adapter, &port, nullptr)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_002, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + port.dir = PORT_IN; + port.portId = 1; + port.portName = "abc"; + AudioPortPassthroughMode mode; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPassthroughMode(adapter, &port, &mode)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_003, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort *port = new AudioPort; + port->dir = PORT_OUT; + port->portId = 0; + port->portName = "AOP"; + AudioPortPassthroughMode mode; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterInitAllPorts(adapter)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterGetPassthroughMode(adapter, port, &mode)); + delete port; + port = nullptr; +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_004, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + port.dir = PORT_OUT; + port.portId = 1; + port.portName = "abc"; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPassthroughMode(adapter, &port, &mode)); +} + +HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_005, TestSize.Level1) +{ + ASSERT_NE(adapter, nullptr); + struct AudioPort port; + port.dir = PORT_OUT; + port.portId = 1; + port.portName = "AOP"; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle; + hwAdapter->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPassthroughMode(adapter, &port, &mode)); + hwAdapter->proxyRemoteHandle = proxyRemoteHandle; +} +} diff --git a/audio/test/unittest/hdi/client/common/BUILD.gn b/audio/test/unittest/hdi/client/common/BUILD.gn new file mode 100644 index 0000000000..8c5a9c2ddb --- /dev/null +++ b/audio/test/unittest/hdi/client/common/BUILD.gn @@ -0,0 +1,47 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +ohos_unittest("hdf_audio_proxy_common_test") { + module_out_path = "hdf/audio" + sources = [ "//drivers/peripheral/audio/test/unittest/hdi/client/common/src/audio_proxy_common_test.cpp" ] + + include_dirs = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/common/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "//drivers/hdf_core/adapter/uhdf2/include/hdi", + "//drivers/hdf_core/adapter/uhdf2/shared/include", + "//third_party/googletest/googletest/include/gtest", + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_binder/proxy:hdi_audio_client", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio_common", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "utils_base:utils", + ] +} diff --git a/audio/test/unittest/hdi/client/common/include/audio_proxy_common_fun_test.h b/audio/test/unittest/hdi/client/common/include/audio_proxy_common_fun_test.h new file mode 100644 index 0000000000..50f9be2aca --- /dev/null +++ b/audio/test/unittest/hdi/client/common/include/audio_proxy_common_fun_test.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2022 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_PROXY_COMMON_FUN_TEST_H +#define AUDIO_PROXY_COMMON_FUN_TEST_H + +#include +#include "hdf_base.h" +#include "audio_types.h" +#include "audio_internal.h" +#include "audio_proxy_internal.h" +#include "audio_proxy_manager.h" +#include "audio_render.h" +#include "audio_capture.h" + +namespace comfun { + const int32_t PORTNUM = 1; + const int32_t AUDIO_CHANNELCOUNT = 2; + const int32_t AUDIO_SAMPLE_RATE_48K = 48000; + const int32_t DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096; + const int32_t INT_32_MAX = 0x7fffffff; + const int32_t SILENCE_THRESHOLD = 16 * 1024; + const int32_t DEFAULT_RENDER_SAMPLING_RATE = 48000; + const int32_t DEEP_BUFFER_RENDER_PERIOD_COUNT = 8; + const int32_t AUDIO_FORMAT_PCM_BIT = 16; + const int32_t MANAGER_ADAPTER_NAME_LEN = 32; + const int32_t AUDIO_CAPTURE_BUF_TEST = 8192 * 2; + const int32_t AUDIO_RENDER_BUF_TEST = 1024; + const int32_t ADAPTER_COUNT = 32; + const int32_t DYNAMIC_LIB_PATH_MAX = 256; + const float HALF_OF_NORMAL_VALUE = 0.5; + const float MIN_VALUE_OUT_OF_BOUNDS = -1; + const float MAX_VALUE_OUT_OF_BOUNDS = 2; + using TestAudioManager = struct AudioManager; + const std::string ADAPTER_NAME_USB = "usb"; + const std::string FUNCTION_NAME = "GetAudioManagerFuncs"; + const std::string RESOLVED_PATH = HDF_LIBRARY_FULL_PATH("libhdi_audio_client"); + + void *GetDynamicLibHandle(const std::string path); + int32_t InitPort(struct AudioPort &portIndex); + int32_t InitHwRender(struct AudioHwRender &hwRender, + const struct AudioDeviceDescriptor &desc, const struct AudioSampleAttributes &attrs); + int32_t InitHwCapture(struct AudioHwCapture &hwCapture, const struct AudioDeviceDescriptor &desc, + const struct AudioSampleAttributes &attrs); + int32_t InitAttrs(struct AudioSampleAttributes &attrs); + int32_t InitDevDesc(struct AudioDeviceDescriptor &devDesc); + int32_t InitDevDesc(struct AudioDeviceDescriptor &devDesc, const uint32_t portId, int pins); + int32_t InitAttrsCapture(struct AudioSampleAttributes &attrs); + int32_t InitDevDescCapture(struct AudioDeviceDescriptor &devDesc); + int32_t AudioRenderCallbackUtTest(enum AudioCallbackType type, void *reserved, void *cookie); + int32_t GetLoadAdapter(TestAudioManager *manager, int portType, + const std::string &adapterName, struct AudioAdapter **adapter, struct AudioPort *&audioPort); + int32_t GetAdapters(TestAudioManager *manager, struct AudioAdapterDescriptor **descs, int &size); + int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string &adapterNameCase, + int portFlag, struct AudioPort *&audioPort, int size); +} +#endif diff --git a/audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp b/audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp new file mode 100644 index 0000000000..99a00ed236 --- /dev/null +++ b/audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2022 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_proxy_common_fun_test.h" +#include +#include +#include +#include "hdf_remote_service.h" + +namespace comfun { +void *GetDynamicLibHandle(const std::string path) +{ + char absPath[DYNAMIC_LIB_PATH_MAX] = {0}; + if (realpath(path.c_str(), absPath) == nullptr) { + return nullptr; + } + void *handleSo = dlopen(absPath, RTLD_LAZY); + if (handleSo == nullptr) { + return nullptr; + } + return handleSo; +} + +int32_t InitPort(struct AudioPort &portIndex) +{ + portIndex.dir = PORT_OUT; + portIndex.portId = 1; + portIndex.portName = "usb"; + return HDF_SUCCESS; +} + +int32_t InitHwRender(struct AudioHwRender &hwRender, const struct AudioDeviceDescriptor &desc, + const struct AudioSampleAttributes &attrs) +{ + hwRender.renderParam.renderMode.hwInfo.deviceDescript = desc; + hwRender.renderParam.frameRenderMode.attrs = attrs; + hwRender.renderParam.renderMode.ctlParam.audioGain.gainMax = 15; // gainMax 15 + hwRender.renderParam.renderMode.ctlParam.audioGain.gainMin = 0; + hwRender.renderParam.frameRenderMode.frames = 0; + hwRender.renderParam.frameRenderMode.time.tvNSec = 0; + hwRender.renderParam.frameRenderMode.time.tvSec = 0; + hwRender.renderParam.frameRenderMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE; + hwRender.renderParam.frameRenderMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE; + hwRender.renderParam.frameRenderMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT; + hwRender.renderParam.frameRenderMode.attrs.period = attrs.period; + hwRender.renderParam.frameRenderMode.attrs.frameSize = attrs.frameSize; + hwRender.renderParam.frameRenderMode.attrs.startThreshold = attrs.startThreshold; + hwRender.renderParam.frameRenderMode.attrs.stopThreshold = attrs.stopThreshold; + hwRender.renderParam.frameRenderMode.attrs.silenceThreshold = attrs.silenceThreshold; + hwRender.renderParam.frameRenderMode.attrs.isBigEndian = attrs.isBigEndian; + hwRender.renderParam.frameRenderMode.attrs.isSignedData = attrs.isSignedData; + return HDF_SUCCESS; +} + +int32_t InitHwCapture(struct AudioHwCapture &hwCapture, const struct AudioDeviceDescriptor &desc, + const struct AudioSampleAttributes &attrs) +{ + hwCapture.captureParam.captureMode.hwInfo.deviceDescript = desc; + hwCapture.captureParam.frameCaptureMode.attrs = attrs; + hwCapture.captureParam.captureMode.ctlParam.audioGain.gainMax = 15; // gainMax 15 + hwCapture.captureParam.captureMode.ctlParam.audioGain.gainMin = 0; + hwCapture.captureParam.frameCaptureMode.frames = 0; + hwCapture.captureParam.frameCaptureMode.time.tvNSec = 0; + hwCapture.captureParam.frameCaptureMode.time.tvSec = 0; + hwCapture.captureParam.frameCaptureMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE; + hwCapture.captureParam.frameCaptureMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE; + hwCapture.captureParam.frameCaptureMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT; + hwCapture.captureParam.frameCaptureMode.attrs.period = attrs.period; + hwCapture.captureParam.frameCaptureMode.attrs.frameSize = attrs.frameSize; + hwCapture.captureParam.frameCaptureMode.attrs.startThreshold = attrs.startThreshold; + hwCapture.captureParam.frameCaptureMode.attrs.stopThreshold = attrs.stopThreshold; + hwCapture.captureParam.frameCaptureMode.attrs.silenceThreshold = attrs.silenceThreshold; + hwCapture.captureParam.frameCaptureMode.attrs.isBigEndian = attrs.isBigEndian; + hwCapture.captureParam.frameCaptureMode.attrs.isSignedData = attrs.isSignedData; + return HDF_SUCCESS; +} + +void InitAttrsCommon(struct AudioSampleAttributes &attrs) +{ + /* Initialization of audio parameters for playback */ + attrs.format = AUDIO_FORMAT_PCM_16_BIT; + attrs.channelCount = AUDIO_CHANNELCOUNT; + attrs.sampleRate = AUDIO_SAMPLE_RATE_48K; + attrs.interleaved = 0; + attrs.type = AUDIO_IN_MEDIA; + attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE; + attrs.frameSize = AUDIO_FORMAT_PCM_BIT * AUDIO_CHANNELCOUNT / 8; /* divide 8 is for bit to byte */ + attrs.isBigEndian = false; + attrs.isSignedData = true; + /* DEEP_BUFFER_RENDER_PERIOD_SIZE / (16 * attrs->channelCount / 8) divide 8 is for bit to byte */ + attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (AUDIO_FORMAT_PCM_BIT * AUDIO_CHANNELCOUNT / 8); + attrs.stopThreshold = INT_32_MAX; +} + +int32_t InitAttrs(struct AudioSampleAttributes &attrs) +{ + InitAttrsCommon(attrs); + attrs.silenceThreshold = 0; + return HDF_SUCCESS; +} + +int32_t InitDevDesc(struct AudioDeviceDescriptor &devDesc) +{ + /* Initialization of audio parameters for playback */ + devDesc.portId = 0; + devDesc.pins = PIN_OUT_SPEAKER; + devDesc.desc = NULL; + return HDF_SUCCESS; +} + +int32_t InitDevDesc(struct AudioDeviceDescriptor &devDesc, const uint32_t portId, int pins) +{ + devDesc.portId = portId; + devDesc.pins = (enum AudioPortPin)pins; + devDesc.desc = nullptr; + return HDF_SUCCESS; +} + +int32_t InitAttrsCapture(struct AudioSampleAttributes &attrs) +{ + InitAttrsCommon(attrs); + attrs.silenceThreshold = SILENCE_THRESHOLD; + return HDF_SUCCESS; +} + +int32_t InitDevDescCapture(struct AudioDeviceDescriptor &devDesc) +{ + /* Initialization of audio parameters for playback */ + devDesc.portId = 0; + devDesc.pins = PIN_IN_MIC; + devDesc.desc = NULL; + return HDF_SUCCESS; +} + +int32_t AudioRenderCallbackUtTest(enum AudioCallbackType type, void *reserved, void *cookie) +{ + switch (type) { + case AUDIO_NONBLOCK_WRITE_COMPELETED: + return HDF_SUCCESS; + case AUDIO_RENDER_FULL: + return HDF_SUCCESS; + case AUDIO_FLUSH_COMPLETED: + return HDF_SUCCESS; + case AUDIO_ERROR_OCCUR: + return HDF_FAILURE; + case AUDIO_DRAIN_COMPELETED: + return HDF_FAILURE; + default: + return HDF_FAILURE; + } + return HDF_FAILURE; +} + +int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string &adapterNameCase, + int portFlag, struct AudioPort *&audioPort, int size) +{ + if (descs == nullptr || size > ADAPTER_COUNT) { + return HDF_FAILURE; + } + + for (int index = 0; index < size; index++) { + struct AudioAdapterDescriptor *desc = &descs[index]; + if (desc == nullptr || desc->adapterName == nullptr) { + continue; + } + if (strcmp(desc->adapterName, adapterNameCase.c_str())) { + continue; + } + for (uint32_t port = 0; port < desc->portNum; port++) { + if (desc->ports[port].dir == portFlag) { + audioPort = &desc->ports[port]; + return index; + } + } + } + return HDF_FAILURE; +} + +int32_t GetAdapters(TestAudioManager *manager, struct AudioAdapterDescriptor **descs, int &size) +{ + int32_t ret = -1; + if (descs == nullptr) { + return AUDIO_HAL_ERR_INVALID_PARAM; + } + ret = manager->GetAllAdapters(manager, descs, &size); + if (ret < 0) { + return ret; + } + if (*descs == nullptr) { + return AUDIO_HAL_ERR_INTERNAL; + } + return AUDIO_HAL_SUCCESS; +} + +int32_t GetLoadAdapter(TestAudioManager *manager, int portType, + const std::string &adapterName, struct AudioAdapter **adapter, struct AudioPort *&audioPort) +{ + int32_t ret = -1; + int size = 0; + struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapterDescriptor *descs = nullptr; + if (adapter == nullptr) { + return AUDIO_HAL_ERR_INVALID_PARAM; + } + ret = GetAdapters(manager, &descs, size); + if (ret < 0) { + return ret; + } + if (descs == nullptr) { + return AUDIO_HAL_ERR_INTERNAL; + } + + int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); + if (index < 0) { + return AUDIO_HAL_ERR_INTERNAL; + } + desc = &descs[index]; + if (desc == nullptr) { + return AUDIO_HAL_ERR_INVALID_PARAM; + } + ret = manager->LoadAdapter(manager, desc, adapter); + if (ret < 0) { + return ret; + } + if (*adapter == nullptr) { + return AUDIO_HAL_ERR_INTERNAL; + } + return AUDIO_HAL_SUCCESS; +} +} diff --git a/audio/test/unittest/hdi/client/common/src/audio_proxy_common_test.cpp b/audio/test/unittest/hdi/client/common/src/audio_proxy_common_test.cpp new file mode 100644 index 0000000000..4d2c11918c --- /dev/null +++ b/audio/test/unittest/hdi/client/common/src/audio_proxy_common_test.cpp @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2022 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 +#include +#include +#include "hdf_remote_service.h" +#include "audio_proxy_common.h" +#include "audio_proxy_common_fun_test.h" + +struct HdfSBuf { + struct HdfSBufImpl *impl; + uint32_t type; +}; + +using namespace std; +using namespace testing::ext; +namespace { +class AudioProxyCommonTest : public testing::Test { +public: + virtual void SetUp(); + virtual void TearDown(); +}; + +void AudioProxyCommonTest::SetUp() {} + +void AudioProxyCommonTest::TearDown() {} + +HWTEST_F(AudioProxyCommonTest, AudioProxyObtainHdfSBufWhenNormal, TestSize.Level1) +{ + struct HdfSBuf *data = AudioProxyObtainHdfSBuf(); + EXPECT_NE(nullptr, data); + HdfSbufRecycle(data); + data = nullptr; +} + +HWTEST_F(AudioProxyCommonTest, AudioProxyObtainHdfSBuf_001, TestSize.Level1) +{ + struct HdfSBuf *data = nullptr; + struct HdfSBuf *reply = nullptr; + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessSBuf(nullptr, &reply)); + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessSBuf(&data, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, AudioProxyDispatchCall_001, TestSize.Level1) +{ + int32_t id = 0; + struct HdfSBuf data; + struct HdfSBuf reply; + struct HdfRemoteService self; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyDispatchCall(nullptr, id, &data, &reply)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyDispatchCall(&self, id, nullptr, &reply)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyDispatchCall(&self, id, &data, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, AudioProxyDispatchCall_002, TestSize.Level1) +{ + int32_t id = 0; + struct HdfSBuf data; + struct HdfSBuf reply; + struct HdfRemoteService self; + self.dispatcher = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyDispatchCall(nullptr, id, &data, &reply)); +} + +HWTEST_F(AudioProxyCommonTest, AdapterGetRemoteHandle_001, TestSize.Level1) +{ + char adapterName[NAME_LEN]; + struct AudioHwAdapter hwAdapter; + struct AudioProxyManager proxyManager; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetRemoteHandle(nullptr, &hwAdapter, adapterName)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetRemoteHandle(&proxyManager, nullptr, adapterName)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetRemoteHandle(&proxyManager, &hwAdapter, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, AdapterGetRemoteHandle_002, TestSize.Level1) +{ + const char *adapterName = "abc"; + struct AudioHwAdapter hwAdapter; + struct AudioProxyManager proxyManager; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetRemoteHandle(&proxyManager, &hwAdapter, adapterName)); +} + +HWTEST_F(AudioProxyCommonTest, AudioProxyPreprocessRender_001, TestSize.Level1) +{ + struct HdfSBuf *data = nullptr; + struct HdfSBuf *reply = nullptr; + struct AudioHwRender render; + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessRender(nullptr, &data, &reply)); + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessRender(&render, nullptr, &reply)); + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessRender(&render, &data, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, AudioProxyPreprocessCapture_001, TestSize.Level1) +{ + struct HdfSBuf *data = nullptr; + struct HdfSBuf *reply = nullptr; + struct AudioHwCapture capture; + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessCapture(nullptr, &data, &reply)); + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessCapture(&capture, nullptr, &reply)); + EXPECT_EQ(HDF_FAILURE, AudioProxyPreprocessCapture(&capture, &data, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, AudioProxyWriteSampleAttributes_001, TestSize.Level1) +{ + struct HdfSBuf data; + struct AudioSampleAttributes attrs; + EXPECT_EQ(HDF_FAILURE, AudioProxyWriteSampleAttributes(nullptr, &attrs)); + EXPECT_EQ(HDF_FAILURE, AudioProxyWriteSampleAttributes(&data, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, AudioProxyReadSapmleAttrbutes_001, TestSize.Level1) +{ + struct HdfSBuf data; + struct AudioSampleAttributes attrs; + EXPECT_EQ(HDF_FAILURE, AudioProxyReadSapmleAttrbutes(nullptr, &attrs)); + EXPECT_EQ(HDF_FAILURE, AudioProxyReadSapmleAttrbutes(&data, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, SetRenderCtrlParam_001, TestSize.Level1) +{ + int cmId = AUDIO_HDI_RENDER_SET_VOLUME; + float param = comfun::HALF_OF_NORMAL_VALUE; // normal value + struct AudioHwRender hwRender; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCommonSetRenderCtrlParam(cmId, nullptr, param)); + + hwRender.proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCommonSetRenderCtrlParam(cmId, (AudioHandle)(&hwRender), param)); +} + +HWTEST_F(AudioProxyCommonTest, SetRenderCtrlParam_002, TestSize.Level1) +{ + int cmId = AUDIO_HDI_RENDER_SET_VOLUME; + float volume = comfun::MIN_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1] + struct AudioHwRender hwRender; + struct HdfRemoteService remoteHandle; + hwRender.proxyRemoteHandle = &remoteHandle; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCommonSetRenderCtrlParam(cmId, (AudioHandle)(&hwRender), volume)); + volume = comfun::MAX_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1] + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCommonSetRenderCtrlParam(cmId, (AudioHandle)(&hwRender), volume)); +} + +HWTEST_F(AudioProxyCommonTest, GetRenderCtrlParam_001, TestSize.Level1) +{ + int cmId = AUDIO_HDI_RENDER_SET_VOLUME; + float param = comfun::HALF_OF_NORMAL_VALUE; // normal value + struct AudioHwRender hwRender; + int32_t ret = AudioProxyCommonGetRenderCtrlParam(cmId, nullptr, ¶m); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); + ret = AudioProxyCommonGetRenderCtrlParam(cmId, (AudioHandle)(&hwRender), nullptr); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); + hwRender.proxyRemoteHandle = nullptr; + ret = AudioProxyCommonGetRenderCtrlParam(cmId, (AudioHandle)(&hwRender), ¶m); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); +} + + +HWTEST_F(AudioProxyCommonTest, SetCaptureCtrlParam_001, TestSize.Level1) +{ + int cmId = AUDIO_HDI_RENDER_SET_VOLUME; + float param = comfun::HALF_OF_NORMAL_VALUE; // normal value + struct AudioHwCapture hwCapture; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCommonSetCaptureCtrlParam(cmId, nullptr, param)); + + hwCapture.proxyRemoteHandle = nullptr; + int32_t ret = AudioProxyCommonSetCaptureCtrlParam(cmId, (AudioHandle)(&hwCapture), param); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); +} + +HWTEST_F(AudioProxyCommonTest, SetCaptureCtrlParam_002, TestSize.Level1) +{ + int cmId = AUDIO_HDI_CAPTURE_SET_VOLUME; + float volume = comfun::MIN_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1]. + struct AudioHwCapture hwCapture; + struct HdfRemoteService remoteHandle; + hwCapture.proxyRemoteHandle = &remoteHandle; + int32_t ret = AudioProxyCommonSetCaptureCtrlParam(cmId, (AudioHandle)(&hwCapture), volume); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); + ret = AudioProxyCommonSetCaptureCtrlParam(cmId, (AudioHandle)(&hwCapture), volume); + volume = comfun::MAX_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1]. + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); +} + +HWTEST_F(AudioProxyCommonTest, GetCaptureCtrlParam_001, TestSize.Level1) +{ + int cmId = AUDIO_HDI_CAPTURE_SET_VOLUME; + float param = comfun::HALF_OF_NORMAL_VALUE; // normal value + struct AudioHwCapture hwCapture; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCommonGetCaptureCtrlParam(cmId, nullptr, ¶m)); + int32_t ret = AudioProxyCommonGetCaptureCtrlParam(cmId, (AudioHandle)(&hwCapture), nullptr); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); + hwCapture.proxyRemoteHandle = nullptr; + ret = AudioProxyCommonGetCaptureCtrlParam(cmId, (AudioHandle)(&hwCapture), ¶m); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); +} + +HWTEST_F(AudioProxyCommonTest, GetMmapPositionRead_001, TestSize.Level1) +{ + uint64_t frames = 0; + struct HdfSBuf reply; + struct AudioTimeStamp time; + EXPECT_EQ(HDF_FAILURE, AudioProxyGetMmapPositionRead(nullptr, &frames, &time)); + EXPECT_EQ(HDF_FAILURE, AudioProxyGetMmapPositionRead(&reply, nullptr, &time)); + EXPECT_EQ(HDF_FAILURE, AudioProxyGetMmapPositionRead(&reply, &frames, nullptr)); +} + +HWTEST_F(AudioProxyCommonTest, ReqMmapBufferWrite_001, TestSize.Level1) +{ + int32_t reqSize = 0; + struct HdfSBuf data; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(HDF_FAILURE, AudioProxyReqMmapBufferWrite(nullptr, reqSize, &desc)); + EXPECT_EQ(HDF_FAILURE, AudioProxyReqMmapBufferWrite(&data, reqSize, nullptr)); +} +} diff --git a/audio/test/unittest/hdi/client/manager/BUILD.gn b/audio/test/unittest/hdi/client/manager/BUILD.gn new file mode 100644 index 0000000000..2157644c82 --- /dev/null +++ b/audio/test/unittest/hdi/client/manager/BUILD.gn @@ -0,0 +1,50 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +ohos_unittest("hdf_audio_proxy_manager_test") { + module_out_path = "hdf/audio" + sources = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/client/manager/src/audio_proxy_manager_test.cpp", + ] + + include_dirs = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/common/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "//drivers/hdf_core/adapter/uhdf2/include/hdi", + "//drivers/hdf_core/adapter/uhdf2/shared/include", + "//third_party/googletest/googletest/include/gtest", + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_binder/proxy:hdi_audio_client", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio_common", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "utils_base:utils", + ] +} diff --git a/audio/test/unittest/hdi/client/manager/src/audio_proxy_manager_test.cpp b/audio/test/unittest/hdi/client/manager/src/audio_proxy_manager_test.cpp new file mode 100644 index 0000000000..12dd4d94ac --- /dev/null +++ b/audio/test/unittest/hdi/client/manager/src/audio_proxy_manager_test.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2022 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 +#include +#include "hdf_dlist.h" +#include "audio_proxy_common_fun_test.h" + +using namespace std; +using namespace comfun; +using namespace testing::ext; +namespace { +class AudioProxyManagerTest : public testing::Test { +public: + uint32_t audioCheck = 0xAAAAAAAA; + struct AudioManager *manager = nullptr; + struct AudioManager *(*getAudioManager)(void) = NULL; + struct AudioAdapterDescriptor *descs = nullptr; + struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapter *adapter = nullptr; + void *clientHandle = nullptr; + virtual void SetUp(); + virtual void TearDown(); +}; + +void AudioProxyManagerTest::SetUp() +{ + clientHandle = GetDynamicLibHandle(RESOLVED_PATH); + ASSERT_NE(clientHandle, nullptr); + getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str())); + ASSERT_NE(getAudioManager, nullptr); + manager = getAudioManager(); + ASSERT_NE(manager, nullptr); + int32_t size = 0; + ASSERT_EQ(HDF_SUCCESS, manager->GetAllAdapters(manager, &descs, &size)); + desc = &descs[0]; + ASSERT_EQ(HDF_SUCCESS, manager->LoadAdapter(manager, desc, &adapter)); +} + +void AudioProxyManagerTest::TearDown() +{ + if (manager != nullptr) { + manager->UnloadAdapter(manager, adapter); + adapter = nullptr; + manager->ReleaseAudioManagerObject(manager); + manager = nullptr; + } + if (clientHandle != nullptr) { + dlclose(clientHandle); + clientHandle = nullptr; + } +} + +HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_001, TestSize.Level1) +{ + struct AudioManager managerFuncs; + struct AudioAdapterDescriptor *descs = nullptr; + int size = 0; + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(nullptr, &descs, &size)); + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(&managerFuncs, nullptr, &size)); + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(&managerFuncs, &descs, nullptr)); +} + +HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_002, TestSize.Level1) +{ + struct AudioProxyManager proxyMgr; + struct AudioManager *managerFuncs = &proxyMgr.impl; + struct AudioAdapterDescriptor *descs = nullptr; + int size = 0; + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(managerFuncs, &descs, &size)); +} + +HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_003, TestSize.Level1) +{ + ASSERT_NE(manager, nullptr); + int size = 0; + struct HdfRemoteService *remoteService = nullptr; + struct HdfRemoteService *usbRemoteService = nullptr; + struct HdfRemoteService *a2dpRemoteService = nullptr; + struct AudioProxyManager *proxyManager = CONTAINER_OF(manager, struct AudioProxyManager, impl); + remoteService = proxyManager->remote; + usbRemoteService = proxyManager->usbRemote; + a2dpRemoteService = proxyManager->a2dpRemote; + proxyManager->remote = nullptr; + proxyManager->usbRemote = nullptr; + proxyManager->a2dpRemote = nullptr; + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(manager, &descs, &size)); + proxyManager->remote = remoteService; + proxyManager->usbRemote = usbRemoteService; + proxyManager->a2dpRemote = a2dpRemoteService; + + uint32_t audioMagic = proxyManager->audioMagic; + proxyManager->audioMagic = audioCheck - 1; + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(manager, &descs, &size)); + proxyManager->audioMagic = audioMagic; + + remoteService = nullptr; + audioMagic = 0; +} + +HWTEST_F(AudioProxyManagerTest, ManagerLoadAdapter_001, TestSize.Level1) +{ + struct AudioManager managerFuncs; + struct AudioAdapterDescriptor descObject; + const struct AudioAdapterDescriptor *desc = &descObject; + struct AudioAdapter adapterObject; + struct AudioAdapter *adapter = &adapterObject; + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(nullptr, desc, &adapter)); + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(&managerFuncs, nullptr, &adapter)); + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(&managerFuncs, desc, nullptr)); +} + +HWTEST_F(AudioProxyManagerTest, ManagerLoadAdapter_002, TestSize.Level1) +{ + ASSERT_NE(manager, nullptr); + struct AudioManager managerFuncs; + struct AudioAdapterDescriptor descObject; + const struct AudioAdapterDescriptor *desc = &descObject; + struct AudioAdapter adapterObject; + struct AudioAdapter *adapter = &adapterObject; + + struct HdfRemoteService *remoteService = nullptr; + struct AudioProxyManager *proxyManager = CONTAINER_OF(manager, struct AudioProxyManager, impl); + + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(&managerFuncs, desc, &adapter)); + + remoteService = proxyManager->remote; + proxyManager->remote = nullptr; + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(manager, desc, &adapter)); + proxyManager->remote = remoteService; + + uint32_t audioMagic = proxyManager->audioMagic; + proxyManager->audioMagic = audioCheck - 1; + ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(manager, desc, &adapter)); + proxyManager->audioMagic = audioMagic; + + remoteService = nullptr; + audioMagic = 0; +} +} + diff --git a/audio/test/unittest/hdi/manager/include/audio_manager_test.h b/audio/test/unittest/hdi/manager/include/audio_manager_test.h deleted file mode 100644 index 6323c84933..0000000000 --- a/audio/test/unittest/hdi/manager/include/audio_manager_test.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (c) 2021 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_MANAGER_TEST_H -#define AUDIO_MANAGER_TEST_H - -#endif diff --git a/audio/test/unittest/hdi/BUILD.gn b/audio/test/unittest/hdi/passthrough/BUILD.gn similarity index 69% rename from audio/test/unittest/hdi/BUILD.gn rename to audio/test/unittest/hdi/passthrough/BUILD.gn index 34078b95ee..5453eca6c6 100644 --- a/audio/test/unittest/hdi/BUILD.gn +++ b/audio/test/unittest/hdi/passthrough/BUILD.gn @@ -20,19 +20,14 @@ if (defined(ohos_lite)) { import("//drivers/peripheral/audio/audio.gni") } -###########################group########################### -group("hdi") { +group("hdi_passthrough") { if (!defined(ohos_lite)) { testonly = true } - deps = [] - if (drivers_peripheral_audio_full_test_suite) { - deps += [ - "adapter:hdf_audio_hdi_adapter_test", - "capture:hdf_audio_hdi_capture_test", - "manager:hdf_audio_hdi_manager_test", - "render:hdf_audio_hdi_render_test", - ] - } + deps = [ + "adapter:hdf_audio_hdi_adapter_test", + "capture:hdf_audio_hdi_capture_test", + "manager:hdf_audio_hdi_manager_test", + "render:hdf_audio_hdi_render_test", + ] } -############################end############################ diff --git a/audio/test/unittest/hdi/adapter/BUILD.gn b/audio/test/unittest/hdi/passthrough/adapter/BUILD.gn similarity index 72% rename from audio/test/unittest/hdi/adapter/BUILD.gn rename to audio/test/unittest/hdi/passthrough/adapter/BUILD.gn index f03684ced6..fa43cfe937 100644 --- a/audio/test/unittest/hdi/adapter/BUILD.gn +++ b/audio/test/unittest/hdi/passthrough/adapter/BUILD.gn @@ -25,13 +25,12 @@ if (defined(ohos_lite)) { ###########################hdf_audio_hdi_adapter_test########################### unittest("hdf_audio_hdi_adapter_test") { sources = [ - "//drivers/peripheral/audio/test/unittest/hdi/adapter/src/audio_adapter_test.cpp", - "//drivers/peripheral/audio/test/unittest/hdi/common/src/audio_common_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/adapter/src/audio_adapter_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp", ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/adapter/include", - "//drivers/peripheral/audio/test/unittest/hdi/common/include", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -54,32 +53,18 @@ if (defined(ohos_lite)) { "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", ] - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - "-std=c++11", - ] } } else { - ###########################unittest########################### - module_output_path = "hdf/audio" - ###########################hdf_audio_hdi_adapter_test########################### ohos_unittest("hdf_audio_hdi_adapter_test") { - module_out_path = module_output_path + module_out_path = "hdf/audio" sources = [ - "//drivers/peripheral/audio/test/unittest/hdi/adapter/src/audio_adapter_test.cpp", - "//drivers/peripheral/audio/test/unittest/hdi/common/src/audio_common_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/adapter/src/audio_adapter_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp", ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/adapter/include", - "//drivers/peripheral/audio/test/unittest/hdi/common/include", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -94,17 +79,12 @@ if (defined(ohos_lite)) { ] if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] - external_deps = [ "hdf_core:libhdf_utils" ] + external_deps = [ + "hdf_core:libhdf_utils", + "utils_base:utils", + ] } else { deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] } } diff --git a/audio/test/unittest/hdi/adapter/src/audio_adapter_test.cpp b/audio/test/unittest/hdi/passthrough/adapter/src/audio_adapter_test.cpp similarity index 95% rename from audio/test/unittest/hdi/adapter/src/audio_adapter_test.cpp rename to audio/test/unittest/hdi/passthrough/adapter/src/audio_adapter_test.cpp index 53ac3e279c..bbd1a71d40 100644 --- a/audio/test/unittest/hdi/adapter/src/audio_adapter_test.cpp +++ b/audio/test/unittest/hdi/passthrough/adapter/src/audio_adapter_test.cpp @@ -13,7 +13,6 @@ * limitations under the License. */ -#include "audio_adapter_test.h" #include #include #include "audio_common_test.h" @@ -44,6 +43,7 @@ void AudioAdapterTest::SetUp() void AudioAdapterTest::TearDown() { + ASSERT_NE(managerFuncs, nullptr); managerFuncs->UnloadAdapter(managerFuncs, adapter); adapter = nullptr; } @@ -54,7 +54,7 @@ HWTEST_F(AudioAdapterTest, GetAudioRenderFuncWhenHwRenderIsNull, TestSize.Level1 EXPECT_EQ(HDF_FAILURE, GetAudioRenderFunc(hwRender)); } -HWTEST_F(AudioAdapterTest, GetAudioRenderFuncWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, GetAudioRenderFuncWhenParamIsValid, TestSize.Level1) { struct AudioHwRender hwRender; EXPECT_EQ(HDF_SUCCESS, GetAudioRenderFunc(&hwRender)); @@ -100,7 +100,7 @@ HWTEST_F(AudioAdapterTest, CheckParaDescWhenTypeIsError, TestSize.Level1) EXPECT_EQ(HDF_ERR_NOT_SUPPORT, CheckParaDesc(&desc, type)); } -HWTEST_F(AudioAdapterTest, CheckParaDescWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, CheckParaDescWhenParamIsValid, TestSize.Level1) { struct AudioDeviceDescriptor desc; EXPECT_EQ(HDF_SUCCESS, InitDevDesc(desc)); @@ -138,7 +138,7 @@ HWTEST_F(AudioAdapterTest, CheckParaAttrWhenFormatIsNotSupport, TestSize.Level1) EXPECT_EQ(HDF_ERR_NOT_SUPPORT, CheckParaAttr(&attrs)); } -HWTEST_F(AudioAdapterTest, CheckParaAttrWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, CheckParaAttrWhenParamIsValid, TestSize.Level1) { struct AudioSampleAttributes attrs; EXPECT_EQ(HDF_SUCCESS, InitAttrs(attrs)); @@ -168,7 +168,7 @@ HWTEST_F(AudioAdapterTest, AttrFormatToBitWhenAttrsIsNotSupport, TestSize.Level1 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AttrFormatToBit(&attrs, &format)); } -HWTEST_F(AudioAdapterTest, AttrFormatToBitWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AttrFormatToBitWhenParamIsValid, TestSize.Level1) { struct AudioSampleAttributes attrs; EXPECT_EQ(HDF_SUCCESS, InitAttrs(attrs)); @@ -245,7 +245,7 @@ HWTEST_F(AudioAdapterTest, InitHwRenderParamWhenChannelCountIsZero, TestSize.Lev EXPECT_EQ(HDF_FAILURE, InitHwRenderParam(&hwRender, &desc, &attrs)); } -HWTEST_F(AudioAdapterTest, InitHwRenderParamWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, InitHwRenderParamWhenParamIsValid, TestSize.Level1) { struct AudioDeviceDescriptor desc; EXPECT_EQ(HDF_SUCCESS, InitDevDesc(desc)); @@ -335,7 +335,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterReleaseCapSubPortsWhenPortCapabilitysIsNu EXPECT_EQ(nullptr, portCapabilitys); } -HWTEST_F(AudioAdapterTest, AudioAdapterReleaseCapSubPortsWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterReleaseCapSubPortsWhenParamIsValid, TestSize.Level1) { struct AudioPortAndCapability portCapabilitys; struct AudioSubPortCapability *subPorts = @@ -378,7 +378,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterInitAllPortsWhenPortNumIsZero, TestSize.L EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterInitAllPorts((struct AudioAdapter *)hwAdapter)); } -HWTEST_F(AudioAdapterTest, AudioAdapterInitAllPortsWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterInitAllPortsWhenParamIsValid, TestSize.Level1) { EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterInitAllPorts(adapter)); } @@ -473,7 +473,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderPreWhenAdapterNameIsNull, Tes hwRender = nullptr; } -HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderPreWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderPreWhenParamIsValid, TestSize.Level1) { struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); ASSERT_NE(hwRender, nullptr); @@ -545,7 +545,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenPeriodIsLessThanZero, Tes EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterCreateRender(adapter, &devDesc, &attrs, &render)); } -HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenParamIsValid, TestSize.Level1) { struct AudioDeviceDescriptor devDesc; EXPECT_EQ(HDF_SUCCESS, InitDevDesc(devDesc)); @@ -588,7 +588,7 @@ HWTEST_F(AudioAdapterTest, GetAudioCaptureFuncWhenHwCaptureIsNull, TestSize.Leve EXPECT_EQ(HDF_FAILURE, GetAudioCaptureFunc(hwCapture)); } -HWTEST_F(AudioAdapterTest, GetAudioCaptureFuncWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, GetAudioCaptureFuncWhenParamIsValid, TestSize.Level1) { struct AudioHwCapture hwCapture; EXPECT_EQ(HDF_SUCCESS, GetAudioCaptureFunc(&hwCapture)); @@ -663,7 +663,7 @@ HWTEST_F(AudioAdapterTest, InitHwCaptureParamWhenChannelCountIsZero, TestSize.Le EXPECT_EQ(HDF_FAILURE, InitHwCaptureParam(&hwCapture, &desc, &attrs)); } -HWTEST_F(AudioAdapterTest, InitHwCaptureParamWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, InitHwCaptureParamWhenParamIsValid, TestSize.Level1) { struct AudioDeviceDescriptor desc; EXPECT_EQ(HDF_SUCCESS, InitDevDescCapture(desc)); @@ -790,7 +790,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenPeriodIsLessThanZero, Te EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterCreateCapture(adapter, &devDesc, &attrs, &capture)); } -HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenParamIsValid, TestSize.Level1) { struct AudioDeviceDescriptor devDesc; EXPECT_EQ(HDF_SUCCESS, InitDevDescCapture(devDesc)); @@ -877,7 +877,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterGetPortCapabilityWhenPortNumIsZero, TestS AudioAdapterGetPortCapability((struct AudioAdapter *)hwAdapter, port, &capability)); } -HWTEST_F(AudioAdapterTest, AudioAdapterGetPortCapabilityWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterGetPortCapabilityWhenParamIsValid, TestSize.Level1) { ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterInitAllPorts(adapter)); struct AudioPort *port = desc->ports; @@ -899,13 +899,13 @@ HWTEST_F(AudioAdapterTest, AudioAdapterGetPortCapabilityWhenPortIdIsError, TestS HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenAdapterIsNull, TestSize.Level1) { struct AudioPort port; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioAdapterSetPassthroughMode(nullptr, &port, mode)); } HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenPortIsNull, TestSize.Level1) { - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioAdapterSetPassthroughMode(adapter, nullptr, mode)); } @@ -913,7 +913,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenPortNameIsNull, Tes { struct AudioPort port; port.portName = nullptr; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioAdapterSetPassthroughMode(adapter, &port, mode)); } @@ -922,7 +922,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenPortDirIsPortIn, Te struct AudioPort port; port.portName = "usb"; port.dir = PORT_IN; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterSetPassthroughMode(adapter, &port, mode)); } @@ -931,7 +931,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenPortCapabilitysIsNu struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; hwAdapter->portCapabilitys = nullptr; struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterSetPassthroughMode((struct AudioAdapter *)hwAdapter, port, mode)); } @@ -941,7 +941,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenPortIdIsError, Test struct AudioPort *port = desc->ports; uint32_t portId = port->portId; port->portId = 1; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterSetPassthroughMode(adapter, port, mode)); port->portId = portId; } @@ -952,7 +952,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenPortNumIsZero, Test struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; hwAdapter->adapterDescriptor.portNum = 0; struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterSetPassthroughMode((struct AudioAdapter *)hwAdapter, port, mode)); } @@ -963,15 +963,15 @@ HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenSubPortsIsNull, Tes free(hwAdapter->portCapabilitys->capability.subPorts); hwAdapter->portCapabilitys->capability.subPorts = nullptr; struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterSetPassthroughMode((struct AudioAdapter *)hwAdapter, port, mode)); } -HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenParamIsValid, TestSize.Level1) { ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterInitAllPorts(adapter)); struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterSetPassthroughMode(adapter, port, mode)); } @@ -979,21 +979,21 @@ HWTEST_F(AudioAdapterTest, AudioAdapterSetPassthroughModeWhenModeIsError, TestSi { ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterInitAllPorts(adapter)); struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_RAW; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_RAW; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterSetPassthroughMode(adapter, port, mode)); } HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenAdapterIsNull, TestSize.Level1) { struct AudioPort port; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioAdapterGetPassthroughMode(nullptr, &port, &mode)); } HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenPortIsNull, TestSize.Level1) { struct AudioPort *port = nullptr; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioAdapterGetPassthroughMode(adapter, port, &mode)); } @@ -1007,7 +1007,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenPortNameIsNull, Tes { struct AudioPort port; port.portName = nullptr; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioAdapterGetPassthroughMode(adapter, &port, &mode)); } @@ -1016,7 +1016,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenPortDirIsPortIn, Te struct AudioPort port; port.portName = "usb"; port.dir = PORT_IN; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterGetPassthroughMode(adapter, &port, &mode)); } @@ -1025,7 +1025,7 @@ HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenPortCapabilitysIsNu struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; hwAdapter->portCapabilitys = nullptr; struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterGetPassthroughMode((AudioAdapter *)hwAdapter, port, &mode)); } @@ -1035,15 +1035,15 @@ HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenPortNumIsZero, Test struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; hwAdapter->adapterDescriptor.portNum = 0; struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterGetPassthroughMode((AudioAdapter *)hwAdapter, port, &mode)); } -HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenParamIsValid, TestSize.Level1) { ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterInitAllPorts(adapter)); struct AudioPort *port = desc->ports; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterGetPassthroughMode(adapter, port, &mode)); } @@ -1053,8 +1053,8 @@ HWTEST_F(AudioAdapterTest, AudioAdapterGetPassthroughModeWhenPortIdIsError, Test struct AudioPort *port = desc->ports; uint32_t portId = port->portId; port->portId = 1; - enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioAdapterGetPassthroughMode(adapter, port, &mode)); port->portId = portId; } -} \ No newline at end of file +} diff --git a/audio/test/unittest/hdi/capture/BUILD.gn b/audio/test/unittest/hdi/passthrough/capture/BUILD.gn similarity index 72% rename from audio/test/unittest/hdi/capture/BUILD.gn rename to audio/test/unittest/hdi/passthrough/capture/BUILD.gn index b5729b1b5a..9b9e486a7a 100644 --- a/audio/test/unittest/hdi/capture/BUILD.gn +++ b/audio/test/unittest/hdi/passthrough/capture/BUILD.gn @@ -25,13 +25,12 @@ if (defined(ohos_lite)) { ###########################hdf_audio_hdi_capture_test########################### unittest("hdf_audio_hdi_capture_test") { sources = [ - "//drivers/peripheral/audio/test/unittest/hdi/capture/src/audio_capture_test.cpp", - "//drivers/peripheral/audio/test/unittest/hdi/common/src/audio_common_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/capture/src/audio_capture_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp", ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/adapter/include", - "//drivers/peripheral/audio/test/unittest/hdi/common/include", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -54,32 +53,18 @@ if (defined(ohos_lite)) { "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", ] - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - "-std=c++11", - ] } } else { - ###########################unittest########################### - module_output_path = "hdf/audio" - ###########################hdf_audio_hdi_capture_test########################### ohos_unittest("hdf_audio_hdi_capture_test") { - module_out_path = module_output_path + module_out_path = "hdf/audio" sources = [ - "//drivers/peripheral/audio/test/unittest/hdi/capture/src/audio_capture_test.cpp", - "//drivers/peripheral/audio/test/unittest/hdi/common/src/audio_common_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/capture/src/audio_capture_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp", ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/capture/include", - "//drivers/peripheral/audio/test/unittest/hdi/common/include", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -93,20 +78,18 @@ if (defined(ohos_lite)) { "//third_party/googletest:gtest_main", ] + if (drivers_peripheral_audio_alsa_lib) { + defines = [ "ALSA_LIB_MODE" ] + } + if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] - external_deps = [ "hdf_core:libhdf_utils" ] + external_deps = [ + "hdf_core:libhdf_utils", + "utils_base:utils", + ] } else { deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] } } diff --git a/audio/test/unittest/hdi/capture/src/audio_capture_test.cpp b/audio/test/unittest/hdi/passthrough/capture/src/audio_capture_test.cpp similarity index 75% rename from audio/test/unittest/hdi/capture/src/audio_capture_test.cpp rename to audio/test/unittest/hdi/passthrough/capture/src/audio_capture_test.cpp index b52eb3bf9c..60f5929231 100644 --- a/audio/test/unittest/hdi/capture/src/audio_capture_test.cpp +++ b/audio/test/unittest/hdi/passthrough/capture/src/audio_capture_test.cpp @@ -13,7 +13,6 @@ * limitations under the License. */ -#include "audio_capture_test.h" #include #include #include "audio_common_test.h" @@ -87,21 +86,25 @@ HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenDevDataHandleIsError, TestSize.L struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devDataHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureStart(handle)); +#endif hwCapture->devDataHandle = devDataHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); } - HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenHandleIsNull, TestSize.Level1) { struct AudioHwCapture *hwCapture = nullptr; @@ -135,14 +138,19 @@ HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenDevDataHandleIsError, TestSize.Le ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devDataHandle = (struct DevHandleCapture *)service; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStop(handle)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureStop(handle)); +#endif hwCapture->devDataHandle = devDataHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); @@ -191,14 +199,19 @@ HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenDevDataHandleIsError, TestSize.L ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devDataHandle = (struct DevHandleCapture *)service; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCapturePause(handle)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCapturePause(handle)); +#endif hwCapture->devDataHandle = devDataHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); @@ -242,14 +255,19 @@ HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenDevDataHandleIsError, TestSize. ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCapturePause(handle)); struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devDataHandle = (struct DevHandleCapture *)service; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureResume(handle)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureResume(handle)); +#endif hwCapture->devDataHandle = devDataHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); @@ -264,13 +282,9 @@ HWTEST_F(AudioCaptureTest, AudioCaptureFlushWhenHandleIsNull, TestSize.Level1) EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureFlush(handle)); } -HWTEST_F(AudioCaptureTest, AudioCaptureFlushWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureFlushWhenParamIsValid, TestSize.Level1) { - AudioHwCapture *hwCapture = new AudioHwCapture; - AudioHandle handle = (AudioHandle)hwCapture; - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureFlush(handle)); - delete(hwCapture); - hwCapture = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioCaptureFlush(capture)); } HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenHandleIsNull, TestSize.Level1) @@ -297,7 +311,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenParamIsNotSupport, TestSi EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureGetFrameSize(handle, &frameSize)); } -HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; uint64_t frameSize = FRAME_DATA; @@ -319,7 +333,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameCountWhenCountIsNull, TestSize.Le EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetFrameCount(handle, count)); } -HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameCountWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameCountWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; uint64_t count = FRAME_DATA; @@ -350,7 +364,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenDevDataHandleIsNul HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenFormatIsError, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; - enum AudioFormat format = attrs.format; + AudioFormat format = attrs.format; attrs.format = AUDIO_FORMAT_G711A; EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureSetSampleAttributes(handle, &attrs)); attrs.format = format; @@ -361,15 +375,20 @@ HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenDevDataHandleIsErr struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devDataHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetSampleAttributes(handle, &attrs)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetSampleAttributes(handle, &attrs)); +#endif hwCapture->devDataHandle = devDataHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetSampleAttributes(handle, &attrs)); @@ -389,7 +408,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenAttrsIsNull, TestS EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetSampleAttributes(handle, nullptr)); } -HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; EXPECT_EQ(HDF_SUCCESS, AudioCaptureGetSampleAttributes(handle, &attrs)); @@ -408,7 +427,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetCurrentChannelIdWhenChannelIdIsNull, T EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetCurrentChannelId(handle, nullptr)); } -HWTEST_F(AudioCaptureTest, AudioCaptureGetCurrentChannelIdWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetCurrentChannelIdWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; uint32_t channelId = 1; @@ -454,7 +473,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenPinsIsError, Test } } -HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; struct AudioSceneDescriptor scene; @@ -502,6 +521,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenDevCtlHandleIsError, TestS struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; struct AudioSceneDescriptor scene; @@ -517,7 +537,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenDevCtlHandleIsError, TestS service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; struct AudioSceneDescriptor scene; @@ -552,20 +572,27 @@ HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenDevCtlHandleIsError, TestSize. AudioHwCapture *hwCapture = (AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; bool mute = true; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetMute(handle, mute)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetMute(handle, mute)); +#endif hwCapture->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; bool mute = true; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetMute(handle, mute)); + mute = false; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetMute(handle, mute)); } HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenHandleIsNull, TestSize.Level1) @@ -597,16 +624,21 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenDevCtlHandleIsError, TestSize. AudioHwCapture *hwCapture = (AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; bool mute = false; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetMute(handle, &mute)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetMute(handle, &mute)); +#endif hwCapture->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenParamValid, TestSize.Level1) { bool mute = false; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetMute((AudioHandle)capture, &mute)); @@ -650,18 +682,25 @@ HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenDevCtlHandleIsError, TestSiz AudioHwCapture *hwCapture = (AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; float volume = 0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetVolume(handle, volume)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetVolume(handle, volume)); +#endif hwCapture->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenParamValid, TestSize.Level1) { - float volume = 0; + float volume = 0.0; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetVolume((AudioHandle)capture, volume)); + volume = 0.6; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetVolume((AudioHandle)capture, volume)); } @@ -692,10 +731,15 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenDevCtlHandleIsError, TestSiz AudioHwCapture *hwCapture = (AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; float volume = 0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetVolume(handle, &volume)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetVolume(handle, &volume)); +#endif hwCapture->devCtlHandle = devCtlHandle; delete(service); service = nullptr; @@ -711,7 +755,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenVolumeIsError, TestSize.Leve EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetVolume(handle, &volume)); } -HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenParamValid, TestSize.Level1) { float volume = 0; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetVolume((AudioHandle)capture, &volume)); @@ -754,17 +798,22 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenDevCtlHandleIsError, AudioHwCapture *hwCapture = (AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; float min = GAIN_MIN; float max = GAIN_MAX; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetGainThreshold(handle, &min, &max)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetGainThreshold(handle, &min, &max)); +#endif hwCapture->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenParamValid, TestSize.Level1) { float min = GAIN_MIN; float max = GAIN_MAX; @@ -798,16 +847,21 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenDevCtlHandleIsError, TestSize. struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; float gain = 0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetGain(handle, &gain)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetGain(handle, &gain)); +#endif hwCapture->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenParamValid, TestSize.Level1) { float gain = 0; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetGain((AudioHandle)capture, &gain)); @@ -841,16 +895,21 @@ HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenDevCtlHandleIsError, TestSize. struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devCtlHandle = (struct DevHandleCapture *)service; AudioHandle handle = (AudioHandle)hwCapture; float gain = 0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetGain(handle, gain)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetGain(handle, gain)); +#endif hwCapture->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenParamValid, TestSize.Level1) { float gain = 0; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetGain((AudioHandle)capture, gain)); @@ -906,12 +965,17 @@ HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenDevDataHandleIsError, Tes struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwCapture->devDataHandle = (struct DevHandleCapture *)service; void *frame = (void *)calloc(1, FRAME_DATA); ASSERT_NE(nullptr, frame); uint64_t requestBytes = FRAME_DATA; uint64_t replyBytes; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureCaptureFrame(capture, frame, requestBytes, &replyBytes)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureCaptureFrame(capture, frame, requestBytes, &replyBytes)); +#endif hwCapture->devDataHandle = devDataHandle; delete(service); service = nullptr; @@ -945,7 +1009,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenSampleRateIsZero, TestSiz frame = nullptr; } -HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenParamIsValid, TestSize.Level1) { ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart((AudioHandle)capture)); void *frame = (void *)calloc(1, FRAME_DATA); @@ -984,7 +1048,7 @@ HWTEST_F(AudioCaptureTest, AudioCaptureGetCapturePositionWhenTimeIsNull, TestSiz EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetCapturePosition(capture, &frames, nullptr)); } -HWTEST_F(AudioCaptureTest, AudioCaptureGetCapturePositionWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureGetCapturePositionWhenParamIsValid, TestSize.Level1) { uint64_t frames = 1024; struct AudioTimeStamp *time = new AudioTimeStamp; @@ -1006,10 +1070,219 @@ HWTEST_F(AudioCaptureTest, AudioCaptureTurnStandbyModeWhenStopIsError, TestSize. EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureTurnStandbyMode(handle)); } -HWTEST_F(AudioCaptureTest, AudioCaptureTurnStandbyModeWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioCaptureTest, AudioCaptureTurnStandbyModeWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)capture; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle)); EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureTurnStandbyMode(handle)); } + +HWTEST_F(AudioCaptureTest, AudioCaptureAudioDevDumpWhenHandleIsNull, TestSize.Level1) +{ + AudioHwCapture *hwCapture = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t range = RANGE_MIN; + int32_t fd = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureAudioDevDump(handle, range, fd)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureAudioDevDumpWhenRangeOverMax, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + int32_t range = RANGE_MAX; + int32_t fd = 0; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureAudioDevDump(handle, range, fd)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureAudioDevDumpWhenParamIsValid, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + int32_t range = RANGE_MIN; + int32_t fd = 0; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureAudioDevDump(handle, range, fd)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetMmapPositionWhenHandleIsNull, TestSize.Level1) +{ + AudioHwCapture *hwCapture = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + uint64_t frames = 0; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetMmapPosition(handle, &frames, &time)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetMmapPositionWhenFramesIsNull, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetMmapPosition(handle, nullptr, &time)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetMmapPositionWhenTimeIsNull, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + uint64_t frames = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetMmapPosition(handle, &frames, nullptr)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetMmapPositionWhenDevDataHandleIsNull, TestSize.Level1) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; + hwCapture->devDataHandle = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + uint64_t frames = 0; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetMmapPosition(handle, &frames, &time)); + hwCapture->devDataHandle = devDataHandle; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetMmapPositionWhenDevDataHandleIsError, TestSize.Level1) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + AudioHandle handle = (AudioHandle)hwCapture; + struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; + struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); + hwCapture->devDataHandle = (struct DevHandleCapture *)service; + uint64_t frames = 0; + struct AudioTimeStamp time; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetMmapPosition(handle, &frames, &time)); +#else + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetMmapPosition(handle, &frames, &time)); +#endif + hwCapture->devDataHandle = devDataHandle; + delete(service); + service = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetMmapPositionWhenParamIsValid, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + uint64_t frames = 0; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetMmapPosition(handle, &frames, &time)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureReqMmapBufferWhenHandleIsNull, TestSize.Level1) +{ + AudioHwCapture *hwCapture = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureReqMmapBuffer(handle, reqSize, &desc)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureReqMmapBufferWhenDescIsNull, TestSize.Level1) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t reqSize = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureReqMmapBuffer(handle, reqSize, nullptr)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureReqMmapBufferWhenDevDataHandleIsNull, TestSize.Level1) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; + hwCapture->devDataHandle = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureReqMmapBuffer(handle, reqSize, &desc)); + hwCapture->devDataHandle = devDataHandle; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureReqMmapBufferWhenDevDataHandleIsError, TestSize.Level1) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + AudioHandle handle = (AudioHandle)hwCapture; + struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle; + struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); + hwCapture->devDataHandle = (struct DevHandleCapture *)service; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureReqMmapBuffer(handle, reqSize, &desc)); + hwCapture->devDataHandle = devDataHandle; + delete(service); + service = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureReqMmapBufferWhenFormatIsError, TestSize.Level1) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + hwCapture->captureParam.frameCaptureMode.attrs.format = AUDIO_FORMAT_G711A; + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureReqMmapBuffer(handle, reqSize, &desc)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureReqMmapBufferWhenReqSizeOverThanFileSize, TestSize.Level1) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t reqSize = 1024; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureReqMmapBuffer(handle, reqSize, &desc)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetExtraParamsWhenHandleIsNull, TestSize.Level1) +{ + char keyValueList[PARAMS_LEN] = {0}; + int32_t listLenth = PARAMS_LEN; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetExtraParams(nullptr, keyValueList, listLenth)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetExtraParamsWhenKeyValueListIsNull, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + int32_t listLenth = PARAMS_LEN; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetExtraParams(handle, nullptr, listLenth)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetExtraParamsWhenListLenthIsZero, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + char keyValueList[PARAMS_LEN] = {0}; + int32_t listLenth = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetExtraParams(handle, keyValueList, listLenth)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetExtraParamsWhenListLenthLessThanBufferSize, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + char keyValueList[PARAMS_LEN] = {0}; + int32_t listLenth = 1; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetExtraParams(handle, keyValueList, listLenth)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetExtraParamsWhenParamIsValid, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + char keyValueList[PARAMS_LEN] = {0}; + int32_t listLenth = PARAMS_LEN; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetExtraParams(handle, keyValueList, listLenth)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetExtraParamsWhenHandleIsNull, TestSize.Level1) +{ + char keyValueList[PARAMS_LEN] = "attr-frame-count=4096;"; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetExtraParams(nullptr, keyValueList)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetExtraParamsWhenKeyValueListIsNull, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetExtraParams(handle, nullptr)); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetExtraParamsWhenParamIsValid, TestSize.Level1) +{ + AudioHandle handle = (AudioHandle)capture; + char keyValueList[PARAMS_LEN] = "attr-frame-count=4096;"; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetExtraParams(handle, keyValueList)); +} } diff --git a/audio/test/unittest/hdi/common/include/audio_common_test.h b/audio/test/unittest/hdi/passthrough/common/include/audio_common_test.h similarity index 95% rename from audio/test/unittest/hdi/common/include/audio_common_test.h rename to audio/test/unittest/hdi/passthrough/common/include/audio_common_test.h index 77da566c35..4a2e947af0 100644 --- a/audio/test/unittest/hdi/common/include/audio_common_test.h +++ b/audio/test/unittest/hdi/passthrough/common/include/audio_common_test.h @@ -30,6 +30,9 @@ const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096; const int INT_32_MAX = 0x7fffffff; const int DEFAULT_RENDER_SAMPLING_RATE = 48000; const int DEEP_BUFFER_RENDER_PERIOD_COUNT = 8; +const int PARAMS_LEN = 256; +const int PARAMS_ERR = 10; +const int REQ_SIZE = 1024; int32_t InitPort(struct AudioPort &portIndex); int32_t InitHwRender(struct AudioHwRender &hwRender, diff --git a/audio/test/unittest/hdi/common/src/audio_common_test.cpp b/audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp similarity index 100% rename from audio/test/unittest/hdi/common/src/audio_common_test.cpp rename to audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp diff --git a/audio/test/unittest/hdi/manager/BUILD.gn b/audio/test/unittest/hdi/passthrough/manager/BUILD.gn similarity index 78% rename from audio/test/unittest/hdi/manager/BUILD.gn rename to audio/test/unittest/hdi/passthrough/manager/BUILD.gn index 367c6cd795..6e1dc0f7b5 100644 --- a/audio/test/unittest/hdi/manager/BUILD.gn +++ b/audio/test/unittest/hdi/passthrough/manager/BUILD.gn @@ -24,10 +24,9 @@ if (defined(ohos_lite)) { ###########################LITEOS########################### ###########################hdf_audio_hdi_manager_test########################### unittest("hdf_audio_hdi_manager_test") { - sources = [ "//drivers/peripheral/audio/test/unittest/hdi/manager/src/audio_manager_test.cpp" ] + sources = [ "//drivers/peripheral/audio/test/unittest/hdi/passthrough/manager/src/audio_manager_test.cpp" ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/manager/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -50,28 +49,14 @@ if (defined(ohos_lite)) { "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", ] - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - "-std=c++11", - ] } } else { - ###########################unittest########################### - module_output_path = "hdf/audio" - ###########################hdf_audio_hdi_manager_test########################### ohos_unittest("hdf_audio_hdi_manager_test") { - module_out_path = module_output_path - sources = [ "//drivers/peripheral/audio/test/unittest/hdi/manager/src/audio_manager_test.cpp" ] + module_out_path = "hdf/audio" + sources = [ "//drivers/peripheral/audio/test/unittest/hdi/passthrough/manager/src/audio_manager_test.cpp" ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/manager/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -86,18 +71,12 @@ if (defined(ohos_lite)) { ] if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] - external_deps = [ "hdf_core:libhdf_utils" ] + external_deps = [ + "hdf_core:libhdf_utils", + "utils_base:utils", + ] } else { deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] } } diff --git a/audio/test/unittest/hdi/manager/src/audio_manager_test.cpp b/audio/test/unittest/hdi/passthrough/manager/src/audio_manager_test.cpp similarity index 94% rename from audio/test/unittest/hdi/manager/src/audio_manager_test.cpp rename to audio/test/unittest/hdi/passthrough/manager/src/audio_manager_test.cpp index be44b76df7..1cee85e663 100644 --- a/audio/test/unittest/hdi/manager/src/audio_manager_test.cpp +++ b/audio/test/unittest/hdi/passthrough/manager/src/audio_manager_test.cpp @@ -13,7 +13,6 @@ * limitations under the License. */ -#include "audio_manager_test.h" #include #include #include "audio_internal.h" @@ -62,7 +61,7 @@ HWTEST_F(AudioManagerTest, AudioManagerGetAllAdaptersWhenSizeIsNull, TestSize.Le EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); } -HWTEST_F(AudioManagerTest, AudioManagerGetAllAdaptersWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioManagerTest, AudioManagerGetAllAdaptersWhenParamIsValid, TestSize.Level1) { struct AudioManager *managerFuncs = GetAudioManagerFuncs(); int32_t size = 0; @@ -122,13 +121,18 @@ HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenDescIsError, TestSize.Leve struct AudioAdapterDescriptor *descs; ret = managerFuncs->GetAllAdapters(managerFuncs, &descs, &size); ASSERT_EQ(HDF_SUCCESS, ret); - - struct AudioAdapterDescriptor *desc = &descs[size]; - static struct AudioAdapter *adapter; + struct AudioAdapterDescriptor *desc = new AudioAdapterDescriptor; + struct AudioPort ports; + desc->adapterName = " "; + desc->ports = &ports; + desc->portNum = 1; + struct AudioAdapter *adapter; ret = managerFuncs->LoadAdapter(managerFuncs, desc, &adapter); EXPECT_EQ(AUDIO_HAL_ERR_INVALID_OBJECT, ret); managerFuncs->UnloadAdapter(managerFuncs, adapter); adapter = nullptr; + delete desc; + desc = nullptr; } HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenAdapterNameIsError, TestSize.Level1) @@ -150,7 +154,7 @@ HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenAdapterNameIsError, TestSi adapter = nullptr; } -HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenParamIsValid, TestSize.Level1) { int32_t ret; struct AudioManager *managerFuncs = GetAudioManagerFuncs(); diff --git a/audio/test/unittest/hdi/render/BUILD.gn b/audio/test/unittest/hdi/passthrough/render/BUILD.gn similarity index 73% rename from audio/test/unittest/hdi/render/BUILD.gn rename to audio/test/unittest/hdi/passthrough/render/BUILD.gn index 3d0da1ece6..b4f5d75a0f 100644 --- a/audio/test/unittest/hdi/render/BUILD.gn +++ b/audio/test/unittest/hdi/passthrough/render/BUILD.gn @@ -25,13 +25,12 @@ if (defined(ohos_lite)) { ###########################hdf_audio_hdi_render_test########################### unittest("hdf_audio_hdi_render_test") { sources = [ - "//drivers/peripheral/audio/test/unittest/hdi/common/src/audio_common_test.cpp", - "//drivers/peripheral/audio/test/unittest/hdi/render/src/audio_render_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/render/src/audio_render_test.cpp", ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/render/include", - "//drivers/peripheral/audio/test/unittest/hdi/common/include", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -54,32 +53,18 @@ if (defined(ohos_lite)) { "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", ] - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - "-std=c++11", - ] } } else { - ###########################unittest########################### - module_output_path = "hdf/audio" - ###########################hdf_audio_hdi_render_test########################### ohos_unittest("hdf_audio_hdi_render_test") { - module_out_path = module_output_path + module_out_path = "hdf/audio" sources = [ - "//drivers/peripheral/audio/test/unittest/hdi/common/src/audio_common_test.cpp", - "//drivers/peripheral/audio/test/unittest/hdi/render/src/audio_render_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/src/audio_common_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/render/src/audio_render_test.cpp", ] include_dirs = [ - "//drivers/peripheral/audio/test/unittest/hdi/render/include", - "//drivers/peripheral/audio/test/unittest/hdi/common/include", + "//drivers/peripheral/audio/test/unittest/hdi/passthrough/common/include", "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -92,19 +77,19 @@ if (defined(ohos_lite)) { "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", ] + + if (drivers_peripheral_audio_alsa_lib) { + defines = [ "ALSA_LIB_MODE" ] + } + if (!drivers_peripheral_audio_user_mode) { deps += [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio" ] - external_deps = [ "hdf_core:libhdf_utils" ] + external_deps = [ + "hdf_core:libhdf_utils", + "utils_base:utils", + ] } else { deps += [ "//device/soc/${product_company}/common/hal/media:hdi_audio" ] } - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] } } diff --git a/audio/test/unittest/hdi/render/src/audio_render_test.cpp b/audio/test/unittest/hdi/passthrough/render/src/audio_render_test.cpp similarity index 81% rename from audio/test/unittest/hdi/render/src/audio_render_test.cpp rename to audio/test/unittest/hdi/passthrough/render/src/audio_render_test.cpp index 3556c9aed1..1e8bd76b38 100644 --- a/audio/test/unittest/hdi/render/src/audio_render_test.cpp +++ b/audio/test/unittest/hdi/passthrough/render/src/audio_render_test.cpp @@ -13,7 +13,6 @@ * limitations under the License. */ -#include "audio_render_test.h" #include #include #include "audio_common_test.h" @@ -99,7 +98,7 @@ HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenChannelCountIsZero, TestSize.Level frameRenderMode = nullptr; } -HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenParamIsValid, TestSize.Level1) { struct AudioFrameRenderMode *frameRenderMode = new struct AudioFrameRenderMode; frameRenderMode->attrs.format = AUDIO_FORMAT_PCM_8_BIT; @@ -142,6 +141,7 @@ HWTEST_F(AudioRenderTest, AudioRenderStartWhenDevDataHandleIsError, TestSize.Lev struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devDataHandle = hwRender->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devDataHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderStart(handle)); @@ -150,7 +150,7 @@ HWTEST_F(AudioRenderTest, AudioRenderStartWhenDevDataHandleIsError, TestSize.Lev service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderStartWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderStartWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle)); @@ -190,6 +190,7 @@ HWTEST_F(AudioRenderTest, AudioRenderStopWhenDevDataHandleIsError, TestSize.Leve ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle)); struct DevHandle *devDataHandle = hwRender->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devDataHandle = (struct DevHandle *)service; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderStop(handle)); hwRender->devDataHandle = devDataHandle; @@ -197,7 +198,7 @@ HWTEST_F(AudioRenderTest, AudioRenderStopWhenDevDataHandleIsError, TestSize.Leve service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderStopWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderStopWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle)); @@ -246,6 +247,7 @@ HWTEST_F(AudioRenderTest, AudioRenderPauseWhenDevDataHandleIsError, TestSize.Lev ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle)); struct DevHandle *devDataHandle = hwRender->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devDataHandle = (struct DevHandle *)service; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderPause(handle)); hwRender->devDataHandle = devDataHandle; @@ -253,7 +255,7 @@ HWTEST_F(AudioRenderTest, AudioRenderPauseWhenDevDataHandleIsError, TestSize.Lev service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderPauseWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderPauseWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle)); @@ -297,6 +299,7 @@ HWTEST_F(AudioRenderTest, AudioRenderResumeWhenDevDataHandleIsError, TestSize.Le ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderPause(handle)); struct DevHandle *devDataHandle = hwRender->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devDataHandle = (struct DevHandle *)service; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderResume(handle)); hwRender->devDataHandle = devDataHandle; @@ -304,7 +307,7 @@ HWTEST_F(AudioRenderTest, AudioRenderResumeWhenDevDataHandleIsError, TestSize.Le service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderResumeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderResumeWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle)); @@ -319,13 +322,9 @@ HWTEST_F(AudioRenderTest, AudioRenderFlushWhenHandleIsNull, TestSize.Level1) EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderFlush(handle)); } -HWTEST_F(AudioRenderTest, AudioRenderFlushWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderFlushWhenParamIsValid, TestSize.Level1) { - AudioHwRender *hwRender = new AudioHwRender; - AudioHandle handle = (AudioHandle)hwRender; - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderFlush(handle)); - delete(hwRender); - hwRender = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioRenderFlush(render)); } HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenHandleIsNull, TestSize.Level1) @@ -352,7 +351,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenParamIsNotSupport, TestSize EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderGetFrameSize(handle, &frameSize)); } -HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; uint64_t frameSize = FRAME_DATA; @@ -374,7 +373,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenCountIsNull, TestSize.Leve EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetFrameCount(handle, count)); } -HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; uint64_t count = FRAME_DATA; @@ -419,6 +418,7 @@ HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenDevDataHandleIsError struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devDataHandle = hwRender->devDataHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devDataHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetSampleAttributes(handle, &attrs)); @@ -427,7 +427,7 @@ HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenDevDataHandleIsError service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetSampleAttributes(handle, &attrs)); @@ -447,7 +447,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenAttrsIsNull, TestSiz EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetSampleAttributes(handle, nullptr)); } -HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; EXPECT_EQ(HDF_SUCCESS, AudioRenderGetSampleAttributes(handle, &attrs)); @@ -469,7 +469,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenChannelIdIsNull, Tes EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetCurrentChannelId(handle, channelId)); } -HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; uint32_t channelId = 1; @@ -519,7 +519,7 @@ HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenPinsIsError, TestSi } } -HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; struct AudioSceneDescriptor scene; @@ -568,6 +568,7 @@ HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenDevCtlHandleIsError, TestSiz struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; struct AudioSceneDescriptor scene; @@ -583,7 +584,7 @@ HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenDevCtlHandleIsError, TestSiz service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; struct AudioSceneDescriptor scene; @@ -620,20 +621,27 @@ HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenDevCtlHandleIsError, TestSize.Le AudioHwRender *hwRender = (AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; bool mute = true; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetMute(handle, mute)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetMute(handle, mute)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; bool mute = true; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetMute(handle, mute)); + mute = false; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetMute(handle, mute)); } HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenHandleIsNull, TestSize.Level1) @@ -667,16 +675,21 @@ HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenDevCtlHandleIsError, TestSize.Le AudioHwRender *hwRender = (AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; bool mute = true; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetMute(handle, &mute)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetMute(handle, &mute)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; bool mute = false; @@ -724,19 +737,24 @@ HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenDevCtlHandleIsError, TestSize. AudioHwRender *hwRender = (AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; - float volume = 0; + float volume = 1.0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetVolume(handle, volume)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetVolume(handle, volume)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; - float volume = 0; + float volume = 0.8; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetVolume(handle, volume)); } @@ -771,10 +789,15 @@ HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenDevCtlHandleIsError, TestSize. AudioHwRender *hwRender = (AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; - float volume = 0; + float volume = 1.0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetVolume(handle, &volume)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetVolume(handle, &volume)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; @@ -790,7 +813,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenVolumeIsError, TestSize.Level1 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetVolume(handle, &volume)); } -HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; float volume = 0; @@ -839,17 +862,22 @@ HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenDevCtlHandleIsError, Te AudioHwRender *hwRender = (AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; float min = GAIN_MIN; float max = GAIN_MAX; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetGainThreshold(handle, &min, &max)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetGainThreshold(handle, &min, &max)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; float min = GAIN_MIN; @@ -888,16 +916,21 @@ HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenDevCtlHandleIsError, TestSize.Le struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; float gain = 0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetGain(handle, &gain)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetGain(handle, &gain)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; float gain = 0; @@ -935,16 +968,21 @@ HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenDevCtlHandleIsError, TestSize.Le struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; AudioHandle handle = (AudioHandle)hwRender; float gain = 0; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetGain(handle, gain)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetGain(handle, gain)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenParamValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; float gain = 0; @@ -972,7 +1010,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenByteRateIsZero, TestSize.Leve EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetLatency((struct AudioRender *)hwRender, &ms)); } -HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenParamVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenParamValid, TestSize.Level1) { uint32_t ms = 96; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetLatency(render, &ms)); @@ -1071,7 +1109,7 @@ HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenSampleRateIsZero, TestSize.L frame = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenParamIsValid, TestSize.Level1) { ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart((AudioHandle)render)); void *frame = (void *)calloc(1, FRAME_DATA); @@ -1109,7 +1147,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenTimeIsNull, TestSize.L EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetRenderPosition(render, &frames, time)); } -HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenParamIsValid, TestSize.Level1) { uint64_t frames = 1024; struct AudioTimeStamp *time = new AudioTimeStamp; @@ -1125,7 +1163,7 @@ HWTEST_F(AudioRenderTest, AudioRenderSetRenderSpeedWhenRenderIsNull, TestSize.Le EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetRenderSpeed(utRender, speed)); } -HWTEST_F(AudioRenderTest, AudioRenderSetRenderSpeedWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderSetRenderSpeedWhenParamIsValid, TestSize.Level1) { float speed = 1.0; EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderSetRenderSpeed(render, speed)); @@ -1144,7 +1182,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenSpeedIsNull, TestSize.Lev EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetRenderSpeed(render, speed)); } -HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenParamIsValid, TestSize.Level1) { float speed = 1.0; EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderGetRenderSpeed(render, &speed)); @@ -1153,7 +1191,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenParamIsVaild, TestSize.Le HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenRenderIsNull, TestSize.Level1) { struct AudioRender *utRender = nullptr; - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetChannelMode(utRender, mode)); } @@ -1162,7 +1200,7 @@ HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenDevCtlHandleIsNull, TestS struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; hwRender->devCtlHandle = nullptr; - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetChannelMode((struct AudioRender *)hwRender, mode)); hwRender->devCtlHandle = devCtlHandle; } @@ -1172,30 +1210,35 @@ HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenDevCtlHandleIsError, Test struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetChannelMode((struct AudioRender *)hwRender, mode)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetChannelMode((struct AudioRender *)hwRender, mode)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenParamIsValid, TestSize.Level1) { - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetChannelMode(render, mode)); } HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenRenderIsNull, TestSize.Level1) { struct AudioRender *utRender = nullptr; - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetChannelMode(utRender, &mode)); } HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenModeIsNull, TestSize.Level1) { - enum AudioChannelMode *mode = nullptr; + AudioChannelMode *mode = nullptr; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetChannelMode(render, mode)); } @@ -1204,7 +1247,7 @@ HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenDevCtlHandleIsNull, TestS struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; hwRender->devCtlHandle = nullptr; - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetChannelMode((struct AudioRender *)hwRender, &mode)); hwRender->devCtlHandle = devCtlHandle; } @@ -1214,17 +1257,22 @@ HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenDevCtlHandleIsError, Test struct AudioHwRender *hwRender = (struct AudioHwRender *)render; struct DevHandle *devCtlHandle = hwRender->devCtlHandle; struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); hwRender->devCtlHandle = (struct DevHandle *)service; - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; +#ifdef ALSA_LIB_MODE + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetChannelMode((struct AudioRender *)hwRender, &mode)); +#else EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetChannelMode((struct AudioRender *)hwRender, &mode)); +#endif hwRender->devCtlHandle = devCtlHandle; delete(service); service = nullptr; } -HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenParamIsValid, TestSize.Level1) { - enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetChannelMode(render, &mode)); } @@ -1255,7 +1303,7 @@ HWTEST_F(AudioRenderTest, AudioRenderTurnStandbyModeWhenStopIsError, TestSize.Le EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderTurnStandbyMode(handle)); } -HWTEST_F(AudioRenderTest, AudioRenderTurnStandbyModeWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderTurnStandbyModeWhenParamIsValid, TestSize.Level1) { AudioHandle handle = (AudioHandle)render; EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle)); @@ -1270,7 +1318,7 @@ HWTEST_F(AudioRenderTest, AudioRenderRegCallbackWhenRenderIsNull, TestSize.Level EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderRegCallback(utRender, callback, cookie)); } -HWTEST_F(AudioRenderTest, AudioRenderRegCallbackWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, AudioRenderRegCallbackWhenParamIsValid, TestSize.Level1) { RenderCallback callback = AudioRenderCallbackUtTest; void *cookie = nullptr; @@ -1304,7 +1352,7 @@ HWTEST_F(AudioRenderTest, CallbackProcessingWhenCallbackIsError, TestSize.Level1 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, CallbackProcessing(handle, (enum AudioCallbackType)callBackType)); } -HWTEST_F(AudioRenderTest, CallbackProcessingWhenParamIsVaild, TestSize.Level1) +HWTEST_F(AudioRenderTest, CallbackProcessingWhenParamIsValid, TestSize.Level1) { RenderCallback callback = AudioRenderCallbackUtTest; void *cookie = nullptr; @@ -1313,4 +1361,150 @@ HWTEST_F(AudioRenderTest, CallbackProcessingWhenParamIsVaild, TestSize.Level1) AudioCallbackType callBackType = AUDIO_ERROR_OCCUR; EXPECT_EQ(HDF_SUCCESS, CallbackProcessing(handle, callBackType)); } + +HWTEST_F(AudioRenderTest, AudioRenderSetExtraParamsWhenRenderIsNull, TestSize.Level1) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000"; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetExtraParams(handle, keyValueList)); +} + +HWTEST_F(AudioRenderTest, AudioRenderSetExtraParamsWhenParamIsNull, TestSize.Level1) +{ + char *keyValueList = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetExtraParams(render, keyValueList)); +} + +HWTEST_F(AudioRenderTest, AudioRenderSetExtraParamsWhenParamIsError, TestSize.Level1) +{ + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\ +attr-frame-count=82;attr-sampling-rate=48000;attr-para=123"; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetExtraParams(render, keyValueList)); +} + +HWTEST_F(AudioRenderTest, AudioRenderSetExtraParamsWhenParamIsValid, TestSize.Level1) +{ + char keyValueListOne[] = "attr-frame-count=1024;"; + char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000"; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetExtraParams(render, keyValueListOne)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetExtraParams(render, keyValueListFour)); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetExtraParamsWhenRenderIsNull, TestSize.Level1) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + int32_t listLenth = PARAMS_LEN; + char keyValueListValue[PARAMS_LEN] = {}; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetExtraParams(handle, keyValueListValue, listLenth)); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetExtraParamsWhenParamIsNull, TestSize.Level1) +{ + int32_t listLenth = PARAMS_LEN; + char* keyValueListValue = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetExtraParams(render, keyValueListValue, listLenth)); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetExtraParamsWhenParamIsError0, TestSize.Level1) +{ + int32_t listLenth = 0; + char keyValueListValue[PARAMS_LEN] = {}; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetExtraParams(render, keyValueListValue, listLenth)); + listLenth = PARAMS_ERR; + EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetExtraParams(render, keyValueListValue, listLenth)); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetExtraParamsWhenParamIsValid, TestSize.Level1) +{ + int32_t listLenth = PARAMS_LEN; + char keyValueListValue[PARAMS_LEN] = {}; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetExtraParams(render, keyValueListValue, listLenth)); +} + +HWTEST_F(AudioRenderTest, AudioRenderReqMmapBufferWhenRenderIsNull, TestSize.Level1) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + int32_t reqSize = REQ_SIZE; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderReqMmapBuffer(handle, reqSize, &desc)); +} + +HWTEST_F(AudioRenderTest, AudioRenderReqMmapBufferWhenDevCtlHandleIsNull, TestSize.Level1) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct DevHandle *devDataHandle = hwRender->devDataHandle; + hwRender->devDataHandle = nullptr; + struct AudioMmapBufferDescripter desc; + int32_t reqSize = REQ_SIZE; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderReqMmapBuffer((struct AudioRender *)hwRender, reqSize, &desc)); + hwRender->devDataHandle = devDataHandle; +} + +HWTEST_F(AudioRenderTest, AudioRenderReqMmapBufferWhenDevCtlHandleIsError, TestSize.Level1) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct DevHandle *devDataHandle = hwRender->devDataHandle; + struct HdfIoService *service = new HdfIoService; + (void)memset_s(service, sizeof(struct HdfIoService), 0, sizeof(struct HdfIoService)); + hwRender->devDataHandle = (struct DevHandle *)service; + struct AudioMmapBufferDescripter desc; + int32_t reqSize = REQ_SIZE; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderReqMmapBuffer((struct AudioRender *)hwRender, reqSize, &desc)); + hwRender->devDataHandle = devDataHandle; + delete(service); + service = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderReqMmapBufferWhenDescIsNull, TestSize.Level1) +{ + struct AudioMmapBufferDescripter *desc = nullptr; + int32_t reqSize = REQ_SIZE; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderReqMmapBuffer(render, reqSize, desc)); +} + +HWTEST_F(AudioRenderTest, AudioRenderReqMmapBufferWhenFormatIsError, TestSize.Level1) +{ + struct AudioMmapBufferDescripter desc; + int32_t reqSize = REQ_SIZE; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + AudioFormat tempFormat = hwRender->renderParam.frameRenderMode.attrs.format; + hwRender->renderParam.frameRenderMode.attrs.format = AUDIO_FORMAT_G726; + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderReqMmapBuffer(render, reqSize, &desc)); + hwRender->renderParam.frameRenderMode.attrs.format = tempFormat; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetMmapPositionWhenRenderIsNull, TestSize.Level1) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + uint64_t frames = REQ_SIZE; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetMmapPosition(handle, &frames, &time)); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetMmapPositionWhenFramesIsNull, TestSize.Level1) +{ + uint64_t *frames = nullptr; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetMmapPosition(render, frames, &time)); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetMmapPositionWhenTimeIsNull, TestSize.Level1) +{ + uint64_t frames = REQ_SIZE; + struct AudioTimeStamp *time = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetMmapPosition(render, &frames, time)); +} + +HWTEST_F(AudioRenderTest, AudioRenderAudioDevDumpWhenRenderIsNull, TestSize.Level1) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + int32_t range = 0; + int32_t fd = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderAudioDevDump(handle, range, fd)); +} } diff --git a/audio/test/unittest/hdi/render/include/audio_render_test.h b/audio/test/unittest/hdi/render/include/audio_render_test.h deleted file mode 100644 index 2659307cea..0000000000 --- a/audio/test/unittest/hdi/render/include/audio_render_test.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (c) 2021 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_RENDER_TEST_H -#define AUDIO_RENDER_TEST_H - -#endif -- Gitee From cfe309ca975d2cc5aaa249ab76f3036369cf5393 Mon Sep 17 00:00:00 2001 From: jiachanglin Date: Mon, 1 Aug 2022 09:10:43 +0000 Subject: [PATCH 18/33] fix:Failed to resolve the HDI test case Signed-off-by: jiachanglin --- wlan/hdi_service/service_common/wlan_common_cmd.c | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/hdi_service/service_common/wlan_common_cmd.c b/wlan/hdi_service/service_common/wlan_common_cmd.c index 8fdb09b617..4aa453fd45 100644 --- a/wlan/hdi_service/service_common/wlan_common_cmd.c +++ b/wlan/hdi_service/service_common/wlan_common_cmd.c @@ -190,6 +190,7 @@ int32_t WlanInterfaceGetAsscociatedStas(struct IWlanInterface *self, const struc ret = HDF_FAILURE; break; } + staInfo[i].macLen = WIFI_MAC_ADDR_LENGTH; } } OsalMemFree(wifiStaInfo); -- Gitee From f43f44a7b7879d275b78463b5e75ee926a7b576c Mon Sep 17 00:00:00 2001 From: zenglifeng Date: Wed, 3 Aug 2022 10:04:10 +0800 Subject: [PATCH 19/33] feat:audio ut part2 Signed-off-by: zenglifeng --- .../proxy/include/audio_proxy_common.h | 6 + .../proxy/include/audio_proxy_internal.h | 7 +- audio/test/unittest/hdi/client/BUILD.gn | 29 + .../test/unittest/hdi/client/adapter/BUILD.gn | 50 ++ .../test/unittest/hdi/client/capture/BUILD.gn | 50 ++ .../capture/src/audio_proxy_capture_test.cpp | 652 +++++++++++++++ .../test/unittest/hdi/client/render/BUILD.gn | 50 ++ .../render/src/audio_proxy_render_test.cpp | 742 ++++++++++++++++++ 8 files changed, 1585 insertions(+), 1 deletion(-) create mode 100644 audio/test/unittest/hdi/client/BUILD.gn create mode 100644 audio/test/unittest/hdi/client/adapter/BUILD.gn create mode 100644 audio/test/unittest/hdi/client/capture/BUILD.gn create mode 100644 audio/test/unittest/hdi/client/capture/src/audio_proxy_capture_test.cpp create mode 100644 audio/test/unittest/hdi/client/render/BUILD.gn create mode 100644 audio/test/unittest/hdi/client/render/src/audio_proxy_render_test.cpp diff --git a/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h b/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h index a2e69537b8..38fcbb1dd5 100644 --- a/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h @@ -23,6 +23,9 @@ #define GAIN_MAX 50.0 #define STR_MAX 512 +#ifdef __cplusplus +extern "C" { +#endif struct HdfSBuf *AudioProxyObtainHdfSBuf(void); void AudioProxyBufReplyRecycle(struct HdfSBuf *data, struct HdfSBuf *reply); int32_t AudioProxyPreprocessSBuf(struct HdfSBuf **data, struct HdfSBuf **reply); @@ -45,4 +48,7 @@ int32_t AudioProxyRenderAddEffect(AudioHandle handle, uint64_t effectid); int32_t AudioProxyRenderRemoveEffect(AudioHandle handle, uint64_t effectid); int32_t AudioProxyCaptureAddEffect(AudioHandle handle, uint64_t effectid); int32_t AudioProxyCaptureRemoveEffect(AudioHandle handle, uint64_t effectid); +#ifdef __cplusplus +} +#endif #endif diff --git a/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h b/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h index 6e9d27024f..80cc33c03c 100644 --- a/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h @@ -18,6 +18,9 @@ #include "audio_adapter.h" +#ifdef __cplusplus +extern "C" { +#endif int32_t AudioProxyAdapterInitAllPorts(struct AudioAdapter *adapter); int32_t AudioProxyAdapterCreateRender(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, @@ -114,5 +117,7 @@ int32_t AudioProxyCaptureAudioDevDump(AudioHandle capture, int32_t range, int32_ int32_t AudioProxyAdapterSetMicMute(struct AudioAdapter *adapter, bool mute); int32_t AudioProxyAdapterGetMicMute(struct AudioAdapter *adapter, bool *mute); int32_t AudioProxyAdapterSetVoiceVolume(struct AudioAdapter *adapter, float volume); - +#ifdef __cplusplus +} +#endif #endif diff --git a/audio/test/unittest/hdi/client/BUILD.gn b/audio/test/unittest/hdi/client/BUILD.gn new file mode 100644 index 0000000000..f045b0d50e --- /dev/null +++ b/audio/test/unittest/hdi/client/BUILD.gn @@ -0,0 +1,29 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +group("hdi_client") { + if (!defined(ohos_lite) && !drivers_peripheral_audio_user_mode) { + testonly = true + deps = [ + "adapter:hdf_audio_proxy_adapter_test", + "capture:hdf_audio_proxy_capture_test", + "common:hdf_audio_proxy_common_test", + "manager:hdf_audio_proxy_manager_test", + "render:hdf_audio_proxy_render_test", + ] + } +} diff --git a/audio/test/unittest/hdi/client/adapter/BUILD.gn b/audio/test/unittest/hdi/client/adapter/BUILD.gn new file mode 100644 index 0000000000..b604974c7e --- /dev/null +++ b/audio/test/unittest/hdi/client/adapter/BUILD.gn @@ -0,0 +1,50 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +ohos_unittest("hdf_audio_proxy_adapter_test") { + module_out_path = "hdf/audio" + sources = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/adapter/src/audio_proxy_adapter_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp", + ] + + include_dirs = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/common/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "//drivers/hdf_core/adapter/uhdf2/include/hdi", + "//drivers/hdf_core/adapter/uhdf2/shared/include", + "//third_party/googletest/googletest/include/gtest", + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_binder/proxy:hdi_audio_client", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio_common", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "utils_base:utils", + ] +} diff --git a/audio/test/unittest/hdi/client/capture/BUILD.gn b/audio/test/unittest/hdi/client/capture/BUILD.gn new file mode 100644 index 0000000000..02026ff314 --- /dev/null +++ b/audio/test/unittest/hdi/client/capture/BUILD.gn @@ -0,0 +1,50 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +ohos_unittest("hdf_audio_proxy_capture_test") { + module_out_path = "hdf/audio" + sources = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/capture/src/audio_proxy_capture_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp", + ] + + include_dirs = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/common/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//third_party/googletest/googletest/include/gtest", + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_binder/proxy:hdi_audio_client", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio_common", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "utils_base:utils", + ] +} diff --git a/audio/test/unittest/hdi/client/capture/src/audio_proxy_capture_test.cpp b/audio/test/unittest/hdi/client/capture/src/audio_proxy_capture_test.cpp new file mode 100644 index 0000000000..b48fc0b370 --- /dev/null +++ b/audio/test/unittest/hdi/client/capture/src/audio_proxy_capture_test.cpp @@ -0,0 +1,652 @@ +/* + * Copyright (c) 2022 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 +#include +#include "audio_proxy_common_fun_test.h" + +using namespace comfun; +using namespace testing::ext; +namespace { +class AudioProxyCaptureTest : public testing::Test { +public: + struct AudioManager *managerFuncs = nullptr; + struct AudioManager *(*getAudioManager)(void) = NULL; + struct AudioAdapterDescriptor *descs = nullptr; + struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioPort *audioPort = nullptr; + void *clientHandle = nullptr; + struct AudioDeviceDescriptor devDescCapture = {}; + struct AudioSampleAttributes attrsCapture = {}; + virtual void SetUp(); + virtual void TearDown(); +}; + +void AudioProxyCaptureTest::SetUp() +{ + clientHandle = GetDynamicLibHandle(RESOLVED_PATH); + ASSERT_NE(clientHandle, nullptr); + getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str())); + ASSERT_NE(getAudioManager, nullptr); + managerFuncs = getAudioManager(); + ASSERT_NE(managerFuncs, nullptr); + int32_t size = 0; + ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size)); + + desc = &descs[0]; + ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter)); + ASSERT_NE(adapter, nullptr); + ASSERT_EQ(HDF_SUCCESS, InitDevDescCapture(devDescCapture)); + ASSERT_EQ(HDF_SUCCESS, InitAttrsCapture(attrsCapture)); + ASSERT_EQ(HDF_SUCCESS, adapter->CreateCapture(adapter, &devDescCapture, &attrsCapture, &capture)); +} + +void AudioProxyCaptureTest::TearDown() +{ + if (adapter != nullptr) { + adapter->DestroyCapture(adapter, capture); + capture = nullptr; + } + if (managerFuncs != nullptr) { + managerFuncs->UnloadAdapter(managerFuncs, adapter); + adapter = nullptr; + managerFuncs->ReleaseAudioManagerObject(managerFuncs); + managerFuncs = nullptr; + } + if (clientHandle != nullptr) { + dlclose(clientHandle); + clientHandle = nullptr; + } +} + +HWTEST_F(AudioProxyCaptureTest, CaptureStart_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStart(nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureStart_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStart((AudioHandle)capture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureStart_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStart((AudioHandle)capture)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStop((AudioHandle)capture)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureStop_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStop(nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureStop_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStop((AudioHandle)capture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CapturePause_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCapturePause(nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CapturePause_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCapturePause((AudioHandle)capture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureResume_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureResume(nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureResume_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureResume((AudioHandle)capture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureFlush_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureFlush(nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureFlush_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyCaptureFlush((AudioHandle)capture)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameSize_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + uint64_t size = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameSize(nullptr, &size)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameSize((AudioHandle)capture, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameSize_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + uint64_t size = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameSize((AudioHandle)capture, &size)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameSize_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + uint64_t size = 0; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureGetFrameSize((AudioHandle)capture, &size)); + EXPECT_NE(size, 0); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameCount_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + uint64_t count = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameCount(nullptr, &count)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameCount((AudioHandle)capture, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameCount_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + uint64_t count = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameCount((AudioHandle)capture, &count)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetSampleAttributes_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetSampleAttributes(nullptr, &attrsCapture)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetSampleAttributes_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetSampleAttributes((AudioHandle)capture, &attrsCapture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetSampleAttributes_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetSampleAttributes(nullptr, &attrsCapture)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetSampleAttributes_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetSampleAttributes((AudioHandle)capture, &attrsCapture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetCurrentChannelId_001, TestSize.Level1) +{ + uint32_t channelId = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCurrentChannelId(nullptr, &channelId)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCurrentChannelId((AudioHandle)capture, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetCurrentChannelId_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + uint32_t channelId = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCurrentChannelId((AudioHandle)capture, &channelId)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureCheckSceneCapability_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioSceneDescriptor scene; + bool supported = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability(nullptr, &scene, &supported)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability((AudioHandle)capture, nullptr, + &supported)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability((AudioHandle)capture, &scene, + nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureCheckSceneCapability_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + struct AudioSceneDescriptor scene; + bool supported = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability((AudioHandle)capture, &scene, + &supported)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSelectScene_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioSceneDescriptor scene; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSelectScene(nullptr, &scene)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSelectScene((AudioHandle)capture, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSelectScene_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + struct AudioSceneDescriptor scene; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSelectScene((AudioHandle)capture, &scene)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSelectScene_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioSceneDescriptor *scene = new AudioSceneDescriptor; + scene->scene.id = 0; // 0 is Media + scene->desc.pins = PIN_IN_HS_MIC; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSelectScene((AudioHandle)capture, scene)); + scene->desc.pins = PIN_IN_MIC; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSelectScene((AudioHandle)capture, scene)); + delete scene; + scene = nullptr; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetMute_001, TestSize.Level1) +{ + bool mute = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetMute(nullptr, mute)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetMute_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + bool mute = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetMute((AudioHandle)capture, mute)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetMute_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + bool mute; + mute = true; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSetMute((AudioHandle)capture, mute)); + mute = false; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSetMute((AudioHandle)capture, mute)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetMute_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + bool mute = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMute(nullptr, &mute)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMute((AudioHandle)capture, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetMute_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + bool mute = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMute((AudioHandle)capture, &mute)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetMute_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + bool mute = false; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureGetMute((AudioHandle)capture, &mute)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_001, TestSize.Level1) +{ + float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume(nullptr, volume)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume((AudioHandle)capture, volume)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + float volume = MIN_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1] + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume((AudioHandle)capture, volume)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_004, TestSize.Level1) +{ + float volume = MAX_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1] + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume((AudioHandle)capture, volume)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetVolume_001, TestSize.Level1) +{ + float volume = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetVolume(nullptr, &volume)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetVolume_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + float volume = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetVolume((AudioHandle)capture, &volume)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetVolume_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + float volume = 0; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureGetVolume((AudioHandle)capture, &volume)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetGainThreshold_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + float min = 0; + float max = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold(nullptr, &min, &max)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold((AudioHandle)capture, nullptr, &max)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold((AudioHandle)capture, &min, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetGainThreshold_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + float min = 0; + float max = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold((AudioHandle)capture, &min, &max)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetGain_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + float gain = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGain(nullptr, &gain)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGain((AudioHandle)capture, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetGain_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + float gain = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGain((AudioHandle)capture, &gain)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetGain_001, TestSize.Level1) +{ + float gain = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetGain(nullptr, gain)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetGain_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + float gain = HALF_OF_NORMAL_VALUE; // The parameter is adjusted to half the threshold of 1 + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetGain((AudioHandle)capture, gain)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetGain_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + float gain = MIN_VALUE_OUT_OF_BOUNDS; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetGain((AudioHandle)capture, gain)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureFrame_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + int8_t frame[AUDIO_CAPTURE_BUF_TEST]; + uint64_t frameLen = AUDIO_CAPTURE_BUF_TEST; + uint64_t requestBytes = AUDIO_CAPTURE_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(nullptr, &frame, frameLen, &requestBytes)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(capture, nullptr, frameLen, &requestBytes)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(capture, &frame, frameLen, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureFrame_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + int8_t frame[AUDIO_CAPTURE_BUF_TEST]; + uint64_t frameLen = AUDIO_CAPTURE_BUF_TEST; + uint64_t requestBytes = AUDIO_CAPTURE_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(capture, &frame, frameLen, &requestBytes)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureFrame_003, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + int8_t frame[AUDIO_CAPTURE_BUF_TEST ]; + uint64_t frameLen = AUDIO_CAPTURE_BUF_TEST; + uint64_t requestBytes = AUDIO_CAPTURE_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStart((AudioHandle)capture)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureCaptureFrame(capture, &frame, frameLen, &requestBytes)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStop((AudioHandle)capture)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetCapturePosition_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + uint64_t frames; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(nullptr, &frames, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(capture, nullptr, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(capture, &frames, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetCapturePosition_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + uint64_t frames; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(capture, &frames, &time)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetExtraParams_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + char keyValueList[AUDIO_CAPTURE_BUF_TEST]; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetExtraParams(nullptr, keyValueList)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetExtraParams((AudioHandle)capture, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureSetExtraParams_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + char keyValueList[AUDIO_CAPTURE_BUF_TEST]; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetExtraParams((AudioHandle)capture, keyValueList)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetExtraParams_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + char keyValueList[AUDIO_CAPTURE_BUF_TEST]; + int32_t listLenth = AUDIO_CAPTURE_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams(nullptr, keyValueList, listLenth)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams((AudioHandle)capture, nullptr, listLenth)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams((AudioHandle)capture, keyValueList, 0)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetExtraParams_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + char keyValueList[AUDIO_CAPTURE_BUF_TEST]; + int32_t listLenth = AUDIO_CAPTURE_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams((AudioHandle)capture, keyValueList, + listLenth)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureReqMmapBuffer_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureReqMmapBuffer(nullptr, reqSize, &desc)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureReqMmapBuffer((AudioHandle)capture, reqSize, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureReqMmapBuffer_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureReqMmapBuffer((AudioHandle)capture, reqSize, &desc)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetMmapPosition_001, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + uint64_t frames; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition(nullptr, &frames, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition((AudioHandle)capture, nullptr, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition((AudioHandle)capture, &frames, nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureGetMmapPosition_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + uint64_t frames; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition((AudioHandle)capture, &frames, &time)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureTurnStandbyMode_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureTurnStandbyMode(nullptr)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureTurnStandbyMode_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureTurnStandbyMode((AudioHandle)capture)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyCaptureTest, CaptureAudioDevDump_001, TestSize.Level1) +{ + int32_t range = 0; + int32_t fd = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureAudioDevDump(nullptr, range, fd)); +} + +HWTEST_F(AudioProxyCaptureTest, CaptureAudioDevDump_002, TestSize.Level1) +{ + ASSERT_NE(capture, nullptr); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle; + hwCapture->proxyRemoteHandle = nullptr; + int32_t range = 0; + int32_t fd = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureAudioDevDump((AudioHandle)capture, range, fd)); + hwCapture->proxyRemoteHandle = proxyRemoteHandle; +} +} diff --git a/audio/test/unittest/hdi/client/render/BUILD.gn b/audio/test/unittest/hdi/client/render/BUILD.gn new file mode 100644 index 0000000000..6904074468 --- /dev/null +++ b/audio/test/unittest/hdi/client/render/BUILD.gn @@ -0,0 +1,50 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +ohos_unittest("hdf_audio_proxy_render_test") { + module_out_path = "hdf/audio" + sources = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/common/src/audio_proxy_common_fun_test.cpp", + "//drivers/peripheral/audio/test/unittest/hdi/client/render/src/audio_proxy_render_test.cpp", + ] + + include_dirs = [ + "//drivers/peripheral/audio/test/unittest/hdi/client/common/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "//drivers/hdf_core/adapter/uhdf2/include/hdi", + "//drivers/hdf_core/adapter/uhdf2/shared/include", + "//third_party/googletest/googletest/include/gtest", + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_binder/proxy:hdi_audio_client", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio_common", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "utils_base:utils", + ] +} diff --git a/audio/test/unittest/hdi/client/render/src/audio_proxy_render_test.cpp b/audio/test/unittest/hdi/client/render/src/audio_proxy_render_test.cpp new file mode 100644 index 0000000000..e991150ad2 --- /dev/null +++ b/audio/test/unittest/hdi/client/render/src/audio_proxy_render_test.cpp @@ -0,0 +1,742 @@ +/* + * Copyright (c) 2022 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 +#include +#include "audio_proxy_common_fun_test.h" + +using namespace std; +using namespace comfun; +using namespace testing::ext; +namespace { +class AudioProxyRenderTest : public testing::Test { +public: + struct AudioManager *managerFuncs = nullptr; + struct AudioManager *(*getAudioManager)(void) = NULL; + struct AudioAdapterDescriptor *descs = nullptr; + struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + void *clientHandle = nullptr; + struct AudioDeviceDescriptor devDescRender = {}; + struct AudioSampleAttributes attrsRender = {}; + virtual void SetUp(); + virtual void TearDown(); +}; + +void AudioProxyRenderTest::SetUp() +{ + clientHandle = GetDynamicLibHandle(RESOLVED_PATH); + ASSERT_NE(clientHandle, nullptr); + getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str())); + ASSERT_NE(getAudioManager, nullptr); + managerFuncs = getAudioManager(); + ASSERT_NE(managerFuncs, nullptr); + int32_t size = 0; + ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size)); + ASSERT_NE(descs, nullptr); + desc = &descs[0]; + ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter)); + ASSERT_NE(adapter, nullptr); + ASSERT_EQ(HDF_SUCCESS, InitDevDesc(devDescRender)); + ASSERT_EQ(HDF_SUCCESS, InitAttrs(attrsRender)); + ASSERT_EQ(HDF_SUCCESS, adapter->CreateRender(adapter, &devDescRender, &attrsRender, &render)); +} + +void AudioProxyRenderTest::TearDown() +{ + if (adapter != nullptr) { + adapter->DestroyRender(adapter, render); + render = nullptr; + } + if (managerFuncs != nullptr) { + managerFuncs->UnloadAdapter(managerFuncs, adapter); + adapter = nullptr; + managerFuncs->ReleaseAudioManagerObject(managerFuncs); + managerFuncs = nullptr; + } + if (clientHandle != nullptr) { + dlclose(clientHandle); + clientHandle = nullptr; + } +} + +HWTEST_F(AudioProxyRenderTest, RenderStart_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStart(nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderStart_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStart((AudioHandle)render)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderStart_003, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStart((AudioHandle)render)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStop((AudioHandle)render)); +} + +HWTEST_F(AudioProxyRenderTest, RenderStop_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStop(nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderStop_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStop((AudioHandle)render)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderPause_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderPause(nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderPause_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderPause((AudioHandle)render)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderResume_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderResume(nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderResume_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderResume((AudioHandle)render)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderFlush_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderFlush(nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderFlush_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyRenderFlush((AudioHandle)render)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetFrameSize_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t size = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameSize(nullptr, &size)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameSize((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetFrameSize_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t size = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameSize((AudioHandle)render, &size)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetFrameCount_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t count = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameCount(nullptr, &count)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameCount((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetFrameCount_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t count = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameCount((AudioHandle)render, &count)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSetSampleAttributes_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioSampleAttributes attrs; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetSampleAttributes(nullptr, &attrs)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetSampleAttributes((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetSampleAttributes_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioSampleAttributes attrs; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetSampleAttributes((AudioHandle)render, &attrs)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetSampleAttributes_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioSampleAttributes attrs; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetSampleAttributes(nullptr, &attrs)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetSampleAttributes((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetSampleAttributes_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioSampleAttributes attrs; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetSampleAttributes((AudioHandle)render, &attrs)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetCurrentChannelId_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint32_t channelId = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetCurrentChannelId(nullptr, &channelId)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetCurrentChannelId((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetCurrentChannelId_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint32_t channelId = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetCurrentChannelId((AudioHandle)render, &channelId)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderCheckSceneCapability_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioSceneDescriptor scene; + bool supported = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability(nullptr, &scene, &supported)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability((AudioHandle)render, nullptr, + &supported)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability((AudioHandle)render, &scene, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderCheckSceneCapability_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioSceneDescriptor scene; + bool supported = false; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability((AudioHandle)render, &scene, + &supported)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSelectScene_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioSceneDescriptor scene; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSelectScene(nullptr, &scene)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSelectScene((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSelectScene_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioSceneDescriptor scene; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSelectScene((AudioHandle)render, &scene)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSelectScene_003, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioSceneDescriptor scene; + scene.scene.id = 0; // 0 is Media + scene.desc.pins = PIN_OUT_HEADSET; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderSelectScene((AudioHandle)render, &scene)); + scene.desc.pins = PIN_OUT_SPEAKER; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderSelectScene((AudioHandle)render, &scene)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetMute_001, TestSize.Level1) +{ + bool mute = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetMute(nullptr, mute)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetMute_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + bool mute = false; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetMute((AudioHandle)render, mute)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetMute_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + bool mute = false; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMute(nullptr, &mute)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMute((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetMute_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + bool mute = false; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMute((AudioHandle)render, &mute)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSetVolume_001, TestSize.Level1) +{ + float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume(nullptr, volume)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetVolume_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume((AudioHandle)render, volume)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSetVolume_003, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float volume = MIN_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1] + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume((AudioHandle)render, volume)); + volume = MAX_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1] + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume((AudioHandle)render, volume)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetVolume_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float volume = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetVolume(nullptr, &volume)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetVolume((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetVolume_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float volume = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetVolume((AudioHandle)render, &volume)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetGainThreshold_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float min = 0; + float max = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold(nullptr, &min, &max)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold((AudioHandle)render, nullptr, &max)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold((AudioHandle)render, &min, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetGainThreshold_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float min = 0; + float max = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold((AudioHandle)render, &min, &max)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetGain_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float gain = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGain(nullptr, &gain)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGain((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetGain_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float gain = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGain((AudioHandle)render, &gain)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSetGain_001, TestSize.Level1) +{ + float gain = HALF_OF_NORMAL_VALUE; // Adjust the gain to half + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetGain(nullptr, gain)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetGain_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float gain = HALF_OF_NORMAL_VALUE; // Adjust the gain to half + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetGain((AudioHandle)render, gain)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSetGain_003, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float gain = MIN_VALUE_OUT_OF_BOUNDS; // The gain value is not within the threshold range [0,1] + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetGain((AudioHandle)render, gain)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetLatency_001, TestSize.Level1) +{ + uint32_t ms = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetLatency(nullptr, &ms)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetLatency_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint32_t ms = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetLatency(render, &ms)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetLatency_003, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint32_t ms = 0; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderGetLatency(render, &ms)); +} + +HWTEST_F(AudioProxyRenderTest, RenderFrame_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + int8_t frame[AUDIO_RENDER_BUF_TEST]; + uint64_t frameLen = AUDIO_RENDER_BUF_TEST; + uint64_t requestBytes = AUDIO_RENDER_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(nullptr, &frame, frameLen, &requestBytes)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(render, nullptr, frameLen, &requestBytes)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(render, &frame, frameLen, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderFrame_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + int8_t frame[AUDIO_RENDER_BUF_TEST]; + uint64_t frameLen = AUDIO_RENDER_BUF_TEST; + uint64_t requestBytes = AUDIO_RENDER_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(render, &frame, frameLen, &requestBytes)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderFrame_003, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + int8_t frame[AUDIO_RENDER_BUF_TEST] = {0}; + uint64_t frameLen = AUDIO_RENDER_BUF_TEST; + uint64_t requestBytes = AUDIO_RENDER_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStart((AudioHandle)render)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderRenderFrame(render, &frame, frameLen, &requestBytes)); + EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStop((AudioHandle)render)); +} + + +HWTEST_F(AudioProxyRenderTest, RenderGetRenderPosition_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t frames = 0; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(nullptr, &frames, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(render, nullptr, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(render, &frames, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetRenderPosition_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t frames = 0; + struct AudioTimeStamp time; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(render, &frames, &time)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSetRenderSpeed_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float speed = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetRenderSpeed(nullptr, speed)); + EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyRenderSetRenderSpeed(render, speed)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetRenderSpeed_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + float speed = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderSpeed(nullptr, &speed)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderSpeed(render, nullptr)); + EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyRenderGetRenderSpeed(render, &speed)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetChannelMode_001, TestSize.Level1) +{ + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetChannelMode(nullptr, mode)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetChannelMode_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetChannelMode(render, mode)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetChannelMode_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetChannelMode(nullptr, &mode)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetChannelMode(render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetChannelMode_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetChannelMode(render, &mode)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderSetExtraParams_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + char keyValueList[AUDIO_RENDER_BUF_TEST]; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetExtraParams(nullptr, keyValueList)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetExtraParams((AudioHandle)render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderSetExtraParams_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + char keyValueList[AUDIO_RENDER_BUF_TEST]; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetExtraParams((AudioHandle)render, keyValueList)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetExtraParams_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + char keyValueList[AUDIO_RENDER_BUF_TEST]; + int32_t listLenth = AUDIO_RENDER_BUF_TEST; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetExtraParams(nullptr, keyValueList, listLenth)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetExtraParams((AudioHandle)render, nullptr, listLenth)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetExtraParams_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + char keyValueList[AUDIO_RENDER_BUF_TEST]; + int32_t listLenth = AUDIO_RENDER_BUF_TEST; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + int32_t ret = AudioProxyRenderGetExtraParams((AudioHandle)render, keyValueList, listLenth); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderReqMmapBuffer_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderReqMmapBuffer(nullptr, reqSize, &desc)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderReqMmapBuffer((AudioHandle)render, reqSize, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderReqMmapBuffer_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + int32_t reqSize = 0; + struct AudioMmapBufferDescripter desc; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderReqMmapBuffer((AudioHandle)render, reqSize, &desc)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderGetMmapPosition_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t frames; + struct AudioTimeStamp time; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition(nullptr, &frames, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition((AudioHandle)render, nullptr, &time)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition((AudioHandle)render, &frames, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderGetMmapPosition_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t frames; + struct AudioTimeStamp time; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition((AudioHandle)render, &frames, &time)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderTurnStandbyMode_001, TestSize.Level1) +{ + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderTurnStandbyMode(nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderTurnStandbyMode_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderTurnStandbyMode((AudioHandle)render)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderAudioDevDump_001, TestSize.Level1) +{ + int32_t range = 0; + int32_t fd = 0; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderAudioDevDump(nullptr, range, fd)); +} + +HWTEST_F(AudioProxyRenderTest, RenderAudioDevDump_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + int32_t range = 0; + int32_t fd = 0; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderAudioDevDump((AudioHandle)render, range, fd)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderRegCallback_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t tempAddr = 1; + void *cookie = (void *)(uintptr_t)tempAddr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(nullptr, AudioRenderCallbackUtTest, cookie)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(render, nullptr, cookie)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(render, AudioRenderCallbackUtTest, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderRegCallback_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + uint64_t tempAddr = 1; + void *cookie = (void *)(uintptr_t)tempAddr; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(render, AudioRenderCallbackUtTest, cookie)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} + +HWTEST_F(AudioProxyRenderTest, RenderDrainBuffer_001, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderDrainBuffer(nullptr, &type)); + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderDrainBuffer(render, nullptr)); +} + +HWTEST_F(AudioProxyRenderTest, RenderDrainBuffer_002, TestSize.Level1) +{ + ASSERT_NE(render, nullptr); + AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle; + hwRender->proxyRemoteHandle = nullptr; + EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderDrainBuffer(render, &type)); + hwRender->proxyRemoteHandle = proxyRemoteHandle; +} +} -- Gitee From 55d3cc4cf6daa5ecfbb8a529e2c5c1d83e7dfd13 Mon Sep 17 00:00:00 2001 From: kevin Date: Fri, 5 Aug 2022 10:25:11 +0000 Subject: [PATCH 20/33] =?UTF-8?q?=E5=9B=9E=E9=80=80=20'Pull=20Request=20!1?= =?UTF-8?q?904=20:=20fix:camera=20abnormal=20pictures=20and=20dead=20lock?= =?UTF-8?q?=20issue'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/driver_adapter/include/v4l2_temp.h | 3 +- .../src/driver_adapter/src/v4l2_buffer.cpp | 30 +-- .../v4l2_source_node/v4l2_source_node.cpp | 14 +- .../src/stream_operator/stream_base.cpp | 2 +- .../nodes/src/fork_node/fork_node.cpp | 185 +++++++----------- .../nodes/src/fork_node/fork_node.h | 13 +- .../nodes/src/sink_node/sink_node.h | 8 +- .../nodes/src/source_node/source_node.cpp | 2 +- .../src/stream_pipeline_core.cpp | 22 +-- .../pipeline_impl/src/stream_pipeline_core.h | 2 +- 10 files changed, 101 insertions(+), 180 deletions(-) diff --git a/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h b/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h index ff01db11d1..d637245da9 100644 --- a/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h +++ b/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h @@ -26,10 +26,9 @@ namespace OHOS::Camera { enum CameraBufferStatus { - CAMERA_BUFFER_STATUS_OK = 0, CAMERA_BUFFER_STATUS_DROP, - CAMERA_BUFFER_STATUS_INVALID, }; + class IBuffer { public: IBuffer() {} diff --git a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp index 4bae466308..ebfd9d8922 100644 --- a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp +++ b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp @@ -139,8 +139,6 @@ RetCode HosV4L2Buffers::V4L2DequeueBuffer(int fd) buf.index, (void*)buf.m.userptr, buf.length); } - std::lock_guard l(bufferLock_); - auto IterMap = queueBuffers_.find(fd); if (IterMap == queueBuffers_.end()) { CAMERA_LOGE("std::map queueBuffers_ no fd\n"); @@ -156,12 +154,14 @@ RetCode HosV4L2Buffers::V4L2DequeueBuffer(int fd) if (dequeueBuffer_ == nullptr) { CAMERA_LOGE("V4L2DequeueBuffer buf.index == %{public}d no callback\n", buf.index); + std::lock_guard l(bufferLock_); bufferMap.erase(Iter); return RC_ERROR; } // callback to up dequeueBuffer_(Iter->second); + std::lock_guard l(bufferLock_); bufferMap.erase(Iter); return RC_OK; @@ -240,31 +240,7 @@ void HosV4L2Buffers::SetCallback(BufCallback cb) } RetCode HosV4L2Buffers::Flush(int fd) { - CAMERA_LOGD("HosV4L2Buffers::Flush enter\n"); - std::lock_guard l(bufferLock_); - - if (dequeueBuffer_ == nullptr) { - CAMERA_LOGE("HosV4L2Buffers::Flush dequeueBuffer_ == nullptr"); - return RC_ERROR; - } - - auto IterMap = queueBuffers_.find(fd); - if (IterMap == queueBuffers_.end()) { - CAMERA_LOGE("HosV4L2Buffers::Flush std::map queueBuffers_ no fd"); - return RC_ERROR; - } - auto& bufferMap = IterMap->second; - - for (auto& it : bufferMap) { - std::shared_ptr frameSpec = it.second; - CAMERA_LOGD("HosV4L2Buffers::Flush throw up buffer begin, buffpool=%{public}d", - (int32_t)frameSpec->bufferPoolId_); - frameSpec->buffer_->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); - dequeueBuffer_(frameSpec); - CAMERA_LOGD("HosV4L2Buffers::Flush throw up buffer end"); - } - - bufferMap.clear(); + CAMERA_LOGE("HosV4L2Buffers::Flush\n"); return RC_OK; } } // namespace OHOS::Camera diff --git a/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp b/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp index 3b4e978fbe..8a5b991b45 100644 --- a/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp +++ b/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp @@ -75,23 +75,19 @@ V4L2SourceNode::~V4L2SourceNode() RetCode V4L2SourceNode::Flush(const int32_t streamId) { - RetCode rc; - - rc = sensorController_->Flush(streamId); - CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); + RetCode rc = RC_OK; rc = SourceNode::Flush(streamId); + CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); + rc = sensorController_->Flush(streamId); return rc; } RetCode V4L2SourceNode::Stop(const int32_t streamId) { - RetCode rc; - - rc = sensorController_->Stop(); - CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); + SourceNode::Stop(streamId); - return SourceNode::Stop(streamId); + return sensorController_->Stop(); } void V4L2SourceNode::SetBufferCallback() diff --git a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp index b63e2ce1ea..c1d88d1a21 100644 --- a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp +++ b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp @@ -426,7 +426,6 @@ void StreamBase::HandleResult(std::shared_ptr& buffer) } if (r->GetCaptureId() == captureId) { request = r; - break; } } } @@ -441,6 +440,7 @@ void StreamBase::HandleResult(std::shared_ptr& buffer) // To synchronize multiple stream, bottom-layer device stream need be synchronized first. request->OnResult(streamId_); lastRequest_ = request; + return; } RetCode StreamBase::OnFrame(const std::shared_ptr& request) diff --git a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp index 7aea0ad906..e67a8f50d6 100644 --- a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp +++ b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp @@ -22,49 +22,30 @@ ForkNode::ForkNode(const std::string& name, const std::string& type) : NodeBase( ForkNode::~ForkNode() { - StopForkThread(); + streamRunning_ = false; + cv_.notify_all(); + if (forkThread_ != nullptr) { + CAMERA_LOGI("forkThread need join"); + forkThread_->join(); + forkThread_ = nullptr; + } + CAMERA_LOGI("fork Node exit."); } RetCode ForkNode::Start(const int32_t streamId) { - int32_t id = 0; - uint64_t bufferPoolId = 0; - CAMERA_LOGI("ForkNode::Start streamId = %{public}d\n", streamId); - if (streamRunning_) { + if (streamRunning_ == true) return RC_OK; - } inPutPorts_ = GetInPorts(); outPutPorts_ = GetOutPorts(); - - for (auto& in : inPutPorts_) { - for (auto& out : outPutPorts_) { - if (out->format_.streamId_ != in->format_.streamId_) { - id = out->format_.streamId_; - bufferPoolId = out->format_.bufferPoolId_; - CAMERA_LOGI("fork buffer get buffer streamId = %{public}d", out->format_.streamId_); - } - } - } - - BufferManager* bufferManager = Camera::BufferManager::GetInstance(); - if (bufferManager == nullptr) { - CAMERA_LOGE("fork buffer get instance failed"); - return RC_ERROR; + if (streamRunning_ == false) { + CAMERA_LOGI("ForkNode::Start::streamrunning = false"); + streamRunning_ = true; + ForkBuffers(); } - - bufferPool_ = bufferManager->GetBufferPool(bufferPoolId); - if (bufferPool_ == nullptr) { - CAMERA_LOGE("get bufferpool failed: %{public}zu", bufferPoolId); - return RC_ERROR; - } - - streamId_ = id; - RunForkThread(); - streamRunning_ = true; - return RC_OK; } @@ -72,25 +53,19 @@ RetCode ForkNode::Stop(const int32_t streamId) { CAMERA_LOGI("ForkNode::Stop streamId = %{public}d\n", streamId); - if (!streamRunning_) { - return RC_OK; - } - - StopForkThread(); - DrainForkBufferPool(); - streamRunning_ = false; - + cv_.notify_all(); + if (forkThread_ != nullptr) { + CAMERA_LOGI("ForkNode::Stop need join"); + forkThread_->join(); + forkThread_ = nullptr; + } return RC_OK; } RetCode ForkNode::Flush(const int32_t streamId) { - if (streamId_ == streamId) { - StopForkThread(); - DrainForkBufferPool(); - } - + CAMERA_LOGI("ForkNode::Flush streamId = %{public}d\n", streamId); return RC_OK; } @@ -100,24 +75,12 @@ void ForkNode::DeliverBuffer(std::shared_ptr& buffer) CAMERA_LOGE("frameSpec is null"); return; } - - if (buffer->GetBufferStatus() == CAMERA_BUFFER_STATUS_OK && bufferPool_ != nullptr) { + int32_t id = buffer->GetStreamId(); + { std::unique_lock lck(mtx_); - // If previous pending buffer was not handled, do not replace it. - if (pendingBuffer_ == nullptr) { - pendingBuffer_ = bufferPool_->AcquireBuffer(0); - if (pendingBuffer_ != nullptr) { - if (memcpy_s(pendingBuffer_->GetVirAddress(), pendingBuffer_->GetSize(), - buffer->GetVirAddress(), buffer->GetSize()) != 0) { - pendingBuffer_->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); - CAMERA_LOGE("memcpy_s failed."); - } - cv_.notify_all(); - } - } + tmpBuffer_ = buffer; + cv_.notify_one(); } - - int32_t id = buffer->GetStreamId(); for (auto& it : outPutPorts_) { if (it->format_.streamId_ == id) { it->DeliverBuffer(buffer); @@ -157,47 +120,39 @@ RetCode ForkNode::CancelCapture(const int32_t streamId) return RC_OK; } -void ForkNode::RunForkThread() +void ForkNode::ForkBuffers() { - if (forkThread_ != nullptr) { - CAMERA_LOGI("Fork thread is running."); - return; + int32_t id = 0; + uint64_t bufferPoolId = 0; + for (auto& in : inPutPorts_) { + for (auto& out : outPutPorts_) { + if (out->format_.streamId_ != in->format_.streamId_) { + id = out->format_.streamId_; + bufferPoolId = out->format_.bufferPoolId_; + CAMERA_LOGI("fork buffer get buffer streamId = %{public}d", out->format_.streamId_); + } + } } - - forkThreadRunFlag_ = true; - - forkThread_ = std::make_shared([this] { - prctl(PR_SET_NAME, "deliver_fork_buffers"); + forkThread_ = std::make_shared([this, id, bufferPoolId] { + prctl(PR_SET_NAME, "fork_buffers"); + std::shared_ptr frameSpec = std::make_shared(); std::shared_ptr buffer = nullptr; - int32_t id = streamId_; - - while (true) { - { - std::unique_lock lck(mtx_); - // Break the loop when stream was stopped and there was no pending buffer. - if (!forkThreadRunFlag_ && (pendingBuffer_ == nullptr)) { - break; - } - - if (pendingBuffer_ == nullptr) { - cv_.wait(lck); - continue; // rewind to the front of loop to check breaking condition. - } - // go ahead to deliver buffer. - buffer = pendingBuffer_; - pendingBuffer_ = nullptr; + while (streamRunning_ == true) { + if (CopyBuffer(bufferPoolId, buffer) != RC_OK) { + continue; } - for (auto& it : outPutPorts_) { if (it->format_.streamId_ == id) { - CAMERA_LOGI("fork node deliver buffer streamid = %{public}d begin", it->format_.streamId_); + CAMERA_LOGI("fork node deliver buffer streamid = %{public}d", it->format_.streamId_); int32_t id = buffer->GetStreamId(); { std::lock_guard l(requestLock_); CAMERA_LOGV("ForkNode::deliver a buffer to stream id:%{public}d, queue size:%{public}u", id, captureRequests_[id].size()); - if (captureRequests_.count(id) == 0 || captureRequests_[id].empty()) { + if (captureRequests_.count(id) == 0) { + buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); + } else if (captureRequests_[id].empty()) { buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); } else { buffer->SetCaptureId(captureRequests_[id].front()); @@ -209,40 +164,38 @@ void ForkNode::RunForkThread() } } } - CAMERA_LOGI("ForkNode RunForkThread closed"); + CAMERA_LOGI("fork thread closed"); return RC_OK; }); return; } -void ForkNode::StopForkThread() +RetCode ForkNode::CopyBuffer(uint64_t poolId, std::shared_ptr& buffer) { - if (forkThread_ != nullptr) { - std::unique_lock lck(mtx_); - forkThreadRunFlag_ = false; - cv_.notify_all(); - forkThread_->join(); - forkThread_ = nullptr; + BufferManager* bufferManager = Camera::BufferManager::GetInstance(); + CHECK_IF_PTR_NULL_RETURN_VALUE(bufferManager, RC_ERROR); + std::unique_lock lck(mtx_); + cv_.wait(lck); + std::shared_ptr bufferPool = bufferManager->GetBufferPool(poolId); + if (bufferPool == nullptr) { + CAMERA_LOGE("get bufferpool failed"); + return RC_ERROR; } - CAMERA_LOGI("ForkNode::StopForkThread exit"); -} -void ForkNode::DrainForkBufferPool() -{ - // Drain all buffers from Buffer Pool to Stream Tunnel. - if (bufferPool_ != nullptr) { - std::shared_ptr buffer = nullptr; - - while ((buffer = bufferPool_->AcquireBuffer(0)) != nullptr) { - buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); - - for (auto& it : outPutPorts_) { - if (it->format_.streamId_ == streamId_) { - it->DeliverBuffer(buffer); - break; - } - } - } + CAMERA_LOGI("fork node acquirebuffer enter"); + buffer = bufferPool->AcquireBuffer(); + CAMERA_LOGI("fork node acquirebuffer exit"); + if (buffer == nullptr) { + CAMERA_LOGE("acquire buffer failed."); + return RC_ERROR; + } + if (memcpy_s(buffer->GetVirAddress(), buffer->GetSize(), + tmpBuffer_->GetVirAddress(), tmpBuffer_->GetSize()) != 0) { + CAMERA_LOGE("memcpy_s failed."); } + buffer->SetEsFrameSize(buffer->GetSize()); + buffer->SetEsTimestamp(tmpBuffer_->GetEsFrameInfo().timestamp); + return RC_OK; } + REGISTERNODE(ForkNode, {"fork"}) } // namespace OHOS::Camera diff --git a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h index 37c88c38cb..8e9a3076f6 100644 --- a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h +++ b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h @@ -29,23 +29,20 @@ public: RetCode Start(const int32_t streamId) override; RetCode Stop(const int32_t streamId) override; void DeliverBuffer(std::shared_ptr& buffer) override; + void ForkBuffers(); RetCode Capture(const int32_t streamId, const int32_t captureId) override; RetCode CancelCapture(const int32_t streamId) override; RetCode Flush(const int32_t streamId); private: - void RunForkThread(); - void StopForkThread(); - void DrainForkBufferPool(); + RetCode CopyBuffer(uint64_t poolId, std::shared_ptr& buffer); +private: std::mutex mtx_; std::condition_variable cv_; std::shared_ptr forkThread_ = nullptr; + std::shared_ptr tmpBuffer_ = nullptr; std::vector> inPutPorts_; std::vector> outPutPorts_; - std::atomic_bool streamRunning_ = false; - std::atomic_bool forkThreadRunFlag_ = false; - std::shared_ptr bufferPool_ = nullptr; // buffer pool of branch stream - int32_t streamId_; // stream id of branch stream - std::shared_ptr pendingBuffer_ = nullptr; // pending buffer for branch stream + std::atomic_bool streamRunning_ = false; std::mutex requestLock_; std::unordered_map> captureRequests_ = {}; }; diff --git a/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h b/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h index 8bccd2c2cc..eff0e5a070 100644 --- a/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h +++ b/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h @@ -15,10 +15,10 @@ #define HOS_CAMERA_SINK_NODE_H #include -#include "camera.h" #include "device_manager_adapter.h" -#include "node_base.h" #include "utils.h" +#include "camera.h" +#include "node_base.h" namespace OHOS::Camera { class SinkNode : virtual public NodeBase { @@ -34,7 +34,7 @@ public: } protected: - BufferCb cb_; + BufferCb cb_; }; -} // namespace OHOS::Camera +}// namespace OHOS::Camera #endif diff --git a/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp b/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp index f869c61a7a..6bbf46f57b 100644 --- a/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp +++ b/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp @@ -257,12 +257,12 @@ RetCode SourceNode::PortHandler::StartDistributeBuffers() RetCode SourceNode::PortHandler::StopDistributeBuffers() { CAMERA_LOGV("SourceNode::PortHandler::StopDistributeBuffers enter"); + FlushBuffers(); dbtRun = false; rbcv.notify_one(); if (distributor != nullptr) { distributor->join(); } - FlushBuffers(); // flush buffers after stopping distributor CAMERA_LOGV("SourceNode::PortHandler::StopDistributeBuffers exit"); return RC_OK; } diff --git a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp index b3862ca557..058d0fda62 100644 --- a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp +++ b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp @@ -43,7 +43,7 @@ RetCode StreamPipelineCore::PreConfig(const ModeMeta& meta) RetCode StreamPipelineCore::CreatePipeline(const int32_t& mode) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); std::shared_ptr spec = strategy_->GeneratePipelineSpec(mode); if (spec == nullptr) { return RC_ERROR; @@ -57,7 +57,7 @@ RetCode StreamPipelineCore::CreatePipeline(const int32_t& mode) RetCode StreamPipelineCore::DestroyPipeline(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Destroy(it) | re; @@ -69,7 +69,7 @@ RetCode StreamPipelineCore::DestroyPipeline(const std::vector& streamIds) RetCode StreamPipelineCore::Prepare(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Prepare(it) | re; @@ -79,7 +79,7 @@ RetCode StreamPipelineCore::Prepare(const std::vector& streamIds) RetCode StreamPipelineCore::Start(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Start(it) | re; @@ -90,7 +90,7 @@ RetCode StreamPipelineCore::Start(const std::vector& streamIds) RetCode StreamPipelineCore::SetCallback(const MetaDataCb cb) { CAMERA_LOGE("StreamPipelineCore %{public}s: line: %{public}d", __FUNCTION__, __LINE__); - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; dispatcher_->SetCallback(cb); return re; @@ -109,7 +109,7 @@ RetCode StreamPipelineCore::Stop(const std::vector& streamIds) RetCode StreamPipelineCore::Config(const std::vector& streamIds, const CaptureMeta& meta) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Config(it, meta) | re; @@ -120,7 +120,7 @@ RetCode StreamPipelineCore::Config(const std::vector& streamIds, const Capt RetCode StreamPipelineCore::UpdateSettingsConfig(const CaptureMeta& meta) { CAMERA_LOGE("StreamPipelineCore %{public}s: line: %{public}d", __FUNCTION__, __LINE__); - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; dispatcher_->UpdateSettingsConfig(meta); return re; @@ -128,7 +128,7 @@ RetCode StreamPipelineCore::UpdateSettingsConfig(const CaptureMeta& meta) RetCode StreamPipelineCore::Capture(const std::vector& streamIds, const int32_t captureId) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Capture(it, captureId) | re; @@ -138,7 +138,7 @@ RetCode StreamPipelineCore::Capture(const std::vector& streamIds, const int RetCode StreamPipelineCore::CancelCapture(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->CancelCapture(it) | re; @@ -148,7 +148,7 @@ RetCode StreamPipelineCore::CancelCapture(const std::vector& streamIds) RetCode StreamPipelineCore::Flush(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { CAMERA_LOGV("flush stream %{public}d begin", it); @@ -160,7 +160,7 @@ RetCode StreamPipelineCore::Flush(const std::vector& streamIds) std::shared_ptr StreamPipelineCore::GetOfflinePipeline(const int32_t id) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); std::shared_ptr node = dispatcher_->GetNode(id, "ipp"); return std::static_pointer_cast(node); } diff --git a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h index cdcd162d88..d3688cd42c 100644 --- a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h +++ b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h @@ -45,7 +45,7 @@ public: const ModeMeta& meta, const std::vector& configs) override; protected: - std::recursive_mutex mutex_; + std::mutex mutex_; OperationMode mode_ = NORMAL; std::shared_ptr context_ = nullptr; std::unique_ptr strategy_ = nullptr; -- Gitee From 0405a92cba118f882fb91c7016d16060c6539c9d Mon Sep 17 00:00:00 2001 From: chen Date: Thu, 21 Jul 2022 20:17:13 +0800 Subject: [PATCH 21/33] modify samgr partname Signed-off-by: chen Change-Id: I553ab2dbcb8600e0a4e440782b6bb336deb8adb7 --- bluetooth/audio/hal/hdi_passthrough/BUILD.gn | 2 +- camera/bundle.json | 2 +- camera/hal/buffer_manager/test/BUILD.gn | 4 ++-- camera/hal/hdi_impl/test/BUILD.gn | 2 +- camera/hal/init/BUILD.gn | 4 ++-- camera/hal/pipeline_core/test/BUILD.gn | 2 +- camera/hal/test/fuzz/BUILD.gn | 14 +++++++------- camera/hal/test/mpi/BUILD.gn | 4 ++-- camera/hal/test/v4l2/BUILD.gn | 4 ++-- distributed_camera/hdi_service/test/BUILD.gn | 2 +- usb/test/unittest/hal/BUILD.gn | 8 ++++---- 11 files changed, 24 insertions(+), 24 deletions(-) diff --git a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn index 6a4a9d3bda..89e6c83870 100644 --- a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn +++ b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn @@ -15,7 +15,7 @@ import("//build/ohos.gni") import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") import("//drivers/peripheral/audio/audio.gni") -samgr_dir = "//foundation/distributedschedule/samgr" +samgr_dir = "//foundation/systemabilitymgr/samgr" config("hdi_audio_config") { visibility = [ ":*" ] diff --git a/camera/bundle.json b/camera/bundle.json index e6c291e4d1..781c4c622f 100644 --- a/camera/bundle.json +++ b/camera/bundle.json @@ -16,7 +16,7 @@ "hdf_core", "hiviewdfx_hilog_native", "multimedia_camera_standard", - "samgr_standard", + "samgr", "drivers_peripheral_display", "ipc", "utils_base" diff --git a/camera/hal/buffer_manager/test/BUILD.gn b/camera/hal/buffer_manager/test/BUILD.gn index 128e2130c8..b456d293ae 100644 --- a/camera/hal/buffer_manager/test/BUILD.gn +++ b/camera/hal/buffer_manager/test/BUILD.gn @@ -79,7 +79,7 @@ if (defined(ohos_lite)) { external_deps = [ "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", "utils_base:utils", ] } else { @@ -88,7 +88,7 @@ if (defined(ohos_lite)) { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] public_configs = [ ":buffer_manager_utest_config" ] } diff --git a/camera/hal/hdi_impl/test/BUILD.gn b/camera/hal/hdi_impl/test/BUILD.gn index 3eccdf8615..c5978ac4be 100644 --- a/camera/hal/hdi_impl/test/BUILD.gn +++ b/camera/hal/hdi_impl/test/BUILD.gn @@ -244,7 +244,7 @@ if (defined(ohos_lite)) { external_deps = [ "hilog:libhilog" ] } - external_deps += [ "samgr_standard:samgr_proxy" ] + external_deps += [ "samgr:samgr_proxy" ] public_configs = [ ":camhdi_impl_utest_config" ] } } diff --git a/camera/hal/init/BUILD.gn b/camera/hal/init/BUILD.gn index 9879898f83..701ddb31d1 100644 --- a/camera/hal/init/BUILD.gn +++ b/camera/hal/init/BUILD.gn @@ -152,7 +152,7 @@ if (defined(ohos_lite)) { "hdf_core:libhdf_utils", "hdf_core:libhdi", "hiviewdfx_hilog_native:libhilog", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", "utils_base:utils", ] } else { @@ -161,7 +161,7 @@ if (defined(ohos_lite)) { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] public_configs = [ ":ohos_camera_demo_config" ] diff --git a/camera/hal/pipeline_core/test/BUILD.gn b/camera/hal/pipeline_core/test/BUILD.gn index 96ce395809..7dc7869fc1 100644 --- a/camera/hal/pipeline_core/test/BUILD.gn +++ b/camera/hal/pipeline_core/test/BUILD.gn @@ -233,7 +233,7 @@ if (defined(ohos_lite)) { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] public_configs = [ ":pipe_config" ] } diff --git a/camera/hal/test/fuzz/BUILD.gn b/camera/hal/test/fuzz/BUILD.gn index 5af0b929d5..e5eb2b96a5 100644 --- a/camera/hal/test/fuzz/BUILD.gn +++ b/camera/hal/test/fuzz/BUILD.gn @@ -94,7 +94,7 @@ ohos_fuzztest("CameraIpcCameraDeviceRemoteFuzzTest") { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] install_enable = true @@ -174,7 +174,7 @@ ohos_fuzztest("CameraIpcCameraHostServiceFuzzTest") { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] install_enable = true @@ -253,7 +253,7 @@ ohos_fuzztest("CameraIpcOfflineFuzzTest") { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] install_enable = true @@ -332,7 +332,7 @@ ohos_fuzztest("CameraIpcStreamOperatorFuzzTest") { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] install_enable = true @@ -414,7 +414,7 @@ ohos_fuzztest("CameraIpcCameraDeviceCallbackFuzzTest") { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] install_enable = true @@ -494,7 +494,7 @@ ohos_fuzztest("CameraIpcCameraHostCallbackFuzzTest") { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] install_enable = true @@ -574,7 +574,7 @@ ohos_fuzztest("CameraIpcStreamOperatorCallbackFuzzTest") { external_deps += [ "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] install_enable = true diff --git a/camera/hal/test/mpi/BUILD.gn b/camera/hal/test/mpi/BUILD.gn index 7538508e32..26939e320b 100644 --- a/camera/hal/test/mpi/BUILD.gn +++ b/camera/hal/test/mpi/BUILD.gn @@ -174,7 +174,7 @@ if (defined(ohos_lite)) { #producer "//utils/native/base/include", - "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy/include", "$camera_path/pipeline_core/utils", "$camera_path/pipeline_core/include", "$camera_path/pipeline_core/host_stream/include", @@ -222,7 +222,7 @@ if (defined(ohos_lite)) { external_deps += [ "init:libbegetutil", "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] public_configs = [ ":cameraTest_config" ] diff --git a/camera/hal/test/v4l2/BUILD.gn b/camera/hal/test/v4l2/BUILD.gn index c79a7fd52b..2f08485d60 100644 --- a/camera/hal/test/v4l2/BUILD.gn +++ b/camera/hal/test/v4l2/BUILD.gn @@ -169,7 +169,7 @@ if (defined(ohos_lite)) { #producer "//utils/native/base/include", - "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy/include", "$camera_path/pipeline_core/utils", "$camera_path/pipeline_core/include", "$camera_path/pipeline_core/host_stream/include", @@ -220,7 +220,7 @@ if (defined(ohos_lite)) { external_deps += [ "init:libbegetutil", "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] public_configs = [ ":cameraTest_config" ] diff --git a/distributed_camera/hdi_service/test/BUILD.gn b/distributed_camera/hdi_service/test/BUILD.gn index 8bd239160a..41011022d9 100644 --- a/distributed_camera/hdi_service/test/BUILD.gn +++ b/distributed_camera/hdi_service/test/BUILD.gn @@ -58,7 +58,7 @@ ohos_executable("dcamera_hdi_sample") { "graphic_chipsetsdk:surface", "hiviewdfx_hilog_native:libhilog", "ipc:ipc_single", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", ] part_name = "distributed_camera" diff --git a/usb/test/unittest/hal/BUILD.gn b/usb/test/unittest/hal/BUILD.gn index 2d82cb22cd..832f65c0cd 100644 --- a/usb/test/unittest/hal/BUILD.gn +++ b/usb/test/unittest/hal/BUILD.gn @@ -48,7 +48,7 @@ ohos_unittest("test_transfer") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_single", "safwk:system_ability_fwk", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", "utils_base:utils", ] module_out_path = module_output_path @@ -72,7 +72,7 @@ ohos_unittest("test_device") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_single", "safwk:system_ability_fwk", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", "utils_base:utils", ] module_out_path = module_output_path @@ -92,7 +92,7 @@ ohos_unittest("test_function") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_single", "safwk:system_ability_fwk", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", "utils_base:utils", ] module_out_path = module_output_path @@ -120,7 +120,7 @@ ohos_unittest("test_request") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_single", "safwk:system_ability_fwk", - "samgr_standard:samgr_proxy", + "samgr:samgr_proxy", "utils_base:utils", ] module_out_path = module_output_path -- Gitee From 9ab451b8349de5cc2e841c3a2349aaaf406410c6 Mon Sep 17 00:00:00 2001 From: wu Date: Sat, 6 Aug 2022 02:10:07 -0700 Subject: [PATCH 22/33] remove system function of usb driver Signed-off-by: wu --- usb/ddk/device/src/adapter_if.c | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 19b4cb4350..902da66dcc 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -281,7 +281,6 @@ static int32_t UsbFnAdapterWriteUDC(const char *deviceName, const char *udcName, int32_t ret, i; char tmp[MAX_PATHLEN] = {0}; char udcTmp[MAX_NAMELEN] = {0}; - char tmpCmd[MAX_PATHLEN] = {0}; if (deviceName == NULL || udcName == NULL || IsDeviceDirExist(deviceName) == false) { return HDF_ERR_INVALID_PARAM; } @@ -304,13 +303,25 @@ static int32_t UsbFnAdapterWriteUDC(const char *deviceName, const char *udcName, return HDF_ERR_IO; } } else { - ret = snprintf_s(tmpCmd, MAX_PATHLEN, MAX_PATHLEN - 1, "echo \"\" > %s/%s/UDC", - CONFIGFS_DIR, deviceName); - if (ret < 0) { - HDF_LOGE("%{public}s: snprintf_s failed", __func__); - return HDF_ERR_IO; + FILE *fp = fopen(tmp, "w+"); + if (fp == NULL) { + HDF_LOGE("%{public}s: fopen tmp failure!", __func__); + return HDF_ERR_BAD_FD; + } + + ret = fputs("\0", fp); + if (ret == EOF) { + if (fclose(fp)) { + HDF_LOGE("%{public}s:fputs and fclose failure!", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%{public}s:fputs null failure!", __func__); + return HDF_FAILURE; + } + if (fclose(fp)) { + HDF_LOGE("%{public}s:fclose failure!", __func__); + return HDF_FAILURE; } - system(tmpCmd); } return 0; } -- Gitee From 859534776a8a6d1eecec0cabed023955d8c87f7f Mon Sep 17 00:00:00 2001 From: JasonYujia Date: Fri, 5 Aug 2022 15:48:41 +0000 Subject: [PATCH 23/33] Add hdi driver for composer and buffer Signed-off-by: JasonYujia --- display/standard/buffer/BUILD.gn | 22 ++ display/standard/buffer/hdi_service/BUILD.gn | 120 +++++++ .../include/allocator_interface_service.h | 50 +++ .../hdi_service/include/idisplay_buffer_hwi.h | 154 +++++++++ .../include/mapper_interface_service.h | 65 ++++ .../src/allocator_interface_driver.cpp | 114 +++++++ .../src/allocator_interface_service.cpp | 105 ++++++ .../src/mapper_interface_driver.cpp | 114 +++++++ .../src/mapper_interface_service.cpp | 140 ++++++++ display/standard/composer/BUILD.gn | 19 ++ .../standard/composer/hdi_service/BUILD.gn | 103 ++++++ .../include/display_composer_service.h | 113 +++++++ .../include/idisplay_composer_hwi.h | 98 ++++++ .../src/display_composer_driver.cpp | 109 ++++++ .../src/display_composer_service.cpp | 318 ++++++++++++++++++ .../standard/utils/include/display_common.h | 30 ++ display/standard/utils/include/display_log.h | 127 +++++++ 17 files changed, 1801 insertions(+) create mode 100644 display/standard/buffer/BUILD.gn create mode 100644 display/standard/buffer/hdi_service/BUILD.gn create mode 100644 display/standard/buffer/hdi_service/include/allocator_interface_service.h create mode 100644 display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h create mode 100644 display/standard/buffer/hdi_service/include/mapper_interface_service.h create mode 100644 display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp create mode 100644 display/standard/buffer/hdi_service/src/allocator_interface_service.cpp create mode 100644 display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp create mode 100644 display/standard/buffer/hdi_service/src/mapper_interface_service.cpp create mode 100644 display/standard/composer/BUILD.gn create mode 100644 display/standard/composer/hdi_service/BUILD.gn create mode 100644 display/standard/composer/hdi_service/include/display_composer_service.h create mode 100644 display/standard/composer/hdi_service/include/idisplay_composer_hwi.h create mode 100644 display/standard/composer/hdi_service/src/display_composer_driver.cpp create mode 100644 display/standard/composer/hdi_service/src/display_composer_service.cpp create mode 100644 display/standard/utils/include/display_common.h create mode 100644 display/standard/utils/include/display_log.h diff --git a/display/standard/buffer/BUILD.gn b/display/standard/buffer/BUILD.gn new file mode 100644 index 0000000000..82b8775b28 --- /dev/null +++ b/display/standard/buffer/BUILD.gn @@ -0,0 +1,22 @@ +# Copyright (c) 2022 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. + +import("//build/ohos.gni") +import("//vendor/${product_company}/${product_name}/product.gni") + +group("display_buffer_entry") { + deps = [ + "hdi_service:hdf_display_buffer_service", + "//device/soc/rockchip/rk3568/hardware/display:display_buffer_hwi_group", + ] +} diff --git a/display/standard/buffer/hdi_service/BUILD.gn b/display/standard/buffer/hdi_service/BUILD.gn new file mode 100644 index 0000000000..1c18caa32c --- /dev/null +++ b/display/standard/buffer/hdi_service/BUILD.gn @@ -0,0 +1,120 @@ +# Copyright (c) 2021 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. + +import("//build/ohos.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") + +group("hdf_display_buffer_service") { + deps = [ + ":liballocator_interface_driver_1.0", + ":liballocator_interface_service_1.0", + ":libmapper_interface_driver_1.0", + ":libmapper_interface_service_1.0", + ] +} + +ohos_shared_library("liballocator_interface_service_1.0") { + include_dirs = [ + "include", + "//drivers/interface/display/buffer", + "//drivers/hdf_core/adapter/uhdf2/model/display/base/buffer_parcelable", + "//drivers/peripheral/display/standard/utils/include", + "//drivers/peripheral/display/standard/buffer/hdi_service/include", + ] + sources = [ "src/allocator_interface_service.cpp" ] + + deps = [] + + public_deps = [ + "//drivers/hdf_core/adapter/uhdf2/model/display/base/buffer_parcelable:libbufferhandle_parcelable", + "//drivers/interface/display/buffer/v1_0:libdisplay_buffer_stub_1.0", + ] + + external_deps = [ + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + "utils_base:utils", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_display_buffer" +} + +ohos_shared_library("liballocator_interface_driver_1.0") { + include_dirs = [] + sources = [ "src/allocator_interface_driver.cpp" ] + deps = [ ":liballocator_interface_service_1.0" ] + + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + "utils_base:utils", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_display_buffer" +} + +ohos_shared_library("libmapper_interface_service_1.0") { + include_dirs = [ + "include", + "//drivers/interface/display/buffer", + "//drivers/hdf_core/adapter/uhdf2/model/display/base/buffer_parcelable", + "//drivers/peripheral/display/standard/utils/include", + "//drivers/peripheral/display/standard/buffer/hdi_service/include", + ] + sources = [ "src/mapper_interface_service.cpp" ] + + deps = [] + + public_deps = [ + "//drivers/hdf_core/adapter/uhdf2/model/display/base/buffer_parcelable:libbufferhandle_parcelable", + "//drivers/interface/display/buffer/v1_0:libdisplay_buffer_stub_1.0", + ] + + external_deps = [ + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + "utils_base:utils", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_display_buffer" +} + +ohos_shared_library("libmapper_interface_driver_1.0") { + include_dirs = [] + sources = [ "src/mapper_interface_driver.cpp" ] + deps = [ ":libmapper_interface_service_1.0" ] + + external_deps = [ + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + "utils_base:utils", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_display_buffer" +} diff --git a/display/standard/buffer/hdi_service/include/allocator_interface_service.h b/display/standard/buffer/hdi_service/include/allocator_interface_service.h new file mode 100644 index 0000000000..936b93ae75 --- /dev/null +++ b/display/standard/buffer/hdi_service/include/allocator_interface_service.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2022 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 OHOS_HDI_DISPLAY_BUFFER_V1_0_ALLOCATORINTERFACESERVICE_H +#define OHOS_HDI_DISPLAY_BUFFER_V1_0_ALLOCATORINTERFACESERVICE_H + +#include "buffer_handle_parcelable.h" +#include "v1_0/iallocator_interface.h" +#include "v1_0/display_buffer_type.h" +#include "idisplay_buffer_hwi.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Buffer { +namespace V1_0 { + +class AllocatorInterfaceService : public IAllocatorInterface { +public: + AllocatorInterfaceService(); + virtual ~AllocatorInterfaceService(); + int32_t AllocMem(const AllocInfo& info, sptr& handle) override; +private: + int32_t LoadHwi(); +private: + void* libHandle_; + IDisplayBufferHwi* hwiImpl_; + + Create_DisplayBufferHwiFunc_t* createHwi_; + Destroy_DisplayBufferHwiFunc_t* destroyHwi_; +}; +} // V1_0 +} // Buffer +} // Display +} // HDI +} // OHOS + +#endif // OHOS_HDI_DISPLAY_BUFFER_V1_0_ALLOCATORINTERFACESERVICE_H diff --git a/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h b/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h new file mode 100644 index 0000000000..1b02d6e245 --- /dev/null +++ b/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2021 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 OHOS_HDI_DISPLAY_V1_0_IDISPLAYBUFFERHWI_H +#define OHOS_HDI_DISPLAY_V1_0_IDISPLAYBUFFERHWI_H + +#include +#include "buffer_handle.h" +#include "v1_0/display_buffer_type.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Buffer { +namespace V1_0 { +#define DISPLAY_BUFFER_HWI_LIBRARY_PATH "/vendor/lib/libdisplay_buffer_hwi_impl.z.so" + +class IDisplayBufferHwi { +public: + virtual ~IDisplayBufferHwi() = default; + + /** + * @brief Allocates memory based on the parameters passed by the GUI. + * + * @param info Indicates the description of the memory to allocate. + * + * @param handle Indicates the pointer to the buffer of the memory to allocate. + * + * @return Returns 0 if the operation is successful; returns an error code defined in {@link DispErrCode} + * otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual int32_t AllocMem(const AllocInfo &info, BufferHandle *&handle) const = 0; + + /** + * @brief Releases memory. + * + * @param handle Indicates the reference to the buffer of the memory to release. + * + * @since 1.0 + * @version 1.0 + */ + virtual void FreeMem(const BufferHandle &handle) const = 0; + + /** + * @brief Maps memory to memory without cache in the process's address space. + * + * @param handle Indicates the reference to the buffer of the memory to map. + * + * @return Returns the pointer to a valid address if the operation is successful; returns NULL otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual void *Mmap(const BufferHandle &handle) const = 0; + + /** + * @brief Maps memory to memory with cache in the process's address space. + * + * @param handle Indicates the reference to the buffer of the memory to map. + * + * @return Returns the pointer to a valid address if the operation is successful; returns NULL otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual void *MmapCache(const BufferHandle &buffer) const = 0; + + /** + * @brief Unmaps memory, that is, removes mappings from the process's address space. + * + * @param handle Indicates the reference to the buffer of the memory to unmap. + * + * @return Returns 0 if the operation is successful; returns an error code defined in {@link DispErrCode} + * otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual int32_t Unmap(const BufferHandle &handle) const = 0; + + /** + * @brief Flushes data from the cache to memory and invalidates the data in the cache. + * + * @param handle Indicates the reference to the buffer of the cache to flush. + * + * @return Returns 0 if the operation is successful; returns an error code defined in {@link DispErrCode} + * otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual int32_t FlushCache(const BufferHandle &handle) const = 0; + + /** + * @brief Flushes data from the cache mapped via {@link Mmap} to memory and invalidates the data in the cache. + * + * @param handle Indicates the reference to the buffer of the cache to flush. + * + * @return Returns 0 if the operation is successful; returns an error code defined in {@link DispErrCode} + * otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual int32_t FlushMCache(const BufferHandle &buffer) const = 0; + + /** + * @brief Invalidates the cache to update it from memory. + * + * @param handle Indicates the reference to the buffer of the cache, which will be invalidated. + * + * @return Returns 0 if the operation is successful; returns an error code defined in {@link DispErrCode} + * otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual int32_t InvalidateCache(const BufferHandle &handle) const = 0; + + /** + * @brief Checks whether the given VerifyAllocInfo array is allocatable. + * + * @param infos Indicates the VerifyAllocInfo array. + * @param supporteds Indicates whether the array is allocatable. + * + * @return Returns 0 if the operation is successful; returns an error code defined in {@link DispErrCode} + * otherwise. + * @since 1.0 + * @version 1.0 + */ + virtual int32_t IsSupportedAlloc(const std::vector &infos, + std::vector &supporteds) const = 0; +}; + +typedef IDisplayBufferHwi* Create_DisplayBufferHwiFunc_t(); +typedef void Destroy_DisplayBufferHwiFunc_t(IDisplayBufferHwi*); +extern "C" IDisplayBufferHwi* Create_DisplayBufferHwi(); +extern "C" void Destroy_DisplayBufferHwi(IDisplayBufferHwi*); + +} // namespace V1_0 +} // namespace Buffer +} // namespace Display +} // namespace HDI +} // namespace OHOS + +#endif // OHOS_HDI_DISPLAY_V1_0_IDISPLAYBUFFERHWI_H diff --git a/display/standard/buffer/hdi_service/include/mapper_interface_service.h b/display/standard/buffer/hdi_service/include/mapper_interface_service.h new file mode 100644 index 0000000000..fa61a3a718 --- /dev/null +++ b/display/standard/buffer/hdi_service/include/mapper_interface_service.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2022 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 OHOS_HDI_DISPLAY_BUFFER_V1_0_MAPPERINTERFACESERVICE_H +#define OHOS_HDI_DISPLAY_BUFFER_V1_0_MAPPERINTERFACESERVICE_H + +#include "buffer_handle_parcelable.h" +#include "v1_0/imapper_interface.h" +#include "v1_0/display_buffer_type.h" +#include "idisplay_buffer_hwi.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Buffer { +namespace V1_0 { + +class MapperInterfaceService : public IMapperInterface { +public: + MapperInterfaceService(); + virtual ~MapperInterfaceService(); + + int32_t FreeMem(const sptr& handle) override; + + int32_t Mmap(const sptr& handle) override; + + int32_t MmapCache(const sptr& buffer) override; + + int32_t Unmap(const sptr& handle) override; + + int32_t FlushCache(const sptr& handle) override; + + int32_t FlushMCache(const sptr& buffer) override; + + int32_t InvalidateCache(const sptr& handle) override; + +private: + int32_t LoadHwi(); + +private: + void* libHandle_; + IDisplayBufferHwi* hwiImpl_; + + Create_DisplayBufferHwiFunc_t* createHwi_; + Destroy_DisplayBufferHwiFunc_t* destroyHwi_; +}; +} // V1_0 +} // Buffer +} // Display +} // HDI +} // OHOS + +#endif // OHOS_HDI_DISPLAY_BUFFER_V1_0_MAPPERINTERFACESERVICE_H diff --git a/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp b/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp new file mode 100644 index 0000000000..f126d4a797 --- /dev/null +++ b/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2022 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 +#include +#include +#include +#include "v1_0/allocator_interface_stub.h" + +using namespace OHOS::HDI::Display::Buffer::V1_0; + +struct HdfAllocatorInterfaceHost { + struct IDeviceIoService ioService; + OHOS::sptr stub; +}; + +static int32_t AllocatorInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + auto *hdfAllocatorInterfaceHost = CONTAINER_OF(client->device->service, struct HdfAllocatorInterfaceHost, ioService); + + OHOS::MessageParcel *dataParcel = nullptr; + OHOS::MessageParcel *replyParcel = nullptr; + OHOS::MessageOption option; + + if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + + return hdfAllocatorInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); +} + +static int HdfAllocatorInterfaceDriverInit(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfAllocatorInterfaceDriverInit enter"); + return HDF_SUCCESS; +} + +static int HdfAllocatorInterfaceDriverBind(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfAllocatorInterfaceDriverBind enter"); + + auto *hdfAllocatorInterfaceHost = new (std::nothrow) HdfAllocatorInterfaceHost; + if (hdfAllocatorInterfaceHost == nullptr) { + HDF_LOGE("%{public}s: failed to create create HdfAllocatorInterfaceHost object", __func__); + return HDF_FAILURE; + } + + hdfAllocatorInterfaceHost->ioService.Dispatch = AllocatorInterfaceDriverDispatch; + hdfAllocatorInterfaceHost->ioService.Open = NULL; + hdfAllocatorInterfaceHost->ioService.Release = NULL; + + auto serviceImpl = IAllocatorInterface::Get(true); + if (serviceImpl == nullptr) { + HDF_LOGE("%{public}s: failed to get of implement service", __func__); + delete hdfAllocatorInterfaceHost; + return HDF_FAILURE; + } + + hdfAllocatorInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, + IAllocatorInterface::GetDescriptor()); + if (hdfAllocatorInterfaceHost->stub == nullptr) { + HDF_LOGE("%{public}s: failed to get stub object", __func__); + delete hdfAllocatorInterfaceHost; + return HDF_FAILURE; + } + + deviceObject->service = &hdfAllocatorInterfaceHost->ioService; + return HDF_SUCCESS; +} + +static void HdfAllocatorInterfaceDriverRelease(struct HdfDeviceObject *deviceObject){ + HDF_LOGI("HdfAllocatorInterfaceDriverRelease enter"); + if (deviceObject->service == nullptr) { + HDF_LOGE("HdfAllocatorInterfaceDriverRelease not initted"); + return; + } + + auto *hdfAllocatorInterfaceHost = CONTAINER_OF(deviceObject->service, struct HdfAllocatorInterfaceHost, ioService); + delete hdfAllocatorInterfaceHost; +} + +struct HdfDriverEntry g_allocatorinterfaceDriverEntry = { + .moduleVersion = 1, + .moduleName = "display_buffer", + .Bind = HdfAllocatorInterfaceDriverBind, + .Init = HdfAllocatorInterfaceDriverInit, + .Release = HdfAllocatorInterfaceDriverRelease, +}; + +#ifndef __cplusplus +extern "C" { +#endif +HDF_INIT(g_allocatorinterfaceDriverEntry); +#ifndef __cplusplus +} +#endif diff --git a/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp new file mode 100644 index 0000000000..70f397b134 --- /dev/null +++ b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2022 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 "allocator_interface_service.h" +#include +#include +#include "hdf_log.h" +#include "display_log.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Buffer { +namespace V1_0 { + +extern "C" IAllocatorInterface *AllocatorInterfaceImplGetInstance(void) +{ + return new (std::nothrow) AllocatorInterfaceService(); +} + +AllocatorInterfaceService::AllocatorInterfaceService() + : libHandle_(nullptr), + hwiImpl_(nullptr), + createHwi_(nullptr), + destroyHwi_(nullptr) +{ + int32_t ret = LoadHwi(); + if (ret == HDF_SUCCESS) { + hwiImpl_ = createHwi_(); + CHECK_NULLPOINTER_RETURN(hwiImpl_); + } else { + HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", + DISPLAY_BUFFER_HWI_LIBRARY_PATH); + } +} + +AllocatorInterfaceService::~AllocatorInterfaceService() +{ + if (destroyHwi_ != nullptr && hwiImpl_ != nullptr) { + destroyHwi_(hwiImpl_); + } + if (libHandle_ != nullptr) { + dlclose(libHandle_); + } +} + +int32_t AllocatorInterfaceService::LoadHwi() +{ + const char* errStr = dlerror(); + if (errStr) { + HDF_LOGI("warning, existing dlerror: %{public}s", errStr); + } + libHandle_ = dlopen(DISPLAY_BUFFER_HWI_LIBRARY_PATH, RTLD_NOW); + CHECK_NULLPOINTER_RETURN_VALUE(libHandle_, HDF_FAILURE); + + createHwi_ = reinterpret_cast(dlsym(libHandle_, + "Create_DisplayBufferHwi")); + errStr = dlerror(); + if (errStr) { + HDF_LOGE("error: %{public}s", errStr); + return HDF_FAILURE; + } + + destroyHwi_ = reinterpret_cast(dlsym(libHandle_, + "Destroy_DisplayBufferHwi")); + errStr = dlerror(); + if (errStr) { + HDF_LOGE("error: %{public}s", errStr); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AllocatorInterfaceService::AllocMem(const AllocInfo &info, + sptr &handle) +{ + BufferHandle* buffer = nullptr; + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->AllocMem(info, buffer); + if (ec == HDF_SUCCESS) { + CHECK_NULLPOINTER_RETURN_VALUE(buffer, HDF_FAILURE); + } + BufferHandleParcelable* hdiBuffer = new BufferHandleParcelable(*buffer); + CHECK_NULLPOINTER_RETURN_VALUE(hdiBuffer, HDF_FAILURE); + handle = hdiBuffer; + return HDF_SUCCESS; +} +} // namespace V1_0 +} // Buffer +} // Display +} // namespace HDI +} // namespace OHOS diff --git a/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp b/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp new file mode 100644 index 0000000000..3cfac2fb8c --- /dev/null +++ b/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2022 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 +#include +#include +#include +#include "v1_0/mapper_interface_stub.h" + +using namespace OHOS::HDI::Display::Buffer::V1_0; + +struct HdfMapperInterfaceHost { + struct IDeviceIoService ioService; + OHOS::sptr stub; +}; + +static int32_t MapperInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + auto *hdfMapperInterfaceHost = CONTAINER_OF(client->device->service, struct HdfMapperInterfaceHost, ioService); + + OHOS::MessageParcel *dataParcel = nullptr; + OHOS::MessageParcel *replyParcel = nullptr; + OHOS::MessageOption option; + + if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + + return hdfMapperInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); +} + +static int HdfMapperInterfaceDriverInit(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfMapperInterfaceDriverInit enter"); + return HDF_SUCCESS; +} + +static int HdfMapperInterfaceDriverBind(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfMapperInterfaceDriverBind enter"); + + auto *hdfMapperInterfaceHost = new (std::nothrow) HdfMapperInterfaceHost; + if (hdfMapperInterfaceHost == nullptr) { + HDF_LOGE("%{public}s: failed to create create HdfMapperInterfaceHost object", __func__); + return HDF_FAILURE; + } + + hdfMapperInterfaceHost->ioService.Dispatch = MapperInterfaceDriverDispatch; + hdfMapperInterfaceHost->ioService.Open = NULL; + hdfMapperInterfaceHost->ioService.Release = NULL; + + auto serviceImpl = IMapperInterface::Get(true); + if (serviceImpl == nullptr) { + HDF_LOGE("%{public}s: failed to get of implement service", __func__); + delete hdfMapperInterfaceHost; + return HDF_FAILURE; + } + + hdfMapperInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, + IMapperInterface::GetDescriptor()); + if (hdfMapperInterfaceHost->stub == nullptr) { + HDF_LOGE("%{public}s: failed to get stub object", __func__); + delete hdfMapperInterfaceHost; + return HDF_FAILURE; + } + + deviceObject->service = &hdfMapperInterfaceHost->ioService; + return HDF_SUCCESS; +} + +static void HdfMapperInterfaceDriverRelease(struct HdfDeviceObject *deviceObject){ + HDF_LOGI("HdfMapperInterfaceDriverRelease enter"); + if (deviceObject->service == nullptr) { + HDF_LOGE("HdfMapperInterfaceDriverRelease not initted"); + return; + } + + auto *hdfMapperInterfaceHost = CONTAINER_OF(deviceObject->service, struct HdfMapperInterfaceHost, ioService); + delete hdfMapperInterfaceHost; +} + +struct HdfDriverEntry g_mapperinterfaceDriverEntry = { + .moduleVersion = 1, + .moduleName = "display_buffer", + .Bind = HdfMapperInterfaceDriverBind, + .Init = HdfMapperInterfaceDriverInit, + .Release = HdfMapperInterfaceDriverRelease, +}; + +#ifndef __cplusplus +extern "C" { +#endif +HDF_INIT(g_mapperinterfaceDriverEntry); +#ifndef __cplusplus +} +#endif diff --git a/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp new file mode 100644 index 0000000000..a995f658cd --- /dev/null +++ b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2022 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 "mapper_interface_service.h" +#include +#include +#include "hdf_log.h" +#include "display_log.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Buffer { +namespace V1_0 { +extern "C" IMapperInterface *MapperInterfaceImplGetInstance(void) +{ + return new (std::nothrow) MapperInterfaceService(); +} + +MapperInterfaceService::MapperInterfaceService() + : libHandle_(nullptr), + hwiImpl_(nullptr), + createHwi_(nullptr), + destroyHwi_(nullptr) +{ + int32_t ret = LoadHwi(); + if (ret == HDF_SUCCESS) { + hwiImpl_ = createHwi_(); + CHECK_NULLPOINTER_RETURN(hwiImpl_); + } else { + HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", + DISPLAY_BUFFER_HWI_LIBRARY_PATH); + } +} + +MapperInterfaceService::~MapperInterfaceService() +{ + if (destroyHwi_ != nullptr && hwiImpl_ != nullptr) { + destroyHwi_(hwiImpl_); + } + if (libHandle_ != nullptr) { + dlclose(libHandle_); + } +} + +int32_t MapperInterfaceService::LoadHwi() +{ + const char* errStr = dlerror(); + if (errStr) { + HDF_LOGI("warning, existing dlerror: %{public}s", errStr); + } + libHandle_ = dlopen(DISPLAY_BUFFER_HWI_LIBRARY_PATH, RTLD_NOW); + CHECK_NULLPOINTER_RETURN_VALUE(libHandle_, HDF_FAILURE); + + createHwi_ = reinterpret_cast(dlsym(libHandle_, + "Create_DisplayBufferHwi")); + errStr = dlerror(); + if (errStr) { + HDF_LOGE("error: %{public}s", errStr); + return HDF_FAILURE; + } + + destroyHwi_ = reinterpret_cast(dlsym(libHandle_, + "Destroy_DisplayBufferHwi")); + errStr = dlerror(); + if (errStr) { + HDF_LOGE("error: %{public}s", errStr); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t MapperInterfaceService::FreeMem(const sptr &handle) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + hwiImpl_->FreeMem(*handle->Move()); + return HDF_SUCCESS; +} + +int32_t MapperInterfaceService::Mmap(const sptr &handle) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + void* retPtr = hwiImpl_->Mmap(*handle->GetBufferHandle()); + HDF_LOGD("%{public}s@%{public}d virAddr=%{public}p", __func__, __LINE__, handle->GetBufferHandle()->virAddr); + CHECK_NULLPOINTER_RETURN_VALUE(retPtr, HDF_FAILURE); + return HDF_SUCCESS; +} + +int32_t MapperInterfaceService::MmapCache(const sptr &handle) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + void* retPtr = hwiImpl_->MmapCache(*handle->GetBufferHandle()); + CHECK_NULLPOINTER_RETURN_VALUE(retPtr, HDF_FAILURE); + return HDF_SUCCESS; +} + +int32_t MapperInterfaceService::Unmap(const sptr &handle) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->Unmap(*handle->GetBufferHandle()); + return ec; +} + +int32_t MapperInterfaceService::FlushCache(const sptr &handle) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->FlushCache(*handle->GetBufferHandle()); + return ec; +} + +int32_t MapperInterfaceService::FlushMCache(const sptr &handle) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->FlushMCache(*handle->GetBufferHandle()); + return ec; +} + +int32_t MapperInterfaceService::InvalidateCache(const sptr &handle) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->InvalidateCache(*handle->GetBufferHandle()); + return ec; +} +} // namespace V1_0 +} // Buffer +} // Display +} // namespace HDI +} // namespace OHOS diff --git a/display/standard/composer/BUILD.gn b/display/standard/composer/BUILD.gn new file mode 100644 index 0000000000..f2a91c6c98 --- /dev/null +++ b/display/standard/composer/BUILD.gn @@ -0,0 +1,19 @@ +# Copyright (c) 2022 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. + +group("display_composer_entry") { + deps = [ + "//device/soc/rockchip/rk3568/hardware/display:display_composer_hwi_group", + "//drivers/peripheral/display/standard/composer/hdi_service:display_composer_hdi_service", + ] +} diff --git a/display/standard/composer/hdi_service/BUILD.gn b/display/standard/composer/hdi_service/BUILD.gn new file mode 100644 index 0000000000..c9f62ccb1d --- /dev/null +++ b/display/standard/composer/hdi_service/BUILD.gn @@ -0,0 +1,103 @@ +# Copyright (c) 2022 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. +import("//build/ohos.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") + +group("display_composer_hdi_service") { + deps = [ + ":libdisplay_composer_driver_1.0", + ":libdisplay_composer_service_1.0", + ] +} + +ohos_shared_library("libdisplay_composer_service_1.0") { + include_dirs = [ + "//drivers/interface/display/composer", + "//drivers/hdf_core/adapter/uhdf2/model/display/composer", + "//drivers/hdf_core/adapter/uhdf2/model/display/base/command_pack", + "//drivers/peripheral/display/standard/utils/include", + "//drivers/peripheral/display/standard/composer/hdi_service/include", + "//drivers/hdf_core/adapter/uhdf2/include/hdi", + "//foundation/graphic/graphic_2d/utils/buffer_handle/export", + ] + sources = [ "src/display_composer_service.cpp" ] + + deps = [ + "//drivers/interface/display/composer/v1_0:libdisplay_composer_stub_1.0", + "//foundation/graphic/graphic_2d/utils/buffer_handle:buffer_handle", + "//utils/native/base:utils", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + + if (is_standard_system) { + external_deps = [ + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + ] + } else { + external_deps = [ "hilog:libhilog" ] + } + external_deps += [ "ipc:ipc_single" ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_display_composer" +} + +ohos_shared_library("libdisplay_composer_driver_1.0") { + include_dirs = [ + "//drivers/hdf_core/adapter/uhdf2/ipc/include", + "//drivers/hdf_core/adapter/uhdf2/include/host", + "//drivers/hdf_core/adapter/uhdf2/include/hdi", + ] + sources = [ "src/display_composer_driver.cpp" ] + + deps = [ + "//drivers/hdf_core/adapter/uhdf2/ipc:libhdf_ipc_adapter", + "//drivers/interface/display/composer/v1_0:libdisplay_composer_stub_1.0", + "//utils/native/base:utils", + ] + + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + + if (is_standard_system) { + external_deps = [ + "hdf_core:libhdf_utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + ] + } else { + external_deps = [ + "hilog:libhilog", + "ipc:ipc_single", + ] + } + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_display_composer" +} diff --git a/display/standard/composer/hdi_service/include/display_composer_service.h b/display/standard/composer/hdi_service/include/display_composer_service.h new file mode 100644 index 0000000000..d756f107ec --- /dev/null +++ b/display/standard/composer/hdi_service/include/display_composer_service.h @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2022 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 OHOS_HDI_DISPLAY_V1_0_DISPLAYCOMPOSERSERVICE_H +#define OHOS_HDI_DISPLAY_V1_0_DISPLAYCOMPOSERSERVICE_H + +#include "v1_0/display_command/display_cmd_responser.h" +#include "v1_0/idisplay_composer.h" +#include "idisplay_composer_hwi.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Composer { +namespace V1_0 { +using namespace OHOS::HDI::Display::Composer::V1_0; + +class DisplayComposerService : public IDisplayComposer { +public: + DisplayComposerService(); + virtual ~DisplayComposerService(); + + int32_t RegHotPlugCallback(const sptr& cb) override; + + int32_t GetDisplayCapability(uint32_t devId, DisplayCapability& info) override; + + int32_t GetDisplaySupportedModes(uint32_t devId, + std::vector& modes) override; + + int32_t GetDisplayMode(uint32_t devId, uint32_t& modeId) override; + + int32_t SetDisplayMode(uint32_t devId, uint32_t modeId) override; + + int32_t GetDisplayPowerStatus(uint32_t devId, DispPowerStatus& status) override; + + int32_t SetDisplayPowerStatus(uint32_t devId, DispPowerStatus status) override; + + int32_t GetDisplayBacklight(uint32_t devId, uint32_t& level) override; + + int32_t SetDisplayBacklight(uint32_t devId, uint32_t level) override; + + int32_t GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t& value) override; + + int32_t GetDisplayCompChange(uint32_t devId, std::vector& layers, + std::vector& type) override; + + int32_t SetDisplayClientCrop(uint32_t devId, const IRect& rect) override; + + int32_t SetDisplayClientDestRect(uint32_t devId, const IRect& rect) override; + + int32_t SetDisplayVsyncEnabled(uint32_t devId, bool enabled) override; + + int32_t RegDisplayVBlankCallback(uint32_t devId, const sptr& cb) override; + + int32_t GetDisplayReleaseFence(uint32_t devId, std::vector& layers, + std::vector>& fences) override; + + int32_t CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t& format, uint32_t& devId) override; + + int32_t DestroyVirtualDisplay(uint32_t devId) override; + + int32_t SetVirtualDisplayBuffer(uint32_t devId, const sptr& buffer, + const sptr& fence) override; + + int32_t SetDisplayProperty(uint32_t devId, uint32_t id, uint64_t value) override; + + int32_t CreateLayer(uint32_t devId, const LayerInfo& layerInfo, uint32_t& layerId) override; + + int32_t DestroyLayer(uint32_t devId, uint32_t layerId) override; + + int32_t InitCmdRequest(const std::shared_ptr>& request) override; + + int32_t CmdRequest(uint32_t inEleCnt, const std::vector& inFds, uint32_t& outEleCnt, + std::vector& outFds) override; + + int32_t GetCmdReply(std::shared_ptr>& reply) override; + +private: + int32_t LoadHwi(); + + static void OnHotPlug(uint32_t outputId, bool connected, void* data); + + static void OnVBlank(unsigned int sequence, uint64_t ns, void *data); + +private: + void* libHandle_; + CreateComposerHwiFunc_t* createHwiFunc_; + DestroyComposerHwiFunc_t* destroyHwiFunc_; + + std::shared_ptr hwiImpl_; + std::unique_ptr cmdResponser_; + sptr hotPlugCb_; + sptr vBlankCb_; +}; +} // V1_0 +} // Composer +} // Display +} // HDI +} // OHOS + +#endif // OHOS_HDI_DISPLAY_V1_0_DISPLAYCOMPOSERSERVICE_H diff --git a/display/standard/composer/hdi_service/include/idisplay_composer_hwi.h b/display/standard/composer/hdi_service/include/idisplay_composer_hwi.h new file mode 100644 index 0000000000..ca95475554 --- /dev/null +++ b/display/standard/composer/hdi_service/include/idisplay_composer_hwi.h @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2022 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 OHOS_HDI_DISPLAY_V1_0_IDISPLAYCOMPOSERHWI_H +#define OHOS_HDI_DISPLAY_V1_0_IDISPLAYCOMPOSERHWI_H + +#include +#include "display_common.h" +#include "v1_0/display_composer_type.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Composer { +namespace V1_0 { +using namespace OHOS::HDI::Display::Composer::V1_0; + +#define DISPLAY_COMPOSER_HWI_LIBRARY_PATH "/vendor/lib/libdisplay_composer_hwi_impl.z.so" +class IDisplayComposerHwi { +public: + virtual ~IDisplayComposerHwi() = default; + // *** device func + virtual int32_t RegHotPlugCallback(HotPlugCallback cb, void *data) = 0; + virtual int32_t GetDisplayCapability(uint32_t devId, DisplayCapability& info) = 0; + virtual int32_t GetDisplaySupportedModes(uint32_t devId, + std::vector& modes) = 0; + virtual int32_t GetDisplayMode(uint32_t devId, uint32_t& modeId) = 0; + virtual int32_t SetDisplayMode(uint32_t devId, uint32_t modeId) = 0; + virtual int32_t GetDisplayPowerStatus(uint32_t devId, DispPowerStatus& status) = 0; + virtual int32_t SetDisplayPowerStatus(uint32_t devId, DispPowerStatus status) = 0; + virtual int32_t GetDisplayBacklight(uint32_t devId, uint32_t& level) = 0; + virtual int32_t SetDisplayBacklight(uint32_t devId, uint32_t level) = 0; + virtual int32_t GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t& value) = 0; + virtual int32_t GetDisplayCompChange(uint32_t devId, std::vector& layers, + std::vector& types) = 0; + virtual int32_t SetDisplayClientCrop(uint32_t devId, const IRect& rect) = 0; + virtual int32_t SetDisplayClientDestRect(uint32_t devId, const IRect& rect) = 0; + virtual int32_t SetDisplayClientBuffer(uint32_t devId, + const BufferHandle& buffer, int32_t fence) = 0; + virtual int32_t SetDisplayClientDamage(uint32_t devId, std::vector& rects) = 0; + virtual int32_t SetDisplayVsyncEnabled(uint32_t devId, bool enabled) = 0; + virtual int32_t RegDisplayVBlankCallback(uint32_t devId, VBlankCallback cb, + void* data) = 0; + virtual int32_t GetDisplayReleaseFence(uint32_t devId, std::vector& layers, + std::vector& fences) = 0; + virtual int32_t CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t& format, + uint32_t& devId) = 0; + virtual int32_t DestroyVirtualDisplay(uint32_t devId) = 0; + virtual int32_t SetVirtualDisplayBuffer(uint32_t devId, + const BufferHandle& buffer, const int32_t fence) = 0; + virtual int32_t SetDisplayProperty(uint32_t devId, uint32_t id, uint64_t value) = 0; + virtual int32_t Commit(uint32_t devId, int32_t& fence) = 0; + // *** layer func + virtual int32_t CreateLayer(uint32_t devId, const LayerInfo& layerInfo, + uint32_t& layerId) = 0; + virtual int32_t DestroyLayer(uint32_t devId, uint32_t layerId) = 0; + virtual int32_t PrepareDisplayLayers(uint32_t devId, bool& needFlushFb) = 0; + virtual int32_t SetLayerAlpha(uint32_t devId, uint32_t layerId, const LayerAlpha& alpha) = 0; + virtual int32_t SetLayerPosition(uint32_t devId, uint32_t layerId, const IRect& rect) = 0; + virtual int32_t SetLayerCrop(uint32_t devId, uint32_t layerId, const IRect& rect) = 0; + virtual int32_t SetLayerZorder(uint32_t devId, uint32_t layerId, uint32_t zorder) = 0; + virtual int32_t SetLayerPreMulti(uint32_t devId, uint32_t layerId, bool preMul) = 0; + virtual int32_t SetTransformMode(uint32_t devId, uint32_t layerId, TransformType type) = 0; + virtual int32_t SetLayerDirtyRegion(uint32_t devIdHWI, uint32_t layerId, + const IRect& region) = 0; + virtual int32_t SetLayerVisibleRegion(uint32_t devId, uint32_t layerId, + std::vector& rects) = 0; + virtual int32_t SetLayerBuffer(uint32_t devId, uint32_t layerId, + BufferHandle& buffer, int32_t fence) = 0; + virtual int32_t SetLayerCompositionType(uint32_t devId, uint32_t layerId, + CompositionType type) = 0; + virtual int32_t SetLayerBlendType(uint32_t devId, uint32_t layerId, BlendType type) = 0; + virtual int32_t SetLayerVisible(uint32_t devId, uint32_t layerId, bool visible) = 0; +}; + +typedef IDisplayComposerHwi* CreateComposerHwiFunc_t(); +extern "C" IDisplayComposerHwi* CreateComposerHwi(); +typedef void DestroyComposerHwiFunc_t(IDisplayComposerHwi*); +extern "C" void DestroyComposerHwi(IDisplayComposerHwi* hwi); +} // namespace V1_0 +} // namespace Composer +} // namespace Display +} // namespace HDI +} // namespace OHOS + +#endif // OHOS_HDI_DISPLAY_V1_0_IDISPLAYCOMPOSERHWI_H diff --git a/display/standard/composer/hdi_service/src/display_composer_driver.cpp b/display/standard/composer/hdi_service/src/display_composer_driver.cpp new file mode 100644 index 0000000000..de571ca528 --- /dev/null +++ b/display/standard/composer/hdi_service/src/display_composer_driver.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2022 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 +#include +#include +#include +#include "v1_0/display_composer_stub.h" + +using namespace OHOS::HDI::Display::Composer::V1_0; + +struct HdfDisplayComposerHost { + struct IDeviceIoService ioService; + OHOS::sptr stub; +}; + +static int32_t DisplayComposerDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + auto *hdfDisplayComposerHost = CONTAINER_OF(client->device->service, struct HdfDisplayComposerHost, ioService); + + OHOS::MessageParcel *dataParcel = nullptr; + OHOS::MessageParcel *replyParcel = nullptr; + OHOS::MessageOption option; + + if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); + return HDF_ERR_INVALID_PARAM; + } + + return hdfDisplayComposerHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); +} + +static int HdfDisplayComposerDriverInit(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfDisplayComposerDriverInit enter"); + return HDF_SUCCESS; +} + +static int HdfDisplayComposerDriverBind(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfDisplayComposerDriverBind enter"); + + auto *hdfDisplayComposerHost = new (std::nothrow) HdfDisplayComposerHost; + if (hdfDisplayComposerHost == nullptr) { + HDF_LOGE("%{public}s: failed to create create HdfDisplayComposerHost object", __func__); + return HDF_FAILURE; + } + + hdfDisplayComposerHost->ioService.Dispatch = DisplayComposerDriverDispatch; + hdfDisplayComposerHost->ioService.Open = NULL; + hdfDisplayComposerHost->ioService.Release = NULL; + + auto serviceImpl = IDisplayComposer::Get(true); + if (serviceImpl == nullptr) { + HDF_LOGE("%{public}s: failed to get of implement service", __func__); + delete hdfDisplayComposerHost; + return HDF_FAILURE; + } + + hdfDisplayComposerHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, + IDisplayComposer::GetDescriptor()); + if (hdfDisplayComposerHost->stub == nullptr) { + HDF_LOGE("%{public}s: failed to get stub object", __func__); + delete hdfDisplayComposerHost; + return HDF_FAILURE; + } + + deviceObject->service = &hdfDisplayComposerHost->ioService; + return HDF_SUCCESS; +} + +static void HdfDisplayComposerDriverRelease(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("HdfDisplayComposerDriverRelease enter"); + if (deviceObject->service == nullptr) { + HDF_LOGE("HdfDisplayComposerDriverRelease not initted"); + return; + } + + auto *hdfDisplayComposerHost = CONTAINER_OF(deviceObject->service, struct HdfDisplayComposerHost, ioService); + delete hdfDisplayComposerHost; +} + +struct HdfDriverEntry g_displaycomposerDriverEntry = { + .moduleVersion = 1, + .moduleName = "display_composer", + .Bind = HdfDisplayComposerDriverBind, + .Init = HdfDisplayComposerDriverInit, + .Release = HdfDisplayComposerDriverRelease, +}; + +HDF_INIT(g_displaycomposerDriverEntry); diff --git a/display/standard/composer/hdi_service/src/display_composer_service.cpp b/display/standard/composer/hdi_service/src/display_composer_service.cpp new file mode 100644 index 0000000000..9941fd9e20 --- /dev/null +++ b/display/standard/composer/hdi_service/src/display_composer_service.cpp @@ -0,0 +1,318 @@ +/* + * Copyright (c) 2022 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 "display_composer_service.h" +#include +#include +#include "hdf_log.h" +#include "display_log.h" + +namespace OHOS { +namespace HDI { +namespace Display { +namespace Composer { +namespace V1_0 { +extern "C" IDisplayComposer *DisplayComposerImplGetInstance(void) +{ + return new (std::nothrow) DisplayComposerService(); +} + +DisplayComposerService::DisplayComposerService() + : libHandle_(nullptr), + createHwiFunc_(nullptr), + destroyHwiFunc_(nullptr), + hwiImpl_(nullptr), + cmdResponser_(nullptr), + hotPlugCb_(nullptr), + vBlankCb_(nullptr) +{ + int32_t ret = LoadHwi(); + if (ret == HDF_SUCCESS) { + hwiImpl_.reset(createHwiFunc_()); + CHECK_NULLPOINTER_RETURN(hwiImpl_); + cmdResponser_ = HdiDisplayCmdResponser::Create(hwiImpl_); + CHECK_NULLPOINTER_RETURN(cmdResponser_); + } else { + HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", + DISPLAY_COMPOSER_HWI_LIBRARY_PATH); + } +} + +DisplayComposerService::~DisplayComposerService() +{ + if (destroyHwiFunc_ != nullptr && hwiImpl_ != nullptr) { + destroyHwiFunc_(hwiImpl_.get()); + hwiImpl_.reset(); + } + if (libHandle_ != nullptr) { + dlclose(libHandle_); + } +} + +int32_t DisplayComposerService::LoadHwi() +{ + const char* errStr = dlerror(); + if (errStr) { + HDF_LOGI("warning, existing dlerror: %{public}s", errStr); + } + libHandle_ = dlopen(DISPLAY_COMPOSER_HWI_LIBRARY_PATH, RTLD_LAZY); + CHECK_NULLPOINTER_RETURN_VALUE(libHandle_, HDF_FAILURE); + + createHwiFunc_ = + reinterpret_cast(dlsym(libHandle_, "CreateComposerHwi")); + errStr = dlerror(); + if (errStr) { + HDF_LOGE("error: %{public}s", errStr); + return HDF_FAILURE; + } + + destroyHwiFunc_ = + reinterpret_cast(dlsym(libHandle_, "DestroyComposerHwi")); + errStr = dlerror(); + if (errStr) { + HDF_LOGE("error: %{public}s", errStr); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +void DisplayComposerService::OnHotPlug(uint32_t outputId, bool connected, void* data) +{ + if (data != nullptr) { + sptr remoteCb = + reinterpret_cast(data)->hotPlugCb_; + if (remoteCb != nullptr) { + remoteCb->OnHotPlug(outputId, connected); + } else { + HDF_LOGE("error: OnHotPlug hotPlugCb_ nullptr"); + } + } else { + HDF_LOGE("error: OnHotPlug cb data nullptr"); + } + return; +} + +void DisplayComposerService::OnVBlank(unsigned int sequence, uint64_t ns, void *data) +{ + IVBlankCallback* remoteCb; + if (data != nullptr) { + remoteCb = reinterpret_cast(data); + if (remoteCb != nullptr) { + remoteCb->OnVBlank(sequence, ns); + } else { + HDF_LOGE("error: OnVBlank hotPlugCb_ nullptr"); + } + } else { + HDF_LOGE("error: OnVBlank cb data nullptr"); + } + return; +} + +int32_t DisplayComposerService::RegHotPlugCallback(const sptr& cb) +{ + hotPlugCb_ = cb; + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->RegHotPlugCallback(OnHotPlug, this); + return ec; +} + +int32_t DisplayComposerService::GetDisplayCapability(uint32_t devId, DisplayCapability& info) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplayCapability(devId, info); + return ec; +} + +int32_t DisplayComposerService::GetDisplaySupportedModes(uint32_t devId, + std::vector& modes) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplaySupportedModes(devId, modes); + return ec; +} + +int32_t DisplayComposerService::GetDisplayMode(uint32_t devId, uint32_t& modeId) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplayMode(devId, modeId); + return ec; +} + +int32_t DisplayComposerService::SetDisplayMode(uint32_t devId, uint32_t modeId) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetDisplayMode(devId, modeId); + return ec; +} + +int32_t DisplayComposerService::GetDisplayPowerStatus(uint32_t devId, DispPowerStatus& status) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplayPowerStatus(devId, status); + return ec; +} + +int32_t DisplayComposerService::SetDisplayPowerStatus(uint32_t devId, DispPowerStatus status) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetDisplayPowerStatus(devId, status); + return ec; +} + +int32_t DisplayComposerService::GetDisplayBacklight(uint32_t devId, uint32_t& level) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplayBacklight(devId, level); + return ec; +} + +int32_t DisplayComposerService::SetDisplayBacklight(uint32_t devId, uint32_t level) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetDisplayBacklight(devId, level); + return ec; +} + +int32_t DisplayComposerService::GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t& value) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplayProperty(devId, id, value); + return ec; +} + +int32_t DisplayComposerService::GetDisplayCompChange(uint32_t devId, std::vector& layers, + std::vector& type) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplayCompChange(devId, layers, type); + return ec; +} + +int32_t DisplayComposerService::SetDisplayClientCrop(uint32_t devId, const IRect& rect) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetDisplayClientCrop(devId, rect); + return ec; +} + +int32_t DisplayComposerService::SetDisplayClientDestRect(uint32_t devId, const IRect& rect) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetDisplayClientDestRect(devId, rect); + return ec; +} + +int32_t DisplayComposerService::SetDisplayVsyncEnabled(uint32_t devId, bool enabled) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetDisplayVsyncEnabled(devId, enabled); + return ec; +} + +int32_t DisplayComposerService::RegDisplayVBlankCallback(uint32_t devId, const sptr& cb) +{ + vBlankCb_ = cb; + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->RegDisplayVBlankCallback(devId, OnVBlank, vBlankCb_.GetRefPtr()); + return ec; +} + +int32_t DisplayComposerService::GetDisplayReleaseFence(uint32_t devId, std::vector& layers, + std::vector>& fences) +{ + std::vector outFences; + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->GetDisplayReleaseFence(devId, layers, outFences); + for (int i = 0; i < outFences.size(); i++) { + int32_t dupFd = outFences[i]; + sptr hdifd(new HdifdParcelable()); + hdifd->Init(dupFd); + fences.push_back(hdifd); + } + return ec; +} + +int32_t DisplayComposerService::CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t& format, uint32_t& devId) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->CreateVirtualDisplay(width, height, format, devId); + return ec; +} + +int32_t DisplayComposerService::DestroyVirtualDisplay(uint32_t devId) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->DestroyVirtualDisplay(devId); + return ec; +} + +int32_t DisplayComposerService::SetVirtualDisplayBuffer(uint32_t devId, const sptr& buffer, + const sptr& fence) +{ + BufferHandle* handle = buffer->GetBufferHandle(); + int32_t inFence = fence->GetFd(); + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetVirtualDisplayBuffer(devId, *handle, inFence); + return ec; +} + +int32_t DisplayComposerService::SetDisplayProperty(uint32_t devId, uint32_t id, uint64_t value) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->SetDisplayProperty(devId, id, value); + return ec; +} + +int32_t DisplayComposerService::CreateLayer(uint32_t devId, const LayerInfo& layerInfo, uint32_t& layerId) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->CreateLayer(devId, layerInfo, layerId); + return ec; +} + +int32_t DisplayComposerService::DestroyLayer(uint32_t devId, uint32_t layerId) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = hwiImpl_->DestroyLayer(devId, layerId); + return ec; +} + +int32_t DisplayComposerService::InitCmdRequest(const std::shared_ptr>& request) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = cmdResponser_->InitCmdRequest(request); + return ec; +} + +int32_t DisplayComposerService::CmdRequest(uint32_t inEleCnt, const std::vector& inFds, + uint32_t& outEleCnt, std::vector& outFds) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = cmdResponser_->CmdRequest(inEleCnt, inFds, outEleCnt, outFds); + return ec; +} + +int32_t DisplayComposerService::GetCmdReply(std::shared_ptr>& reply) +{ + CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); + int32_t ec = cmdResponser_->GetCmdReply(reply); + return ec; +} +} // V1_0 +} // Composer +} // Display +} // HDI +} // OHOS diff --git a/display/standard/utils/include/display_common.h b/display/standard/utils/include/display_common.h new file mode 100644 index 0000000000..c8d0146705 --- /dev/null +++ b/display/standard/utils/include/display_common.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2022 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 DISPLAY_COMMON_H +#define DISPLAY_COMMON_H + +#include + +namespace OHOS { +namespace HDI { +namespace Display { +typedef void (*HotPlugCallback)(uint32_t devId, bool connected, void *data); +typedef void (*VBlankCallback)(unsigned int sequence, uint64_t ns, void *data); +typedef void (*RefreshCallback)(uint32_t devId, void *data); +} // Display +} // HDI +} // OHOS +#endif /* DISPLAY_COMMON_H */ diff --git a/display/standard/utils/include/display_log.h b/display/standard/utils/include/display_log.h new file mode 100644 index 0000000000..c5801cb3b3 --- /dev/null +++ b/display/standard/utils/include/display_log.h @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2021 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 DISPLAY_LOG_H +#define DISPLAY_LOG_H +#include +#include +#include "hilog/log.h" +#include "stdio.h" +#ifdef HDF_LOG_TAG +#undef HDF_LOG_TAG +#endif + +#if defined(__cplusplus) +extern "C" { +#endif + +#undef LOG_TAG +#undef LOG_DOMAIN +#define LOG_TAG "DISP" +#define LOG_DOMAIN 0xD001400 + +#ifndef DISPLAY_UNUSED +#define DISPLAY_UNUSED(x) (void)(x) +#endif + +#define __DISPLAY_FILENAME__ (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1) : __FILE__) + +#ifndef DISPLAY_DEBUG_ENABLE +#define DISPLAY_DEBUG_ENABLE 1 +#endif + +#ifndef DISPLAY_LOGD +#define DISPLAY_LOGD(format, ...) \ + do { \ + if (DISPLAY_DEBUG_ENABLE) { \ + HILOG_DEBUG(LOG_CORE, "[%{public}s@%{public}s:%{public}d] " format "\n", \ + __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, \ + ##__VA_ARGS__); \ + } \ + } while (0) +#endif + +#ifndef DISPLAY_LOGI +#define DISPLAY_LOGI(format, ...) \ + do { \ + HILOG_INFO(LOG_CORE, "[%{public}s@%{public}s:%{public}d] " format "\n", __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, \ + ##__VA_ARGS__); \ + } while (0) +#endif + +#ifndef DISPLAY_LOGW +#define DISPLAY_LOGW(format, ...) \ + do { \ + HILOG_WARN(LOG_CORE, "[%{public}s@%{public}s:%{public}d] " format "\n", __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, \ + ##__VA_ARGS__); \ + } while (0) +#endif + +#ifndef DISPLAY_LOGE +#define DISPLAY_LOGE(format, ...) \ + do { \ + HILOG_ERROR(LOG_CORE, \ + "\033[0;32;31m" \ + "[%{public}s@%{public}s:%{public}d] " format "\033[m" \ + "\n", \ + __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, ##__VA_ARGS__); \ + } while (0) +#endif + +#ifndef CHECK_NULLPOINTER_RETURN_VALUE +#define CHECK_NULLPOINTER_RETURN_VALUE(pointer, ret) \ + do { \ + if ((pointer) == NULL) { \ + DISPLAY_LOGE("pointer is null and return ret\n"); \ + return (ret); \ + } \ + } while (0) +#endif + +#ifndef CHECK_NULLPOINTER_RETURN +#define CHECK_NULLPOINTER_RETURN(pointer) \ + do { \ + if ((pointer) == NULL) { \ + DISPLAY_LOGE("pointer is null and return\n"); \ + return; \ + } \ + } while (0) +#endif + +#ifndef DISPLAY_CHK_RETURN +#define DISPLAY_CHK_RETURN(val, ret, ...) \ + do { \ + if (val) { \ + __VA_ARGS__; \ + return (ret); \ + } \ + } while (0) +#endif + +#ifndef DISPLAY_CHK_RETURN_NOT_VALUE +#define DISPLAY_CHK_RETURN_NOT_VALUE(val, ...) \ + do { \ + if (val) { \ + __VA_ARGS__; \ + return; \ + } \ + } while (0) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* DISPLAY_LOG_H */ -- Gitee From 19ea5979f5ba4c434b7e443a975d0da6cf4f52c2 Mon Sep 17 00:00:00 2001 From: JasonYujia Date: Sat, 6 Aug 2022 07:35:28 +0000 Subject: [PATCH 24/33] modify codeCheck Signed-off-by: JasonYujia --- .../include/allocator_interface_service.h | 4 +- .../hdi_service/include/idisplay_buffer_hwi.h | 1 - .../include/mapper_interface_service.h | 1 - .../src/allocator_interface_driver.cpp | 18 ++++--- .../src/allocator_interface_service.cpp | 3 +- .../src/mapper_interface_driver.cpp | 11 ++-- .../src/mapper_interface_service.cpp | 2 +- display/standard/composer/BUILD.gn | 2 +- .../src/display_composer_driver.cpp | 8 ++- display/standard/utils/include/display_log.h | 52 +++++++++---------- 10 files changed, 53 insertions(+), 49 deletions(-) diff --git a/display/standard/buffer/hdi_service/include/allocator_interface_service.h b/display/standard/buffer/hdi_service/include/allocator_interface_service.h index 936b93ae75..6e7afabe78 100644 --- a/display/standard/buffer/hdi_service/include/allocator_interface_service.h +++ b/display/standard/buffer/hdi_service/include/allocator_interface_service.h @@ -26,18 +26,18 @@ namespace HDI { namespace Display { namespace Buffer { namespace V1_0 { - class AllocatorInterfaceService : public IAllocatorInterface { public: AllocatorInterfaceService(); virtual ~AllocatorInterfaceService(); int32_t AllocMem(const AllocInfo& info, sptr& handle) override; + private: int32_t LoadHwi(); + private: void* libHandle_; IDisplayBufferHwi* hwiImpl_; - Create_DisplayBufferHwiFunc_t* createHwi_; Destroy_DisplayBufferHwiFunc_t* destroyHwi_; }; diff --git a/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h b/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h index 1b02d6e245..5256ecbf57 100644 --- a/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h +++ b/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h @@ -144,7 +144,6 @@ typedef IDisplayBufferHwi* Create_DisplayBufferHwiFunc_t(); typedef void Destroy_DisplayBufferHwiFunc_t(IDisplayBufferHwi*); extern "C" IDisplayBufferHwi* Create_DisplayBufferHwi(); extern "C" void Destroy_DisplayBufferHwi(IDisplayBufferHwi*); - } // namespace V1_0 } // namespace Buffer } // namespace Display diff --git a/display/standard/buffer/hdi_service/include/mapper_interface_service.h b/display/standard/buffer/hdi_service/include/mapper_interface_service.h index fa61a3a718..42a59ffa57 100644 --- a/display/standard/buffer/hdi_service/include/mapper_interface_service.h +++ b/display/standard/buffer/hdi_service/include/mapper_interface_service.h @@ -26,7 +26,6 @@ namespace HDI { namespace Display { namespace Buffer { namespace V1_0 { - class MapperInterfaceService : public IMapperInterface { public: MapperInterfaceService(); diff --git a/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp b/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp index f126d4a797..59f4ded60c 100644 --- a/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp +++ b/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp @@ -26,10 +26,11 @@ struct HdfAllocatorInterfaceHost { OHOS::sptr stub; }; -static int32_t AllocatorInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, - struct HdfSBuf *reply) +static int32_t AllocatorInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, + struct HdfSBuf *data, struct HdfSBuf *reply) { - auto *hdfAllocatorInterfaceHost = CONTAINER_OF(client->device->service, struct HdfAllocatorInterfaceHost, ioService); + auto *hdfAllocatorInterfaceHost = CONTAINER_OF(client->device->service, + struct HdfAllocatorInterfaceHost, ioService); OHOS::MessageParcel *dataParcel = nullptr; OHOS::MessageParcel *replyParcel = nullptr; @@ -86,7 +87,8 @@ static int HdfAllocatorInterfaceDriverBind(struct HdfDeviceObject *deviceObject) return HDF_SUCCESS; } -static void HdfAllocatorInterfaceDriverRelease(struct HdfDeviceObject *deviceObject){ +static void HdfAllocatorInterfaceDriverRelease(struct HdfDeviceObject *deviceObject) +{ HDF_LOGI("HdfAllocatorInterfaceDriverRelease enter"); if (deviceObject->service == nullptr) { HDF_LOGE("HdfAllocatorInterfaceDriverRelease not initted"); @@ -97,7 +99,7 @@ static void HdfAllocatorInterfaceDriverRelease(struct HdfDeviceObject *deviceObj delete hdfAllocatorInterfaceHost; } -struct HdfDriverEntry g_allocatorinterfaceDriverEntry = { +static struct HdfDriverEntry g_allocatorinterfaceDriverEntry = { .moduleVersion = 1, .moduleName = "display_buffer", .Bind = HdfAllocatorInterfaceDriverBind, @@ -105,10 +107,10 @@ struct HdfDriverEntry g_allocatorinterfaceDriverEntry = { .Release = HdfAllocatorInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { #endif HDF_INIT(g_allocatorinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif \ No newline at end of file diff --git a/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp index 70f397b134..b800d240c5 100644 --- a/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp +++ b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp @@ -24,7 +24,6 @@ namespace HDI { namespace Display { namespace Buffer { namespace V1_0 { - extern "C" IAllocatorInterface *AllocatorInterfaceImplGetInstance(void) { return new (std::nothrow) AllocatorInterfaceService(); @@ -38,7 +37,7 @@ AllocatorInterfaceService::AllocatorInterfaceService() { int32_t ret = LoadHwi(); if (ret == HDF_SUCCESS) { - hwiImpl_ = createHwi_(); + hwiImpl_ = createHwi_(); CHECK_NULLPOINTER_RETURN(hwiImpl_); } else { HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", diff --git a/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp b/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp index 3cfac2fb8c..97972fe022 100644 --- a/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp +++ b/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp @@ -86,7 +86,8 @@ static int HdfMapperInterfaceDriverBind(struct HdfDeviceObject *deviceObject) return HDF_SUCCESS; } -static void HdfMapperInterfaceDriverRelease(struct HdfDeviceObject *deviceObject){ +static void HdfMapperInterfaceDriverRelease(struct HdfDeviceObject *deviceObject) +{ HDF_LOGI("HdfMapperInterfaceDriverRelease enter"); if (deviceObject->service == nullptr) { HDF_LOGE("HdfMapperInterfaceDriverRelease not initted"); @@ -97,7 +98,7 @@ static void HdfMapperInterfaceDriverRelease(struct HdfDeviceObject *deviceObject delete hdfMapperInterfaceHost; } -struct HdfDriverEntry g_mapperinterfaceDriverEntry = { +static struct HdfDriverEntry g_mapperinterfaceDriverEntry = { .moduleVersion = 1, .moduleName = "display_buffer", .Bind = HdfMapperInterfaceDriverBind, @@ -105,10 +106,10 @@ struct HdfDriverEntry g_mapperinterfaceDriverEntry = { .Release = HdfMapperInterfaceDriverRelease, }; -#ifndef __cplusplus +#ifdef __cplusplus extern "C" { #endif HDF_INIT(g_mapperinterfaceDriverEntry); -#ifndef __cplusplus +#ifdef __cplusplus } -#endif +#endif \ No newline at end of file diff --git a/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp index a995f658cd..724279126b 100644 --- a/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp +++ b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp @@ -37,7 +37,7 @@ MapperInterfaceService::MapperInterfaceService() { int32_t ret = LoadHwi(); if (ret == HDF_SUCCESS) { - hwiImpl_ = createHwi_(); + hwiImpl_ = createHwi_(); CHECK_NULLPOINTER_RETURN(hwiImpl_); } else { HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", diff --git a/display/standard/composer/BUILD.gn b/display/standard/composer/BUILD.gn index f2a91c6c98..7bd21c70a1 100644 --- a/display/standard/composer/BUILD.gn +++ b/display/standard/composer/BUILD.gn @@ -16,4 +16,4 @@ group("display_composer_entry") { "//device/soc/rockchip/rk3568/hardware/display:display_composer_hwi_group", "//drivers/peripheral/display/standard/composer/hdi_service:display_composer_hdi_service", ] -} +} \ No newline at end of file diff --git a/display/standard/composer/hdi_service/src/display_composer_driver.cpp b/display/standard/composer/hdi_service/src/display_composer_driver.cpp index de571ca528..a975d48e73 100644 --- a/display/standard/composer/hdi_service/src/display_composer_driver.cpp +++ b/display/standard/composer/hdi_service/src/display_composer_driver.cpp @@ -98,7 +98,7 @@ static void HdfDisplayComposerDriverRelease(struct HdfDeviceObject *deviceObject delete hdfDisplayComposerHost; } -struct HdfDriverEntry g_displaycomposerDriverEntry = { +static struct HdfDriverEntry g_displaycomposerDriverEntry = { .moduleVersion = 1, .moduleName = "display_composer", .Bind = HdfDisplayComposerDriverBind, @@ -106,4 +106,10 @@ struct HdfDriverEntry g_displaycomposerDriverEntry = { .Release = HdfDisplayComposerDriverRelease, }; +#ifdef __cplusplus +extern "C" { +#endif HDF_INIT(g_displaycomposerDriverEntry); +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/display/standard/utils/include/display_log.h b/display/standard/utils/include/display_log.h index c5801cb3b3..a6b846a7de 100644 --- a/display/standard/utils/include/display_log.h +++ b/display/standard/utils/include/display_log.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 @@ -36,47 +36,45 @@ extern "C" { #define DISPLAY_UNUSED(x) (void)(x) #endif -#define __DISPLAY_FILENAME__ (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1) : __FILE__) - #ifndef DISPLAY_DEBUG_ENABLE #define DISPLAY_DEBUG_ENABLE 1 #endif #ifndef DISPLAY_LOGD -#define DISPLAY_LOGD(format, ...) \ - do { \ - if (DISPLAY_DEBUG_ENABLE) { \ - HILOG_DEBUG(LOG_CORE, "[%{public}s@%{public}s:%{public}d] " format "\n", \ - __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, \ - ##__VA_ARGS__); \ - } \ +#define DISPLAY_LOGD(format, ...) \ + do { \ + if (DISPLAY_DEBUG_ENABLE) { \ + HILOG_DEBUG(LOG_CORE, "[%{public}s:%{public}d] " format "\n", \ + __FUNCTION__, __LINE__, \ + ##__VA_ARGS__); \ + } \ } while (0) #endif #ifndef DISPLAY_LOGI -#define DISPLAY_LOGI(format, ...) \ - do { \ - HILOG_INFO(LOG_CORE, "[%{public}s@%{public}s:%{public}d] " format "\n", __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, \ - ##__VA_ARGS__); \ +#define DISPLAY_LOGI(format, ...) \ + do { \ + HILOG_INFO(LOG_CORE, "[%{public}s:%{public}d] " format "\n", \ + __FUNCTION__, __LINE__, ##__VA_ARGS__); \ } while (0) #endif #ifndef DISPLAY_LOGW -#define DISPLAY_LOGW(format, ...) \ - do { \ - HILOG_WARN(LOG_CORE, "[%{public}s@%{public}s:%{public}d] " format "\n", __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, \ - ##__VA_ARGS__); \ +#define DISPLAY_LOGW(format, ...) \ + do { \ + HILOG_WARN(LOG_CORE, "[%{public}s:%{public}d] " format "\n", \ + __FUNCTION__, __LINE__, ##__VA_ARGS__); \ } while (0) #endif #ifndef DISPLAY_LOGE -#define DISPLAY_LOGE(format, ...) \ - do { \ - HILOG_ERROR(LOG_CORE, \ - "\033[0;32;31m" \ - "[%{public}s@%{public}s:%{public}d] " format "\033[m" \ - "\n", \ - __FUNCTION__, __DISPLAY_FILENAME__, __LINE__, ##__VA_ARGS__); \ +#define DISPLAY_LOGE(format, ...) \ + do { \ + HILOG_ERROR(LOG_CORE, \ + "\033[0;32;31m" \ + "[%{public}s:%{public}d] " format "\033[m" \ + "\n", \ + __FUNCTION__, __LINE__, ##__VA_ARGS__); \ } while (0) #endif @@ -111,7 +109,7 @@ extern "C" { #endif #ifndef DISPLAY_CHK_RETURN_NOT_VALUE -#define DISPLAY_CHK_RETURN_NOT_VALUE(val, ...) \ +#define DISPLAY_CHK_RETURN_NOT_VALUE(val, ...) \ do { \ if (val) { \ __VA_ARGS__; \ @@ -124,4 +122,4 @@ extern "C" { } #endif -#endif /* DISPLAY_LOG_H */ +#endif // DISPLAY_LOG_H \ No newline at end of file -- Gitee From d5a1a9cff7d4911c31479d736d8769970e37de2b Mon Sep 17 00:00:00 2001 From: JasonYujia Date: Sat, 6 Aug 2022 11:11:52 +0000 Subject: [PATCH 25/33] modify codeCheck Signed-off-by: JasonYujia --- .../include/allocator_interface_service.h | 25 ++- .../hdi_service/include/idisplay_buffer_hwi.h | 12 +- .../include/mapper_interface_service.h | 42 ++--- .../src/allocator_interface_driver.cpp | 12 +- .../src/allocator_interface_service.cpp | 31 ++-- .../src/mapper_interface_driver.cpp | 8 +- .../src/mapper_interface_service.cpp | 28 ++-- display/standard/composer/BUILD.gn | 2 +- .../standard/composer/hdi_service/BUILD.gn | 22 +-- .../include/display_composer_service.h | 92 ++++------ .../include/idisplay_composer_hwi.h | 79 ++++----- .../src/display_composer_driver.cpp | 8 +- .../src/display_composer_service.cpp | 158 +++++++----------- .../standard/utils/include/display_common.h | 6 +- display/standard/utils/include/display_log.h | 60 ++++--- 15 files changed, 237 insertions(+), 348 deletions(-) diff --git a/display/standard/buffer/hdi_service/include/allocator_interface_service.h b/display/standard/buffer/hdi_service/include/allocator_interface_service.h index 6e7afabe78..a24d639e6e 100644 --- a/display/standard/buffer/hdi_service/include/allocator_interface_service.h +++ b/display/standard/buffer/hdi_service/include/allocator_interface_service.h @@ -17,9 +17,9 @@ #define OHOS_HDI_DISPLAY_BUFFER_V1_0_ALLOCATORINTERFACESERVICE_H #include "buffer_handle_parcelable.h" -#include "v1_0/iallocator_interface.h" -#include "v1_0/display_buffer_type.h" #include "idisplay_buffer_hwi.h" +#include "v1_0/display_buffer_type.h" +#include "v1_0/iallocator_interface.h" namespace OHOS { namespace HDI { @@ -30,21 +30,20 @@ class AllocatorInterfaceService : public IAllocatorInterface { public: AllocatorInterfaceService(); virtual ~AllocatorInterfaceService(); - int32_t AllocMem(const AllocInfo& info, sptr& handle) override; + int32_t AllocMem(const AllocInfo &info, sptr &handle) override; private: int32_t LoadHwi(); private: - void* libHandle_; - IDisplayBufferHwi* hwiImpl_; - Create_DisplayBufferHwiFunc_t* createHwi_; - Destroy_DisplayBufferHwiFunc_t* destroyHwi_; + void *libHandle_; + IDisplayBufferHwi *hwiImpl_; + Create_DisplayBufferHwiFunc_t *createHwi_; + Destroy_DisplayBufferHwiFunc_t *destroyHwi_; }; -} // V1_0 -} // Buffer -} // Display -} // HDI -} // OHOS - +} // namespace V1_0 +} // namespace Buffer +} // namespace Display +} // namespace HDI +} // namespace OHOS #endif // OHOS_HDI_DISPLAY_BUFFER_V1_0_ALLOCATORINTERFACESERVICE_H diff --git a/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h b/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h index 5256ecbf57..eb1a4dab9e 100644 --- a/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h +++ b/display/standard/buffer/hdi_service/include/idisplay_buffer_hwi.h @@ -136,14 +136,14 @@ public: * @since 1.0 * @version 1.0 */ - virtual int32_t IsSupportedAlloc(const std::vector &infos, - std::vector &supporteds) const = 0; + virtual int32_t IsSupportedAlloc( + const std::vector &infos, std::vector &supporteds) const = 0; }; -typedef IDisplayBufferHwi* Create_DisplayBufferHwiFunc_t(); -typedef void Destroy_DisplayBufferHwiFunc_t(IDisplayBufferHwi*); -extern "C" IDisplayBufferHwi* Create_DisplayBufferHwi(); -extern "C" void Destroy_DisplayBufferHwi(IDisplayBufferHwi*); +using IDisplayBufferHwi *Create_DisplayBufferHwiFunc_t(); +using void Destroy_DisplayBufferHwiFunc_t(IDisplayBufferHwi *hwi); +extern "C" IDisplayBufferHwi *Create_DisplayBufferHwi(); +extern "C" void Destroy_DisplayBufferHwi(IDisplayBufferHwi *hwi); } // namespace V1_0 } // namespace Buffer } // namespace Display diff --git a/display/standard/buffer/hdi_service/include/mapper_interface_service.h b/display/standard/buffer/hdi_service/include/mapper_interface_service.h index 42a59ffa57..75a088a184 100644 --- a/display/standard/buffer/hdi_service/include/mapper_interface_service.h +++ b/display/standard/buffer/hdi_service/include/mapper_interface_service.h @@ -17,9 +17,9 @@ #define OHOS_HDI_DISPLAY_BUFFER_V1_0_MAPPERINTERFACESERVICE_H #include "buffer_handle_parcelable.h" -#include "v1_0/imapper_interface.h" -#include "v1_0/display_buffer_type.h" #include "idisplay_buffer_hwi.h" +#include "v1_0/display_buffer_type.h" +#include "v1_0/imapper_interface.h" namespace OHOS { namespace HDI { @@ -31,34 +31,28 @@ public: MapperInterfaceService(); virtual ~MapperInterfaceService(); - int32_t FreeMem(const sptr& handle) override; - - int32_t Mmap(const sptr& handle) override; - - int32_t MmapCache(const sptr& buffer) override; - - int32_t Unmap(const sptr& handle) override; - - int32_t FlushCache(const sptr& handle) override; - - int32_t FlushMCache(const sptr& buffer) override; - - int32_t InvalidateCache(const sptr& handle) override; + int32_t FreeMem(const sptr &handle) override; + int32_t Mmap(const sptr &handle) override; + int32_t MmapCache(const sptr &buffer) override; + int32_t Unmap(const sptr &handle) override; + int32_t FlushCache(const sptr &handle) override; + int32_t FlushMCache(const sptr &buffer) override; + int32_t InvalidateCache(const sptr &handle) override; private: int32_t LoadHwi(); private: - void* libHandle_; - IDisplayBufferHwi* hwiImpl_; + void *libHandle_; + IDisplayBufferHwi *hwiImpl_; - Create_DisplayBufferHwiFunc_t* createHwi_; - Destroy_DisplayBufferHwiFunc_t* destroyHwi_; + Create_DisplayBufferHwiFunc_t *createHwi_; + Destroy_DisplayBufferHwiFunc_t *destroyHwi_; }; -} // V1_0 -} // Buffer -} // Display -} // HDI -} // OHOS +} // namespace V1_0 +} // namespace Buffer +} // namespace Display +} // namespace HDI +} // namespace OHOS #endif // OHOS_HDI_DISPLAY_BUFFER_V1_0_MAPPERINTERFACESERVICE_H diff --git a/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp b/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp index 59f4ded60c..e383f45863 100644 --- a/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp +++ b/display/standard/buffer/hdi_service/src/allocator_interface_driver.cpp @@ -26,11 +26,11 @@ struct HdfAllocatorInterfaceHost { OHOS::sptr stub; }; -static int32_t AllocatorInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, - struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t AllocatorInterfaceDriverDispatch( + struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { - auto *hdfAllocatorInterfaceHost = CONTAINER_OF(client->device->service, - struct HdfAllocatorInterfaceHost, ioService); + auto *hdfAllocatorInterfaceHost = + CONTAINER_OF(client->device->service, struct HdfAllocatorInterfaceHost, ioService); OHOS::MessageParcel *dataParcel = nullptr; OHOS::MessageParcel *replyParcel = nullptr; @@ -75,8 +75,8 @@ static int HdfAllocatorInterfaceDriverBind(struct HdfDeviceObject *deviceObject) return HDF_FAILURE; } - hdfAllocatorInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, - IAllocatorInterface::GetDescriptor()); + hdfAllocatorInterfaceHost->stub = + OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, IAllocatorInterface::GetDescriptor()); if (hdfAllocatorInterfaceHost->stub == nullptr) { HDF_LOGE("%{public}s: failed to get stub object", __func__); delete hdfAllocatorInterfaceHost; diff --git a/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp index b800d240c5..8924d15051 100644 --- a/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp +++ b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp @@ -16,8 +16,8 @@ #include "allocator_interface_service.h" #include #include -#include "hdf_log.h" #include "display_log.h" +#include "hdf_log.h" namespace OHOS { namespace HDI { @@ -29,19 +29,15 @@ extern "C" IAllocatorInterface *AllocatorInterfaceImplGetInstance(void) return new (std::nothrow) AllocatorInterfaceService(); } -AllocatorInterfaceService::AllocatorInterfaceService() - : libHandle_(nullptr), - hwiImpl_(nullptr), - createHwi_(nullptr), - destroyHwi_(nullptr) +AllocatorInterfaceService::AllocatorInterfaceService() : + libHandle_(nullptr), hwiImpl_(nullptr), createHwi_(nullptr), destroyHwi_(nullptr) { int32_t ret = LoadHwi(); if (ret == HDF_SUCCESS) { hwiImpl_ = createHwi_(); CHECK_NULLPOINTER_RETURN(hwiImpl_); } else { - HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", - DISPLAY_BUFFER_HWI_LIBRARY_PATH); + HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", DISPLAY_BUFFER_HWI_LIBRARY_PATH); } } @@ -57,23 +53,21 @@ AllocatorInterfaceService::~AllocatorInterfaceService() int32_t AllocatorInterfaceService::LoadHwi() { - const char* errStr = dlerror(); + const char *errStr = dlerror(); if (errStr) { HDF_LOGI("warning, existing dlerror: %{public}s", errStr); } libHandle_ = dlopen(DISPLAY_BUFFER_HWI_LIBRARY_PATH, RTLD_NOW); CHECK_NULLPOINTER_RETURN_VALUE(libHandle_, HDF_FAILURE); - createHwi_ = reinterpret_cast(dlsym(libHandle_, - "Create_DisplayBufferHwi")); + createHwi_ = reinterpret_cast(dlsym(libHandle_, "Create_DisplayBufferHwi")); errStr = dlerror(); if (errStr) { HDF_LOGE("error: %{public}s", errStr); return HDF_FAILURE; } - destroyHwi_ = reinterpret_cast(dlsym(libHandle_, - "Destroy_DisplayBufferHwi")); + destroyHwi_ = reinterpret_cast(dlsym(libHandle_, "Destroy_DisplayBufferHwi")); errStr = dlerror(); if (errStr) { HDF_LOGE("error: %{public}s", errStr); @@ -83,22 +77,21 @@ int32_t AllocatorInterfaceService::LoadHwi() return HDF_SUCCESS; } -int32_t AllocatorInterfaceService::AllocMem(const AllocInfo &info, - sptr &handle) +int32_t AllocatorInterfaceService::AllocMem(const AllocInfo &info, sptr &handle) { - BufferHandle* buffer = nullptr; + BufferHandle *buffer = nullptr; CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); int32_t ec = hwiImpl_->AllocMem(info, buffer); if (ec == HDF_SUCCESS) { CHECK_NULLPOINTER_RETURN_VALUE(buffer, HDF_FAILURE); } - BufferHandleParcelable* hdiBuffer = new BufferHandleParcelable(*buffer); + BufferHandleParcelable *hdiBuffer = new BufferHandleParcelable(*buffer); CHECK_NULLPOINTER_RETURN_VALUE(hdiBuffer, HDF_FAILURE); handle = hdiBuffer; return HDF_SUCCESS; } } // namespace V1_0 -} // Buffer -} // Display +} // namespace Buffer +} // namespace Display } // namespace HDI } // namespace OHOS diff --git a/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp b/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp index 97972fe022..c8284f07a9 100644 --- a/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp +++ b/display/standard/buffer/hdi_service/src/mapper_interface_driver.cpp @@ -26,8 +26,8 @@ struct HdfMapperInterfaceHost { OHOS::sptr stub; }; -static int32_t MapperInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, - struct HdfSBuf *reply) +static int32_t MapperInterfaceDriverDispatch( + struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { auto *hdfMapperInterfaceHost = CONTAINER_OF(client->device->service, struct HdfMapperInterfaceHost, ioService); @@ -74,8 +74,8 @@ static int HdfMapperInterfaceDriverBind(struct HdfDeviceObject *deviceObject) return HDF_FAILURE; } - hdfMapperInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, - IMapperInterface::GetDescriptor()); + hdfMapperInterfaceHost->stub = + OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, IMapperInterface::GetDescriptor()); if (hdfMapperInterfaceHost->stub == nullptr) { HDF_LOGE("%{public}s: failed to get stub object", __func__); delete hdfMapperInterfaceHost; diff --git a/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp index 724279126b..dcac9ebbc8 100644 --- a/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp +++ b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp @@ -16,8 +16,8 @@ #include "mapper_interface_service.h" #include #include -#include "hdf_log.h" #include "display_log.h" +#include "hdf_log.h" namespace OHOS { namespace HDI { @@ -29,19 +29,15 @@ extern "C" IMapperInterface *MapperInterfaceImplGetInstance(void) return new (std::nothrow) MapperInterfaceService(); } -MapperInterfaceService::MapperInterfaceService() - : libHandle_(nullptr), - hwiImpl_(nullptr), - createHwi_(nullptr), - destroyHwi_(nullptr) +MapperInterfaceService::MapperInterfaceService() : + libHandle_(nullptr), hwiImpl_(nullptr), createHwi_(nullptr), destroyHwi_(nullptr) { int32_t ret = LoadHwi(); if (ret == HDF_SUCCESS) { hwiImpl_ = createHwi_(); CHECK_NULLPOINTER_RETURN(hwiImpl_); } else { - HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", - DISPLAY_BUFFER_HWI_LIBRARY_PATH); + HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", DISPLAY_BUFFER_HWI_LIBRARY_PATH); } } @@ -57,23 +53,21 @@ MapperInterfaceService::~MapperInterfaceService() int32_t MapperInterfaceService::LoadHwi() { - const char* errStr = dlerror(); + const char *errStr = dlerror(); if (errStr) { HDF_LOGI("warning, existing dlerror: %{public}s", errStr); } libHandle_ = dlopen(DISPLAY_BUFFER_HWI_LIBRARY_PATH, RTLD_NOW); CHECK_NULLPOINTER_RETURN_VALUE(libHandle_, HDF_FAILURE); - createHwi_ = reinterpret_cast(dlsym(libHandle_, - "Create_DisplayBufferHwi")); + createHwi_ = reinterpret_cast(dlsym(libHandle_, "Create_DisplayBufferHwi")); errStr = dlerror(); if (errStr) { HDF_LOGE("error: %{public}s", errStr); return HDF_FAILURE; } - destroyHwi_ = reinterpret_cast(dlsym(libHandle_, - "Destroy_DisplayBufferHwi")); + destroyHwi_ = reinterpret_cast(dlsym(libHandle_, "Destroy_DisplayBufferHwi")); errStr = dlerror(); if (errStr) { HDF_LOGE("error: %{public}s", errStr); @@ -92,7 +86,7 @@ int32_t MapperInterfaceService::FreeMem(const sptr &hand int32_t MapperInterfaceService::Mmap(const sptr &handle) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - void* retPtr = hwiImpl_->Mmap(*handle->GetBufferHandle()); + void *retPtr = hwiImpl_->Mmap(*handle->GetBufferHandle()); HDF_LOGD("%{public}s@%{public}d virAddr=%{public}p", __func__, __LINE__, handle->GetBufferHandle()->virAddr); CHECK_NULLPOINTER_RETURN_VALUE(retPtr, HDF_FAILURE); return HDF_SUCCESS; @@ -101,7 +95,7 @@ int32_t MapperInterfaceService::Mmap(const sptr &handle) int32_t MapperInterfaceService::MmapCache(const sptr &handle) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - void* retPtr = hwiImpl_->MmapCache(*handle->GetBufferHandle()); + void *retPtr = hwiImpl_->MmapCache(*handle->GetBufferHandle()); CHECK_NULLPOINTER_RETURN_VALUE(retPtr, HDF_FAILURE); return HDF_SUCCESS; } @@ -134,7 +128,7 @@ int32_t MapperInterfaceService::InvalidateCache(const sptr& cb) override; - - int32_t GetDisplayCapability(uint32_t devId, DisplayCapability& info) override; - - int32_t GetDisplaySupportedModes(uint32_t devId, - std::vector& modes) override; - - int32_t GetDisplayMode(uint32_t devId, uint32_t& modeId) override; - + int32_t RegHotPlugCallback(const sptr &cb) override; + int32_t GetDisplayCapability(uint32_t devId, DisplayCapability &info) override; + int32_t GetDisplaySupportedModes(uint32_t devId, std::vector &modes) override; + int32_t GetDisplayMode(uint32_t devId, uint32_t &modeId) override; int32_t SetDisplayMode(uint32_t devId, uint32_t modeId) override; - - int32_t GetDisplayPowerStatus(uint32_t devId, DispPowerStatus& status) override; - + int32_t GetDisplayPowerStatus(uint32_t devId, DispPowerStatus &status) override; int32_t SetDisplayPowerStatus(uint32_t devId, DispPowerStatus status) override; - - int32_t GetDisplayBacklight(uint32_t devId, uint32_t& level) override; - + int32_t GetDisplayBacklight(uint32_t devId, uint32_t &level) override; int32_t SetDisplayBacklight(uint32_t devId, uint32_t level) override; - - int32_t GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t& value) override; - - int32_t GetDisplayCompChange(uint32_t devId, std::vector& layers, - std::vector& type) override; - - int32_t SetDisplayClientCrop(uint32_t devId, const IRect& rect) override; - - int32_t SetDisplayClientDestRect(uint32_t devId, const IRect& rect) override; - + int32_t GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t &value) override; + int32_t GetDisplayCompChange(uint32_t devId, std::vector &layers, std::vector &type) override; + int32_t SetDisplayClientCrop(uint32_t devId, const IRect &rect) override; + int32_t SetDisplayClientDestRect(uint32_t devId, const IRect &rect) override; int32_t SetDisplayVsyncEnabled(uint32_t devId, bool enabled) override; - - int32_t RegDisplayVBlankCallback(uint32_t devId, const sptr& cb) override; - - int32_t GetDisplayReleaseFence(uint32_t devId, std::vector& layers, - std::vector>& fences) override; - - int32_t CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t& format, uint32_t& devId) override; - + int32_t RegDisplayVBlankCallback(uint32_t devId, const sptr &cb) override; + int32_t GetDisplayReleaseFence( + uint32_t devId, std::vector &layers, std::vector> &fences) override; + int32_t CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t &format, uint32_t &devId) override; int32_t DestroyVirtualDisplay(uint32_t devId) override; - - int32_t SetVirtualDisplayBuffer(uint32_t devId, const sptr& buffer, - const sptr& fence) override; - + int32_t SetVirtualDisplayBuffer( + uint32_t devId, const sptr &buffer, const sptr &fence) override; int32_t SetDisplayProperty(uint32_t devId, uint32_t id, uint64_t value) override; - - int32_t CreateLayer(uint32_t devId, const LayerInfo& layerInfo, uint32_t& layerId) override; - + int32_t CreateLayer(uint32_t devId, const LayerInfo &layerInfo, uint32_t &layerId) override; int32_t DestroyLayer(uint32_t devId, uint32_t layerId) override; - - int32_t InitCmdRequest(const std::shared_ptr>& request) override; - - int32_t CmdRequest(uint32_t inEleCnt, const std::vector& inFds, uint32_t& outEleCnt, - std::vector& outFds) override; - - int32_t GetCmdReply(std::shared_ptr>& reply) override; + int32_t InitCmdRequest(const std::shared_ptr> &request) override; + int32_t CmdRequest(uint32_t inEleCnt, const std::vector &inFds, uint32_t &outEleCnt, + std::vector &outFds) override; + int32_t GetCmdReply(std::shared_ptr> &reply) override; private: int32_t LoadHwi(); - - static void OnHotPlug(uint32_t outputId, bool connected, void* data); - + static void OnHotPlug(uint32_t outputId, bool connected, void *data); static void OnVBlank(unsigned int sequence, uint64_t ns, void *data); private: - void* libHandle_; - CreateComposerHwiFunc_t* createHwiFunc_; - DestroyComposerHwiFunc_t* destroyHwiFunc_; + void *libHandle_; + CreateComposerHwiFunc_t *createHwiFunc_; + DestroyComposerHwiFunc_t *destroyHwiFunc_; std::shared_ptr hwiImpl_; std::unique_ptr cmdResponser_; sptr hotPlugCb_; sptr vBlankCb_; }; -} // V1_0 -} // Composer -} // Display -} // HDI -} // OHOS - +} // namespace V1_0 +} // namespace Composer +} // namespace Display +} // namespace HDI +} // namespace OHOS #endif // OHOS_HDI_DISPLAY_V1_0_DISPLAYCOMPOSERSERVICE_H diff --git a/display/standard/composer/hdi_service/include/idisplay_composer_hwi.h b/display/standard/composer/hdi_service/include/idisplay_composer_hwi.h index ca95475554..d6ebd0c975 100644 --- a/display/standard/composer/hdi_service/include/idisplay_composer_hwi.h +++ b/display/standard/composer/hdi_service/include/idisplay_composer_hwi.h @@ -27,72 +27,61 @@ namespace Composer { namespace V1_0 { using namespace OHOS::HDI::Display::Composer::V1_0; -#define DISPLAY_COMPOSER_HWI_LIBRARY_PATH "/vendor/lib/libdisplay_composer_hwi_impl.z.so" +#define DISPLAY_COMPOSER_HWI_LIBRARY_NAME "libdisplay_composer_hwi_impl.z.so" class IDisplayComposerHwi { public: virtual ~IDisplayComposerHwi() = default; - // *** device func + /** device func */ virtual int32_t RegHotPlugCallback(HotPlugCallback cb, void *data) = 0; - virtual int32_t GetDisplayCapability(uint32_t devId, DisplayCapability& info) = 0; - virtual int32_t GetDisplaySupportedModes(uint32_t devId, - std::vector& modes) = 0; - virtual int32_t GetDisplayMode(uint32_t devId, uint32_t& modeId) = 0; + virtual int32_t GetDisplayCapability(uint32_t devId, DisplayCapability &info) = 0; + virtual int32_t GetDisplaySupportedModes(uint32_t devId, std::vector &modes) = 0; + virtual int32_t GetDisplayMode(uint32_t devId, uint32_t &modeId) = 0; virtual int32_t SetDisplayMode(uint32_t devId, uint32_t modeId) = 0; - virtual int32_t GetDisplayPowerStatus(uint32_t devId, DispPowerStatus& status) = 0; + virtual int32_t GetDisplayPowerStatus(uint32_t devId, DispPowerStatus &status) = 0; virtual int32_t SetDisplayPowerStatus(uint32_t devId, DispPowerStatus status) = 0; - virtual int32_t GetDisplayBacklight(uint32_t devId, uint32_t& level) = 0; + virtual int32_t GetDisplayBacklight(uint32_t devId, uint32_t &level) = 0; virtual int32_t SetDisplayBacklight(uint32_t devId, uint32_t level) = 0; - virtual int32_t GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t& value) = 0; - virtual int32_t GetDisplayCompChange(uint32_t devId, std::vector& layers, - std::vector& types) = 0; - virtual int32_t SetDisplayClientCrop(uint32_t devId, const IRect& rect) = 0; - virtual int32_t SetDisplayClientDestRect(uint32_t devId, const IRect& rect) = 0; - virtual int32_t SetDisplayClientBuffer(uint32_t devId, - const BufferHandle& buffer, int32_t fence) = 0; - virtual int32_t SetDisplayClientDamage(uint32_t devId, std::vector& rects) = 0; + virtual int32_t GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t &value) = 0; + virtual int32_t GetDisplayCompChange( + uint32_t devId, std::vector &layers, std::vector &types) = 0; + virtual int32_t SetDisplayClientCrop(uint32_t devId, const IRect &rect) = 0; + virtual int32_t SetDisplayClientDestRect(uint32_t devId, const IRect &rect) = 0; + virtual int32_t SetDisplayClientBuffer(uint32_t devId, const BufferHandle &buffer, int32_t fence) = 0; + virtual int32_t SetDisplayClientDamage(uint32_t devId, std::vector &rects) = 0; virtual int32_t SetDisplayVsyncEnabled(uint32_t devId, bool enabled) = 0; - virtual int32_t RegDisplayVBlankCallback(uint32_t devId, VBlankCallback cb, - void* data) = 0; - virtual int32_t GetDisplayReleaseFence(uint32_t devId, std::vector& layers, - std::vector& fences) = 0; - virtual int32_t CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t& format, - uint32_t& devId) = 0; + virtual int32_t RegDisplayVBlankCallback(uint32_t devId, VBlankCallback cb, void *data) = 0; + virtual int32_t GetDisplayReleaseFence( + uint32_t devId, std::vector &layers, std::vector &fences) = 0; + virtual int32_t CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t &format, uint32_t &devId) = 0; virtual int32_t DestroyVirtualDisplay(uint32_t devId) = 0; - virtual int32_t SetVirtualDisplayBuffer(uint32_t devId, - const BufferHandle& buffer, const int32_t fence) = 0; + virtual int32_t SetVirtualDisplayBuffer(uint32_t devId, const BufferHandle &buffer, const int32_t fence) = 0; virtual int32_t SetDisplayProperty(uint32_t devId, uint32_t id, uint64_t value) = 0; - virtual int32_t Commit(uint32_t devId, int32_t& fence) = 0; - // *** layer func - virtual int32_t CreateLayer(uint32_t devId, const LayerInfo& layerInfo, - uint32_t& layerId) = 0; + virtual int32_t Commit(uint32_t devId, int32_t &fence) = 0; + /* layer func */ + virtual int32_t CreateLayer(uint32_t devId, const LayerInfo &layerInfo, uint32_t &layerId) = 0; virtual int32_t DestroyLayer(uint32_t devId, uint32_t layerId) = 0; - virtual int32_t PrepareDisplayLayers(uint32_t devId, bool& needFlushFb) = 0; - virtual int32_t SetLayerAlpha(uint32_t devId, uint32_t layerId, const LayerAlpha& alpha) = 0; - virtual int32_t SetLayerPosition(uint32_t devId, uint32_t layerId, const IRect& rect) = 0; - virtual int32_t SetLayerCrop(uint32_t devId, uint32_t layerId, const IRect& rect) = 0; + virtual int32_t PrepareDisplayLayers(uint32_t devId, bool &needFlushFb) = 0; + virtual int32_t SetLayerAlpha(uint32_t devId, uint32_t layerId, const LayerAlpha &alpha) = 0; + virtual int32_t SetLayerPosition(uint32_t devId, uint32_t layerId, const IRect &rect) = 0; + virtual int32_t SetLayerCrop(uint32_t devId, uint32_t layerId, const IRect &rect) = 0; virtual int32_t SetLayerZorder(uint32_t devId, uint32_t layerId, uint32_t zorder) = 0; virtual int32_t SetLayerPreMulti(uint32_t devId, uint32_t layerId, bool preMul) = 0; virtual int32_t SetTransformMode(uint32_t devId, uint32_t layerId, TransformType type) = 0; - virtual int32_t SetLayerDirtyRegion(uint32_t devIdHWI, uint32_t layerId, - const IRect& region) = 0; - virtual int32_t SetLayerVisibleRegion(uint32_t devId, uint32_t layerId, - std::vector& rects) = 0; - virtual int32_t SetLayerBuffer(uint32_t devId, uint32_t layerId, - BufferHandle& buffer, int32_t fence) = 0; - virtual int32_t SetLayerCompositionType(uint32_t devId, uint32_t layerId, - CompositionType type) = 0; + virtual int32_t SetLayerDirtyRegion(uint32_t devIdHWI, uint32_t layerId, const IRect ®ion) = 0; + virtual int32_t SetLayerVisibleRegion(uint32_t devId, uint32_t layerId, std::vector &rects) = 0; + virtual int32_t SetLayerBuffer(uint32_t devId, uint32_t layerId, BufferHandle &buffer, int32_t fence) = 0; + virtual int32_t SetLayerCompositionType(uint32_t devId, uint32_t layerId, CompositionType type) = 0; virtual int32_t SetLayerBlendType(uint32_t devId, uint32_t layerId, BlendType type) = 0; virtual int32_t SetLayerVisible(uint32_t devId, uint32_t layerId, bool visible) = 0; }; -typedef IDisplayComposerHwi* CreateComposerHwiFunc_t(); -extern "C" IDisplayComposerHwi* CreateComposerHwi(); -typedef void DestroyComposerHwiFunc_t(IDisplayComposerHwi*); -extern "C" void DestroyComposerHwi(IDisplayComposerHwi* hwi); +using IDisplayComposerHwi *CreateComposerHwiFunc_t(); +extern "C" IDisplayComposerHwi *CreateComposerHwi(); +using void DestroyComposerHwiFunc_t(IDisplayComposerHwi *hwi); +extern "C" void DestroyComposerHwi(IDisplayComposerHwi *hwi); } // namespace V1_0 } // namespace Composer } // namespace Display } // namespace HDI } // namespace OHOS - #endif // OHOS_HDI_DISPLAY_V1_0_IDISPLAYCOMPOSERHWI_H diff --git a/display/standard/composer/hdi_service/src/display_composer_driver.cpp b/display/standard/composer/hdi_service/src/display_composer_driver.cpp index a975d48e73..76116f0cab 100644 --- a/display/standard/composer/hdi_service/src/display_composer_driver.cpp +++ b/display/standard/composer/hdi_service/src/display_composer_driver.cpp @@ -26,8 +26,8 @@ struct HdfDisplayComposerHost { OHOS::sptr stub; }; -static int32_t DisplayComposerDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, - struct HdfSBuf *reply) +static int32_t DisplayComposerDriverDispatch( + struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { auto *hdfDisplayComposerHost = CONTAINER_OF(client->device->service, struct HdfDisplayComposerHost, ioService); @@ -74,8 +74,8 @@ static int HdfDisplayComposerDriverBind(struct HdfDeviceObject *deviceObject) return HDF_FAILURE; } - hdfDisplayComposerHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, - IDisplayComposer::GetDescriptor()); + hdfDisplayComposerHost->stub = + OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, IDisplayComposer::GetDescriptor()); if (hdfDisplayComposerHost->stub == nullptr) { HDF_LOGE("%{public}s: failed to get stub object", __func__); delete hdfDisplayComposerHost; diff --git a/display/standard/composer/hdi_service/src/display_composer_service.cpp b/display/standard/composer/hdi_service/src/display_composer_service.cpp index 9941fd9e20..7e0ba929d9 100644 --- a/display/standard/composer/hdi_service/src/display_composer_service.cpp +++ b/display/standard/composer/hdi_service/src/display_composer_service.cpp @@ -16,8 +16,9 @@ #include "display_composer_service.h" #include #include -#include "hdf_log.h" + #include "display_log.h" +#include "hdf_log.h" namespace OHOS { namespace HDI { @@ -29,8 +30,8 @@ extern "C" IDisplayComposer *DisplayComposerImplGetInstance(void) return new (std::nothrow) DisplayComposerService(); } -DisplayComposerService::DisplayComposerService() - : libHandle_(nullptr), +DisplayComposerService::DisplayComposerService() : + libHandle_(nullptr), createHwiFunc_(nullptr), destroyHwiFunc_(nullptr), hwiImpl_(nullptr), @@ -45,8 +46,7 @@ DisplayComposerService::DisplayComposerService() cmdResponser_ = HdiDisplayCmdResponser::Create(hwiImpl_); CHECK_NULLPOINTER_RETURN(cmdResponser_); } else { - HDF_LOGE("error: LoadHwi failure, lib path:%{public}s", - DISPLAY_COMPOSER_HWI_LIBRARY_PATH); + HDF_LOGE("error: LoadHwi failure, lib name:%{public}s", DISPLAY_COMPOSER_HWI_LIBRARY_NAME); } } @@ -63,23 +63,21 @@ DisplayComposerService::~DisplayComposerService() int32_t DisplayComposerService::LoadHwi() { - const char* errStr = dlerror(); + const char *errStr = dlerror(); if (errStr) { HDF_LOGI("warning, existing dlerror: %{public}s", errStr); } - libHandle_ = dlopen(DISPLAY_COMPOSER_HWI_LIBRARY_PATH, RTLD_LAZY); + libHandle_ = dlopen(DISPLAY_COMPOSER_HWI_LIBRARY_NAME, RTLD_LAZY); CHECK_NULLPOINTER_RETURN_VALUE(libHandle_, HDF_FAILURE); - createHwiFunc_ = - reinterpret_cast(dlsym(libHandle_, "CreateComposerHwi")); + createHwiFunc_ = reinterpret_cast(dlsym(libHandle_, "CreateComposerHwi")); errStr = dlerror(); if (errStr) { HDF_LOGE("error: %{public}s", errStr); return HDF_FAILURE; } - destroyHwiFunc_ = - reinterpret_cast(dlsym(libHandle_, "DestroyComposerHwi")); + destroyHwiFunc_ = reinterpret_cast(dlsym(libHandle_, "DestroyComposerHwi")); errStr = dlerror(); if (errStr) { HDF_LOGE("error: %{public}s", errStr); @@ -89,11 +87,10 @@ int32_t DisplayComposerService::LoadHwi() return HDF_SUCCESS; } -void DisplayComposerService::OnHotPlug(uint32_t outputId, bool connected, void* data) +void DisplayComposerService::OnHotPlug(uint32_t outputId, bool connected, void *data) { if (data != nullptr) { - sptr remoteCb = - reinterpret_cast(data)->hotPlugCb_; + sptr remoteCb = reinterpret_cast(data)->hotPlugCb_; if (remoteCb != nullptr) { remoteCb->OnHotPlug(outputId, connected); } else { @@ -107,9 +104,9 @@ void DisplayComposerService::OnHotPlug(uint32_t outputId, bool connected, void* void DisplayComposerService::OnVBlank(unsigned int sequence, uint64_t ns, void *data) { - IVBlankCallback* remoteCb; + IVBlankCallback *remoteCb; if (data != nullptr) { - remoteCb = reinterpret_cast(data); + remoteCb = reinterpret_cast(data); if (remoteCb != nullptr) { remoteCb->OnVBlank(sequence, ns); } else { @@ -121,117 +118,101 @@ void DisplayComposerService::OnVBlank(unsigned int sequence, uint64_t ns, void * return; } -int32_t DisplayComposerService::RegHotPlugCallback(const sptr& cb) +int32_t DisplayComposerService::RegHotPlugCallback(const sptr &cb) { hotPlugCb_ = cb; CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->RegHotPlugCallback(OnHotPlug, this); - return ec; + return hwiImpl_->RegHotPlugCallback(OnHotPlug, this); } -int32_t DisplayComposerService::GetDisplayCapability(uint32_t devId, DisplayCapability& info) +int32_t DisplayComposerService::GetDisplayCapability(uint32_t devId, DisplayCapability &info) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->GetDisplayCapability(devId, info); - return ec; + return hwiImpl_->GetDisplayCapability(devId, info); } -int32_t DisplayComposerService::GetDisplaySupportedModes(uint32_t devId, - std::vector& modes) +int32_t DisplayComposerService::GetDisplaySupportedModes(uint32_t devId, std::vector &modes) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->GetDisplaySupportedModes(devId, modes); - return ec; + return hwiImpl_->GetDisplaySupportedModes(devId, modes); } -int32_t DisplayComposerService::GetDisplayMode(uint32_t devId, uint32_t& modeId) +int32_t DisplayComposerService::GetDisplayMode(uint32_t devId, uint32_t &modeId) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->GetDisplayMode(devId, modeId); - return ec; + return hwiImpl_->GetDisplayMode(devId, modeId); } int32_t DisplayComposerService::SetDisplayMode(uint32_t devId, uint32_t modeId) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetDisplayMode(devId, modeId); - return ec; + return hwiImpl_->SetDisplayMode(devId, modeId); } -int32_t DisplayComposerService::GetDisplayPowerStatus(uint32_t devId, DispPowerStatus& status) +int32_t DisplayComposerService::GetDisplayPowerStatus(uint32_t devId, DispPowerStatus &status) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->GetDisplayPowerStatus(devId, status); - return ec; + return hwiImpl_->GetDisplayPowerStatus(devId, status); } int32_t DisplayComposerService::SetDisplayPowerStatus(uint32_t devId, DispPowerStatus status) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetDisplayPowerStatus(devId, status); - return ec; + return hwiImpl_->SetDisplayPowerStatus(devId, status); } -int32_t DisplayComposerService::GetDisplayBacklight(uint32_t devId, uint32_t& level) +int32_t DisplayComposerService::GetDisplayBacklight(uint32_t devId, uint32_t &level) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->GetDisplayBacklight(devId, level); - return ec; + return hwiImpl_->GetDisplayBacklight(devId, level); } int32_t DisplayComposerService::SetDisplayBacklight(uint32_t devId, uint32_t level) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetDisplayBacklight(devId, level); - return ec; + return hwiImpl_->SetDisplayBacklight(devId, level); } -int32_t DisplayComposerService::GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t& value) +int32_t DisplayComposerService::GetDisplayProperty(uint32_t devId, uint32_t id, uint64_t &value) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->GetDisplayProperty(devId, id, value); - return ec; + return hwiImpl_->GetDisplayProperty(devId, id, value); } -int32_t DisplayComposerService::GetDisplayCompChange(uint32_t devId, std::vector& layers, - std::vector& type) +int32_t DisplayComposerService::GetDisplayCompChange( + uint32_t devId, std::vector &layers, std::vector &type) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->GetDisplayCompChange(devId, layers, type); - return ec; + return hwiImpl_->GetDisplayCompChange(devId, layers, type); } -int32_t DisplayComposerService::SetDisplayClientCrop(uint32_t devId, const IRect& rect) +int32_t DisplayComposerService::SetDisplayClientCrop(uint32_t devId, const IRect &rect) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetDisplayClientCrop(devId, rect); - return ec; + return hwiImpl_->SetDisplayClientCrop(devId, rect); } -int32_t DisplayComposerService::SetDisplayClientDestRect(uint32_t devId, const IRect& rect) +int32_t DisplayComposerService::SetDisplayClientDestRect(uint32_t devId, const IRect &rect) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetDisplayClientDestRect(devId, rect); - return ec; + return hwiImpl_->SetDisplayClientDestRect(devId, rect); } int32_t DisplayComposerService::SetDisplayVsyncEnabled(uint32_t devId, bool enabled) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetDisplayVsyncEnabled(devId, enabled); - return ec; + return hwiImpl_->SetDisplayVsyncEnabled(devId, enabled); } -int32_t DisplayComposerService::RegDisplayVBlankCallback(uint32_t devId, const sptr& cb) +int32_t DisplayComposerService::RegDisplayVBlankCallback(uint32_t devId, const sptr &cb) { vBlankCb_ = cb; CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->RegDisplayVBlankCallback(devId, OnVBlank, vBlankCb_.GetRefPtr()); - return ec; + return hwiImpl_->RegDisplayVBlankCallback(devId, OnVBlank, vBlankCb_.GetRefPtr()); } -int32_t DisplayComposerService::GetDisplayReleaseFence(uint32_t devId, std::vector& layers, - std::vector>& fences) +int32_t DisplayComposerService::GetDisplayReleaseFence( + uint32_t devId, std::vector &layers, std::vector> &fences) { std::vector outFences; CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); @@ -245,74 +226,65 @@ int32_t DisplayComposerService::GetDisplayReleaseFence(uint32_t devId, std::vect return ec; } -int32_t DisplayComposerService::CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t& format, uint32_t& devId) +int32_t DisplayComposerService::CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t &format, uint32_t &devId) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->CreateVirtualDisplay(width, height, format, devId); - return ec; + return hwiImpl_->CreateVirtualDisplay(width, height, format, devId); } int32_t DisplayComposerService::DestroyVirtualDisplay(uint32_t devId) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->DestroyVirtualDisplay(devId); - return ec; + return hwiImpl_->DestroyVirtualDisplay(devId); } -int32_t DisplayComposerService::SetVirtualDisplayBuffer(uint32_t devId, const sptr& buffer, - const sptr& fence) +int32_t DisplayComposerService::SetVirtualDisplayBuffer( + uint32_t devId, const sptr &buffer, const sptr &fence) { - BufferHandle* handle = buffer->GetBufferHandle(); + BufferHandle *handle = buffer->GetBufferHandle(); int32_t inFence = fence->GetFd(); CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetVirtualDisplayBuffer(devId, *handle, inFence); - return ec; + return hwiImpl_->SetVirtualDisplayBuffer(devId, *handle, inFence); } int32_t DisplayComposerService::SetDisplayProperty(uint32_t devId, uint32_t id, uint64_t value) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->SetDisplayProperty(devId, id, value); - return ec; + return hwiImpl_->SetDisplayProperty(devId, id, value); } -int32_t DisplayComposerService::CreateLayer(uint32_t devId, const LayerInfo& layerInfo, uint32_t& layerId) +int32_t DisplayComposerService::CreateLayer(uint32_t devId, const LayerInfo &layerInfo, uint32_t &layerId) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->CreateLayer(devId, layerInfo, layerId); - return ec; + return hwiImpl_->CreateLayer(devId, layerInfo, layerId); } int32_t DisplayComposerService::DestroyLayer(uint32_t devId, uint32_t layerId) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = hwiImpl_->DestroyLayer(devId, layerId); - return ec; + return hwiImpl_->DestroyLayer(devId, layerId); } -int32_t DisplayComposerService::InitCmdRequest(const std::shared_ptr>& request) +int32_t DisplayComposerService::InitCmdRequest(const std::shared_ptr> &request) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = cmdResponser_->InitCmdRequest(request); - return ec; + return cmdResponser_->InitCmdRequest(request); } -int32_t DisplayComposerService::CmdRequest(uint32_t inEleCnt, const std::vector& inFds, - uint32_t& outEleCnt, std::vector& outFds) +int32_t DisplayComposerService::CmdRequest( + uint32_t inEleCnt, const std::vector &inFds, uint32_t &outEleCnt, std::vector &outFds) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = cmdResponser_->CmdRequest(inEleCnt, inFds, outEleCnt, outFds); - return ec; + return cmdResponser_->CmdRequest(inEleCnt, inFds, outEleCnt, outFds); } -int32_t DisplayComposerService::GetCmdReply(std::shared_ptr>& reply) +int32_t DisplayComposerService::GetCmdReply(std::shared_ptr> &reply) { CHECK_NULLPOINTER_RETURN_VALUE(hwiImpl_, HDF_FAILURE); - int32_t ec = cmdResponser_->GetCmdReply(reply); - return ec; + return cmdResponser_->GetCmdReply(reply); } -} // V1_0 -} // Composer -} // Display -} // HDI -} // OHOS +} // namespace V1_0 +} // namespace Composer +} // namespace Display +} // namespace HDI +} // namespace OHOS diff --git a/display/standard/utils/include/display_common.h b/display/standard/utils/include/display_common.h index c8d0146705..ecfdb32775 100644 --- a/display/standard/utils/include/display_common.h +++ b/display/standard/utils/include/display_common.h @@ -24,7 +24,7 @@ namespace Display { typedef void (*HotPlugCallback)(uint32_t devId, bool connected, void *data); typedef void (*VBlankCallback)(unsigned int sequence, uint64_t ns, void *data); typedef void (*RefreshCallback)(uint32_t devId, void *data); -} // Display -} // HDI -} // OHOS +} // namespace Display +} // namespace HDI +} // namespace OHOS #endif /* DISPLAY_COMMON_H */ diff --git a/display/standard/utils/include/display_log.h b/display/standard/utils/include/display_log.h index a6b846a7de..e68e08f5d4 100644 --- a/display/standard/utils/include/display_log.h +++ b/display/standard/utils/include/display_log.h @@ -15,10 +15,10 @@ #ifndef DISPLAY_LOG_H #define DISPLAY_LOG_H -#include #include +#include #include "hilog/log.h" -#include "stdio.h" + #ifdef HDF_LOG_TAG #undef HDF_LOG_TAG #endif @@ -28,9 +28,9 @@ extern "C" { #endif #undef LOG_TAG -#undef LOG_DOMAIN #define LOG_TAG "DISP" -#define LOG_DOMAIN 0xD001400 +#undef LOG_DOMAIN +#define LOG_DOMAIN 0xD002500 #ifndef DISPLAY_UNUSED #define DISPLAY_UNUSED(x) (void)(x) @@ -41,40 +41,36 @@ extern "C" { #endif #ifndef DISPLAY_LOGD -#define DISPLAY_LOGD(format, ...) \ - do { \ - if (DISPLAY_DEBUG_ENABLE) { \ - HILOG_DEBUG(LOG_CORE, "[%{public}s:%{public}d] " format "\n", \ - __FUNCTION__, __LINE__, \ - ##__VA_ARGS__); \ - } \ +#define DISPLAY_LOGD(format, ...) \ + do { \ + if (DISPLAY_DEBUG_ENABLE) { \ + HILOG_DEBUG(LOG_CORE, "[%{public}s:%{public}d] " format "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \ + } \ } while (0) #endif #ifndef DISPLAY_LOGI -#define DISPLAY_LOGI(format, ...) \ - do { \ - HILOG_INFO(LOG_CORE, "[%{public}s:%{public}d] " format "\n", \ - __FUNCTION__, __LINE__, ##__VA_ARGS__); \ +#define DISPLAY_LOGI(format, ...) \ + do { \ + HILOG_INFO(LOG_CORE, "[%{public}s:%{public}d] " format "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \ } while (0) #endif #ifndef DISPLAY_LOGW -#define DISPLAY_LOGW(format, ...) \ - do { \ - HILOG_WARN(LOG_CORE, "[%{public}s:%{public}d] " format "\n", \ - __FUNCTION__, __LINE__, ##__VA_ARGS__); \ +#define DISPLAY_LOGW(format, ...) \ + do { \ + HILOG_WARN(LOG_CORE, "[%{public}s:%{public}d] " format "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \ } while (0) #endif #ifndef DISPLAY_LOGE -#define DISPLAY_LOGE(format, ...) \ - do { \ - HILOG_ERROR(LOG_CORE, \ - "\033[0;32;31m" \ - "[%{public}s:%{public}d] " format "\033[m" \ - "\n", \ - __FUNCTION__, __LINE__, ##__VA_ARGS__); \ +#define DISPLAY_LOGE(format, ...) \ + do { \ + HILOG_ERROR(LOG_CORE, \ + "\033[0;32;31m" \ + "[%{public}s:%{public}d] " format "\033[m" \ + "\n", \ + __FUNCTION__, __LINE__, ##__VA_ARGS__); \ } while (0) #endif @@ -109,12 +105,12 @@ extern "C" { #endif #ifndef DISPLAY_CHK_RETURN_NOT_VALUE -#define DISPLAY_CHK_RETURN_NOT_VALUE(val, ...) \ - do { \ - if (val) { \ - __VA_ARGS__; \ - return; \ - } \ +#define DISPLAY_CHK_RETURN_NOT_VALUE(val, ...) \ + do { \ + if (val) { \ + __VA_ARGS__; \ + return; \ + } \ } while (0) #endif -- Gitee From 72ae73fabde5f3a18051de56cb69763c4376ad69 Mon Sep 17 00:00:00 2001 From: JasonYujia Date: Sat, 6 Aug 2022 12:00:01 +0000 Subject: [PATCH 26/33] modify codeCheck Signed-off-by: JasonYujia --- .../buffer/hdi_service/src/allocator_interface_service.cpp | 7 +++++-- .../buffer/hdi_service/src/mapper_interface_service.cpp | 7 +++++-- .../composer/hdi_service/src/display_composer_service.cpp | 4 ++-- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp index 8924d15051..c33cebd3c0 100644 --- a/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp +++ b/display/standard/buffer/hdi_service/src/allocator_interface_service.cpp @@ -29,8 +29,11 @@ extern "C" IAllocatorInterface *AllocatorInterfaceImplGetInstance(void) return new (std::nothrow) AllocatorInterfaceService(); } -AllocatorInterfaceService::AllocatorInterfaceService() : - libHandle_(nullptr), hwiImpl_(nullptr), createHwi_(nullptr), destroyHwi_(nullptr) +AllocatorInterfaceService::AllocatorInterfaceService() + : libHandle_(nullptr), + hwiImpl_(nullptr), + createHwi_(nullptr), + destroyHwi_(nullptr) { int32_t ret = LoadHwi(); if (ret == HDF_SUCCESS) { diff --git a/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp index dcac9ebbc8..eb0a3ad906 100644 --- a/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp +++ b/display/standard/buffer/hdi_service/src/mapper_interface_service.cpp @@ -29,8 +29,11 @@ extern "C" IMapperInterface *MapperInterfaceImplGetInstance(void) return new (std::nothrow) MapperInterfaceService(); } -MapperInterfaceService::MapperInterfaceService() : - libHandle_(nullptr), hwiImpl_(nullptr), createHwi_(nullptr), destroyHwi_(nullptr) +MapperInterfaceService::MapperInterfaceService() + : libHandle_(nullptr), + hwiImpl_(nullptr), + createHwi_(nullptr), + destroyHwi_(nullptr) { int32_t ret = LoadHwi(); if (ret == HDF_SUCCESS) { diff --git a/display/standard/composer/hdi_service/src/display_composer_service.cpp b/display/standard/composer/hdi_service/src/display_composer_service.cpp index 7e0ba929d9..6e0b3377e4 100644 --- a/display/standard/composer/hdi_service/src/display_composer_service.cpp +++ b/display/standard/composer/hdi_service/src/display_composer_service.cpp @@ -30,8 +30,8 @@ extern "C" IDisplayComposer *DisplayComposerImplGetInstance(void) return new (std::nothrow) DisplayComposerService(); } -DisplayComposerService::DisplayComposerService() : - libHandle_(nullptr), +DisplayComposerService::DisplayComposerService() + : libHandle_(nullptr), createHwiFunc_(nullptr), destroyHwiFunc_(nullptr), hwiImpl_(nullptr), -- Gitee From 56966a236f081e59c4a3c3107a7634967286cc19 Mon Sep 17 00:00:00 2001 From: yichengzhao Date: Mon, 8 Aug 2022 11:14:25 +0800 Subject: [PATCH 27/33] change bootslot -> bootslots Signed-off-by: yichengzhao Change-Id: I2fddfd62bf08833f34eccd3b29a56bf6a9c77484 --- partitionslot/hal/src/partitionslot_manager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/partitionslot/hal/src/partitionslot_manager.cpp b/partitionslot/hal/src/partitionslot_manager.cpp index c37b2cebbe..0a76379a1c 100644 --- a/partitionslot/hal/src/partitionslot_manager.cpp +++ b/partitionslot/hal/src/partitionslot_manager.cpp @@ -38,7 +38,7 @@ constexpr off_t MISC_PARTITION_UNBOOT_SLOT_SIZE = 4; int32_t PartitionSlotManager::GetCurrentSlot(int32_t& numOfSlots) { HILOG_DEBUG(LOG_CORE, "%{public}s called!", __func__); - numOfSlots = system::GetIntParameter("ohos.boot.bootslot", 1); + numOfSlots = system::GetIntParameter("ohos.boot.bootslots", 1); char miscDev[PATH_MAX] = { 0 }; int ret = GetBlockDevicePath("/misc", miscDev, PATH_MAX); if (ret != 0) { -- Gitee From fc6a9ce75bd8156ebb020632146bca114894676d Mon Sep 17 00:00:00 2001 From: yanghaizhou Date: Mon, 8 Aug 2022 15:18:23 +0800 Subject: [PATCH 28/33] nullptr check before access to StreamBase::lastRequest_ Signed-off-by: yanghaizhou --- .../platform/v4l2/src/driver_adapter/src/v4l2_stream.cpp | 2 +- camera/hal/hdi_impl/src/stream_operator/stream_base.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_stream.cpp b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_stream.cpp index 778cf05338..8f61a9e40a 100644 --- a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_stream.cpp +++ b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_stream.cpp @@ -36,7 +36,7 @@ RetCode HosV4L2Streams::V4L2StreamOn(int fd) buf_type = bufferType_; rc = ioctl(fd, VIDIOC_STREAMON, &buf_type); if (rc < 0) { - CAMERA_LOGE("error: ioctl VIDIOC_STREAMON failed: %s\n", strerror(errno)); + CAMERA_LOGE("error: ioctl VIDIOC_STREAMON failed: %{public}s\n", strerror(errno)); return RC_ERROR; } diff --git a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp index c1d88d1a21..a774b4e636 100644 --- a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp +++ b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp @@ -219,7 +219,7 @@ RetCode StreamBase::StopStream() return RC_ERROR; } - if (lastRequest_->IsContinous() && !inTransitList_.empty()) { + if (lastRequest_ != nullptr && lastRequest_->IsContinous() && !inTransitList_.empty()) { std::shared_ptr endMessage = std::make_shared(streamId_, lastRequest_->GetCaptureId(), lastRequest_->GetEndTime(), lastRequest_->GetOwnerCount(), tunnel_->GetFrameCount()); -- Gitee From ccb45edb8323f551b7f928c8b0c39842d832998c Mon Sep 17 00:00:00 2001 From: chenhaifan Date: Mon, 8 Aug 2022 18:09:50 +0800 Subject: [PATCH 29/33] File path verification, data type modification and loop splitting Signed-off-by: chenhaifan --- audio/hal/hdi_passthrough/src/audio_adapter.c | 8 ++++---- .../src/audio_adapter_info_common.c | 15 ++++++++++++--- audio/hal/hdi_passthrough/src/audio_capture.c | 4 ++-- audio/hal/hdi_passthrough/src/audio_common.c | 5 +++-- audio/hal/hdi_passthrough/src/audio_manager.c | 11 ++++------- audio/hal/hdi_passthrough/src/audio_render.c | 5 +++-- 6 files changed, 28 insertions(+), 20 deletions(-) diff --git a/audio/hal/hdi_passthrough/src/audio_adapter.c b/audio/hal/hdi_passthrough/src/audio_adapter.c index 468c9fe302..b1d939c6a2 100644 --- a/audio/hal/hdi_passthrough/src/audio_adapter.c +++ b/audio/hal/hdi_passthrough/src/audio_adapter.c @@ -1060,7 +1060,7 @@ int32_t AudioAdapterGetPortCapability(struct AudioAdapter *adapter, const struct AUDIO_FUNC_LOGE("hwAdapter portCapabilitys is NULL!"); return AUDIO_HAL_ERR_INTERNAL; } - int32_t portNum = hwAdapter->adapterDescriptor.portNum; + uint32_t portNum = hwAdapter->adapterDescriptor.portNum; while (hwAdapterPortCapabilitys != NULL && portNum) { if (hwAdapterPortCapabilitys->port.portId == port->portId) { *capability = hwAdapterPortCapabilitys->capability; @@ -1085,7 +1085,7 @@ int32_t AudioAdapterSetPassthroughModeExec(struct AudioHwAdapter *hwAdapter, uin } struct AudioPortAndCapability *portCapabilityTemp = hwAdapter->portCapabilitys; struct AudioPortCapability *portCapability = NULL; - int32_t portNum = hwAdapter->adapterDescriptor.portNum; + uint32_t portNum = hwAdapter->adapterDescriptor.portNum; while (portCapabilityTemp != NULL && portNum > 0) { if (portCapabilityTemp->port.portId == portId) { portCapability = &portCapabilityTemp->capability; @@ -1103,7 +1103,7 @@ int32_t AudioAdapterSetPassthroughModeExec(struct AudioHwAdapter *hwAdapter, uin AUDIO_FUNC_LOGE("portCapability->subPorts is NULL!"); return AUDIO_HAL_ERR_INTERNAL; } - int32_t subPortNum = portCapability->subPortsNum; + uint32_t subPortNum = portCapability->subPortsNum; while (subPortCapability != NULL && subPortNum > 0) { if (subPortCapability->mask == mode) { portCapabilityTemp->mode = mode; @@ -1165,7 +1165,7 @@ int32_t AudioAdapterGetPassthroughMode(struct AudioAdapter *adapter, const struc return AUDIO_HAL_ERR_INTERNAL; } struct AudioPortAndCapability *portCapabilitys = hwAdapter->portCapabilitys; - int32_t portNum = hwAdapter->adapterDescriptor.portNum; + uint32_t portNum = hwAdapter->adapterDescriptor.portNum; while (portCapabilitys != NULL && portNum > 0) { if (portCapabilitys->port.portId == port->portId) { *mode = portCapabilitys->mode; diff --git a/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c b/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c index 803cc6885b..bb951367c2 100644 --- a/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c +++ b/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c @@ -851,7 +851,10 @@ static void AudioAdaptersNamesRepair(void) static void AudioPortsNamesRepair(void) { - int i, j, adapterNum, portNum; + int32_t i; + int32_t j; + int32_t adapterNum; + uint32_t portNum; if (g_audioAdapterOut == NULL || g_audioAdapterDescs == NULL || g_adapterNum <= 0) { @@ -892,7 +895,10 @@ static void AudioAdaptersNamesRecord(void) static void AudioPortsNamesRecord(void) { - int i, j, adapterCurNum, portCurNum; + int32_t i; + int32_t j; + int32_t adapterCurNum; + uint32_t portCurNum; if (g_audioAdapterOut == NULL || g_audioAdapterDescs == NULL || g_adapterNum <= 0) { return; @@ -1227,7 +1233,10 @@ int32_t KeyValueListToMap(const char *keyValueList, struct ParamValMap mParamVal char *tempBuf = buffer; char *outPtr = NULL; char *inPtr = NULL; - while (i < MAP_MAX && ((mParaMap[i] = strtok_r(tempBuf, ";", &outPtr)) != NULL)) { + while (i < MAP_MAX) { + if ((mParaMap[i] = strtok_r(tempBuf, ";", &outPtr)) == NULL) { + break; + } tempBuf = mParaMap[i]; if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) { ret = strncpy_s(mParamValMap[i].key, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1); diff --git a/audio/hal/hdi_passthrough/src/audio_capture.c b/audio/hal/hdi_passthrough/src/audio_capture.c index 52c93f5bd4..7a651308f0 100644 --- a/audio/hal/hdi_passthrough/src/audio_capture.c +++ b/audio/hal/hdi_passthrough/src/audio_capture.c @@ -754,7 +754,7 @@ void LogErrorCapture(AudioHandle handle, int errorCode, int reason) } if (errorCode == WRITE_FRAME_ERROR_CODE) { hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].errorCode = errorCode; - hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].count = hwCapture->errorLog.iter; + hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].count = (int32_t)hwCapture->errorLog.iter; hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].frames = hwCapture->captureParam.frameCaptureMode.frames; hwCapture->errorLog.iter++; @@ -958,7 +958,7 @@ int32_t AudioCaptureReqMmapBufferInit(struct AudioHwCapture *capture, int32_t re } // formatBits Move right 3 desc->totalBufferFrames = - reqSize / (capture->captureParam.frameCaptureMode.attrs.channelCount * (formatBits >> 3)); + reqSize / (int32_t)(capture->captureParam.frameCaptureMode.attrs.channelCount * (formatBits >> 3)); InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Is NULL"); diff --git a/audio/hal/hdi_passthrough/src/audio_common.c b/audio/hal/hdi_passthrough/src/audio_common.c index e1e62feff6..1b49e64921 100644 --- a/audio/hal/hdi_passthrough/src/audio_common.c +++ b/audio/hal/hdi_passthrough/src/audio_common.c @@ -124,7 +124,7 @@ int32_t TimeToAudioTimeStamp(uint64_t bufferFrameSize, struct AudioTimeStamp *ti return HDF_FAILURE; } time->tvSec += (int64_t)(bufferFrameSize / sampleRate); - int64_t lastBufFrames = bufferFrameSize % ((int64_t)sampleRate); + int64_t lastBufFrames = (int64_t)bufferFrameSize % ((int64_t)sampleRate); time->tvNSec += (lastBufFrames * SEC_TO_NSEC) / ((int64_t)sampleRate); if (time->tvNSec >= SEC_TO_NSEC) { time->tvSec += 1; @@ -139,6 +139,7 @@ void AudioLogRecord(int errorLevel, const char *format, ...) FILE *fp = NULL; char timeStr[TIME_LEN]; char fileName[FILE_NAME_LEN]; + char pathBuf[PATH_MAX] = {'\0'}; struct tm *tblock = NULL; char folderName[] = "/data/log/drivers_peripheral_audio"; va_start(args, format); @@ -147,7 +148,7 @@ void AudioLogRecord(int errorLevel, const char *format, ...) if (tblock == NULL) { return; } - int32_t ret = strftime(fileName, sizeof(fileName), "//data/log/drivers_peripheral_audio/audio_%Y%m%d_%H%M%S.log", + uint32_t ret = strftime(fileName, sizeof(fileName), "//data/log/drivers_peripheral_audio/audio_%Y%m%d.log", tblock); if (ret == 0) { return; diff --git a/audio/hal/hdi_passthrough/src/audio_manager.c b/audio/hal/hdi_passthrough/src/audio_manager.c index cc8c8b38ba..d738f488a3 100644 --- a/audio/hal/hdi_passthrough/src/audio_manager.c +++ b/audio/hal/hdi_passthrough/src/audio_manager.c @@ -109,8 +109,7 @@ int32_t InitCaptureSoHandle(const char *captureSoPath) return HDF_FAILURE; } if (g_ptrCaptureHandle == NULL) { - char *cPathBuf = pathBuf; - g_ptrCaptureHandle = dlopen(cPathBuf, RTLD_LAZY); + g_ptrCaptureHandle = dlopen(pathBuf, RTLD_LAZY); if (g_ptrCaptureHandle == NULL) { AUDIO_FUNC_LOGE("open lib capture so fail, reason:%{public}s", dlerror()); return HDF_FAILURE; @@ -138,8 +137,7 @@ int32_t InitRenderSoHandle(const char *renderSoPath) return HDF_FAILURE; } if (g_ptrRenderHandle == NULL) { - char *cPathBuf = pathBuf; - g_ptrRenderHandle = dlopen(cPathBuf, RTLD_LAZY); + g_ptrRenderHandle = dlopen(pathBuf, RTLD_LAZY); if (g_ptrRenderHandle == NULL) { AUDIO_FUNC_LOGE("open lib render so fail, reason:%{public}s", dlerror()); return HDF_FAILURE; @@ -168,8 +166,7 @@ int32_t InitPathSelectSoHandle(const char *pathSelectSoPath) return HDF_FAILURE; } if (g_ptrPathSelHandle == NULL) { - char *cPathBuf = pathBuf; - g_ptrPathSelHandle = dlopen(cPathBuf, RTLD_LAZY); + g_ptrPathSelHandle = dlopen(pathBuf, RTLD_LAZY); if (g_ptrPathSelHandle == NULL) { AUDIO_FUNC_LOGE("open lib PathSelct so fail, reason:%s", dlerror()); return HDF_FAILURE; @@ -411,7 +408,7 @@ void AudioManagerUnloadAdapter(struct AudioManager *manager, struct AudioAdapter return; } if (hwAdapter->portCapabilitys != NULL) { - int32_t portNum = hwAdapter->adapterDescriptor.portNum; + uint32_t portNum = hwAdapter->adapterDescriptor.portNum; int32_t i = 0; while (i < portNum) { if (&hwAdapter->portCapabilitys[i] != NULL) { diff --git a/audio/hal/hdi_passthrough/src/audio_render.c b/audio/hal/hdi_passthrough/src/audio_render.c index 45376f0346..1145c612c2 100644 --- a/audio/hal/hdi_passthrough/src/audio_render.c +++ b/audio/hal/hdi_passthrough/src/audio_render.c @@ -790,7 +790,7 @@ void LogError(AudioHandle handle, int32_t errorCode, int reason) } if (errorCode == WRITE_FRAME_ERROR_CODE) { hwRender->errorLog.errorDump[hwRender->errorLog.iter].errorCode = errorCode; - hwRender->errorLog.errorDump[hwRender->errorLog.iter].count = hwRender->errorLog.iter; + hwRender->errorLog.errorDump[hwRender->errorLog.iter].count = (int32_t)hwRender->errorLog.iter; hwRender->errorLog.errorDump[hwRender->errorLog.iter].frames = hwRender->renderParam.frameRenderMode.frames; hwRender->errorLog.iter++; } @@ -1099,7 +1099,8 @@ int32_t AudioRenderReqMmapBufferInit(struct AudioHwRender *render, AUDIO_FUNC_LOGE("AudioRenderReqMmapBuffer mmap FAIL and errno is:%{public}d !", errno); return AUDIO_HAL_ERR_INTERNAL; } - desc->totalBufferFrames = reqSize / (render->renderParam.frameRenderMode.attrs.channelCount * (formatBits >> 3)); + desc->totalBufferFrames = reqSize / (int32_t)(render->renderParam.frameRenderMode.attrs + .channelCount * (formatBits >> 3)); InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL"); -- Gitee From d1e58e59abe566c1d8fcf42a330a4c791a1323cb Mon Sep 17 00:00:00 2001 From: chenhaifan Date: Mon, 8 Aug 2022 18:26:29 +0800 Subject: [PATCH 30/33] File path verification, data type modification and loop splitting Signed-off-by: chenhaifan --- audio/hal/hdi_passthrough/src/audio_common.c | 1 - 1 file changed, 1 deletion(-) diff --git a/audio/hal/hdi_passthrough/src/audio_common.c b/audio/hal/hdi_passthrough/src/audio_common.c index 1b49e64921..06558dd22c 100644 --- a/audio/hal/hdi_passthrough/src/audio_common.c +++ b/audio/hal/hdi_passthrough/src/audio_common.c @@ -139,7 +139,6 @@ void AudioLogRecord(int errorLevel, const char *format, ...) FILE *fp = NULL; char timeStr[TIME_LEN]; char fileName[FILE_NAME_LEN]; - char pathBuf[PATH_MAX] = {'\0'}; struct tm *tblock = NULL; char folderName[] = "/data/log/drivers_peripheral_audio"; va_start(args, format); -- Gitee From 7df5a590c72c7a1cd19b1ec71d45f99e580612da Mon Sep 17 00:00:00 2001 From: lwx1140380 Date: Mon, 8 Aug 2022 17:42:50 +0800 Subject: [PATCH 31/33] fix:File path checksum, data type modification Signed-off-by: lwx1140380 --- codec/hal/src/codec_callback_type_stub.c | 8 +++++++- .../v1.0/buffer_manager/src/buffer_manager.cpp | 4 ++-- .../v2.0/hdi_impl/include/codec_handle_buffer.h | 2 +- codec/hal/v2.0/hdi_impl/src/codec_omx_core.cpp | 16 +++++++++++----- codec/hal/v2.0/hdi_impl/src/component_node.cpp | 12 +++++++++++- codec/hal/v2.0/hdi_impl/src/icodec_buffer.cpp | 2 +- 6 files changed, 33 insertions(+), 11 deletions(-) diff --git a/codec/hal/src/codec_callback_type_stub.c b/codec/hal/src/codec_callback_type_stub.c index 083f4dc681..b1038a201a 100644 --- a/codec/hal/src/codec_callback_type_stub.c +++ b/codec/hal/src/codec_callback_type_stub.c @@ -223,8 +223,14 @@ static void *LoadServiceHandler(void) char *libPath = NULL; void *handler = NULL; + char pathBuf[PATH_MAX] = {'\0'}; libPath = HDF_LIBRARY_FULL_PATH(OMX_CALLBACK_IMPLEMENT); - handler = dlopen(libPath, RTLD_LAZY); + if (realpath(libPath, pathBuf) == NULL) { + HDF_LOGE("%{public}s: realpath failed!", __func__); + return NULL; + } + + handler = dlopen(pathBuf, RTLD_LAZY); if (handler == NULL) { HDF_LOGE("%{public}s: dlopen failed %{public}s", __func__, dlerror()); return NULL; diff --git a/codec/hal/v1.0/buffer_manager/src/buffer_manager.cpp b/codec/hal/v1.0/buffer_manager/src/buffer_manager.cpp index 595191ea6a..18b27b7172 100644 --- a/codec/hal/v1.0/buffer_manager/src/buffer_manager.cpp +++ b/codec/hal/v1.0/buffer_manager/src/buffer_manager.cpp @@ -89,8 +89,8 @@ void BufferManager::ConstructTimespec(struct timespec *time, uint32_t timeout { memset_s(time, sizeof(timespec), 0, sizeof(timespec)); clock_gettime(CLOCK_REALTIME, time); - time->tv_sec += timeoutMs / HDF_KILO_UNIT; - time->tv_nsec += (timeoutMs % HDF_KILO_UNIT) * HDF_KILO_UNIT * HDF_KILO_UNIT; + time->tv_sec += static_cast(timeoutMs) / HDF_KILO_UNIT; + time->tv_nsec += (static_cast(timeoutMs) % HDF_KILO_UNIT) * HDF_KILO_UNIT * HDF_KILO_UNIT; if (time->tv_nsec >= HDF_NANO_UNITS) { time->tv_nsec -= HDF_NANO_UNITS; time->tv_sec += 1; diff --git a/codec/hal/v2.0/hdi_impl/include/codec_handle_buffer.h b/codec/hal/v2.0/hdi_impl/include/codec_handle_buffer.h index cc99fe2038..d8b7e61acb 100644 --- a/codec/hal/v2.0/hdi_impl/include/codec_handle_buffer.h +++ b/codec/hal/v2.0/hdi_impl/include/codec_handle_buffer.h @@ -40,7 +40,7 @@ private: void ResetBuffer(struct OmxCodecBuffer &codecBuffer, OMX_BUFFERHEADERTYPE &omxBuffer); private: - BufferHandle *bufferHandle_; + BufferHandle *bufferHandle_ = nullptr; }; } // namespace Omx } // namespace Codec diff --git a/codec/hal/v2.0/hdi_impl/src/codec_omx_core.cpp b/codec/hal/v2.0/hdi_impl/src/codec_omx_core.cpp index e92c3338df..b8deb3969d 100644 --- a/codec/hal/v2.0/hdi_impl/src/codec_omx_core.cpp +++ b/codec/hal/v2.0/hdi_impl/src/codec_omx_core.cpp @@ -31,7 +31,13 @@ CodecOMXCore::~CodecOMXCore() } int32_t CodecOMXCore::Init(const std::string &libName) { - libHandle_ = dlopen(libName.c_str(), RTLD_LAZY); + char pathBuf[PATH_MAX] = {'\0'}; + if (realpath(libName.c_str(), pathBuf) == NULL) { + HDF_LOGE("%{public}s: realpath failed!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + libHandle_ = dlopen(pathBuf, RTLD_LAZY); if (libHandle_ == NULL) { HDF_LOGE("%{public}s:failed to dlopen %{public}s.", __func__, libName.c_str()); return HDF_ERR_INVALID_PARAM; @@ -107,10 +113,10 @@ int32_t CodecOMXCore::GetRolesOfComponent(std::string &name, std::vector(bufferId); } bool ICodecBuffer::CheckInvalid(struct OmxCodecBuffer &codecBuffer) -- Gitee From 433948006c2b9bac935b8281167d834a19de4e8d Mon Sep 17 00:00:00 2001 From: zenglifeng Date: Fri, 5 Aug 2022 09:31:39 +0800 Subject: [PATCH 32/33] fix: After IDL is enabled, ALSA compilation errors are resolved. Signed-off-by: zenglifeng --- audio/hdi_service/supportlibs/BUILD.gn | 7 +++---- audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c | 2 ++ audio/supportlibs/alsa_adapter/src/alsa_lib_common.c | 4 +++- audio/supportlibs/alsa_adapter/src/alsa_lib_render.c | 2 ++ audio/test/sample/idl_capture.c | 4 ++++ audio/test/sample/idl_render.c | 4 ++++ .../src/audio_threshold_report_test.cpp | 2 ++ audio/test/systemtest/hdi_service/common/adapter/BUILD.gn | 1 + .../common/adapter/src/audio_idlhdi_adapter_test.cpp | 2 ++ audio/test/systemtest/hdi_service/common/capture/BUILD.gn | 1 + .../common/capture/src/audio_idl_hdicapture_attr_test.cpp | 2 ++ .../capture/src/audio_idl_hdicapture_control_test.cpp | 2 ++ .../common/capture/src/audio_idl_hdicapture_scene_test.cpp | 2 ++ .../common/capture/src/audio_idl_hdicapture_test.cpp | 2 ++ .../capture/src/audio_idl_hdicapture_volume_test.cpp | 2 ++ audio/test/systemtest/hdi_service/common/manager/BUILD.gn | 1 + .../common/manager/src/audio_idlhdi_manager_test.cpp | 2 ++ audio/test/systemtest/hdi_service/common/render/BUILD.gn | 1 + .../common/render/src/audio_idl_hdirender_attr_test.cpp | 2 ++ .../common/render/src/audio_idl_hdirender_control_test.cpp | 2 ++ .../common/render/src/audio_idl_hdirender_scene_test.cpp | 2 ++ .../common/render/src/audio_idl_hdirender_test.cpp | 2 ++ .../common/render/src/audio_idl_hdirender_volume_test.cpp | 2 ++ audio/test/systemtest/hdi_service/hdiperformace/BUILD.gn | 3 ++- .../src/audio_idlhdicapture_performace_test.cpp | 2 ++ .../src/audio_idlhdirender_performace_test.cpp | 2 ++ .../hdi_service/hispark_taurus_standard/capture/BUILD.gn | 1 + .../src/audio_idl_hdicapture_hardware_dependence_test.cpp | 2 ++ .../hdi_service/hispark_taurus_standard/render/BUILD.gn | 1 + .../src/audio_idl_hdirender_hardware_dependence_test.cpp | 2 ++ audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn | 1 + .../src/audio_idl_hdicapture_hardware_dependence_test.cpp | 2 ++ audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn | 1 + .../src/audio_idl_hdirender_hardware_dependence_test.cpp | 2 ++ 34 files changed, 66 insertions(+), 6 deletions(-) diff --git a/audio/hdi_service/supportlibs/BUILD.gn b/audio/hdi_service/supportlibs/BUILD.gn index 8fbad92a13..1c66820e6e 100644 --- a/audio/hdi_service/supportlibs/BUILD.gn +++ b/audio/hdi_service/supportlibs/BUILD.gn @@ -94,6 +94,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", ] + public_deps = [ "//drivers/interface/audio/v1_0:audio_idl_headers" ] if (drivers_peripheral_audio_alsa_lib) { include_dirs += [ @@ -111,7 +112,6 @@ if (defined(ohos_lite)) { defines = [ "AUDIO_HDF_LOG" ] } - public_deps = [ "//drivers/interface/audio/v1_0:audio_idl_headers" ] if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", @@ -146,21 +146,20 @@ if (defined(ohos_lite)) { "//drivers/peripheral/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c", ] } - public_deps = [ "//drivers/interface/audio/v1_0:audio_idl_headers" ] include_dirs = [ - "//drivers/peripheral/audio/interfaces/include", "//drivers/peripheral/audio/hdi_service/passthrough/include", "//drivers/peripheral/audio/supportlibs/interfaces/include", "//third_party/bounds_checking_function/include", "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", ] + public_deps = [ "//drivers/interface/audio/v1_0:audio_idl_headers" ] if (drivers_peripheral_audio_alsa_lib) { include_dirs += [ "//third_party/cJSON", - "//drivers/peripheral/audio/supportlibs/alsa_adapter/include", "//third_party/alsa-lib/include", + "//drivers/peripheral/audio/supportlibs/alsa_adapter/include", ] public_deps += [ "//third_party/alsa-lib:libasound" ] } else { diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c index ac7feb9ab3..ae54f5f824 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c @@ -14,7 +14,9 @@ */ #include "alsa_lib_capture.h" +#include "audio_common.h" #include "osal_mem.h" +#include "securec.h" #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c index c40aabcaac..e2fcdbf387 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c @@ -16,9 +16,11 @@ #include "alsa_lib_common.h" #include #include +#include "audio_common.h" +#include "audio_internal.h" #include "cJSON.h" #include "osal_mem.h" -#include "audio_internal.h" +#include "securec.h" #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c index 630bc503d3..9a1b35e3d5 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c @@ -14,7 +14,9 @@ */ #include "alsa_lib_render.h" +#include "audio_common.h" #include "osal_mem.h" +#include "securec.h" #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB diff --git a/audio/test/sample/idl_capture.c b/audio/test/sample/idl_capture.c index 56b9ed836c..723f976c39 100644 --- a/audio/test/sample/idl_capture.c +++ b/audio/test/sample/idl_capture.c @@ -25,6 +25,7 @@ #include #include "hdf_base.h" #include "hdf_io_service_if.h" +#include "hdf_remote_adapter_if.h" #include "hdf_service_status.h" #include "inttypes.h" #include "ioservstat_listener.h" @@ -803,6 +804,9 @@ int32_t GetManagerAndLoadAdapter(const char *adapterNameCase, struct AudioPort * if (getAudioManager == NULL) { return HDF_FAILURE; } + + (void)HdfRemoteGetCallingPid(); + struct AudioManager *audioManager = getAudioManager("idl_audio_service"); if (audioManager == NULL) { AUDIO_FUNC_LOGE("Get audio Manager Fail"); diff --git a/audio/test/sample/idl_render.c b/audio/test/sample/idl_render.c index 3c0b9d974f..0c2093c5eb 100644 --- a/audio/test/sample/idl_render.c +++ b/audio/test/sample/idl_render.c @@ -24,6 +24,7 @@ #include #include #include "hdf_base.h" +#include "hdf_remote_adapter_if.h" #include "inttypes.h" #include "osal_mem.h" #include "v1_0/audio_manager.h" @@ -796,6 +797,9 @@ int32_t GetManagerAndLoadAdapter(const char *adapterNameCase, struct AudioPort * if (getAudioManager == NULL) { return HDF_FAILURE; } + + (void)HdfRemoteGetCallingPid(); + struct AudioManager *audioManagerIns = getAudioManager(SERVICE_NAME); if (audioManagerIns == NULL) { AUDIO_FUNC_LOGE("Get audio Manager Fail"); diff --git a/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp b/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp index 862a6415ff..c780b1c8c8 100644 --- a/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp +++ b/audio/test/systemtest/audio_function/audio_threshold_report/src/audio_threshold_report_test.cpp @@ -15,6 +15,7 @@ #include "hdf_audio_events.h" #include "hdf_io_service_if.h" +#include "hdf_remote_adapter_if.h" #include "hdf_service_status.h" #include "ioservstat_listener.h" #include "servstat_listener_hdi.h" @@ -60,6 +61,7 @@ void AudioThresholdReportTest::SetUpTestCase(void) ASSERT_NE(nullptr, path); handleSo = dlopen(absPath, RTLD_LAZY); ASSERT_NE(nullptr, handleSo); + (void)HdfRemoteGetCallingPid(); GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); manager = GetAudioManager(); diff --git a/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn b/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn index 9e32688944..f6eadda692 100644 --- a/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn @@ -25,6 +25,7 @@ ohos_systemtest("hdf_audio_idlhdi_adapter_test") { "src/audio_idlhdi_adapter_test.cpp", ] external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", "utils_base:utils", diff --git a/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp b/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp index 568337c118..c60c1bbdb7 100644 --- a/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp +++ b/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "osal_mem.h" #include "hdi_service_common.h" @@ -54,6 +55,7 @@ void AudioIdlHdiAdapterTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/capture/BUILD.gn b/audio/test/systemtest/hdi_service/common/capture/BUILD.gn index fa2ec2e933..9b33a05827 100644 --- a/audio/test/systemtest/hdi_service/common/capture/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/capture/BUILD.gn @@ -34,6 +34,7 @@ if (!defined(ohos_lite)) { include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] if (is_standard_system) { external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp index 3b108ee9b8..849f9d09ca 100644 --- a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp +++ b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_attr_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -56,6 +57,7 @@ void AudioIdlHdiCaptureAttrTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_control_test.cpp b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_control_test.cpp index 7131367b65..313158fcc4 100644 --- a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_control_test.cpp +++ b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_control_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -55,6 +56,7 @@ void AudioIdlHdiCaptureControlTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_scene_test.cpp b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_scene_test.cpp index f22b7f9a80..a558e26da2 100644 --- a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_scene_test.cpp +++ b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_scene_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -55,6 +56,7 @@ void AudioIdlHdiCaptureSceneTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_test.cpp b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_test.cpp index 4b4e8d0541..df56a74fd3 100644 --- a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_test.cpp +++ b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -59,6 +60,7 @@ void AudioIdlHdiCaptureTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_volume_test.cpp b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_volume_test.cpp index 4b9d66191b..80dc8666ec 100644 --- a/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_volume_test.cpp +++ b/audio/test/systemtest/hdi_service/common/capture/src/audio_idl_hdicapture_volume_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -55,6 +56,7 @@ void AudioIdlHdiCaptureVolumeTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/manager/BUILD.gn b/audio/test/systemtest/hdi_service/common/manager/BUILD.gn index f8f0781aab..9e16fd60c7 100644 --- a/audio/test/systemtest/hdi_service/common/manager/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/manager/BUILD.gn @@ -30,6 +30,7 @@ if (!defined(ohos_lite)) { include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] if (is_standard_system) { external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/common/manager/src/audio_idlhdi_manager_test.cpp b/audio/test/systemtest/hdi_service/common/manager/src/audio_idlhdi_manager_test.cpp index 8b3590c962..c9e92ab68e 100644 --- a/audio/test/systemtest/hdi_service/common/manager/src/audio_idlhdi_manager_test.cpp +++ b/audio/test/systemtest/hdi_service/common/manager/src/audio_idlhdi_manager_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "osal_mem.h" #include "hdi_service_common.h" @@ -49,6 +50,7 @@ void AudioIdlHdiManagerTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/render/BUILD.gn b/audio/test/systemtest/hdi_service/common/render/BUILD.gn index ab6ad5f309..beb3204789 100644 --- a/audio/test/systemtest/hdi_service/common/render/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/render/BUILD.gn @@ -31,6 +31,7 @@ ohos_systemtest("hdf_audio_idlhdi_render_test") { include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp index 838aaad017..75595b562e 100644 --- a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_attr_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -54,6 +55,7 @@ void AudioIdlHdiRenderAttrTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_control_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_control_test.cpp index f3ac429a0f..ebd17ebb46 100644 --- a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_control_test.cpp +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_control_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -53,6 +54,7 @@ void AudioIdlHdiRenderControlTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_scene_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_scene_test.cpp index ed5ca0fba2..d92f8c6a64 100644 --- a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_scene_test.cpp +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_scene_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -53,6 +54,7 @@ void AudioIdlHdiRenderSceneTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp index b5aa654be5..653b7d2cbf 100644 --- a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -53,6 +54,7 @@ void AudioIdlHdiRenderTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp index 2326cbc3ab..622683f5fc 100644 --- a/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp +++ b/audio/test/systemtest/hdi_service/common/render/src/audio_idl_hdirender_volume_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; using namespace testing::ext; @@ -52,6 +53,7 @@ void AudioIdlHdiRendervolumeTest::SetUpTestCase(void) ASSERT_NE(nullptr, handleSo); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handleSo, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handleSo, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/hdiperformace/BUILD.gn b/audio/test/systemtest/hdi_service/hdiperformace/BUILD.gn index 23d574a07b..7fc9b3621d 100644 --- a/audio/test/systemtest/hdi_service/hdiperformace/BUILD.gn +++ b/audio/test/systemtest/hdi_service/hdiperformace/BUILD.gn @@ -19,7 +19,7 @@ module_output_path = "drivers_peripheral_audio/audio" ohos_systemtest("hdf_audio_idlhdi_performace_test") { module_out_path = module_output_path - public_deps = [ "//drivers/interface/audio/v1_0:libaudio_proxy_1.0" ] + public_deps = [ "//drivers/interface/audio/v1_0:audio_idl_headers" ] sources = [ "../../common/hdi_service_common/src/hdi_service_common.cpp", "src/audio_idlhdicapture_performace_test.cpp", @@ -27,6 +27,7 @@ ohos_systemtest("hdf_audio_idlhdi_performace_test") { ] include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdicapture_performace_test.cpp b/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdicapture_performace_test.cpp index ae4dc122c3..278cc959f6 100644 --- a/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdicapture_performace_test.cpp +++ b/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdicapture_performace_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -57,6 +58,7 @@ void AudioIdlHdiCapturePerformaceTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdirender_performace_test.cpp b/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdirender_performace_test.cpp index 0bef9ea217..e5e4d1ce3e 100644 --- a/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdirender_performace_test.cpp +++ b/audio/test/systemtest/hdi_service/hdiperformace/src/audio_idlhdirender_performace_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "osal_mem.h" #include "hdi_service_common.h" @@ -58,6 +59,7 @@ void AudioIdlHdiRenderPerformaceTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/BUILD.gn b/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/BUILD.gn index e15c9d70f2..abb79be657 100644 --- a/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/BUILD.gn +++ b/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/BUILD.gn @@ -27,6 +27,7 @@ ohos_systemtest("hdf_audio_idlhdi_capture_hardware_dependence_test") { include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp b/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp index c8ef248ed8..a9e5b07366 100644 --- a/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp +++ b/audio/test/systemtest/hdi_service/hispark_taurus_standard/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -56,6 +57,7 @@ void AudioIdlHdiCaptureHardwareDependenceTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/BUILD.gn b/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/BUILD.gn index 0a1fba50a7..59137b174d 100644 --- a/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/BUILD.gn +++ b/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/BUILD.gn @@ -27,6 +27,7 @@ ohos_systemtest("hdf_audio_idlhdi_render_hardware_dependence_test") { include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp b/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp index bdb24b2b9c..c124cf81e3 100644 --- a/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp +++ b/audio/test/systemtest/hdi_service/hispark_taurus_standard/render/src/audio_idl_hdirender_hardware_dependence_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -54,6 +55,7 @@ void AudioIdlHdiRenderHardwareDependenceTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn b/audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn index ff40313be5..2322f1755e 100644 --- a/audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn +++ b/audio/test/systemtest/hdi_service/rk3568/capture/BUILD.gn @@ -26,6 +26,7 @@ ohos_systemtest("hdf_audio_idlhdi_capture_hardware_dependence_test") { ] include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp b/audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp index 82f3732e8a..9f03d6f9c9 100644 --- a/audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp +++ b/audio/test/systemtest/hdi_service/rk3568/capture/src/audio_idl_hdicapture_hardware_dependence_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -56,6 +57,7 @@ void AudioIdlHdiCaptureHardwareDependenceTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); diff --git a/audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn b/audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn index f81dbe601c..537ffa8004 100644 --- a/audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn +++ b/audio/test/systemtest/hdi_service/rk3568/render/BUILD.gn @@ -26,6 +26,7 @@ ohos_systemtest("hdf_audio_idlhdi_render_hardware_dependence_test") { ] include_dirs = [ "//drivers/peripheral/audio/test/systemtest/common/hdi_service_common/include" ] external_deps = [ + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hiviewdfx_hilog_native:libhilog", ] diff --git a/audio/test/systemtest/hdi_service/rk3568/render/src/audio_idl_hdirender_hardware_dependence_test.cpp b/audio/test/systemtest/hdi_service/rk3568/render/src/audio_idl_hdirender_hardware_dependence_test.cpp index a07f513f52..bd52bc7413 100644 --- a/audio/test/systemtest/hdi_service/rk3568/render/src/audio_idl_hdirender_hardware_dependence_test.cpp +++ b/audio/test/systemtest/hdi_service/rk3568/render/src/audio_idl_hdirender_hardware_dependence_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "hdf_remote_adapter_if.h" #include "hdi_service_common.h" using namespace std; @@ -54,6 +55,7 @@ void AudioIdlHdiRenderHardwareDependenceTest::SetUpTestCase(void) ASSERT_NE(nullptr, handle); GetAudioManager = (TestAudioManager *(*)(const char *))(dlsym(handle, FUNCTION_NAME.c_str())); ASSERT_NE(nullptr, GetAudioManager); + (void)HdfRemoteGetCallingPid(); manager = GetAudioManager(IDL_SERVER_NAME.c_str()); ASSERT_NE(nullptr, manager); AudioManagerRelease = (void (*)(struct AudioManager *))(dlsym(handle, "AudioManagerRelease")); -- Gitee From 3038a7b5eef908f7595f57577c2159a93fa64486 Mon Sep 17 00:00:00 2001 From: Erliangqi Date: Tue, 9 Aug 2022 10:09:45 +0800 Subject: [PATCH 33/33] camera abnormal pictures and dead lock issue Signed-off-by: Erliangqi --- .../src/driver_adapter/include/v4l2_temp.h | 3 +- .../src/driver_adapter/src/v4l2_buffer.cpp | 30 ++- .../v4l2_source_node/v4l2_source_node.cpp | 14 +- .../src/stream_operator/stream_base.cpp | 2 +- .../nodes/src/fork_node/fork_node.cpp | 187 +++++++++++------- .../nodes/src/fork_node/fork_node.h | 13 +- .../nodes/src/sink_node/sink_node.h | 8 +- .../nodes/src/source_node/source_node.cpp | 2 +- .../src/stream_pipeline_core.cpp | 22 +-- .../pipeline_impl/src/stream_pipeline_core.h | 2 +- 10 files changed, 182 insertions(+), 101 deletions(-) diff --git a/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h b/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h index d637245da9..ff01db11d1 100644 --- a/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h +++ b/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h @@ -26,9 +26,10 @@ namespace OHOS::Camera { enum CameraBufferStatus { + CAMERA_BUFFER_STATUS_OK = 0, CAMERA_BUFFER_STATUS_DROP, + CAMERA_BUFFER_STATUS_INVALID, }; - class IBuffer { public: IBuffer() {} diff --git a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp index ebfd9d8922..4bae466308 100644 --- a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp +++ b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp @@ -139,6 +139,8 @@ RetCode HosV4L2Buffers::V4L2DequeueBuffer(int fd) buf.index, (void*)buf.m.userptr, buf.length); } + std::lock_guard l(bufferLock_); + auto IterMap = queueBuffers_.find(fd); if (IterMap == queueBuffers_.end()) { CAMERA_LOGE("std::map queueBuffers_ no fd\n"); @@ -154,14 +156,12 @@ RetCode HosV4L2Buffers::V4L2DequeueBuffer(int fd) if (dequeueBuffer_ == nullptr) { CAMERA_LOGE("V4L2DequeueBuffer buf.index == %{public}d no callback\n", buf.index); - std::lock_guard l(bufferLock_); bufferMap.erase(Iter); return RC_ERROR; } // callback to up dequeueBuffer_(Iter->second); - std::lock_guard l(bufferLock_); bufferMap.erase(Iter); return RC_OK; @@ -240,7 +240,31 @@ void HosV4L2Buffers::SetCallback(BufCallback cb) } RetCode HosV4L2Buffers::Flush(int fd) { - CAMERA_LOGE("HosV4L2Buffers::Flush\n"); + CAMERA_LOGD("HosV4L2Buffers::Flush enter\n"); + std::lock_guard l(bufferLock_); + + if (dequeueBuffer_ == nullptr) { + CAMERA_LOGE("HosV4L2Buffers::Flush dequeueBuffer_ == nullptr"); + return RC_ERROR; + } + + auto IterMap = queueBuffers_.find(fd); + if (IterMap == queueBuffers_.end()) { + CAMERA_LOGE("HosV4L2Buffers::Flush std::map queueBuffers_ no fd"); + return RC_ERROR; + } + auto& bufferMap = IterMap->second; + + for (auto& it : bufferMap) { + std::shared_ptr frameSpec = it.second; + CAMERA_LOGD("HosV4L2Buffers::Flush throw up buffer begin, buffpool=%{public}d", + (int32_t)frameSpec->bufferPoolId_); + frameSpec->buffer_->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); + dequeueBuffer_(frameSpec); + CAMERA_LOGD("HosV4L2Buffers::Flush throw up buffer end"); + } + + bufferMap.clear(); return RC_OK; } } // namespace OHOS::Camera diff --git a/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp b/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp index 8a5b991b45..3b4e978fbe 100644 --- a/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp +++ b/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp @@ -75,19 +75,23 @@ V4L2SourceNode::~V4L2SourceNode() RetCode V4L2SourceNode::Flush(const int32_t streamId) { - RetCode rc = RC_OK; - rc = SourceNode::Flush(streamId); - CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); + RetCode rc; rc = sensorController_->Flush(streamId); + CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); + rc = SourceNode::Flush(streamId); + return rc; } RetCode V4L2SourceNode::Stop(const int32_t streamId) { - SourceNode::Stop(streamId); + RetCode rc; + + rc = sensorController_->Stop(); + CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); - return sensorController_->Stop(); + return SourceNode::Stop(streamId); } void V4L2SourceNode::SetBufferCallback() diff --git a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp index a774b4e636..15c08fc70d 100644 --- a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp +++ b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp @@ -426,6 +426,7 @@ void StreamBase::HandleResult(std::shared_ptr& buffer) } if (r->GetCaptureId() == captureId) { request = r; + break; } } } @@ -440,7 +441,6 @@ void StreamBase::HandleResult(std::shared_ptr& buffer) // To synchronize multiple stream, bottom-layer device stream need be synchronized first. request->OnResult(streamId_); lastRequest_ = request; - return; } RetCode StreamBase::OnFrame(const std::shared_ptr& request) diff --git a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp index e67a8f50d6..e497764f5e 100644 --- a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp +++ b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp @@ -22,30 +22,49 @@ ForkNode::ForkNode(const std::string& name, const std::string& type) : NodeBase( ForkNode::~ForkNode() { - streamRunning_ = false; - cv_.notify_all(); - if (forkThread_ != nullptr) { - CAMERA_LOGI("forkThread need join"); - forkThread_->join(); - forkThread_ = nullptr; - } - CAMERA_LOGI("fork Node exit."); + StopForkThread(); } RetCode ForkNode::Start(const int32_t streamId) { + int32_t id = 0; + uint64_t bufferPoolId = 0; + CAMERA_LOGI("ForkNode::Start streamId = %{public}d\n", streamId); - if (streamRunning_ == true) + if (streamRunning_) { return RC_OK; + } inPutPorts_ = GetInPorts(); outPutPorts_ = GetOutPorts(); - if (streamRunning_ == false) { - CAMERA_LOGI("ForkNode::Start::streamrunning = false"); - streamRunning_ = true; - ForkBuffers(); + + for (auto& in : inPutPorts_) { + for (auto& out : outPutPorts_) { + if (out->format_.streamId_ != in->format_.streamId_) { + id = out->format_.streamId_; + bufferPoolId = out->format_.bufferPoolId_; + CAMERA_LOGI("fork buffer get buffer streamId = %{public}d", out->format_.streamId_); + } + } + } + + BufferManager* bufferManager = Camera::BufferManager::GetInstance(); + if (bufferManager == nullptr) { + CAMERA_LOGE("fork buffer get instance failed"); + return RC_ERROR; } + + bufferPool_ = bufferManager->GetBufferPool(bufferPoolId); + if (bufferPool_ == nullptr) { + CAMERA_LOGE("get bufferpool failed: %{public}zu", bufferPoolId); + return RC_ERROR; + } + + streamId_ = id; + RunForkThread(); + streamRunning_ = true; + return RC_OK; } @@ -53,19 +72,25 @@ RetCode ForkNode::Stop(const int32_t streamId) { CAMERA_LOGI("ForkNode::Stop streamId = %{public}d\n", streamId); - streamRunning_ = false; - cv_.notify_all(); - if (forkThread_ != nullptr) { - CAMERA_LOGI("ForkNode::Stop need join"); - forkThread_->join(); - forkThread_ = nullptr; + if (!streamRunning_) { + return RC_OK; } + + StopForkThread(); + DrainForkBufferPool(); + + streamRunning_ = false; + return RC_OK; } RetCode ForkNode::Flush(const int32_t streamId) { - CAMERA_LOGI("ForkNode::Flush streamId = %{public}d\n", streamId); + if (streamId_ == streamId) { + StopForkThread(); + DrainForkBufferPool(); + } + return RC_OK; } @@ -75,12 +100,24 @@ void ForkNode::DeliverBuffer(std::shared_ptr& buffer) CAMERA_LOGE("frameSpec is null"); return; } - int32_t id = buffer->GetStreamId(); - { + + if (buffer->GetBufferStatus() == CAMERA_BUFFER_STATUS_OK && bufferPool_ != nullptr) { std::unique_lock lck(mtx_); - tmpBuffer_ = buffer; - cv_.notify_one(); + // If previous pending buffer was not handled, do not replace it. + if (pendingBuffer_ == nullptr) { + pendingBuffer_ = bufferPool_->AcquireBuffer(0); + if (pendingBuffer_ != nullptr) { + if (memcpy_s(pendingBuffer_->GetVirAddress(), pendingBuffer_->GetSize(), + buffer->GetVirAddress(), buffer->GetSize()) != 0) { + pendingBuffer_->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); + CAMERA_LOGE("memcpy_s failed."); + } + cv_.notify_all(); + } + } } + + int32_t id = buffer->GetStreamId(); for (auto& it : outPutPorts_) { if (it->format_.streamId_ == id) { it->DeliverBuffer(buffer); @@ -120,39 +157,47 @@ RetCode ForkNode::CancelCapture(const int32_t streamId) return RC_OK; } -void ForkNode::ForkBuffers() +void ForkNode::RunForkThread() { - int32_t id = 0; - uint64_t bufferPoolId = 0; - for (auto& in : inPutPorts_) { - for (auto& out : outPutPorts_) { - if (out->format_.streamId_ != in->format_.streamId_) { - id = out->format_.streamId_; - bufferPoolId = out->format_.bufferPoolId_; - CAMERA_LOGI("fork buffer get buffer streamId = %{public}d", out->format_.streamId_); - } - } + if (forkThread_ != nullptr) { + CAMERA_LOGI("Fork thread is running."); + return; } - forkThread_ = std::make_shared([this, id, bufferPoolId] { - prctl(PR_SET_NAME, "fork_buffers"); - std::shared_ptr frameSpec = std::make_shared(); + + forkThreadRunFlag_ = true; + + forkThread_ = std::make_shared([this] { + prctl(PR_SET_NAME, "deliver_fork_buffers"); std::shared_ptr buffer = nullptr; - while (streamRunning_ == true) { - if (CopyBuffer(bufferPoolId, buffer) != RC_OK) { - continue; + int32_t id = streamId_; + + while (true) { + { + std::unique_lock lck(mtx_); + // Break the loop when stream was stopped and there was no pending buffer. + if (!forkThreadRunFlag_ && (pendingBuffer_ == nullptr)) { + break; + } + + if (pendingBuffer_ == nullptr) { + cv_.wait(lck); + continue; // rewind to the front of loop to check breaking condition. + } + // go ahead to deliver buffer. + buffer = pendingBuffer_; + pendingBuffer_ = nullptr; } + for (auto& it : outPutPorts_) { if (it->format_.streamId_ == id) { - CAMERA_LOGI("fork node deliver buffer streamid = %{public}d", it->format_.streamId_); + CAMERA_LOGI("fork node deliver buffer streamid = %{public}d begin", it->format_.streamId_); int32_t id = buffer->GetStreamId(); { std::lock_guard l(requestLock_); CAMERA_LOGV("ForkNode::deliver a buffer to stream id:%{public}d, queue size:%{public}u", id, captureRequests_[id].size()); - if (captureRequests_.count(id) == 0) { - buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); - } else if (captureRequests_[id].empty()) { + if (captureRequests_.count(id) == 0 || captureRequests_[id].empty()) { buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); } else { buffer->SetCaptureId(captureRequests_[id].front()); @@ -164,38 +209,42 @@ void ForkNode::ForkBuffers() } } } - CAMERA_LOGI("fork thread closed"); + CAMERA_LOGI("ForkNode RunForkThread closed"); return RC_OK; }); return; } -RetCode ForkNode::CopyBuffer(uint64_t poolId, std::shared_ptr& buffer) +void ForkNode::StopForkThread() { - BufferManager* bufferManager = Camera::BufferManager::GetInstance(); - CHECK_IF_PTR_NULL_RETURN_VALUE(bufferManager, RC_ERROR); - std::unique_lock lck(mtx_); - cv_.wait(lck); - std::shared_ptr bufferPool = bufferManager->GetBufferPool(poolId); - if (bufferPool == nullptr) { - CAMERA_LOGE("get bufferpool failed"); - return RC_ERROR; - } - CAMERA_LOGI("fork node acquirebuffer enter"); - buffer = bufferPool->AcquireBuffer(); - CAMERA_LOGI("fork node acquirebuffer exit"); - if (buffer == nullptr) { - CAMERA_LOGE("acquire buffer failed."); - return RC_ERROR; - } - if (memcpy_s(buffer->GetVirAddress(), buffer->GetSize(), - tmpBuffer_->GetVirAddress(), tmpBuffer_->GetSize()) != 0) { - CAMERA_LOGE("memcpy_s failed."); + if (forkThread_ != nullptr) { + { + std::unique_lock lck(mtx_); + forkThreadRunFlag_ = false; + cv_.notify_all(); + } + forkThread_->join(); + forkThread_ = nullptr; } - buffer->SetEsFrameSize(buffer->GetSize()); - buffer->SetEsTimestamp(tmpBuffer_->GetEsFrameInfo().timestamp); - return RC_OK; + CAMERA_LOGI("ForkNode::StopForkThread exit"); } +void ForkNode::DrainForkBufferPool() +{ + // Drain all buffers from Buffer Pool to Stream Tunnel. + if (bufferPool_ != nullptr) { + std::shared_ptr buffer = nullptr; + + while ((buffer = bufferPool_->AcquireBuffer(0)) != nullptr) { + buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); + for (auto& it : outPutPorts_) { + if (it->format_.streamId_ == streamId_) { + it->DeliverBuffer(buffer); + break; + } + } + } + } +} REGISTERNODE(ForkNode, {"fork"}) } // namespace OHOS::Camera diff --git a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h index 8e9a3076f6..37c88c38cb 100644 --- a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h +++ b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h @@ -29,20 +29,23 @@ public: RetCode Start(const int32_t streamId) override; RetCode Stop(const int32_t streamId) override; void DeliverBuffer(std::shared_ptr& buffer) override; - void ForkBuffers(); RetCode Capture(const int32_t streamId, const int32_t captureId) override; RetCode CancelCapture(const int32_t streamId) override; RetCode Flush(const int32_t streamId); private: - RetCode CopyBuffer(uint64_t poolId, std::shared_ptr& buffer); -private: + void RunForkThread(); + void StopForkThread(); + void DrainForkBufferPool(); std::mutex mtx_; std::condition_variable cv_; std::shared_ptr forkThread_ = nullptr; - std::shared_ptr tmpBuffer_ = nullptr; std::vector> inPutPorts_; std::vector> outPutPorts_; - std::atomic_bool streamRunning_ = false; + std::atomic_bool streamRunning_ = false; + std::atomic_bool forkThreadRunFlag_ = false; + std::shared_ptr bufferPool_ = nullptr; // buffer pool of branch stream + int32_t streamId_; // stream id of branch stream + std::shared_ptr pendingBuffer_ = nullptr; // pending buffer for branch stream std::mutex requestLock_; std::unordered_map> captureRequests_ = {}; }; diff --git a/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h b/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h index eff0e5a070..8bccd2c2cc 100644 --- a/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h +++ b/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h @@ -15,10 +15,10 @@ #define HOS_CAMERA_SINK_NODE_H #include -#include "device_manager_adapter.h" -#include "utils.h" #include "camera.h" +#include "device_manager_adapter.h" #include "node_base.h" +#include "utils.h" namespace OHOS::Camera { class SinkNode : virtual public NodeBase { @@ -34,7 +34,7 @@ public: } protected: - BufferCb cb_; + BufferCb cb_; }; -}// namespace OHOS::Camera +} // namespace OHOS::Camera #endif diff --git a/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp b/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp index 6bbf46f57b..f869c61a7a 100644 --- a/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp +++ b/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp @@ -257,12 +257,12 @@ RetCode SourceNode::PortHandler::StartDistributeBuffers() RetCode SourceNode::PortHandler::StopDistributeBuffers() { CAMERA_LOGV("SourceNode::PortHandler::StopDistributeBuffers enter"); - FlushBuffers(); dbtRun = false; rbcv.notify_one(); if (distributor != nullptr) { distributor->join(); } + FlushBuffers(); // flush buffers after stopping distributor CAMERA_LOGV("SourceNode::PortHandler::StopDistributeBuffers exit"); return RC_OK; } diff --git a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp index 058d0fda62..b3862ca557 100644 --- a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp +++ b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp @@ -43,7 +43,7 @@ RetCode StreamPipelineCore::PreConfig(const ModeMeta& meta) RetCode StreamPipelineCore::CreatePipeline(const int32_t& mode) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); std::shared_ptr spec = strategy_->GeneratePipelineSpec(mode); if (spec == nullptr) { return RC_ERROR; @@ -57,7 +57,7 @@ RetCode StreamPipelineCore::CreatePipeline(const int32_t& mode) RetCode StreamPipelineCore::DestroyPipeline(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Destroy(it) | re; @@ -69,7 +69,7 @@ RetCode StreamPipelineCore::DestroyPipeline(const std::vector& streamIds) RetCode StreamPipelineCore::Prepare(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Prepare(it) | re; @@ -79,7 +79,7 @@ RetCode StreamPipelineCore::Prepare(const std::vector& streamIds) RetCode StreamPipelineCore::Start(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Start(it) | re; @@ -90,7 +90,7 @@ RetCode StreamPipelineCore::Start(const std::vector& streamIds) RetCode StreamPipelineCore::SetCallback(const MetaDataCb cb) { CAMERA_LOGE("StreamPipelineCore %{public}s: line: %{public}d", __FUNCTION__, __LINE__); - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; dispatcher_->SetCallback(cb); return re; @@ -109,7 +109,7 @@ RetCode StreamPipelineCore::Stop(const std::vector& streamIds) RetCode StreamPipelineCore::Config(const std::vector& streamIds, const CaptureMeta& meta) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Config(it, meta) | re; @@ -120,7 +120,7 @@ RetCode StreamPipelineCore::Config(const std::vector& streamIds, const Capt RetCode StreamPipelineCore::UpdateSettingsConfig(const CaptureMeta& meta) { CAMERA_LOGE("StreamPipelineCore %{public}s: line: %{public}d", __FUNCTION__, __LINE__); - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; dispatcher_->UpdateSettingsConfig(meta); return re; @@ -128,7 +128,7 @@ RetCode StreamPipelineCore::UpdateSettingsConfig(const CaptureMeta& meta) RetCode StreamPipelineCore::Capture(const std::vector& streamIds, const int32_t captureId) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Capture(it, captureId) | re; @@ -138,7 +138,7 @@ RetCode StreamPipelineCore::Capture(const std::vector& streamIds, const int RetCode StreamPipelineCore::CancelCapture(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->CancelCapture(it) | re; @@ -148,7 +148,7 @@ RetCode StreamPipelineCore::CancelCapture(const std::vector& streamIds) RetCode StreamPipelineCore::Flush(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { CAMERA_LOGV("flush stream %{public}d begin", it); @@ -160,7 +160,7 @@ RetCode StreamPipelineCore::Flush(const std::vector& streamIds) std::shared_ptr StreamPipelineCore::GetOfflinePipeline(const int32_t id) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); std::shared_ptr node = dispatcher_->GetNode(id, "ipp"); return std::static_pointer_cast(node); } diff --git a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h index d3688cd42c..cdcd162d88 100644 --- a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h +++ b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h @@ -45,7 +45,7 @@ public: const ModeMeta& meta, const std::vector& configs) override; protected: - std::mutex mutex_; + std::recursive_mutex mutex_; OperationMode mode_ = NORMAL; std::shared_ptr context_ = nullptr; std::unique_ptr strategy_ = nullptr; -- Gitee