From b38471050a73928d4d36087eeede326f59334225 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Mon, 25 Aug 2025 21:29:45 +0530 Subject: [PATCH 01/29] topic/RDKEMW6161-Ramesh Inital commit of interfaces and check native bulid --- build_dependencies.sh | 2 +- ds/host.cpp | 142 ++++++++++++++++++++++++++- ds/include/host.hpp | 223 +++++++++++++++++++++++++++++++++++++++++- 3 files changed, 361 insertions(+), 6 deletions(-) diff --git a/build_dependencies.sh b/build_dependencies.sh index 090f105a..566fca25 100644 --- a/build_dependencies.sh +++ b/build_dependencies.sh @@ -47,7 +47,7 @@ cd rfc autoreconf -i ./configure --enable-rfctool=yes --enable-tr181set=yes cd rfcapi -make librfcapi_la_CPPFLAGS="-I/usr/include/cjson" +make CXXFLAGS="-DUSE_IARMBUS" librfcapi_la_CPPFLAGS="-I/usr/include/cjson" make install export RFC_PATH=$ROOT/rfc diff --git a/ds/host.cpp b/ds/host.cpp index d621e479..af63b132 100644 --- a/ds/host.cpp +++ b/ds/host.cpp @@ -2,7 +2,7 @@ * If not stated otherwise in this file or this component's LICENSE file the * following copyright and licenses apply: * - * Copyright 2016 RDK Management + * Copyright 2025 RDK Management * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -241,7 +241,6 @@ namespace device } } - /** * @fn bool Host::setPowerMode(int mode) * @brief This API is used to change the power mode of the device. @@ -913,6 +912,145 @@ namespace device printf ("%s:%d - Set Audio Mixer levels for audio input: %d with volume = %d\n", __PRETTY_FUNCTION__, __LINE__,aInput, volume); } +/** + * @fn void Host::Register(IHDMIInEvent *listener) + * @brief This API is used to register the Events + * + * @return unint32_t + */ +uint32_t Host::Register(IHDMIInEvent *listener) +{ + return 0; +} + + +/** + * @fn void Host::UnRegister(IHDMIInEvent *listener) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::UnRegister(IHDMIInEvent *listener) +{ + return 0; +} + +/** + * @fn void Host::Register(ICompositeInEvent *Evtnotification) + * @brief This API is used to register the Events + * + * @return unint32_t + */ +uint32_t Host::Register(ICompositeInEvent *listener) +{ + return 0; +} + +/** + * @fn void Host::UnRegister(ICompositeInEvent *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::UnRegister(ICompositeInEvent *listener) +{ + return 0; +} + +/** + * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvent *Evtnotification) + * @brief This API is used to Register the Events + * + * @return unint32_t + */ +uint32_t Host::Register(IDisplayHDMIHotPlugEvent *listener) +{ + return 0; +} + + +/** + * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvent *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::UnRegister(IDisplayHDMIHotPlugEvent *listener) +{ + return 0; +} + +/** + * @fn void Host::UnRegister(IDisplayEvent *Evtnotification) + * @brief This API is used to Register the Events + * + * @return unint32_t + */ +uint32_t Host::Register(IDisplayEvent *listener) +{ + return 0; +} + + +/** + * @fn void Host::UnRegister(IDisplayEvent *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::UnRegister(IDisplayEvent *listener) +{ + return 0; +} + +/** + * @fn void Host::Register(IAudioOutputPortEvent *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::Register(IAudioOutputPortEvent *listener) +{ + return 0; +} + + +/** + * @fn void Host::UnRegister(IAudioOutputPortEvent *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::UnRegister(IAudioOutputPortEvent *listener) +{ + return 0; +} + + +/** + * @fn void Host::Register(IVideoDeviceEvent *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::Register(IVideoDeviceEvent *listener) +{ + return 0; +} + + +/** + * @fn void Host::UnRegister(IVideoDeviceEvent *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::UnRegister(IVideoDeviceEvent *listener) +{ + return 0; +} + + } diff --git a/ds/include/host.hpp b/ds/include/host.hpp index d14d42dc..f7997f55 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -2,7 +2,7 @@ * If not stated otherwise in this file or this component's LICENSE file the * following copyright and licenses apply: * - * Copyright 2016 RDK Management + * Copyright 2025 RDK Management * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,8 +17,6 @@ * limitations under the License. */ - - /** * @defgroup devicesettings * @{ @@ -38,6 +36,9 @@ #include "videoDevice.hpp" #include "sleepMode.hpp" #include "list.hpp" +#include "dsMgr.h" +#include "dsTypes.h" +#include "dsDisplay.h" #include #include @@ -59,6 +60,222 @@ namespace device { */ class Host { public: + + struct IHDMIInEvent { + + // @brief HDMI Event Hot Plug + // @text onHDMIInEventHotPlug + // @param port: port 0 or 1 et al + // @param isConnected: is it connected (true) or not (false) + virtual void OnHDMIInEventHotPlug(dsHdmiInPort_t port, bool isConnected) { }; + + // @brief HDMI Event Signal status + // @text OnHDMIInEventSignalStatus + // @param port: port 0 or 1 et al + // @param signalStatus: Signal Status + virtual void OnHDMIInEventSignalStatus(dsHdmiInPort_t port, dsHdmiInSignalStatus_t signalStatus) { }; + + // @brief HDMI Event Signal status + // @text onHDMIInEventStatus + // @param activePort: port 0 or 1 et al + // @param isPresented: is it presented or not + virtual void OnHDMIInEventStatus(dsHdmiInPort_t activePort, bool isPresented) { }; + + // @brief HDMI Video Mode update + // @text onHDMInVideoModeUpdate + // @param port: port 0 or 1 et al + // @param videoPortResolution: Video port resolution + virtual void OnHDMInVideoModeUpdate(dsHdmiInPort_t port, const dsVideoPortResolution_t& videoPortResolution) { }; + + // @brief HDMI ALLM (Auto Low Latency Mode) status + // @text onHDMInAllmStatus + // @param port: port 0 or 1 et al + // @param allmStatus: allm status + virtual void OnHDMInAllmStatus(dsHdmiInPort_t port, bool allmStatus) { }; + + // @brief HDMI Event AVI content type + // @text OnHDMInAVIContentType + // @param port: port 0 or 1 et al + // @param aviContentType: AVI content type + virtual void OnHDMInAVIContentType(dsHdmiInPort_t port, dsAviContentType_t aviContentType) { }; + + // @brief HDMI VRR status + // @text OnHDMInVRRStatus + // @param port: port 0 or 1 et al + // @param vrrType: VRR type + virtual void OnHDMInVRRStatus(dsHdmiInPort_t port, dsVRRType_t vrrType) { }; + + // @brief Zoom settings changed + // @text OnZoomSettingsChanged + // @param zoomSetting: Currently applied zoom setting + virtual void OnZoomSettingsChanged(dsVideoZoom_t zoomSetting) { }; + }; + + uint32_t Register(IHDMIInEvent *listener); + uint32_t UnRegister(IHDMIInEvent *listener); + + + struct ICompositeInEvent { + // @brief Composite In Hotplug event + // @text onCompositeInHotPlug + // @param port: Port of the hotplug + // @param isConnected: Is it connected (true) or not(false) + virtual void OnCompositeInHotPlug(dsCompositeInPort_t port, bool isConnected) { }; + + // @brief Composite In Signal status + // @text onCompositeInSignalStatus + // @param port: Port of the hotplug + // @param signalStatus: Signal status + virtual void OnCompositeInSignalStatus(dsCompositeInPort_t port, dsCompInSignalStatus_t signalStatus) { }; + + // @brief Composite In status + // @text onCompositeInStatus + // @param activePort: Active port + // @param isPresented: is it presented to user + virtual void OnCompositeInStatus(dsCompositeInPort_t activePort, bool isPresented) { }; + + + // @brief Composite In Video Mode Update + // @text OnCompositeInVideoModeUpdate + // @param activePort: Active port + // @param videoResolution: See DisplayVideoPortResolution + virtual void OnCompositeInVideoModeUpdate(dsCompositeInPort_t activePort, dsVideoPortResolution_t videoResolution) { }; + }; + + uint32_t Register(ICompositeInEvent *listener); + uint32_t UnRegister(ICompositeInEvent *listener); + + + struct IDisplayHDMIHotPlugEvent{ + + // @brief Display HDMI Hot plug event + // @text onDisplayHDMIHotPlug + // @param displayEvent: DS_DISPLAY_EVENT_CONNECTED or DS_DISPLAY_EVENT_DISCONNECTED + virtual void OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent) { }; + }; + + uint32_t Register(IDisplayHDMIHotPlugEvent*listener); + uint32_t UnRegister(IDisplayHDMIHotPlugEvent *listener); + + + + struct IDisplayEvent{ + + // @brief Display RX Sense event + // @text onDisplayRxSense + // @param displayEvent: DS_DISPLAY_RXSENSE_ON or DS_DISPLAY_RXSENSE_OFF + virtual void OnDisplayRxSense(dsDisplayEvent_t displayEvent) { }; + + // @brief Display HDCP Status + // @text OnDisplayHDCPStatus + virtual void OnDisplayHDCPStatus() { }; + }; + + uint32_t Register(IDisplayEvent *listener); + uint32_t UnRegister(IDisplayEvent *listener); + + + struct IAudioOutputPortEvent{ + + // @brief Associated Audio mixing changed + // @text onAssociatedAudioMixingChanged + // @param mixing: true or false + virtual void OnAssociatedAudioMixingChanged(bool mixing) { }; + + // @brief Audio Fader balance changed + // @text onAudioFaderControlChanged + // @param mixerBalance: applied mixer balance value + virtual void OnAudioFaderControlChanged(int mixerBalance) { }; + + // @brief Primary language for Audio changed + // @text onAudioPrimaryLanguageChanged + // @param primaryLanguage: current primary language for audio + virtual void OnAudioPrimaryLanguageChanged(const std::string& primaryLanguage) { }; + + // @brief Secondary language for Audio changed + // @text onAudioSecondaryLanguageChanged + // @param secondaryLanguage: current secondary language for audio + virtual void OnAudioSecondaryLanguageChanged(const std::string& secondaryLanguage) { }; + + // @brief Audio output hot plug event + // @text onAudioOutHotPlug + // @param portType: Type of audio port see AudioPortType + // @param uiPortNumber: The port number assigned by UI + // @param isPortConnected: true (connected) or false (not connected) + virtual void OnAudioOutHotPlug(dsAudioPortType_t audioPortType, int uiPortNumber, bool isPortConnected) { }; + + + // @brief Dolby Atmos capabilities changed + // @text onDolbyAtmosCapabilitiesChanged + // @param atmosCapability: the dolby atmos capability + // @param status: true (available) or false (not available) + virtual void OnDolbyAtmosCapabilitiesChanged(dsATMOSCapability_t atmosCapability, bool status) { }; + + // @brief Audio port state changed + // @text onAudioPortStateChanged + // @param audioPortState: audio port state + virtual void OnAudioPortStateChanged(dsAudioPortState_t audioPortState) { }; + + // @brief Audio mode for the respective audio port - raised for every type of port + // @text onAudioModeEvent + // @param audioPortType: audio port type see AudioPortType + // @param audioMode: audio mode - see audioStereoMode + virtual void OnAudioModeEvent(dsAudioPortType_t audioPortType, dsAudioStereoMode_t audioMode) { }; + + // @brief Audio Output format changed + // @text onAudioFormatUpdate + // @param audioFormat: Type of audio format see AudioFormat + virtual void OnAudioFormatUpdate(dsAudioFormat_t audioFormat) { }; + + }; + + uint32_t Register(IAudioOutputPortEvent *listener); + uint32_t UnRegister(IAudioOutputPortEvent *listener); + + + struct IVideoDeviceEvent { + // @brief Display Framerate Pre-change + // @text OnDisplayFrameratePreChange + // @param frameRate: PreChange framerate + virtual void OnDisplayFrameratePreChange(const std::string& frameRate) { }; + + // @brief Display Framerate Post-change + // @text OnDisplayFrameratePostChange + // @param frameRate: framerate post change + virtual void OnDisplayFrameratePostChange(const std::string& frameRate) { }; + }; + + uint32_t Register(IVideoDeviceEvent *listener); + uint32_t UnRegister(IVideoDeviceEvent *listener); + + + struct IVideoOutputPortEvent { + + // @brief On Resolution Pre changed + // @text OnResolutionPreChange + // @param resolution: resolution + virtual void OnResolutionPreChange(const int width, const int height) { }; + + // @brief On Resolution Post change + // @text onResolutionPostChange + // @param resolution: resolution + virtual void OnResolutionPostChange(const int width, const int height) { }; + + // @brief On HDCP Status change + // @text OnHDCPStatusChange + // @param hdcpStatus: HDCP Status + virtual void OnHDCPStatusChange(dsHdcpStatus_t hdcpStatus) { }; + + // @brief On Video Format update + // @text OnVideoFormatUpdate + // @param videoFormatHDR: Video format HDR standard + virtual void OnVideoFormatUpdate(dsHDRStandard_t videoFormatHDR) { }; + }; + + uint32_t Register(IVideoOutputPortEvent *listener); + uint32_t UnRegister(IVideoOutputPortEvent *listener); + + static const int kPowerOn; static const int kPowerOff; static const int kPowerStandby; From 42042753b2ec71c6d80fc9758e75920df21563d4 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Mon, 25 Aug 2025 21:50:42 +0530 Subject: [PATCH 02/29] topic/RDKEMW6161-Ramesh Zoom interfaces moved to Video Device --- ds/include/host.hpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/ds/include/host.hpp b/ds/include/host.hpp index f7997f55..6398caaa 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -105,10 +105,6 @@ class Host { // @param vrrType: VRR type virtual void OnHDMInVRRStatus(dsHdmiInPort_t port, dsVRRType_t vrrType) { }; - // @brief Zoom settings changed - // @text OnZoomSettingsChanged - // @param zoomSetting: Currently applied zoom setting - virtual void OnZoomSettingsChanged(dsVideoZoom_t zoomSetting) { }; }; uint32_t Register(IHDMIInEvent *listener); @@ -243,6 +239,11 @@ class Host { // @text OnDisplayFrameratePostChange // @param frameRate: framerate post change virtual void OnDisplayFrameratePostChange(const std::string& frameRate) { }; + + // @brief Zoom settings changed + // @text OnZoomSettingsChanged + // @param zoomSetting: Currently applied zoom setting + virtual void OnZoomSettingsChanged(dsVideoZoom_t zoomSetting) { }; }; uint32_t Register(IVideoDeviceEvent *listener); From f5fff98b0a1c9d082bc5a3a906b178e0642d5beb Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Mon, 25 Aug 2025 23:20:29 +0530 Subject: [PATCH 03/29] topic/RDKEMW6161-Ramesh merge changes Video --- cov_build.sh | 2 +- ds/Makefile.am | 8 + ds/host.cpp | 235 +++++-------------- ds/iarm/IarmHostImpl.cpp | 496 +++++++++++++++++++++++++++++++++++++++ ds/iarm/IarmHostImpl.hpp | 188 +++++++++++++++ ds/include/host.hpp | 75 +++--- 6 files changed, 787 insertions(+), 217 deletions(-) create mode 100755 ds/iarm/IarmHostImpl.cpp create mode 100755 ds/iarm/IarmHostImpl.hpp diff --git a/cov_build.sh b/cov_build.sh index 22e8d7d4..a4cc376f 100644 --- a/cov_build.sh +++ b/cov_build.sh @@ -70,4 +70,4 @@ find $WORKDIR -iname "*.o" -exec rm -v {} \; find $WORKDIR -iname "*.so*" -exec rm -v {} \; echo "##### Triggering make" -make CFLAGS+='-fPIC -DDSMGR_LOGGER_ENABLED=ON -DRDK_DSHAL_NAME=\"libdshal.so\" -I${DS_IF_PATH}/include -I${DS_HAL_PATH} -I${DS_MGRS}/stubs -I${IARMBUS_PATH}/core -I${IARMBUS_PATH}/core/include -I${IARM_MGRS}/sysmgr/include -I${DS_MGRS}/ds/include -I${DS_MGRS}/rpc/include -I${POWER_IF_PATH}/include/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I${IARM_MGRS}/mfr/include/ -I${IARM_MGRS}/mfr/common -I${DEEPSLEEP_IF_PATH}/include -I${IARM_MGRS}/hal/include -I${IARM_MGRS}/power -I${IARM_MGRS}/power/include' LDFLAGS="-L/usr/lib/x86_64-linux-gnu/ -L/usr/local/include -lglib-2.0 -lIARMBus -lWPEFrameworkPowerController -ldshal" \ No newline at end of file +make CFLAGS+='-fPIC -DDSMGR_LOGGER_ENABLED=ON -DDS_ENABLE_IARM_PATH -DRDK_DSHAL_NAME=\"libdshal.so\" -I${DS_IF_PATH}/include -I${DS_HAL_PATH} -I${DS_MGRS}/stubs -I${IARMBUS_PATH}/core -I${IARMBUS_PATH}/core/include -I${IARM_MGRS}/sysmgr/include -I${DS_MGRS}/ds/include -I${DS_MGRS}/ds/iarm -I${DS_MGRS}/rpc/include -I${POWER_IF_PATH}/include/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I${IARM_MGRS}/mfr/include/ -I${IARM_MGRS}/mfr/common -I${DEEPSLEEP_IF_PATH}/include -I${IARM_MGRS}/hal/include -I${IARM_MGRS}/power -I${IARM_MGRS}/power/include' LDFLAGS="-L/usr/lib/x86_64-linux-gnu/ -L/usr/local/include -lglib-2.0 -lIARMBus -lWPEFrameworkPowerController -ldshal" diff --git a/ds/Makefile.am b/ds/Makefile.am index 90c9bea4..6b9f3842 100644 --- a/ds/Makefile.am +++ b/ds/Makefile.am @@ -63,3 +63,11 @@ libds_la_SOURCES = aspectRatio.cpp \ host.cpp \ manager.cpp \ videoDFC.cpp + +# DS_ENABLE_IARM_PATH to be defined from the config.ac file +if DS_ENABLE_IARM_PATH +libds_la_SOURCES += iarm/iarmCompositeIn.cpp +else +# plugin files of future +endif + diff --git a/ds/host.cpp b/ds/host.cpp index af63b132..1201aba2 100644 --- a/ds/host.cpp +++ b/ds/host.cpp @@ -28,25 +28,21 @@ #include -#include -#include -#include "iarmProxy.hpp" +#include + #include "audioOutputPortConfig.hpp" #include "videoOutputPortConfig.hpp" #include "list.hpp" #include "host.hpp" #include "videoDeviceConfig.hpp" -#include "dsVideoPort.h" -#include "dsVideoDevice.h" #include "dsAudio.h" -#include "dsDisplay.h" -#include "dslogger.h" #include "dsHost.h" -#include "dsTypes.h" #include "unsupportedOperationException.hpp" -#include "hostEDID.hpp" +/*#include "hostEDID.hpp"*/ #include "dsInternal.h" +#include "iarm/IarmHostImpl.hpp" + /** * @file host.cpp * @brief The host module is the central module of the Device Settings module. @@ -60,20 +56,16 @@ namespace device const int Host::kPowerOn = dsPOWER_ON; const int Host::kPowerOff = dsPOWER_OFF; const int Host::kPowerStandby = dsPOWER_STANDBY; - - - Host::Host() - { - // TODO Auto-generated destructor stub - } - - Host::~Host() { - if (true) - { - IARMProxy::getInstance().UnRegisterPowerEventHandler(); - } - } +Host::Host() + : m_impl(nullptr) +{ +} + +Host::~Host() +{ + m_impl = nullptr; +} /** * @addtogroup dssettingshostapi @@ -103,144 +95,6 @@ namespace device return instance; } - -/** - * @fn void Host::addPowerModeListener(PowerModeChangeListener *l) - * @brief This API is used to register listeners for Power Mode change event. - * The listener object is created by application and should be released by the application once the listener is removed. - * Listeners will be notified with the new mode via the listener's powerModeChanged() callback. - * - * @param[in] PowerModeChangeListener Pointer to Power Mode change listener - * - * @return None - */ - void Host::addPowerModeListener(PowerModeChangeListener *l) - { - std::list < PowerModeChangeListener* > ::iterator it; - - it = find (powerEvntListeners.begin(),powerEvntListeners.end(), l); - if (it == powerEvntListeners.end()) - { - powerEvntListeners.push_back (l); - cout << "Added Power Mode listener...!\n"; - } - else - { - cout << "Already register for Power Mode Change\n"; - } - return ; - } - - -/** - * @fn void Host::removePowerModeChangeListener(PowerModeChangeListener *l) - * @brief This API is used to remove a listener from Power Mode change listener list. - * - * @param[in]PowerModeChangeListener The listener to remove. - * - * @return None - */ - void Host::removePowerModeChangeListener(PowerModeChangeListener *l) - { - std::list < PowerModeChangeListener* > ::iterator it ; - it = find (powerEvntListeners.begin(),powerEvntListeners.end(), l); - if (it == powerEvntListeners.end()) - { - cout << "Not Registered for Power Mode change yet...!\n"; - } - else - { - powerEvntListeners.erase (it); - cout << "Removed from Power Mode listener group..!\n"; - } - return; - } - - -/** - * @fn void Host::addDisplayConnectionListener (DisplayConnectionChangeListener *l) - * @brief This API is used to register listeners for Display connection change event. - * The listener will be notified if Display device is connected/disconnected from the video output port. - * The notification only carries the state change of the connection. - * It does not carry any other system state change that may have been triggered by the connection. - * The application is responsible to query the various parts of system to detect any such change. - * For example, when a TV device is replaced, the application shall query the video output port again upon the connection - * for the new resolution supported by the TV. - * The listener object is created by application and should be released by the application once the listener is removed. - * - * @param[in] DisplayConnectionChangeListener Pointer to Display connection change listener - * - * @return None - */ - void Host::addDisplayConnectionListener (DisplayConnectionChangeListener *l) - { - std::list < DisplayConnectionChangeListener* > ::iterator it; - - it = find (dispEvntListeners.begin(), dispEvntListeners.end(), l); - if (it == dispEvntListeners.end()) - { - dispEvntListeners.push_back (l); - cout << "Added Display listener...!\n"; - } - else - { - cout << "Already registered to the Display listener\n"; - } - return ; - } - - -/** - * @fn void Host::removeDisplayConnectionListener (DisplayConnectionChangeListener *l) - * @brief This API is used to remove listeners from the Display connection change event list. - * - * @param[in] DisplayConnectionChangeListener The listener to remove - * - * @return None - */ - void Host::removeDisplayConnectionListener (DisplayConnectionChangeListener *l) - { - std::list < DisplayConnectionChangeListener* > ::iterator it ; - it = find (dispEvntListeners.begin(), dispEvntListeners.end(), l); - if (it == dispEvntListeners.end()) - { - cout << "Not Registered to Display Listener yet...!\n"; - } - else - { - dispEvntListeners.erase (it); - cout << "Removed from the Display listener...!\n"; - } - return; - } - - -/** - * @fn void Host::notifyPowerChange (const int mode) - * @brief This function is used to get the current power state. - * - * @param[in] mode Power mode of the decoder. - * @return None. - */ - void Host::notifyPowerChange (const int mode) - { - std::list < PowerModeChangeListener* > ::iterator it; - for ( it = powerEvntListeners.begin() ; it != powerEvntListeners.end(); it++ ) - { - (*it)->powerModeChanged (mode); - } - } - - void Host::notifyDisplayConnectionChange (int portHandle, bool newConnectionStatus) - { - std::list < DisplayConnectionChangeListener* > ::iterator it; - for ( it = dispEvntListeners.begin() ; it != dispEvntListeners.end(); it++ ) - { - (*it)->displayConnectionChanged(getVideoOutputPort(portHandle), newConnectionStatus); - getVideoOutputPort(portHandle).setDisplayConnected(newConnectionStatus); - } - } - /** * @fn bool Host::setPowerMode(int mode) * @brief This API is used to change the power mode of the device. @@ -911,6 +765,16 @@ namespace device } printf ("%s:%d - Set Audio Mixer levels for audio input: %d with volume = %d\n", __PRETTY_FUNCTION__, __LINE__,aInput, volume); } + +DefaultImpl& Host::impl() +{ + // lazy instantiation + if (!m_impl) { + m_impl = std::make_unique(); + } + return *m_impl; +} + /** * @fn void Host::Register(IHDMIInEvent *listener) @@ -943,7 +807,7 @@ uint32_t Host::UnRegister(IHDMIInEvent *listener) */ uint32_t Host::Register(ICompositeInEvent *listener) { - return 0; + return 0; //impl().Register(listener); } /** @@ -954,7 +818,7 @@ uint32_t Host::Register(ICompositeInEvent *listener) */ uint32_t Host::UnRegister(ICompositeInEvent *listener) { - return 0; + return 0; //impl().UnRegister(listener); } /** @@ -1004,50 +868,73 @@ uint32_t Host::UnRegister(IDisplayEvent *listener) } /** - * @fn void Host::Register(IAudioOutputPortEvent *Evtnotification) + * @fn void Host::Register(IAudioOutputPortEvents *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::Register(IAudioOutputPortEvent *listener) +uint32_t Host::Register(IAudioOutputPortEvents *listener) { - return 0; + return impl().Register(listener); } /** - * @fn void Host::UnRegister(IAudioOutputPortEvent *Evtnotification) + * @fn void Host::UnRegister(IAudioOutputPortEvents *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::UnRegister(IAudioOutputPortEvent *listener) +uint32_t Host::UnRegister(IAudioOutputPortEvents *listener) { - return 0; + return impl().UnRegister(listener); } /** - * @fn void Host::Register(IVideoDeviceEvent *Evtnotification) + * @fn void Host::Register(IVideoOutputPortEvents *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::Register(IVideoDeviceEvent *listener) +uint32_t Host::Register(IVideoOutputPortEvents *listener) { - return 0; + return impl().Register(listener); } /** - * @fn void Host::UnRegister(IVideoDeviceEvent *Evtnotification) + * @fn void Host::UnRegister(IVideoOutputPortEvents *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::UnRegister(IVideoDeviceEvent *listener) +uint32_t Host::UnRegister(IVideoOutputPortEvents *listener) { - return 0; + return impl().UnRegister(listener); +} + +/** + * @fn void Host::Register(IVideoDeviceEvents *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::Register(IVideoDeviceEvents *listener) +{ + return impl().Register(listener); +} + + +/** + * @fn void Host::UnRegister(IVideoDeviceEvents *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return unint32_t + */ +uint32_t Host::UnRegister(IVideoDeviceEvents *listener) +{ + return impl().UnRegister(listener); } diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp new file mode 100755 index 00000000..998d4b6d --- /dev/null +++ b/ds/iarm/IarmHostImpl.cpp @@ -0,0 +1,496 @@ +#include +#include +#include + +#include "IarmHostImpl.hpp" + +#include "dsMgr.h" +/*#include "dsTypes.h"*/ +#include "dslogger.h" + +#include "libIBus.h" + +using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; +using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; +using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; + +namespace device { + +struct EventHandlerMapping { + IARM_EventId_t eventId; + IARM_EventHandler_t handler; +}; + +// unregisterIarmEvents can be called by registerIarmEvents in case of failure. +// Hence defined before registerIarmEvents +template +static bool unregisterIarmEvents(const EventHandlerMapping (&handlers)[N]) +{ + bool unregistered = true; + + for (const auto& eh : handlers) { + if (IARM_RESULT_SUCCESS != IARM_Bus_UnRegisterEventHandler(IARM_BUS_DSMGR_NAME, eh.eventId)) { + INT_ERROR("Failed to unregister IARM event handler for %d", eh.eventId); + unregistered = false; + // don't break here, try to unregister all handlers + } + } + return unregistered; +} + +template +static bool registerIarmEvents(const EventHandlerMapping (&handlers)[N]) +{ + bool registered = true; + + for (const auto& eh : handlers) { + if (IARM_RESULT_SUCCESS != IARM_Bus_RegisterEventHandler(IARM_BUS_DSMGR_NAME, eh.eventId, eh.handler)) { + INT_ERROR("Failed to register IARM event handler for %d", eh.eventId); + registered = false; + // no point in continuing as we will attempt to unregister anyway + break; + } + } + + if (!registered) { + // in case of failure / partial failure + // we should unregister any handlers that were registered + unregisterIarmEvents(handlers); + } + + return registered; +} + +// IARMGroupXYZ are c to c++ shim (all methods are static) +// Required to perform group event register and unregister with IARM +// Thread safety to be ensured by the caller +class IARMGroupVideoDevice { +public: + static bool RegisterIarmEvents() + { + return registerIarmEvents(handlers); + } + + static bool UnRegisterIarmEvents() + { + return unregisterIarmEvents(handlers); + } + +private: + static void iarmDisplayFrameratePreChangeHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_PRECHANGE received %s %d", owner, eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + std::string framerate(eventData->data.DisplayFrameRateChange.framerate); + + IarmHostImpl::Dispatch([&framerate](IVideoDeviceEvents* listener) { + listener->OnDisplayFrameratePreChange(framerate); + }); + } else { + INT_ERROR("Invalid data received for display framerate pre-change"); + } + } + + static void iarmDisplayFrameratePostChangeHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_POSTCHANGE received %s %d", owner, eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + std::string framerate(eventData->data.DisplayFrameRateChange.framerate); + + IarmHostImpl::Dispatch([&framerate](IVideoDeviceEvents* listener) { + listener->OnDisplayFrameratePostChange(framerate); + }); + } else { + INT_ERROR("Invalid data received for display framerate post-change"); + } + } + + static constexpr EventHandlerMapping handlers[] = { + { IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_PRECHANGE, &IARMGroupVideoDevice::iarmDisplayFrameratePreChangeHandler }, + { IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_POSTCHANGE, &IARMGroupVideoDevice::iarmDisplayFrameratePostChangeHandler }, + }; +}; + +class IARMGroupVideoPort { +public: + static bool RegisterIarmEvents() + { + return registerIarmEvents(handlers); + } + + static bool UnRegisterIarmEvents() + { + return unregisterIarmEvents(handlers); + } + +private: + static void iarmResolutionPreChangeHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_RES_PRECHANGE received, eventId = %d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + int width = eventData->data.resn.width; + int height = eventData->data.resn.height; + + IarmHostImpl::Dispatch([width, height](IVideoOutputPortEvents* listener) { + listener->OnResolutionPreChange(width, height); + }); + } else { + INT_ERROR("Invalid data received for resolution pre-change"); + } + } + + static void iarmResolutionPostChangeHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_RES_POSTCHANGE received, eventId = %d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + int width = eventData->data.resn.width; + int height = eventData->data.resn.height; + + IarmHostImpl::Dispatch([width, height](IVideoOutputPortEvents* listener) { + listener->OnResolutionPostChange(width, height); + }); + } else { + INT_ERROR("Invalid data received for resolution post-change"); + } + } + + static void iarmHDCPStatusChangeHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_HDCP_STATUS received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + // TODO + } else { + INT_ERROR("Invalid data received for HDCP status change"); + } + } + + static void iarmVideoFormatUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_VIDEO_FORMAT_UPDATE received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + dsHDRStandard_t videoFormat = eventData->data.VideoFormatInfo.videoFormat; + + IarmHostImpl::Dispatch([videoFormat](IVideoOutputPortEvents* listener) { + listener->OnVideoFormatUpdate(videoFormat); + }); + } else { + INT_ERROR("Invalid data received for video format update"); + } + } + + static constexpr EventHandlerMapping handlers[] = { + { IARM_BUS_DSMGR_EVENT_RES_PRECHANGE, &IARMGroupVideoPort::iarmResolutionPreChangeHandler }, + { IARM_BUS_DSMGR_EVENT_RES_POSTCHANGE, &IARMGroupVideoPort::iarmResolutionPostChangeHandler }, + { IARM_BUS_DSMGR_EVENT_HDCP_STATUS, &IARMGroupVideoPort::iarmHDCPStatusChangeHandler }, + { IARM_BUS_DSMGR_EVENT_VIDEO_FORMAT_UPDATE, &IARMGroupVideoPort::iarmVideoFormatUpdateHandler }, + }; +}; + +class IARMGroupAudioPort { +public: + static bool RegisterIarmEvents() + { + return registerIarmEvents(handlers); + } + + static bool UnRegisterIarmEvents() + { + return unregisterIarmEvents(handlers); + } + +private: + static void iarmAssociatedAudioMixingChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_ASSOCIATED_AUDIO_MIXING_CHANGED received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + bool mixing = eventData->data.AssociatedAudioMixingInfo.mixing; + + IarmHostImpl::Dispatch([mixing](IAudioOutputPortEvents* listener) { + listener->OnAssociatedAudioMixingChanged(mixing); + }); + } else { + INT_ERROR("Invalid data received for associated audio mixing change"); + } + }; + + static void iarmAudioFaderControlChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_FADER_CONTROL_CHANGED received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + int mixerBalance = eventData->data.FaderControlInfo.mixerbalance; + + IarmHostImpl::Dispatch([mixerBalance](IAudioOutputPortEvents* listener) { + listener->OnAudioFaderControlChanged(mixerBalance); + }); + } else { + INT_ERROR("Invalid data received for audio fader control change"); + } + }; + + static void iarmAudioPrimaryLanguageChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_PRIMARY_LANGUAGE_CHANGED received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + std::string primaryLanguage(eventData->data.AudioLanguageInfo.audioLanguage); + + IarmHostImpl::Dispatch([&primaryLanguage](IAudioOutputPortEvents* listener) { + listener->OnAudioPrimaryLanguageChanged(primaryLanguage); + }); + } else { + INT_ERROR("Invalid data received for primary language change"); + } + }; + + static void iarmAudioSecondaryLanguageChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_SECONDARY_LANGUAGE_CHANGED received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + std::string secondaryLanguage(eventData->data.AudioLanguageInfo.audioLanguage); + + IarmHostImpl::Dispatch([&secondaryLanguage](IAudioOutputPortEvents* listener) { + listener->OnAudioSecondaryLanguageChanged(secondaryLanguage); + }); + } else { + INT_ERROR("Invalid data received for secondary language change"); + } + }; + + static void iarmAudioOutHotPlugHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_OUT_HOTPLUG received, eventId=%d", eventId); + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsAudioPortType_t portType = eventData->data.audio_out_connect.portType; + int uiPortNumber = eventData->data.audio_out_connect.uiPortNo; + bool isPortConnected = eventData->data.audio_out_connect.isPortConnected; + + IarmHostImpl::Dispatch([portType, uiPortNumber, isPortConnected](IAudioOutputPortEvents* listener) { + listener->OnAudioOutHotPlug(portType, uiPortNumber, isPortConnected); + }); + } else { + INT_ERROR("Invalid data received for audio out hot plug change"); + } + }; + + static void iarmDolbyAtmosCapabilitiesChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_ATMOS_CAPS_CHANGED received, eventId=%d", eventId); + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsATMOSCapability_t atmosCapability = eventData->data.AtmosCapsChange.caps; + bool status = eventData->data.AtmosCapsChange.status; + + IarmHostImpl::Dispatch([atmosCapability, status](IAudioOutputPortEvents* listener) { + listener->OnDolbyAtmosCapabilitiesChanged(atmosCapability, status); + }); + + } else { + INT_ERROR("Invalid data received for Dolby Atmos capabilities change"); + } + }; + + // TODO: requires dsMgr.h header for dsAudioPortState_t ? + static void iarmAudioPortStateChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_PORT_STATE received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + dsAudioPortState_t audioPortState = eventData->data.AudioPortStateInfo.audioPortState; + + IarmHostImpl::Dispatch([audioPortState](IAudioOutputPortEvents* listener) { + // TODO: + // listener->OnAudioPortStateChanged(audioPortState); + }); + } else { + INT_ERROR("Invalid data received for audio port state change"); + } + }; + + static void iarmAudioModeEventHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_MODE received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + dsAudioPortType_t audioPortType = static_cast(eventData->data.Audioport.type); + dsAudioStereoMode_t audioStereoMode = static_cast(eventData->data.Audioport.mode); + + IarmHostImpl::Dispatch([audioPortType, audioStereoMode](IAudioOutputPortEvents* listener) { + listener->OnAudioModeEvent(audioPortType, audioStereoMode); + }); + } else { + INT_ERROR("Invalid data received for audio mode change"); + } + }; + + static void iarmAudioLevelChangedEventHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_LEVEL_CHANGED received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + int audioLevel = eventData->data.AudioLevelInfo.level; + + IarmHostImpl::Dispatch([audioLevel](IAudioOutputPortEvents* listener) { + listener->OnAudioLevelChangedEvent(audioLevel); + }); + } else { + INT_ERROR("Invalid data received for audio level change"); + } + }; + + static void iarmAudioFormatUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_FORMAT_UPDATE received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + dsAudioFormat_t audioFormat = eventData->data.AudioFormatInfo.audioFormat; + + IarmHostImpl::Dispatch([audioFormat](IAudioOutputPortEvents* listener) { + listener->OnAudioFormatUpdate(audioFormat); + }); + } else { + INT_ERROR("Invalid data received for audio format update"); + } + }; + +private: + static constexpr EventHandlerMapping handlers[] = { + { IARM_BUS_DSMGR_EVENT_AUDIO_ASSOCIATED_AUDIO_MIXING_CHANGED, &IARMGroupAudioPort::iarmAssociatedAudioMixingChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_FADER_CONTROL_CHANGED, &IARMGroupAudioPort::iarmAudioFaderControlChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_PRIMARY_LANGUAGE_CHANGED, &IARMGroupAudioPort::iarmAudioPrimaryLanguageChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_SECONDARY_LANGUAGE_CHANGED, &IARMGroupAudioPort::iarmAudioSecondaryLanguageChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_OUT_HOTPLUG, &IARMGroupAudioPort::iarmAudioOutHotPlugHandler }, + { IARM_BUS_DSMGR_EVENT_ATMOS_CAPS_CHANGED, &IARMGroupAudioPort::iarmDolbyAtmosCapabilitiesChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_PORT_STATE, &IARMGroupAudioPort::iarmAudioPortStateChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_MODE, &IARMGroupAudioPort::iarmAudioModeEventHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_LEVEL_CHANGED, &IARMGroupAudioPort::iarmAudioLevelChangedEventHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_FORMAT_UPDATE, &IARMGroupAudioPort::iarmAudioFormatUpdateHandler }, + }; +}; + +// static data +std::mutex IarmHostImpl::s_mutex; +IarmHostImpl::CallbackList IarmHostImpl::s_videoDeviceListeners; +IarmHostImpl::CallbackList IarmHostImpl::s_videoPortListeners; +IarmHostImpl::CallbackList IarmHostImpl::s_audioPortListeners; + +IarmHostImpl::~IarmHostImpl() +{ + std::lock_guard lock(s_mutex); + + s_videoDeviceListeners.Release(); + s_videoPortListeners.Release(); + s_audioPortListeners.Release(); +} + +template +/* static */ void IarmHostImpl::Dispatch(const std::list& listeners, F&& fn) +{ + std::stringstream ss; + std::lock_guard lock(s_mutex); + + for (auto* listener : listeners) { + auto start = std::chrono::steady_clock::now(); + + fn(listener); + + auto end = std::chrono::steady_clock::now(); + auto elapsed = std::chrono::duration_cast(end - start); + ss << "\t client =" << listener << ", elapsed = " << elapsed.count() << " ms\n"; + } + + INT_INFO("%s Dispatch done to %zu listeners\n%s", typeid(T).name(), listeners.size(), ss.str().c_str()); +} + +uint32_t IarmHostImpl::Register(IVideoDeviceEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_videoDeviceListeners.Register(listener); +} + +uint32_t IarmHostImpl::UnRegister(IVideoDeviceEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_videoDeviceListeners.UnRegister(listener); +} + +// Dispatcher for IARMGroupVideoDevice +/* static */ void IarmHostImpl::Dispatch(std::function&& fn) +{ + Dispatch(s_videoDeviceListeners, std::move(fn)); +} + +uint32_t IarmHostImpl::Register(IVideoOutputPortEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_videoPortListeners.Register(listener); +} + +uint32_t IarmHostImpl::UnRegister(IVideoOutputPortEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_videoPortListeners.UnRegister(listener); +} + +// Dispatcher for IARMGroupVideoPort +/* static */ void IarmHostImpl::Dispatch(std::function&& fn) +{ + Dispatch(s_videoPortListeners, std::move(fn)); +} + +uint32_t IarmHostImpl::Register(IAudioOutputPortEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_audioPortListeners.Register(listener); +} + +uint32_t IarmHostImpl::UnRegister(IAudioOutputPortEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_audioPortListeners.UnRegister(listener); +} + +// Dispatcher for IARMGroupAudioPort +/* static */ void IarmHostImpl::Dispatch(std::function&& fn) +{ + Dispatch(s_audioPortListeners, std::move(fn)); +} + +} // namespace device diff --git a/ds/iarm/IarmHostImpl.hpp b/ds/iarm/IarmHostImpl.hpp new file mode 100755 index 00000000..c2294dbc --- /dev/null +++ b/ds/iarm/IarmHostImpl.hpp @@ -0,0 +1,188 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2025 RDK Management + * + * 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. + */ +#pragma once + +#include +#include +#include + +#include "dslogger.h" +#include "host.hpp" + +namespace device { + +// Forward declaration for IARM Implementation Groups +class IARMGroupVideoDevice; +class IARMGroupVideoPort; +class IARMGroupAudioPort; + +class IarmHostImpl { + + // Manages a list of listeners and corresponding IARM Event Group operations. + // Private internal class, not to be used directly by clients. + template + class CallbackList : public std::list { + public: + CallbackList() + : m_registered(false) + { + } + + ~CallbackList() + { + // As best practise caller is supposed to call Release() explicitly + // this is just for safety (see IarmHostImpl destructor) + Release(); + } + + // disable copy and move semantics + CallbackList(const CallbackList&) = delete; + CallbackList& operator=(const CallbackList&) = delete; + CallbackList(CallbackList&&) = delete; + CallbackList& operator=(CallbackList&&) = delete; + + // @brief Register a listener, also register IARM events if not already registered + // if the listener is already registered, listener will not be added again + // if IARM event registration fails, listener will not be added + uint32_t Register(T listener) + { + if (listener == nullptr) { + INT_ERROR("%s listener is null", typeid(T).name()); + return 1; // Error: Listener is null + } + + if (!m_registered) { + m_registered = IARMGroup::RegisterIarmEvents(); + + if (!m_registered) { + INT_ERROR("Failed to register IARMGroup %s", typeid(IARMGroup).name()); + return 1; // Error: Failed to register IARM group + } + } + + auto it = std::find(this->begin(), this->end(), listener); + if (it != this->end()) { + // Listener already registered + INT_ERROR("%s %p is already registered", typeid(T).name(), listener); + return 0; + } + + this->push_back(listener); + + INT_INFO("%s %p registered", typeid(T).name(), listener); + + return 0; + } + + // @brief UnRegister a listener, also unregister IARM events if no listeners are left + // if the listener is not registered, it will not be removed + uint32_t UnRegister(T listener) + { + if (listener == nullptr) { + INT_ERROR("%s listener is null", typeid(T).name()); + return 1; // Error: Listener is null + } + + auto it = std::find(this->begin(), this->end(), listener); + if (it == this->end()) { + // Listener not found + INT_ERROR("%s %p is not registered", typeid(T).name(), listener); + return 1; // Error: Listener not found + } + + this->erase(it); + + INT_INFO("%s %p unregistered", typeid(T).name(), listener); + + if (this->empty() && m_registered) { + m_registered = !IARMGroup::UnRegisterIarmEvents(); + } + + return 0; + } + + // @brief Release all listeners and unregister IARM events + // This will clear the list and unregister IARM events if no listeners are left + uint32_t Release() + { + if (m_registered) { + m_registered = !IARMGroup::UnRegisterIarmEvents(); + } + + this->clear(); + INT_INFO("CallbackList[T=%s] released, status: %d", typeid(T).name(), m_registered); + return 0; // Success + } + + private: + bool m_registered = false; // To track if IARM events are registered + }; + +public: + using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; + using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; + using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; + + IarmHostImpl(); + ~IarmHostImpl(); + + // @brief Register a listener for video device events + // @param listener: class object implementing the listener + uint32_t Register(IVideoDeviceEvents* listener); + + // @brief UnRegister a listener for video device events + // @param listener: class object implementing the listener + uint32_t UnRegister(IVideoDeviceEvents* listener); + + // @brief Register a listener for video port events + // @param listener: class object implementing the listener + uint32_t Register(IVideoOutputPortEvents* listener); + + // @brief UnRegister a listener for video port events + // @param listener: class object implementing the listener + uint32_t UnRegister(IVideoOutputPortEvents* listener); + + // @brief Register a listener for audio port events + // @param listener: class object implementing the listener + uint32_t Register(IAudioOutputPortEvents* listener); + + // @brief UnRegister a listener for audio port events + // @param listener: class object implementing the listener + uint32_t UnRegister(IAudioOutputPortEvents* listener); + +private: + static std::mutex s_mutex; + + static CallbackList s_videoDeviceListeners; + static CallbackList s_videoPortListeners; + static CallbackList s_audioPortListeners; + + template + static void Dispatch(const std::list& listeners, F&& fn); + + static void Dispatch(std::function&& fn); + static void Dispatch(std::function&& fn); + static void Dispatch(std::function&& fn); + + // Dispatch is private, so all IARMGroup implementations will need to be friends + friend class IARMGroupVideoDevice; + friend class IARMGroupVideoPort; + friend class IARMGroupAudioPort; +}; +} // namespace device diff --git a/ds/include/host.hpp b/ds/include/host.hpp index 6398caaa..66414495 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -27,22 +27,15 @@ #ifndef _DS_HOST_HPP_ #define _DS_HOST_HPP_ +#include +#include -#include -#include "powerModeChangeListener.hpp" -#include "displayConnectionChangeListener.hpp" #include "audioOutputPort.hpp" -#include "videoOutputPort.hpp" -#include "videoDevice.hpp" +#include "dsAVDTypes.h" +#include "list.hpp" #include "sleepMode.hpp" -#include "list.hpp" -#include "dsMgr.h" -#include "dsTypes.h" -#include "dsDisplay.h" - -#include -#include - +#include "videoDevice.hpp" +#include "videoOutputPort.hpp" /** * @file host.hpp @@ -52,6 +45,10 @@ using namespace std; namespace device { +// Forward declaration of the implementation class +class IarmHostImpl; +// In future add a conditional to choose implementation class based on build configuration +using DefaultImpl = IarmHostImpl; /** * @class Host @@ -61,7 +58,7 @@ namespace device { class Host { public: - struct IHDMIInEvent { + struct IHDMIInEvents { // @brief HDMI Event Hot Plug // @text onHDMIInEventHotPlug @@ -107,11 +104,11 @@ class Host { }; - uint32_t Register(IHDMIInEvent *listener); - uint32_t UnRegister(IHDMIInEvent *listener); + uint32_t Register(IHDMIInEvents *listener); + uint32_t UnRegister(IHDMIInEvents *listener); - struct ICompositeInEvent { + struct ICompositeInEvents { // @brief Composite In Hotplug event // @text onCompositeInHotPlug // @param port: Port of the hotplug @@ -138,11 +135,11 @@ class Host { virtual void OnCompositeInVideoModeUpdate(dsCompositeInPort_t activePort, dsVideoPortResolution_t videoResolution) { }; }; - uint32_t Register(ICompositeInEvent *listener); - uint32_t UnRegister(ICompositeInEvent *listener); + uint32_t Register(ICompositeInEvents *listener); + uint32_t UnRegister(ICompositeInEvents *listener); - struct IDisplayHDMIHotPlugEvent{ + struct IDisplayHDMIHotPlugEvents{ // @brief Display HDMI Hot plug event // @text onDisplayHDMIHotPlug @@ -150,12 +147,12 @@ class Host { virtual void OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent) { }; }; - uint32_t Register(IDisplayHDMIHotPlugEvent*listener); - uint32_t UnRegister(IDisplayHDMIHotPlugEvent *listener); + uint32_t Register(IDisplayHDMIHotPlugEvents *listener); + uint32_t UnRegister(IDisplayHDMIHotPlugEvents *listener); - struct IDisplayEvent{ + struct IDisplayEvents{ // @brief Display RX Sense event // @text onDisplayRxSense @@ -167,11 +164,11 @@ class Host { virtual void OnDisplayHDCPStatus() { }; }; - uint32_t Register(IDisplayEvent *listener); - uint32_t UnRegister(IDisplayEvent *listener); + uint32_t Register(IDisplayEvents *listener); + uint32_t UnRegister(IDisplayEvents *listener); - struct IAudioOutputPortEvent{ + struct IAudioOutputPortEvents{ // @brief Associated Audio mixing changed // @text onAssociatedAudioMixingChanged @@ -225,11 +222,11 @@ class Host { }; - uint32_t Register(IAudioOutputPortEvent *listener); - uint32_t UnRegister(IAudioOutputPortEvent *listener); + uint32_t Register(IAudioOutputPortEvents *listener); + uint32_t UnRegister(IAudioOutputPortEvents *listener); - struct IVideoDeviceEvent { + struct IVideoDeviceEvents { // @brief Display Framerate Pre-change // @text OnDisplayFrameratePreChange // @param frameRate: PreChange framerate @@ -246,11 +243,11 @@ class Host { virtual void OnZoomSettingsChanged(dsVideoZoom_t zoomSetting) { }; }; - uint32_t Register(IVideoDeviceEvent *listener); - uint32_t UnRegister(IVideoDeviceEvent *listener); + uint32_t Register(IVideoDeviceEvents *listener); + uint32_t UnRegister(IVideoDeviceEvents *listener); - struct IVideoOutputPortEvent { + struct IVideoOutputPortEvents { // @brief On Resolution Pre changed // @text OnResolutionPreChange @@ -273,8 +270,8 @@ class Host { virtual void OnVideoFormatUpdate(dsHDRStandard_t videoFormatHDR) { }; }; - uint32_t Register(IVideoOutputPortEvent *listener); - uint32_t UnRegister(IVideoOutputPortEvent *listener); + uint32_t Register(IVideoOutputPortEvents *listener); + uint32_t UnRegister(IVideoOutputPortEvents *listener); static const int kPowerOn; @@ -286,10 +283,6 @@ class Host { SleepMode getPreferredSleepMode(); int setPreferredSleepMode(const SleepMode); List getAvailableSleepModes(); - void addPowerModeListener(PowerModeChangeListener *l); - void removePowerModeChangeListener(PowerModeChangeListener *l); - void addDisplayConnectionListener(DisplayConnectionChangeListener *l); - void removeDisplayConnectionListener(DisplayConnectionChangeListener *l); static Host& getInstance(void); @@ -300,7 +293,6 @@ class Host { VideoOutputPort &getVideoOutputPort(int id); AudioOutputPort &getAudioOutputPort(const std::string &name); AudioOutputPort &getAudioOutputPort(int id); - void notifyPowerChange(const int mode); float getCPUTemperature(); uint32_t getVersion(void); void setVersion(uint32_t versionNumber); @@ -323,15 +315,14 @@ class Host { void getMS12ConfigDetails(std::string &configType); void setAudioMixerLevels (dsAudioInput_t aInput, int volume); private: + std::unique_ptr m_impl; Host(); virtual ~Host(); //To Make the instance as thread-safe, using = delete, the result is, automatically generated methods (constructor, for example) from the compiler will not be created and, therefore, can not be called Host (const Host&)= delete; Host& operator=(const Host&)= delete; - std::list < PowerModeChangeListener* > powerEvntListeners; - std::list < DisplayConnectionChangeListener* > dispEvntListeners; - void notifyDisplayConnectionChange(int portHandle, bool newConnectionStatus); + DefaultImpl& impl(); }; } From bb2c5bc0334943f9c8ee36fa5bc5c32cdc0fefa8 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Mon, 25 Aug 2025 23:33:11 +0530 Subject: [PATCH 04/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/include/host.hpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ds/include/host.hpp b/ds/include/host.hpp index 66414495..972a6e8c 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -36,6 +36,9 @@ #include "sleepMode.hpp" #include "videoDevice.hpp" #include "videoOutputPort.hpp" +#include "dsMgr.h" +#include "dsTypes.h" +#include "dsDisplay.h" /** * @file host.hpp From e74115a05840b5ff94ed793db38e3ea3d50faaa7 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Mon, 25 Aug 2025 23:38:05 +0530 Subject: [PATCH 05/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/host.cpp | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/ds/host.cpp b/ds/host.cpp index 1201aba2..451bd5f7 100644 --- a/ds/host.cpp +++ b/ds/host.cpp @@ -777,92 +777,92 @@ DefaultImpl& Host::impl() /** - * @fn void Host::Register(IHDMIInEvent *listener) + * @fn void Host::Register(IHDMIInEvents *listener) * @brief This API is used to register the Events * * @return unint32_t */ -uint32_t Host::Register(IHDMIInEvent *listener) +uint32_t Host::Register(IHDMIInEvents *listener) { return 0; } /** - * @fn void Host::UnRegister(IHDMIInEvent *listener) + * @fn void Host::UnRegister(IHDMIInEvents *listener) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::UnRegister(IHDMIInEvent *listener) +uint32_t Host::UnRegister(IHDMIInEvents *listener) { return 0; } /** - * @fn void Host::Register(ICompositeInEvent *Evtnotification) + * @fn void Host::Register(ICompositeInEvents *Evtnotification) * @brief This API is used to register the Events * * @return unint32_t */ -uint32_t Host::Register(ICompositeInEvent *listener) +uint32_t Host::Register(ICompositeInEvents *listener) { return 0; //impl().Register(listener); } /** - * @fn void Host::UnRegister(ICompositeInEvent *Evtnotification) + * @fn void Host::UnRegister(ICompositeInEvents *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::UnRegister(ICompositeInEvent *listener) +uint32_t Host::UnRegister(ICompositeInEvents *listener) { return 0; //impl().UnRegister(listener); } /** - * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvent *Evtnotification) + * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvents *Evtnotification) * @brief This API is used to Register the Events * * @return unint32_t */ -uint32_t Host::Register(IDisplayHDMIHotPlugEvent *listener) +uint32_t Host::Register(IDisplayHDMIHotPlugEvents *listener) { return 0; } /** - * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvent *Evtnotification) + * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvents *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::UnRegister(IDisplayHDMIHotPlugEvent *listener) +uint32_t Host::UnRegister(IDisplayHDMIHotPlugEvents *listener) { return 0; } /** - * @fn void Host::UnRegister(IDisplayEvent *Evtnotification) + * @fn void Host::UnRegister(IDisplayEvents *Evtnotification) * @brief This API is used to Register the Events * * @return unint32_t */ -uint32_t Host::Register(IDisplayEvent *listener) +uint32_t Host::Register(IDisplayEvents *listener) { return 0; } /** - * @fn void Host::UnRegister(IDisplayEvent *Evtnotification) + * @fn void Host::UnRegister(IDisplayEvents *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t */ -uint32_t Host::UnRegister(IDisplayEvent *listener) +uint32_t Host::UnRegister(IDisplayEvents *listener) { return 0; } From 6809a87768224bd260cef658f866c84664978bbf Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Mon, 25 Aug 2025 23:44:28 +0530 Subject: [PATCH 06/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/Makefile.am | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ds/Makefile.am b/ds/Makefile.am index 6b9f3842..d8b03507 100644 --- a/ds/Makefile.am +++ b/ds/Makefile.am @@ -66,7 +66,7 @@ libds_la_SOURCES = aspectRatio.cpp \ # DS_ENABLE_IARM_PATH to be defined from the config.ac file if DS_ENABLE_IARM_PATH -libds_la_SOURCES += iarm/iarmCompositeIn.cpp +libds_la_SOURCES += iarm/IarmHostImpl.cpp else # plugin files of future endif From 574a7387e9cc98f8953ce44e8a7891d229ce2579 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Mon, 25 Aug 2025 23:51:42 +0530 Subject: [PATCH 07/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/Makefile | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/ds/Makefile b/ds/Makefile index e7c41ddd..59a31c70 100644 --- a/ds/Makefile +++ b/ds/Makefile @@ -33,7 +33,8 @@ INCLUDE := -I$(PWD) \ -I$(PWD)/hal/src \ -I$(PWD)/ds \ -I$(PWD)/rpc/include \ - -I$(PWD)/ds/include + -I$(PWD)/ds/include \ + -I$(PWD)/ds/iarm else INCLUDE := -I$(PWD) \ -I$(LOG4C_INSTALL_DIR)/include \ @@ -41,7 +42,8 @@ INCLUDE := -I$(PWD) \ -I$(PWD)/hal/include \ -I$(PWD)/ds \ -I$(PWD)/rpc/include \ - -I$(PWD)/ds/include + -I$(PWD)/ds/include \ + -I$(PWD)/ds/iarm endif From 9caee264e6a2045514a7df31e40eb70f70ace596 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 00:01:28 +0530 Subject: [PATCH 08/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/Makefile.am | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ds/Makefile.am b/ds/Makefile.am index d8b03507..ab407564 100644 --- a/ds/Makefile.am +++ b/ds/Makefile.am @@ -65,9 +65,9 @@ libds_la_SOURCES = aspectRatio.cpp \ videoDFC.cpp # DS_ENABLE_IARM_PATH to be defined from the config.ac file -if DS_ENABLE_IARM_PATH +#if DS_ENABLE_IARM_PATH libds_la_SOURCES += iarm/IarmHostImpl.cpp -else +#else # plugin files of future -endif +#endif From 97550627b4a4bb9b5fd61acec65378969f005189 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 00:07:45 +0530 Subject: [PATCH 09/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/ds/Makefile b/ds/Makefile index 59a31c70..d7ff5b7e 100644 --- a/ds/Makefile +++ b/ds/Makefile @@ -23,6 +23,7 @@ LIBNAMEFULL := lib$(LIBNAME).so LIBNAMECLI := lib$(LIBNAME)-cli.so INSTALL := $(PWD)/install OBJS := $(patsubst %.cpp,%.o,$(wildcard *.cpp)) +OBJS += iarm/IarmHostImpl.o #$(PWD)/config should be first include path # to override generic configs ifneq ($(STANDALONE_BUILD_ENABLED),y) From 51d40123afabb968f1a0b57d3f79ea2907057681 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 00:14:40 +0530 Subject: [PATCH 10/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/iarm/IarmHostImpl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 998d4b6d..6e2d3c4e 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -366,7 +366,7 @@ class IARMGroupAudioPort { int audioLevel = eventData->data.AudioLevelInfo.level; IarmHostImpl::Dispatch([audioLevel](IAudioOutputPortEvents* listener) { - listener->OnAudioLevelChangedEvent(audioLevel); + //listener->OnAudioLevelChangedEvent(audioLevel); }); } else { INT_ERROR("Invalid data received for audio level change"); From d2395c678351850c0f5aa0a1cc2028eff17023b8 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 09:22:49 +0530 Subject: [PATCH 11/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/iarm/IarmHostImpl.cpp | 119 +++++++++++++++++++++++++++++++++++++++ ds/iarm/IarmHostImpl.hpp | 18 +++++- 2 files changed, 135 insertions(+), 2 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 6e2d3c4e..0c7e6dd7 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -405,11 +405,111 @@ class IARMGroupAudioPort { }; }; + + +class IARMGroupComposite { +public: + static bool RegisterIarmEvents() + { + return registerIarmEvents(handlers); + } + + static bool UnRegisterIarmEvents() + { + return unregisterIarmEvents(handlers); + } + +private: + static void iarmCompositeInHotPlugHandler(const char*, IARM_EventId_t, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_HOTPLUG received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsCompositeInPort_t compositePort = eventData->data.composite_in_connect.port; + bool isConnected = eventData->data.composite_in_connect.isPortConnected; + + IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + listener->OnCompositeInHotPlug(compositePort,isConnected); + }); + } else { + INT_ERROR("Invalid data received for Composite Status Handler in iarmCompositeInHotPlugHandler"); + } + } + + + static void iarmCompositeInSignalStatusHandler(const char*, IARM_EventId_t, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsCompositeInPort_t compositePort = eventData->data.composite_in_sig_status.port; + dsCompInSignalStatus_t compositeSigStatus = eventData->data.composite_in_sig_status.status; + + IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + listener->OnCompositeInSignalStatus(compositePort,compositeSigStatus); + }); + } else { + INT_ERROR("Invalid data received for Composite Status Handler in iarmCompositeInSignalStatusHandler"); + } + } + + static void iarmCompositeInStatusHandler(const char*, IARM_EventId_t, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_STATUS received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsCompositeInPort_t compositePort = eventData->data.composite_in_status.port; + bool isPresented = eventData->data.composite_in_status.isPresented; + + IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + listener->OnCompositeInStatus(compositePort,isPresented); + }); + } else { + INT_ERROR("Invalid data received for Composite Status Handler in iarmCompositeInStatusHandler"); + } + } + + + static void iarmCompositeInVideoModeUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_VIDEO_MODE_UPDATE received, eventId=%d", eventId); + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + dsCompositeInPort_t compositePort = eventData->data.composite_in_video_mode.port; + dsVideoPortResolution_t videoResolution; + videoResolution.pixelResolution = eventData->data.composite_in_video_mode.resolution.pixelResolution; + videoResolution.interlaced = eventData->data.composite_in_video_mode.resolution.interlaced; + videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; + IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); + }); + } else { + INT_ERROR("Invalid data received for Composite Video Mode Update in iarmCompositeInVideoModeUpdateHandler"); + } + ); +} + +private: + static constexpr EventHandlerMapping handlers[] = { + { IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_HOTPLUG, &IARMGroupComposite::iarmCompositeInHotPlugHandler }, + { IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS, &IARMGroupComposite::iarmCompositeInSignalStatusHandler }, + { IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_STATUS, &IARMGroupComposite::iarmCompositeInStatusHandler }, + { IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_VIDEO_MODE_UPDATE, &IARMGroupComposite::iarmCompositeInVideoModeUpdateHandler }, + }; +}; + + // static data std::mutex IarmHostImpl::s_mutex; IarmHostImpl::CallbackList IarmHostImpl::s_videoDeviceListeners; IarmHostImpl::CallbackList IarmHostImpl::s_videoPortListeners; IarmHostImpl::CallbackList IarmHostImpl::s_audioPortListeners; +IarmHostImpl::CallbackList IarmHostImpl::s_compositeListeners; IarmHostImpl::~IarmHostImpl() { @@ -418,6 +518,7 @@ IarmHostImpl::~IarmHostImpl() s_videoDeviceListeners.Release(); s_videoPortListeners.Release(); s_audioPortListeners.Release(); + s_compositeListeners.Release(); } template @@ -493,4 +594,22 @@ uint32_t IarmHostImpl::UnRegister(IAudioOutputPortEvents* listener) Dispatch(s_audioPortListeners, std::move(fn)); } +uint32_t IarmHostImpl::Register(ICompositeInEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_compositeListeners.Register(listener); +} + +uint32_t IarmHostImpl::UnRegister(ICompositeInEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_compositeListeners.UnRegister(listener); +} + +// Dispatcher for IARMGroupComposite +/* static */ void IarmHostImpl::Dispatch(std::function&& fn) +{ + Dispatch(s_compositeListeners, std::move(fn)); +} + } // namespace device diff --git a/ds/iarm/IarmHostImpl.hpp b/ds/iarm/IarmHostImpl.hpp index c2294dbc..f5ab1c64 100755 --- a/ds/iarm/IarmHostImpl.hpp +++ b/ds/iarm/IarmHostImpl.hpp @@ -31,6 +31,7 @@ namespace device { class IARMGroupVideoDevice; class IARMGroupVideoPort; class IARMGroupAudioPort; +class IARMGroupComposite; class IarmHostImpl { @@ -138,7 +139,8 @@ class IarmHostImpl { using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; - + using ICompositeInEvents = device::Host::ICompositeInEvents; + IarmHostImpl(); ~IarmHostImpl(); @@ -166,23 +168,35 @@ class IarmHostImpl { // @param listener: class object implementing the listener uint32_t UnRegister(IAudioOutputPortEvents* listener); + // @brief Register a listener for Composite events + // @param listener: class object implementing the listener + uint32_t Register(ICompositeInEvents* listener); + + // @brief UnRegister a listener for Composite events + // @param listener: class object implementing the listener + uint32_t UnRegister(ICompositeInEvents* listener); + private: static std::mutex s_mutex; static CallbackList s_videoDeviceListeners; static CallbackList s_videoPortListeners; static CallbackList s_audioPortListeners; - + static CallbackList s_compositeListeners; + template static void Dispatch(const std::list& listeners, F&& fn); static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); + static void Dispatch(std::function&& fn); // Dispatch is private, so all IARMGroup implementations will need to be friends friend class IARMGroupVideoDevice; friend class IARMGroupVideoPort; friend class IARMGroupAudioPort; + friend class IARMGroupComposite; + }; } // namespace device From d91573f5ef50278272bd05d851ef3536f24670e3 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 09:29:38 +0530 Subject: [PATCH 12/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/iarm/IarmHostImpl.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 0c7e6dd7..b6c03201 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -13,6 +13,7 @@ using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; +using ICompositeInEvents = device::Host::ICompositeInEvents; namespace device { From f1791a5521bbf264655a38a3f35e73417fcad85f Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 09:37:43 +0530 Subject: [PATCH 13/29] topic/RDKEMW6161-Ramesh merge changes Video --- ds/iarm/IarmHostImpl.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index b6c03201..a21bc0b8 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -421,7 +421,7 @@ class IARMGroupComposite { } private: - static void iarmCompositeInHotPlugHandler(const char*, IARM_EventId_t, void* data, size_t len) + static void iarmCompositeInHotPlugHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_HOTPLUG received, eventId=%d", eventId); @@ -439,7 +439,7 @@ class IARMGroupComposite { } - static void iarmCompositeInSignalStatusHandler(const char*, IARM_EventId_t, void* data, size_t len) + static void iarmCompositeInSignalStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS received, eventId=%d", eventId); @@ -456,7 +456,7 @@ class IARMGroupComposite { } } - static void iarmCompositeInStatusHandler(const char*, IARM_EventId_t, void* data, size_t len) + static void iarmCompositeInStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_STATUS received, eventId=%d", eventId); From 03bc14164714ee4a9b542a7221446e3acf7db541 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 13:40:20 +0530 Subject: [PATCH 14/29] topic/RDKEMW6161- Updated composite --- ds/host.cpp | 20 ++++++++++---------- ds/iarm/IarmHostImpl.cpp | 4 ++-- ds/iarm/IarmHostImpl.hpp | 4 ++-- ds/include/host.hpp | 18 ++++++++++++++---- 4 files changed, 28 insertions(+), 18 deletions(-) diff --git a/ds/host.cpp b/ds/host.cpp index 451bd5f7..bde9384a 100644 --- a/ds/host.cpp +++ b/ds/host.cpp @@ -803,22 +803,22 @@ uint32_t Host::UnRegister(IHDMIInEvents *listener) * @fn void Host::Register(ICompositeInEvents *Evtnotification) * @brief This API is used to register the Events * - * @return unint32_t + * @return dsError_t */ -uint32_t Host::Register(ICompositeInEvents *listener) +dsError_t Host::Register(ICompositeInEvents *listener) { - return 0; //impl().Register(listener); + return impl().Register(listener); } /** * @fn void Host::UnRegister(ICompositeInEvents *Evtnotification) * @brief This API is used to UnRegister the Events * - * @return unint32_t + * @return dsError_t */ -uint32_t Host::UnRegister(ICompositeInEvents *listener) +dsError_t Host::UnRegister(ICompositeInEvents *listener) { - return 0; //impl().UnRegister(listener); + return impl().UnRegister(listener); } /** @@ -869,7 +869,7 @@ uint32_t Host::UnRegister(IDisplayEvents *listener) /** * @fn void Host::Register(IAudioOutputPortEvents *Evtnotification) - * @brief This API is used to UnRegister the Events + * @brief This API is used to Register the Events * * @return unint32_t */ @@ -880,7 +880,7 @@ uint32_t Host::Register(IAudioOutputPortEvents *listener) /** - * @fn void Host::UnRegister(IAudioOutputPortEvents *Evtnotification) + * @fn void Host::UnRegister(IAudioOutputPortEvent *Evtnotification) * @brief This API is used to UnRegister the Events * * @return unint32_t @@ -893,7 +893,7 @@ uint32_t Host::UnRegister(IAudioOutputPortEvents *listener) /** * @fn void Host::Register(IVideoOutputPortEvents *Evtnotification) - * @brief This API is used to UnRegister the Events + * @brief This API is used to Register the Events * * @return unint32_t */ @@ -916,7 +916,7 @@ uint32_t Host::UnRegister(IVideoOutputPortEvents *listener) /** * @fn void Host::Register(IVideoDeviceEvents *Evtnotification) - * @brief This API is used to UnRegister the Events + * @brief This API is used to Register the Events * * @return unint32_t */ diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index a21bc0b8..822efc24 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -595,13 +595,13 @@ uint32_t IarmHostImpl::UnRegister(IAudioOutputPortEvents* listener) Dispatch(s_audioPortListeners, std::move(fn)); } -uint32_t IarmHostImpl::Register(ICompositeInEvents* listener) +dsError_t IarmHostImpl::Register(ICompositeInEvents* listener) { std::lock_guard lock(s_mutex); return s_compositeListeners.Register(listener); } -uint32_t IarmHostImpl::UnRegister(ICompositeInEvents* listener) +dsError_t IarmHostImpl::UnRegister(ICompositeInEvents* listener) { std::lock_guard lock(s_mutex); return s_compositeListeners.UnRegister(listener); diff --git a/ds/iarm/IarmHostImpl.hpp b/ds/iarm/IarmHostImpl.hpp index f5ab1c64..5273ee37 100755 --- a/ds/iarm/IarmHostImpl.hpp +++ b/ds/iarm/IarmHostImpl.hpp @@ -170,11 +170,11 @@ class IarmHostImpl { // @brief Register a listener for Composite events // @param listener: class object implementing the listener - uint32_t Register(ICompositeInEvents* listener); + dsError_t Register(ICompositeInEvents* listener); // @brief UnRegister a listener for Composite events // @param listener: class object implementing the listener - uint32_t UnRegister(ICompositeInEvents* listener); + dsError_t UnRegister(ICompositeInEvents* listener); private: static std::mutex s_mutex; diff --git a/ds/include/host.hpp b/ds/include/host.hpp index 972a6e8c..8e2c0dd2 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -105,6 +105,12 @@ class Host { // @param vrrType: VRR type virtual void OnHDMInVRRStatus(dsHdmiInPort_t port, dsVRRType_t vrrType) { }; + // @brief HDMI Event AV Latency + // @text OnHDMInAVLatency + // @param audioDelay: audio delay (in millisecs) + // @param videoDelay: video delay (in millisecs) + virtual void OnHDMInAVLatency(int audioDelay, int videoDelay) { }; + }; uint32_t Register(IHDMIInEvents *listener); @@ -138,8 +144,8 @@ class Host { virtual void OnCompositeInVideoModeUpdate(dsCompositeInPort_t activePort, dsVideoPortResolution_t videoResolution) { }; }; - uint32_t Register(ICompositeInEvents *listener); - uint32_t UnRegister(ICompositeInEvents *listener); + dsError_t Register(ICompositeInEvents *listener); + dsError_t UnRegister(ICompositeInEvents *listener); struct IDisplayHDMIHotPlugEvents{ @@ -223,6 +229,10 @@ class Host { // @param audioFormat: Type of audio format see AudioFormat virtual void OnAudioFormatUpdate(dsAudioFormat_t audioFormat) { }; + // @brief Audio level changed + // @text OnAudioLevelChangedEvent + // @param audioiLevel: audio level value + virtual void OnAudioLevelChangedEvent(int audioLevel) { }; }; uint32_t Register(IAudioOutputPortEvents *listener); @@ -239,8 +249,8 @@ class Host { // @text OnDisplayFrameratePostChange // @param frameRate: framerate post change virtual void OnDisplayFrameratePostChange(const std::string& frameRate) { }; - - // @brief Zoom settings changed + + // @brief Zoom settings changed // @text OnZoomSettingsChanged // @param zoomSetting: Currently applied zoom setting virtual void OnZoomSettingsChanged(dsVideoZoom_t zoomSetting) { }; From 6db5886e62ed04cf81e3d58d8f2951b2a1ac6cfa Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 15:18:39 +0530 Subject: [PATCH 15/29] topic/RDKEMW6161- Updated composite --- build_dependencies.sh | 2 +- cov_build.sh | 2 +- ds/Makefile | 9 +- ds/Makefile.am | 8 - ds/host.cpp | 153 +++-------------- ds/iarm/IarmHostImpl.cpp | 327 ++++++++++++++++++++++++------------- ds/iarm/IarmHostImpl.hpp | 65 ++++---- ds/include/host.hpp | 344 +++++++++++++++------------------------ 8 files changed, 403 insertions(+), 507 deletions(-) diff --git a/build_dependencies.sh b/build_dependencies.sh index 566fca25..090f105a 100644 --- a/build_dependencies.sh +++ b/build_dependencies.sh @@ -47,7 +47,7 @@ cd rfc autoreconf -i ./configure --enable-rfctool=yes --enable-tr181set=yes cd rfcapi -make CXXFLAGS="-DUSE_IARMBUS" librfcapi_la_CPPFLAGS="-I/usr/include/cjson" +make librfcapi_la_CPPFLAGS="-I/usr/include/cjson" make install export RFC_PATH=$ROOT/rfc diff --git a/cov_build.sh b/cov_build.sh index a4cc376f..22e8d7d4 100644 --- a/cov_build.sh +++ b/cov_build.sh @@ -70,4 +70,4 @@ find $WORKDIR -iname "*.o" -exec rm -v {} \; find $WORKDIR -iname "*.so*" -exec rm -v {} \; echo "##### Triggering make" -make CFLAGS+='-fPIC -DDSMGR_LOGGER_ENABLED=ON -DDS_ENABLE_IARM_PATH -DRDK_DSHAL_NAME=\"libdshal.so\" -I${DS_IF_PATH}/include -I${DS_HAL_PATH} -I${DS_MGRS}/stubs -I${IARMBUS_PATH}/core -I${IARMBUS_PATH}/core/include -I${IARM_MGRS}/sysmgr/include -I${DS_MGRS}/ds/include -I${DS_MGRS}/ds/iarm -I${DS_MGRS}/rpc/include -I${POWER_IF_PATH}/include/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I${IARM_MGRS}/mfr/include/ -I${IARM_MGRS}/mfr/common -I${DEEPSLEEP_IF_PATH}/include -I${IARM_MGRS}/hal/include -I${IARM_MGRS}/power -I${IARM_MGRS}/power/include' LDFLAGS="-L/usr/lib/x86_64-linux-gnu/ -L/usr/local/include -lglib-2.0 -lIARMBus -lWPEFrameworkPowerController -ldshal" +make CFLAGS+='-fPIC -DDSMGR_LOGGER_ENABLED=ON -DRDK_DSHAL_NAME=\"libdshal.so\" -I${DS_IF_PATH}/include -I${DS_HAL_PATH} -I${DS_MGRS}/stubs -I${IARMBUS_PATH}/core -I${IARMBUS_PATH}/core/include -I${IARM_MGRS}/sysmgr/include -I${DS_MGRS}/ds/include -I${DS_MGRS}/rpc/include -I${POWER_IF_PATH}/include/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I${IARM_MGRS}/mfr/include/ -I${IARM_MGRS}/mfr/common -I${DEEPSLEEP_IF_PATH}/include -I${IARM_MGRS}/hal/include -I${IARM_MGRS}/power -I${IARM_MGRS}/power/include' LDFLAGS="-L/usr/lib/x86_64-linux-gnu/ -L/usr/local/include -lglib-2.0 -lIARMBus -lWPEFrameworkPowerController -ldshal" \ No newline at end of file diff --git a/ds/Makefile b/ds/Makefile index d7ff5b7e..132782e2 100644 --- a/ds/Makefile +++ b/ds/Makefile @@ -20,9 +20,10 @@ RM := rm -rf CFLAGS += -std=c++0x -g -fPIC -D_REENTRANT -Wall LIBNAME := ds LIBNAMEFULL := lib$(LIBNAME).so -LIBNAMECLI := lib$(LIBNAME)-cli.so +LIBNAMECLI := lib$(LIBNAME)-cli.so INSTALL := $(PWD)/install OBJS := $(patsubst %.cpp,%.o,$(wildcard *.cpp)) +# In future add a conditional to choose implementation class based on build configuration OBJS += iarm/IarmHostImpl.o #$(PWD)/config should be first include path # to override generic configs @@ -34,8 +35,7 @@ INCLUDE := -I$(PWD) \ -I$(PWD)/hal/src \ -I$(PWD)/ds \ -I$(PWD)/rpc/include \ - -I$(PWD)/ds/include \ - -I$(PWD)/ds/iarm + -I$(PWD)/ds/include else INCLUDE := -I$(PWD) \ -I$(LOG4C_INSTALL_DIR)/include \ @@ -43,8 +43,7 @@ INCLUDE := -I$(PWD) \ -I$(PWD)/hal/include \ -I$(PWD)/ds \ -I$(PWD)/rpc/include \ - -I$(PWD)/ds/include \ - -I$(PWD)/ds/iarm + -I$(PWD)/ds/include endif diff --git a/ds/Makefile.am b/ds/Makefile.am index ab407564..90c9bea4 100644 --- a/ds/Makefile.am +++ b/ds/Makefile.am @@ -63,11 +63,3 @@ libds_la_SOURCES = aspectRatio.cpp \ host.cpp \ manager.cpp \ videoDFC.cpp - -# DS_ENABLE_IARM_PATH to be defined from the config.ac file -#if DS_ENABLE_IARM_PATH -libds_la_SOURCES += iarm/IarmHostImpl.cpp -#else -# plugin files of future -#endif - diff --git a/ds/host.cpp b/ds/host.cpp index bde9384a..91910d6d 100644 --- a/ds/host.cpp +++ b/ds/host.cpp @@ -38,7 +38,6 @@ #include "dsAudio.h" #include "dsHost.h" #include "unsupportedOperationException.hpp" -/*#include "hostEDID.hpp"*/ #include "dsInternal.h" #include "iarm/IarmHostImpl.hpp" @@ -52,10 +51,10 @@ using namespace std; namespace device { - - const int Host::kPowerOn = dsPOWER_ON; - const int Host::kPowerOff = dsPOWER_OFF; - const int Host::kPowerStandby = dsPOWER_STANDBY; + +const int Host::kPowerOn = dsPOWER_ON; +const int Host::kPowerOff = dsPOWER_OFF; +const int Host::kPowerStandby = dsPOWER_STANDBY; Host::Host() : m_impl(nullptr) @@ -765,40 +764,17 @@ Host::~Host() } printf ("%s:%d - Set Audio Mixer levels for audio input: %d with volume = %d\n", __PRETTY_FUNCTION__, __LINE__,aInput, volume); } - + DefaultImpl& Host::impl() { // lazy instantiation if (!m_impl) { - m_impl = std::make_unique(); + m_impl = std::unique_ptr(new DefaultImpl()); } return *m_impl; } -/** - * @fn void Host::Register(IHDMIInEvents *listener) - * @brief This API is used to register the Events - * - * @return unint32_t - */ -uint32_t Host::Register(IHDMIInEvents *listener) -{ - return 0; -} - - -/** - * @fn void Host::UnRegister(IHDMIInEvents *listener) - * @brief This API is used to UnRegister the Events - * - * @return unint32_t - */ -uint32_t Host::UnRegister(IHDMIInEvents *listener) -{ - return 0; -} - /** * @fn void Host::Register(ICompositeInEvents *Evtnotification) * @brief This API is used to register the Events @@ -821,128 +797,39 @@ dsError_t Host::UnRegister(ICompositeInEvents *listener) return impl().UnRegister(listener); } -/** - * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvents *Evtnotification) - * @brief This API is used to Register the Events - * - * @return unint32_t - */ -uint32_t Host::Register(IDisplayHDMIHotPlugEvents *listener) -{ - return 0; -} - - -/** - * @fn void Host::UnRegister(IDisplayHDMIHotPlugEvents *Evtnotification) - * @brief This API is used to UnRegister the Events - * - * @return unint32_t - */ -uint32_t Host::UnRegister(IDisplayHDMIHotPlugEvents *listener) -{ - return 0; -} - -/** - * @fn void Host::UnRegister(IDisplayEvents *Evtnotification) - * @brief This API is used to Register the Events - * - * @return unint32_t - */ -uint32_t Host::Register(IDisplayEvents *listener) -{ - return 0; -} - - -/** - * @fn void Host::UnRegister(IDisplayEvents *Evtnotification) - * @brief This API is used to UnRegister the Events - * - * @return unint32_t - */ -uint32_t Host::UnRegister(IDisplayEvents *listener) -{ - return 0; -} - -/** - * @fn void Host::Register(IAudioOutputPortEvents *Evtnotification) - * @brief This API is used to Register the Events - * - * @return unint32_t - */ -uint32_t Host::Register(IAudioOutputPortEvents *listener) +dsError_t Host::Register(IVideoDeviceEvents* listener) { - return impl().Register(listener); + return impl().Register(listener); } - -/** - * @fn void Host::UnRegister(IAudioOutputPortEvent *Evtnotification) - * @brief This API is used to UnRegister the Events - * - * @return unint32_t - */ -uint32_t Host::UnRegister(IAudioOutputPortEvents *listener) +dsError_t Host::UnRegister(IVideoDeviceEvents* listener) { - return impl().UnRegister(listener); + return impl().UnRegister(listener); } - -/** - * @fn void Host::Register(IVideoOutputPortEvents *Evtnotification) - * @brief This API is used to Register the Events - * - * @return unint32_t - */ -uint32_t Host::Register(IVideoOutputPortEvents *listener) +dsError_t Host::Register(IVideoOutputPortEvents* listener) { - return impl().Register(listener); + return impl().Register(listener); } - -/** - * @fn void Host::UnRegister(IVideoOutputPortEvents *Evtnotification) - * @brief This API is used to UnRegister the Events - * - * @return unint32_t - */ -uint32_t Host::UnRegister(IVideoOutputPortEvents *listener) +dsError_t Host::UnRegister(IVideoOutputPortEvents* listener) { - return impl().UnRegister(listener); + return impl().UnRegister(listener); } -/** - * @fn void Host::Register(IVideoDeviceEvents *Evtnotification) - * @brief This API is used to Register the Events - * - * @return unint32_t - */ -uint32_t Host::Register(IVideoDeviceEvents *listener) +dsError_t Host::Register(IAudioOutputPortEvents* listener) { - return impl().Register(listener); + return impl().Register(listener); } - -/** - * @fn void Host::UnRegister(IVideoDeviceEvents *Evtnotification) - * @brief This API is used to UnRegister the Events - * - * @return unint32_t - */ -uint32_t Host::UnRegister(IVideoDeviceEvents *listener) +dsError_t Host::UnRegister(IAudioOutputPortEvents* listener) { - return impl().UnRegister(listener); -} - - - + return impl().UnRegister(listener); } - /** @} */ +} // namespace device /** @} */ + /** @} */ diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 822efc24..eaeb7db0 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -5,14 +5,13 @@ #include "IarmHostImpl.hpp" #include "dsMgr.h" -/*#include "dsTypes.h"*/ #include "dslogger.h" #include "libIBus.h" -using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; -using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; -using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; +using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; +using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; +using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; using ICompositeInEvents = device::Host::ICompositeInEvents; namespace device { @@ -62,6 +61,15 @@ static bool registerIarmEvents(const EventHandlerMapping (&handlers)[N]) return registered; } +inline bool isValidOwner(const char* owner) +{ + if (std::string(IARM_BUS_DSMGR_NAME) != std::string(owner)) { + INT_ERROR("Invalid owner %s, expected %s", owner, IARM_BUS_DSMGR_NAME); + return false; + } + return true; +} + // IARMGroupXYZ are c to c++ shim (all methods are static) // Required to perform group event register and unregister with IARM // Thread safety to be ensured by the caller @@ -80,7 +88,11 @@ class IARMGroupVideoDevice { private: static void iarmDisplayFrameratePreChangeHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_PRECHANGE received %s %d", owner, eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_PRECHANGE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -97,7 +109,11 @@ class IARMGroupVideoDevice { static void iarmDisplayFrameratePostChangeHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_POSTCHANGE received %s %d", owner, eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_POSTCHANGE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -112,13 +128,35 @@ class IARMGroupVideoDevice { } } + static void iarmZoomSettingsChangedHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_ZOOM_SETTINGS received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + + if (eventData) { + dsVideoZoom_t zoomSetting = static_cast(eventData->data.dfc.zoomsettings); + + IarmHostImpl::Dispatch([zoomSetting](IVideoDeviceEvents* listener) { + listener->OnZoomSettingsChanged(zoomSetting); + }); + } else { + INT_ERROR("Invalid data received for zoom settings change"); + } + }; + static constexpr EventHandlerMapping handlers[] = { { IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_PRECHANGE, &IARMGroupVideoDevice::iarmDisplayFrameratePreChangeHandler }, { IARM_BUS_DSMGR_EVENT_DISPLAY_FRAMRATE_POSTCHANGE, &IARMGroupVideoDevice::iarmDisplayFrameratePostChangeHandler }, + { IARM_BUS_DSMGR_EVENT_ZOOM_SETTINGS, &IARMGroupVideoDevice::iarmZoomSettingsChangedHandler }, }; }; -class IARMGroupVideoPort { +class IARMGroupVideoOutputPort { public: static bool RegisterIarmEvents() { @@ -131,9 +169,13 @@ class IARMGroupVideoPort { } private: - static void iarmResolutionPreChangeHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmResolutionPreChangeHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_RES_PRECHANGE received, eventId = %d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_RES_PRECHANGE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -149,9 +191,13 @@ class IARMGroupVideoPort { } } - static void iarmResolutionPostChangeHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmResolutionPostChangeHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_RES_POSTCHANGE received, eventId = %d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_RES_POSTCHANGE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -167,9 +213,13 @@ class IARMGroupVideoPort { } } - static void iarmHDCPStatusChangeHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmHDCPStatusChangeHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_HDCP_STATUS received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_HDCP_STATUS received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -180,9 +230,13 @@ class IARMGroupVideoPort { } } - static void iarmVideoFormatUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmVideoFormatUpdateHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_VIDEO_FORMAT_UPDATE received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_VIDEO_FORMAT_UPDATE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -198,14 +252,14 @@ class IARMGroupVideoPort { } static constexpr EventHandlerMapping handlers[] = { - { IARM_BUS_DSMGR_EVENT_RES_PRECHANGE, &IARMGroupVideoPort::iarmResolutionPreChangeHandler }, - { IARM_BUS_DSMGR_EVENT_RES_POSTCHANGE, &IARMGroupVideoPort::iarmResolutionPostChangeHandler }, - { IARM_BUS_DSMGR_EVENT_HDCP_STATUS, &IARMGroupVideoPort::iarmHDCPStatusChangeHandler }, - { IARM_BUS_DSMGR_EVENT_VIDEO_FORMAT_UPDATE, &IARMGroupVideoPort::iarmVideoFormatUpdateHandler }, + { IARM_BUS_DSMGR_EVENT_RES_PRECHANGE, &IARMGroupVideoOutputPort::iarmResolutionPreChangeHandler }, + { IARM_BUS_DSMGR_EVENT_RES_POSTCHANGE, &IARMGroupVideoOutputPort::iarmResolutionPostChangeHandler }, + { IARM_BUS_DSMGR_EVENT_HDCP_STATUS, &IARMGroupVideoOutputPort::iarmHDCPStatusChangeHandler }, + { IARM_BUS_DSMGR_EVENT_VIDEO_FORMAT_UPDATE, &IARMGroupVideoOutputPort::iarmVideoFormatUpdateHandler }, }; }; -class IARMGroupAudioPort { +class IARMGroupAudioOutputPort { public: static bool RegisterIarmEvents() { @@ -218,9 +272,13 @@ class IARMGroupAudioPort { } private: - static void iarmAssociatedAudioMixingChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAssociatedAudioMixingChangedHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_ASSOCIATED_AUDIO_MIXING_CHANGED received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_ASSOCIATED_AUDIO_MIXING_CHANGED received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -235,9 +293,13 @@ class IARMGroupAudioPort { } }; - static void iarmAudioFaderControlChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioFaderControlChangedHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_FADER_CONTROL_CHANGED received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_FADER_CONTROL_CHANGED received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -252,9 +314,13 @@ class IARMGroupAudioPort { } }; - static void iarmAudioPrimaryLanguageChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioPrimaryLanguageChangedHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_PRIMARY_LANGUAGE_CHANGED received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_PRIMARY_LANGUAGE_CHANGED received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -269,9 +335,13 @@ class IARMGroupAudioPort { } }; - static void iarmAudioSecondaryLanguageChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioSecondaryLanguageChangedHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_SECONDARY_LANGUAGE_CHANGED received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_SECONDARY_LANGUAGE_CHANGED received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -286,9 +356,14 @@ class IARMGroupAudioPort { } }; - static void iarmAudioOutHotPlugHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioOutHotPlugHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_OUT_HOTPLUG received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_OUT_HOTPLUG received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { dsAudioPortType_t portType = eventData->data.audio_out_connect.portType; @@ -303,9 +378,14 @@ class IARMGroupAudioPort { } }; - static void iarmDolbyAtmosCapabilitiesChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmDolbyAtmosCapabilitiesChangedHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_ATMOS_CAPS_CHANGED received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_ATMOS_CAPS_CHANGED received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { dsATMOSCapability_t atmosCapability = eventData->data.AtmosCapsChange.caps; @@ -321,9 +401,13 @@ class IARMGroupAudioPort { }; // TODO: requires dsMgr.h header for dsAudioPortState_t ? - static void iarmAudioPortStateChangedHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioPortStateChangedHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_PORT_STATE received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_PORT_STATE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -339,9 +423,13 @@ class IARMGroupAudioPort { } }; - static void iarmAudioModeEventHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioModeEventHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_MODE received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_MODE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -357,9 +445,13 @@ class IARMGroupAudioPort { } }; - static void iarmAudioLevelChangedEventHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioLevelChangedEventHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_LEVEL_CHANGED received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_LEVEL_CHANGED received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -367,16 +459,20 @@ class IARMGroupAudioPort { int audioLevel = eventData->data.AudioLevelInfo.level; IarmHostImpl::Dispatch([audioLevel](IAudioOutputPortEvents* listener) { - //listener->OnAudioLevelChangedEvent(audioLevel); + listener->OnAudioLevelChangedEvent(audioLevel); }); } else { INT_ERROR("Invalid data received for audio level change"); } }; - static void iarmAudioFormatUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmAudioFormatUpdateHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { - INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_FORMAT_UPDATE received, eventId=%d", eventId); + INT_INFO("IARM_BUS_DSMGR_EVENT_AUDIO_FORMAT_UPDATE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; @@ -393,20 +489,20 @@ class IARMGroupAudioPort { private: static constexpr EventHandlerMapping handlers[] = { - { IARM_BUS_DSMGR_EVENT_AUDIO_ASSOCIATED_AUDIO_MIXING_CHANGED, &IARMGroupAudioPort::iarmAssociatedAudioMixingChangedHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_FADER_CONTROL_CHANGED, &IARMGroupAudioPort::iarmAudioFaderControlChangedHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_PRIMARY_LANGUAGE_CHANGED, &IARMGroupAudioPort::iarmAudioPrimaryLanguageChangedHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_SECONDARY_LANGUAGE_CHANGED, &IARMGroupAudioPort::iarmAudioSecondaryLanguageChangedHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_OUT_HOTPLUG, &IARMGroupAudioPort::iarmAudioOutHotPlugHandler }, - { IARM_BUS_DSMGR_EVENT_ATMOS_CAPS_CHANGED, &IARMGroupAudioPort::iarmDolbyAtmosCapabilitiesChangedHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_PORT_STATE, &IARMGroupAudioPort::iarmAudioPortStateChangedHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_MODE, &IARMGroupAudioPort::iarmAudioModeEventHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_LEVEL_CHANGED, &IARMGroupAudioPort::iarmAudioLevelChangedEventHandler }, - { IARM_BUS_DSMGR_EVENT_AUDIO_FORMAT_UPDATE, &IARMGroupAudioPort::iarmAudioFormatUpdateHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_ASSOCIATED_AUDIO_MIXING_CHANGED, &IARMGroupAudioOutputPort::iarmAssociatedAudioMixingChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_FADER_CONTROL_CHANGED, &IARMGroupAudioOutputPort::iarmAudioFaderControlChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_PRIMARY_LANGUAGE_CHANGED, &IARMGroupAudioOutputPort::iarmAudioPrimaryLanguageChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_SECONDARY_LANGUAGE_CHANGED, &IARMGroupAudioOutputPort::iarmAudioSecondaryLanguageChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_OUT_HOTPLUG, &IARMGroupAudioOutputPort::iarmAudioOutHotPlugHandler }, + { IARM_BUS_DSMGR_EVENT_ATMOS_CAPS_CHANGED, &IARMGroupAudioOutputPort::iarmDolbyAtmosCapabilitiesChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_PORT_STATE, &IARMGroupAudioOutputPort::iarmAudioPortStateChangedHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_MODE, &IARMGroupAudioOutputPort::iarmAudioModeEventHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_LEVEL_CHANGED, &IARMGroupAudioOutputPort::iarmAudioLevelChangedEventHandler }, + { IARM_BUS_DSMGR_EVENT_AUDIO_FORMAT_UPDATE, &IARMGroupAudioOutputPort::iarmAudioFormatUpdateHandler }, }; }; - +// static data class IARMGroupComposite { public: @@ -421,79 +517,86 @@ class IARMGroupComposite { } private: - static void iarmCompositeInHotPlugHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) - { - INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_HOTPLUG received, eventId=%d", eventId); - - IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + static void iarmCompositeInHotPlugHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_HOTPLUG received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_connect.port; - bool isConnected = eventData->data.composite_in_connect.isPortConnected; - - IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { - listener->OnCompositeInHotPlug(compositePort,isConnected); + bool isConnected = eventData->data.composite_in_connect.isPortConnected; + IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + listener->OnCompositeInHotPlug(compositePort,isConnected); }); } else { INT_ERROR("Invalid data received for Composite Status Handler in iarmCompositeInHotPlugHandler"); - } - } + } + } - static void iarmCompositeInSignalStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) - { - INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS received, eventId=%d", eventId); - - IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + static void iarmCompositeInSignalStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_sig_status.port; - dsCompInSignalStatus_t compositeSigStatus = eventData->data.composite_in_sig_status.status; - - IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + dsCompInSignalStatus_t compositeSigStatus = eventData->data.composite_in_sig_status.status; + IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { listener->OnCompositeInSignalStatus(compositePort,compositeSigStatus); }); } else { INT_ERROR("Invalid data received for Composite Status Handler in iarmCompositeInSignalStatusHandler"); - } - } - - static void iarmCompositeInStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) - { - INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_STATUS received, eventId=%d", eventId); - - IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + } + } + + static void iarmCompositeInStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_STATUS received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_status.port; - bool isPresented = eventData->data.composite_in_status.isPresented; - - IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { - listener->OnCompositeInStatus(compositePort,isPresented); + bool isPresented = eventData->data.composite_in_status.isPresented; + IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + listener->OnCompositeInStatus(compositePort,isPresented); }); } else { INT_ERROR("Invalid data received for Composite Status Handler in iarmCompositeInStatusHandler"); - } - } - + } + } - static void iarmCompositeInVideoModeUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) - { - INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_VIDEO_MODE_UPDATE received, eventId=%d", eventId); + static void iarmCompositeInVideoModeUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_VIDEO_MODE_UPDATE received owner = %s, eventId = %d", owner, eventId); + if (!isValidOwner(owner)) { + return; + } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; - if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_video_mode.port; dsVideoPortResolution_t videoResolution; videoResolution.pixelResolution = eventData->data.composite_in_video_mode.resolution.pixelResolution; videoResolution.interlaced = eventData->data.composite_in_video_mode.resolution.interlaced; - videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; + videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); }); } else { INT_ERROR("Invalid data received for Composite Video Mode Update in iarmCompositeInVideoModeUpdateHandler"); } - ); -} + } private: static constexpr EventHandlerMapping handlers[] = { @@ -505,11 +608,15 @@ class IARMGroupComposite { }; -// static data +constexpr EventHandlerMapping IARMGroupVideoDevice::handlers[]; +constexpr EventHandlerMapping IARMGroupVideoOutputPort::handlers[]; +constexpr EventHandlerMapping IARMGroupAudioOutputPort::handlers[]; +constexpr EventHandlerMapping IARMGroupComposite::handlers[]; + std::mutex IarmHostImpl::s_mutex; IarmHostImpl::CallbackList IarmHostImpl::s_videoDeviceListeners; -IarmHostImpl::CallbackList IarmHostImpl::s_videoPortListeners; -IarmHostImpl::CallbackList IarmHostImpl::s_audioPortListeners; +IarmHostImpl::CallbackList IarmHostImpl::s_videoOutputPortListeners; +IarmHostImpl::CallbackList IarmHostImpl::s_audioOutputPortListeners; IarmHostImpl::CallbackList IarmHostImpl::s_compositeListeners; IarmHostImpl::~IarmHostImpl() @@ -517,8 +624,8 @@ IarmHostImpl::~IarmHostImpl() std::lock_guard lock(s_mutex); s_videoDeviceListeners.Release(); - s_videoPortListeners.Release(); - s_audioPortListeners.Release(); + s_videoOutputPortListeners.Release(); + s_audioOutputPortListeners.Release(); s_compositeListeners.Release(); } @@ -541,13 +648,13 @@ template INT_INFO("%s Dispatch done to %zu listeners\n%s", typeid(T).name(), listeners.size(), ss.str().c_str()); } -uint32_t IarmHostImpl::Register(IVideoDeviceEvents* listener) +dsError_t IarmHostImpl::Register(IVideoDeviceEvents* listener) { std::lock_guard lock(s_mutex); return s_videoDeviceListeners.Register(listener); } -uint32_t IarmHostImpl::UnRegister(IVideoDeviceEvents* listener) +dsError_t IarmHostImpl::UnRegister(IVideoDeviceEvents* listener) { std::lock_guard lock(s_mutex); return s_videoDeviceListeners.UnRegister(listener); @@ -559,40 +666,40 @@ uint32_t IarmHostImpl::UnRegister(IVideoDeviceEvents* listener) Dispatch(s_videoDeviceListeners, std::move(fn)); } -uint32_t IarmHostImpl::Register(IVideoOutputPortEvents* listener) +dsError_t IarmHostImpl::Register(IVideoOutputPortEvents* listener) { std::lock_guard lock(s_mutex); - return s_videoPortListeners.Register(listener); + return s_videoOutputPortListeners.Register(listener); } -uint32_t IarmHostImpl::UnRegister(IVideoOutputPortEvents* listener) +dsError_t IarmHostImpl::UnRegister(IVideoOutputPortEvents* listener) { std::lock_guard lock(s_mutex); - return s_videoPortListeners.UnRegister(listener); + return s_videoOutputPortListeners.UnRegister(listener); } // Dispatcher for IARMGroupVideoPort /* static */ void IarmHostImpl::Dispatch(std::function&& fn) { - Dispatch(s_videoPortListeners, std::move(fn)); + Dispatch(s_videoOutputPortListeners, std::move(fn)); } -uint32_t IarmHostImpl::Register(IAudioOutputPortEvents* listener) +dsError_t IarmHostImpl::Register(IAudioOutputPortEvents* listener) { std::lock_guard lock(s_mutex); - return s_audioPortListeners.Register(listener); + return s_audioOutputPortListeners.Register(listener); } -uint32_t IarmHostImpl::UnRegister(IAudioOutputPortEvents* listener) +dsError_t IarmHostImpl::UnRegister(IAudioOutputPortEvents* listener) { std::lock_guard lock(s_mutex); - return s_audioPortListeners.UnRegister(listener); + return s_audioOutputPortListeners.UnRegister(listener); } // Dispatcher for IARMGroupAudioPort /* static */ void IarmHostImpl::Dispatch(std::function&& fn) { - Dispatch(s_audioPortListeners, std::move(fn)); + Dispatch(s_audioOutputPortListeners, std::move(fn)); } dsError_t IarmHostImpl::Register(ICompositeInEvents* listener) diff --git a/ds/iarm/IarmHostImpl.hpp b/ds/iarm/IarmHostImpl.hpp index 5273ee37..38e89013 100755 --- a/ds/iarm/IarmHostImpl.hpp +++ b/ds/iarm/IarmHostImpl.hpp @@ -19,9 +19,11 @@ #pragma once #include +#include #include #include +#include "dsError.h" #include "dslogger.h" #include "host.hpp" @@ -29,8 +31,8 @@ namespace device { // Forward declaration for IARM Implementation Groups class IARMGroupVideoDevice; -class IARMGroupVideoPort; -class IARMGroupAudioPort; +class IARMGroupVideoOutputPort; +class IARMGroupAudioOutputPort; class IARMGroupComposite; class IarmHostImpl { @@ -61,11 +63,11 @@ class IarmHostImpl { // @brief Register a listener, also register IARM events if not already registered // if the listener is already registered, listener will not be added again // if IARM event registration fails, listener will not be added - uint32_t Register(T listener) + dsError_t Register(T listener) { - if (listener == nullptr) { + if (nullptr == listener) { INT_ERROR("%s listener is null", typeid(T).name()); - return 1; // Error: Listener is null + return dsERR_INVALID_PARAM; // Error: Listener is null } if (!m_registered) { @@ -73,7 +75,7 @@ class IarmHostImpl { if (!m_registered) { INT_ERROR("Failed to register IARMGroup %s", typeid(IARMGroup).name()); - return 1; // Error: Failed to register IARM group + return dsERR_OPERATION_FAILED; // Error: Failed to register IARM group } } @@ -81,30 +83,30 @@ class IarmHostImpl { if (it != this->end()) { // Listener already registered INT_ERROR("%s %p is already registered", typeid(T).name(), listener); - return 0; + return dsERR_NONE; // Success: Listener already registered } this->push_back(listener); INT_INFO("%s %p registered", typeid(T).name(), listener); - return 0; + return dsERR_NONE; } // @brief UnRegister a listener, also unregister IARM events if no listeners are left // if the listener is not registered, it will not be removed - uint32_t UnRegister(T listener) + dsError_t UnRegister(T listener) { - if (listener == nullptr) { + if (nullptr == listener) { INT_ERROR("%s listener is null", typeid(T).name()); - return 1; // Error: Listener is null + return dsERR_INVALID_PARAM; // Error: Listener is null } auto it = std::find(this->begin(), this->end(), listener); if (it == this->end()) { // Listener not found INT_ERROR("%s %p is not registered", typeid(T).name(), listener); - return 1; // Error: Listener not found + return dsERR_RESOURCE_NOT_AVAILABLE; // Error: Listener not found } this->erase(it); @@ -115,12 +117,12 @@ class IarmHostImpl { m_registered = !IARMGroup::UnRegisterIarmEvents(); } - return 0; + return dsERR_NONE; // Success } // @brief Release all listeners and unregister IARM events // This will clear the list and unregister IARM events if no listeners are left - uint32_t Release() + dsError_t Release() { if (m_registered) { m_registered = !IARMGroup::UnRegisterIarmEvents(); @@ -128,7 +130,7 @@ class IarmHostImpl { this->clear(); INT_INFO("CallbackList[T=%s] released, status: %d", typeid(T).name(), m_registered); - return 0; // Success + return dsERR_NONE; // Success } private: @@ -136,37 +138,37 @@ class IarmHostImpl { }; public: - using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; - using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; - using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; + using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; + using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; + using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; using ICompositeInEvents = device::Host::ICompositeInEvents; - - IarmHostImpl(); + + IarmHostImpl() = default; ~IarmHostImpl(); // @brief Register a listener for video device events // @param listener: class object implementing the listener - uint32_t Register(IVideoDeviceEvents* listener); + dsError_t Register(IVideoDeviceEvents* listener); // @brief UnRegister a listener for video device events // @param listener: class object implementing the listener - uint32_t UnRegister(IVideoDeviceEvents* listener); + dsError_t UnRegister(IVideoDeviceEvents* listener); // @brief Register a listener for video port events // @param listener: class object implementing the listener - uint32_t Register(IVideoOutputPortEvents* listener); + dsError_t Register(IVideoOutputPortEvents* listener); // @brief UnRegister a listener for video port events // @param listener: class object implementing the listener - uint32_t UnRegister(IVideoOutputPortEvents* listener); + dsError_t UnRegister(IVideoOutputPortEvents* listener); // @brief Register a listener for audio port events // @param listener: class object implementing the listener - uint32_t Register(IAudioOutputPortEvents* listener); + dsError_t Register(IAudioOutputPortEvents* listener); // @brief UnRegister a listener for audio port events // @param listener: class object implementing the listener - uint32_t UnRegister(IAudioOutputPortEvents* listener); + dsError_t UnRegister(IAudioOutputPortEvents* listener); // @brief Register a listener for Composite events // @param listener: class object implementing the listener @@ -180,10 +182,10 @@ class IarmHostImpl { static std::mutex s_mutex; static CallbackList s_videoDeviceListeners; - static CallbackList s_videoPortListeners; - static CallbackList s_audioPortListeners; + static CallbackList s_videoOutputPortListeners; + static CallbackList s_audioOutputPortListeners; static CallbackList s_compositeListeners; - + template static void Dispatch(const std::list& listeners, F&& fn); @@ -194,9 +196,8 @@ class IarmHostImpl { // Dispatch is private, so all IARMGroup implementations will need to be friends friend class IARMGroupVideoDevice; - friend class IARMGroupVideoPort; - friend class IARMGroupAudioPort; + friend class IARMGroupVideoOutputPort; + friend class IARMGroupAudioOutputPort; friend class IARMGroupComposite; - }; } // namespace device diff --git a/ds/include/host.hpp b/ds/include/host.hpp index 8e2c0dd2..d7b0d524 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -15,15 +15,14 @@ * 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. -*/ + */ /** -* @defgroup devicesettings -* @{ -* @defgroup ds -* @{ -**/ - + * @defgroup devicesettings + * @{ + * @defgroup ds + * @{ + **/ #ifndef _DS_HOST_HPP_ #define _DS_HOST_HPP_ @@ -32,17 +31,15 @@ #include "audioOutputPort.hpp" #include "dsAVDTypes.h" +#include "dsError.h" #include "list.hpp" #include "sleepMode.hpp" #include "videoDevice.hpp" #include "videoOutputPort.hpp" -#include "dsMgr.h" -#include "dsTypes.h" -#include "dsDisplay.h" /** * @file host.hpp - * @brief It contains class,structures referenced by host.cpp file. + * @brief It contains class, structures referenced by host.cpp file. */ using namespace std; @@ -60,61 +57,9 @@ using DefaultImpl = IarmHostImpl; */ class Host { public: - - struct IHDMIInEvents { - - // @brief HDMI Event Hot Plug - // @text onHDMIInEventHotPlug - // @param port: port 0 or 1 et al - // @param isConnected: is it connected (true) or not (false) - virtual void OnHDMIInEventHotPlug(dsHdmiInPort_t port, bool isConnected) { }; - - // @brief HDMI Event Signal status - // @text OnHDMIInEventSignalStatus - // @param port: port 0 or 1 et al - // @param signalStatus: Signal Status - virtual void OnHDMIInEventSignalStatus(dsHdmiInPort_t port, dsHdmiInSignalStatus_t signalStatus) { }; - - // @brief HDMI Event Signal status - // @text onHDMIInEventStatus - // @param activePort: port 0 or 1 et al - // @param isPresented: is it presented or not - virtual void OnHDMIInEventStatus(dsHdmiInPort_t activePort, bool isPresented) { }; - - // @brief HDMI Video Mode update - // @text onHDMInVideoModeUpdate - // @param port: port 0 or 1 et al - // @param videoPortResolution: Video port resolution - virtual void OnHDMInVideoModeUpdate(dsHdmiInPort_t port, const dsVideoPortResolution_t& videoPortResolution) { }; - - // @brief HDMI ALLM (Auto Low Latency Mode) status - // @text onHDMInAllmStatus - // @param port: port 0 or 1 et al - // @param allmStatus: allm status - virtual void OnHDMInAllmStatus(dsHdmiInPort_t port, bool allmStatus) { }; - - // @brief HDMI Event AVI content type - // @text OnHDMInAVIContentType - // @param port: port 0 or 1 et al - // @param aviContentType: AVI content type - virtual void OnHDMInAVIContentType(dsHdmiInPort_t port, dsAviContentType_t aviContentType) { }; - - // @brief HDMI VRR status - // @text OnHDMInVRRStatus - // @param port: port 0 or 1 et al - // @param vrrType: VRR type - virtual void OnHDMInVRRStatus(dsHdmiInPort_t port, dsVRRType_t vrrType) { }; - - // @brief HDMI Event AV Latency - // @text OnHDMInAVLatency - // @param audioDelay: audio delay (in millisecs) - // @param videoDelay: video delay (in millisecs) - virtual void OnHDMInAVLatency(int audioDelay, int videoDelay) { }; - - }; - - uint32_t Register(IHDMIInEvents *listener); - uint32_t UnRegister(IHDMIInEvents *listener); + static const int kPowerOn; + static const int kPowerOff; + static const int kPowerStandby; struct ICompositeInEvents { @@ -148,192 +93,158 @@ class Host { dsError_t UnRegister(ICompositeInEvents *listener); - struct IDisplayHDMIHotPlugEvents{ - - // @brief Display HDMI Hot plug event - // @text onDisplayHDMIHotPlug - // @param displayEvent: DS_DISPLAY_EVENT_CONNECTED or DS_DISPLAY_EVENT_DISCONNECTED - virtual void OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent) { }; + struct IVideoDeviceEvents { + // @brief Display Frame rate Pre-change notification + // @param frameRate: new framerate + virtual void OnDisplayFrameratePreChange(const std::string& frameRate) { }; + + // @brief Display Frame rate Post-change notification + // @param frameRate: new framerate + virtual void OnDisplayFrameratePostChange(const std::string& frameRate) { }; + + // @brief Zoom settings changed + // @text OnZoomSettingsChanged + // @param zoomSetting: Currently applied zoom setting + virtual void OnZoomSettingsChanged(dsVideoZoom_t zoomSetting) { }; }; - - uint32_t Register(IDisplayHDMIHotPlugEvents *listener); - uint32_t UnRegister(IDisplayHDMIHotPlugEvents *listener); + // @brief Register a listener for video device events + // @param listener: class object implementing the listener + dsError_t Register(IVideoDeviceEvents* listener); + // @brief UnRegister a listener for video device events + // @param listener: class object implementing the listener + dsError_t UnRegister(IVideoDeviceEvents* listener); - struct IDisplayEvents{ + struct IVideoOutputPortEvents { - // @brief Display RX Sense event - // @text onDisplayRxSense - // @param displayEvent: DS_DISPLAY_RXSENSE_ON or DS_DISPLAY_RXSENSE_OFF - virtual void OnDisplayRxSense(dsDisplayEvent_t displayEvent) { }; - - // @brief Display HDCP Status - // @text OnDisplayHDCPStatus - virtual void OnDisplayHDCPStatus() { }; - }; - - uint32_t Register(IDisplayEvents *listener); - uint32_t UnRegister(IDisplayEvents *listener); + // @brief On Resolution Pre changed + // @param width: width of the resolution + // @param height: height of the resolution + virtual void OnResolutionPreChange(int width, int height) { }; + // @brief On Resolution Post change + // @param width: width of the resolution + // @param height: height of the resolution + virtual void OnResolutionPostChange(int width, int height) { }; - struct IAudioOutputPortEvents{ + // @brief On HDCP Status change + // @param hdcpStatus: HDCP Status + virtual void OnHDCPStatusChange(dsHdcpStatus_t hdcpStatus) { }; - // @brief Associated Audio mixing changed - // @text onAssociatedAudioMixingChanged - // @param mixing: true or false - virtual void OnAssociatedAudioMixingChanged(bool mixing) { }; - - // @brief Audio Fader balance changed - // @text onAudioFaderControlChanged - // @param mixerBalance: applied mixer balance value - virtual void OnAudioFaderControlChanged(int mixerBalance) { }; - - // @brief Primary language for Audio changed - // @text onAudioPrimaryLanguageChanged - // @param primaryLanguage: current primary language for audio - virtual void OnAudioPrimaryLanguageChanged(const std::string& primaryLanguage) { }; - - // @brief Secondary language for Audio changed - // @text onAudioSecondaryLanguageChanged - // @param secondaryLanguage: current secondary language for audio - virtual void OnAudioSecondaryLanguageChanged(const std::string& secondaryLanguage) { }; - - // @brief Audio output hot plug event - // @text onAudioOutHotPlug - // @param portType: Type of audio port see AudioPortType - // @param uiPortNumber: The port number assigned by UI - // @param isPortConnected: true (connected) or false (not connected) - virtual void OnAudioOutHotPlug(dsAudioPortType_t audioPortType, int uiPortNumber, bool isPortConnected) { }; - - - // @brief Dolby Atmos capabilities changed - // @text onDolbyAtmosCapabilitiesChanged - // @param atmosCapability: the dolby atmos capability - // @param status: true (available) or false (not available) - virtual void OnDolbyAtmosCapabilitiesChanged(dsATMOSCapability_t atmosCapability, bool status) { }; - - // @brief Audio port state changed - // @text onAudioPortStateChanged - // @param audioPortState: audio port state - virtual void OnAudioPortStateChanged(dsAudioPortState_t audioPortState) { }; - - // @brief Audio mode for the respective audio port - raised for every type of port - // @text onAudioModeEvent - // @param audioPortType: audio port type see AudioPortType - // @param audioMode: audio mode - see audioStereoMode - virtual void OnAudioModeEvent(dsAudioPortType_t audioPortType, dsAudioStereoMode_t audioMode) { }; - - // @brief Audio Output format changed - // @text onAudioFormatUpdate - // @param audioFormat: Type of audio format see AudioFormat - virtual void OnAudioFormatUpdate(dsAudioFormat_t audioFormat) { }; - - // @brief Audio level changed - // @text OnAudioLevelChangedEvent - // @param audioiLevel: audio level value - virtual void OnAudioLevelChangedEvent(int audioLevel) { }; + // @brief On Video Format update + // @param videoFormatHDR: Video format HDR standard + virtual void OnVideoFormatUpdate(dsHDRStandard_t videoFormatHDR) { }; }; - uint32_t Register(IAudioOutputPortEvents *listener); - uint32_t UnRegister(IAudioOutputPortEvents *listener); + // @brief Register a listener for video port events + // @param listener: class object implementing the listener + dsError_t Register(IVideoOutputPortEvents* listener); + // @brief UnRegister a listener for video port events + // @param listener: class object implementing the listener + dsError_t UnRegister(IVideoOutputPortEvents* listener); - struct IVideoDeviceEvents { - // @brief Display Framerate Pre-change - // @text OnDisplayFrameratePreChange - // @param frameRate: PreChange framerate - virtual void OnDisplayFrameratePreChange(const std::string& frameRate) { }; - - // @brief Display Framerate Post-change - // @text OnDisplayFrameratePostChange - // @param frameRate: framerate post change - virtual void OnDisplayFrameratePostChange(const std::string& frameRate) { }; - - // @brief Zoom settings changed - // @text OnZoomSettingsChanged - // @param zoomSetting: Currently applied zoom setting - virtual void OnZoomSettingsChanged(dsVideoZoom_t zoomSetting) { }; - }; - - uint32_t Register(IVideoDeviceEvents *listener); - uint32_t UnRegister(IVideoDeviceEvents *listener); - - - struct IVideoOutputPortEvents { - - // @brief On Resolution Pre changed - // @text OnResolutionPreChange - // @param resolution: resolution - virtual void OnResolutionPreChange(const int width, const int height) { }; - - // @brief On Resolution Post change - // @text onResolutionPostChange - // @param resolution: resolution - virtual void OnResolutionPostChange(const int width, const int height) { }; - - // @brief On HDCP Status change - // @text OnHDCPStatusChange - // @param hdcpStatus: HDCP Status - virtual void OnHDCPStatusChange(dsHdcpStatus_t hdcpStatus) { }; - - // @brief On Video Format update - // @text OnVideoFormatUpdate - // @param videoFormatHDR: Video format HDR standard - virtual void OnVideoFormatUpdate(dsHDRStandard_t videoFormatHDR) { }; - }; + struct IAudioOutputPortEvents { - uint32_t Register(IVideoOutputPortEvents *listener); - uint32_t UnRegister(IVideoOutputPortEvents *listener); + // @brief Associated Audio mixing changed + // @param mixing: true or false + virtual void OnAssociatedAudioMixingChanged(bool mixing) { }; + // @brief Audio Fader balance changed + // @param mixerBalance: applied mixer balance value + virtual void OnAudioFaderControlChanged(int mixerBalance) { }; - static const int kPowerOn; - static const int kPowerOff; - static const int kPowerStandby; + // @brief Primary language for Audio changed + // @param primaryLanguage: current primary language for audio + virtual void OnAudioPrimaryLanguageChanged(const std::string& primaryLanguage) { }; + + // @brief Secondary language for Audio changed + // @param secondaryLanguage: current secondary language for audio + virtual void OnAudioSecondaryLanguageChanged(const std::string& secondaryLanguage) { }; + + // @brief Audio output hot plug event + // @param portType: Type of audio port see AudioPortType + // @param uiPortNumber: The port number assigned by UI + // @param isPortConnected: true (connected) or false (not connected) + virtual void OnAudioOutHotPlug(dsAudioPortType_t portType, int uiPortNumber, bool isPortConnected) { }; - bool setPowerMode(int mode); - int getPowerMode(); + // @brief Dolby Atmos capabilities changed + // @param atmosCapability: the Dolby Atmos capability + // @param status: true (available) or false (not available) + virtual void OnDolbyAtmosCapabilitiesChanged(dsATMOSCapability_t atmosCapability, bool status) { }; + + // @brief Audio port state changed + // @param audioPortState: audio port state + // TODO: requires dsMgr.h header include ?? + // virtual void OnAudioPortStateChanged(dsAudioPortState_t audioPortState) { }; + + // @brief Audio mode for the respective audio port - raised for every type of port + // @param audioPortType: audio port type see dsAudioPortType_t + // @param audioStereoMode: audio stereo mode - see dsAudioStereoMode_t + virtual void OnAudioModeEvent(dsAudioPortType_t audioPortType, dsAudioStereoMode_t audioStereoMode) { }; + + // @brief Audio level changed + // @param audioiLevel: audio level value + virtual void OnAudioLevelChangedEvent(int audioLevel) { }; + + // @brief Audio Output format changed + // @param audioFormat: Type of audio format see AudioFormat + virtual void OnAudioFormatUpdate(dsAudioFormat_t audioFormat) { }; + }; + + // @brief Register a listener for audio port events + // @param listener: class object implementing the listener + dsError_t Register(IAudioOutputPortEvents* listener); + + // @brief UnRegister a listener for audio port events + // @param listener: class object implementing the listener + dsError_t UnRegister(IAudioOutputPortEvents* listener); + + bool setPowerMode(int mode); + int getPowerMode(); SleepMode getPreferredSleepMode(); int setPreferredSleepMode(const SleepMode); - List getAvailableSleepModes(); + List getAvailableSleepModes(); - static Host& getInstance(void); + static Host& getInstance(void); List getVideoOutputPorts(); List getAudioOutputPorts(); List getVideoDevices(); - VideoOutputPort &getVideoOutputPort(const std::string &name); - VideoOutputPort &getVideoOutputPort(int id); - AudioOutputPort &getAudioOutputPort(const std::string &name); - AudioOutputPort &getAudioOutputPort(int id); + VideoOutputPort& getVideoOutputPort(const std::string& name); + VideoOutputPort& getVideoOutputPort(int id); + AudioOutputPort& getAudioOutputPort(const std::string& name); + AudioOutputPort& getAudioOutputPort(int id); float getCPUTemperature(); - uint32_t getVersion(void); + uint32_t getVersion(void); void setVersion(uint32_t versionNumber); - void getHostEDID(std::vector &edid) const; + void getHostEDID(std::vector& edid) const; std::string getSocIDFromSDK(); - void getSinkDeviceAtmosCapability(dsATMOSCapability_t & atmosCapability); + void getSinkDeviceAtmosCapability(dsATMOSCapability_t& atmosCapability); void setAudioAtmosOutputMode(bool enable); void setAssociatedAudioMixing(const bool mixing); - void getAssociatedAudioMixing(bool *mixing); + void getAssociatedAudioMixing(bool* mixing); void setFaderControl(const int mixerbalance); - void getFaderControl(int *mixerBalance); + void getFaderControl(int* mixerBalance); void setPrimaryLanguage(const std::string pLang); - void getPrimaryLanguage(std::string &pLang); + void getPrimaryLanguage(std::string& pLang); void setSecondaryLanguage(const std::string sLang); - void getSecondaryLanguage(std::string &sLang); + void getSecondaryLanguage(std::string& sLang); bool isHDMIOutPortPresent(); std::string getDefaultVideoPortName(); std::string getDefaultAudioPortName(); - void getCurrentAudioFormat(dsAudioFormat_t &audioFormat); - void getMS12ConfigDetails(std::string &configType); - void setAudioMixerLevels (dsAudioInput_t aInput, int volume); + void getCurrentAudioFormat(dsAudioFormat_t& audioFormat); + void getMS12ConfigDetails(std::string& configType); + void setAudioMixerLevels(dsAudioInput_t aInput, int volume); + private: std::unique_ptr m_impl; - Host(); - virtual ~Host(); - //To Make the instance as thread-safe, using = delete, the result is, automatically generated methods (constructor, for example) from the compiler will not be created and, therefore, can not be called - Host (const Host&)= delete; - Host& operator=(const Host&)= delete; + Host(); + virtual ~Host(); + // Avoid copies + Host(const Host&) = delete; + Host& operator=(const Host&) = delete; DefaultImpl& impl(); }; @@ -342,6 +253,5 @@ class Host { #endif /* _DS_HOST_HPP_ */ - /** @} */ /** @} */ From 2cce9ecaa3e2d7282791baed1f32dfba9d53e8bd Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 15:22:22 +0530 Subject: [PATCH 16/29] topic/RDKEMW6161- Updated composite --- build_dependencies.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build_dependencies.sh b/build_dependencies.sh index 090f105a..566fca25 100644 --- a/build_dependencies.sh +++ b/build_dependencies.sh @@ -47,7 +47,7 @@ cd rfc autoreconf -i ./configure --enable-rfctool=yes --enable-tr181set=yes cd rfcapi -make librfcapi_la_CPPFLAGS="-I/usr/include/cjson" +make CXXFLAGS="-DUSE_IARMBUS" librfcapi_la_CPPFLAGS="-I/usr/include/cjson" make install export RFC_PATH=$ROOT/rfc From 9a39ca4c19f16e1d65494fa3187d1a32b0fa0df5 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 15:27:32 +0530 Subject: [PATCH 17/29] topic/RDKEMW6161- Updated composite --- ds/iarm/IarmHostImpl.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index eaeb7db0..612a25f8 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -517,7 +517,7 @@ class IARMGroupComposite { } private: - static void iarmCompositeInHotPlugHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmCompositeInHotPlugHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_HOTPLUG received owner = %s, eventId = %d", owner, eventId); @@ -538,7 +538,7 @@ class IARMGroupComposite { } - static void iarmCompositeInSignalStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmCompositeInSignalStatusHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS received owner = %s, eventId = %d", owner, eventId); @@ -557,7 +557,7 @@ class IARMGroupComposite { } } - static void iarmCompositeInStatusHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmCompositeInStatusHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_STATUS received owner = %s, eventId = %d", owner, eventId); @@ -577,7 +577,7 @@ class IARMGroupComposite { } - static void iarmCompositeInVideoModeUpdateHandler(const char*, IARM_EventId_t eventId, void* data, size_t len) + static void iarmCompositeInVideoModeUpdateHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_VIDEO_MODE_UPDATE received owner = %s, eventId = %d", owner, eventId); if (!isValidOwner(owner)) { From 071e0d45e537f9a7e149d5f95d3c92d2451c1d15 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 15:40:39 +0530 Subject: [PATCH 18/29] topic/RDKEMW6161- Updated composite --- ds/iarm/IarmHostImpl.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 612a25f8..6b335440 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -529,7 +529,7 @@ class IARMGroupComposite { if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_connect.port; bool isConnected = eventData->data.composite_in_connect.isPortConnected; - IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort][isConnected](ICompositeInEvents* listener) { listener->OnCompositeInHotPlug(compositePort,isConnected); }); } else { @@ -549,7 +549,7 @@ class IARMGroupComposite { if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_sig_status.port; dsCompInSignalStatus_t compositeSigStatus = eventData->data.composite_in_sig_status.status; - IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort][compositeSigStatus](ICompositeInEvents* listener) { listener->OnCompositeInSignalStatus(compositePort,compositeSigStatus); }); } else { @@ -568,7 +568,7 @@ class IARMGroupComposite { if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_status.port; bool isPresented = eventData->data.composite_in_status.isPresented; - IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort][isPresented](ICompositeInEvents* listener) { listener->OnCompositeInStatus(compositePort,isPresented); }); } else { @@ -590,7 +590,7 @@ class IARMGroupComposite { videoResolution.pixelResolution = eventData->data.composite_in_video_mode.resolution.pixelResolution; videoResolution.interlaced = eventData->data.composite_in_video_mode.resolution.interlaced; videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; - IarmHostImpl::Dispatch([compositePort](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort][videoResolution](ICompositeInEvents* listener) { listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); }); } else { From 2ef2da1d12796277cef7aa90b5057e8aa2002e72 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 16:19:44 +0530 Subject: [PATCH 19/29] topic/RDKEMW6161- Updated composite --- ds/iarm/IarmHostImpl.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 6b335440..1205ddb6 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -529,7 +529,7 @@ class IARMGroupComposite { if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_connect.port; bool isConnected = eventData->data.composite_in_connect.isPortConnected; - IarmHostImpl::Dispatch([compositePort][isConnected](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort, isConnected](ICompositeInEvents* listener) { listener->OnCompositeInHotPlug(compositePort,isConnected); }); } else { @@ -537,7 +537,6 @@ class IARMGroupComposite { } } - static void iarmCompositeInSignalStatusHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) { INT_INFO("IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS received owner = %s, eventId = %d", owner, eventId); @@ -549,7 +548,7 @@ class IARMGroupComposite { if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_sig_status.port; dsCompInSignalStatus_t compositeSigStatus = eventData->data.composite_in_sig_status.status; - IarmHostImpl::Dispatch([compositePort][compositeSigStatus](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort,compositeSigStatus](ICompositeInEvents* listener) { listener->OnCompositeInSignalStatus(compositePort,compositeSigStatus); }); } else { @@ -568,7 +567,7 @@ class IARMGroupComposite { if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_status.port; bool isPresented = eventData->data.composite_in_status.isPresented; - IarmHostImpl::Dispatch([compositePort][isPresented](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort,isPresented](ICompositeInEvents* listener) { listener->OnCompositeInStatus(compositePort,isPresented); }); } else { @@ -590,7 +589,7 @@ class IARMGroupComposite { videoResolution.pixelResolution = eventData->data.composite_in_video_mode.resolution.pixelResolution; videoResolution.interlaced = eventData->data.composite_in_video_mode.resolution.interlaced; videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; - IarmHostImpl::Dispatch([compositePort][videoResolution](ICompositeInEvents* listener) { + IarmHostImpl::Dispatch([compositePort,videoResolution](ICompositeInEvents* listener) { listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); }); } else { From 494cb98d837f6d97fc334537389b7b3c733b5476 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 19:01:25 +0530 Subject: [PATCH 20/29] topic/RDKEMW6161- Updated Display --- ds/host.cpp | 22 +++++++++++ ds/iarm/IarmHostImpl.cpp | 83 +++++++++++++++++++++++++++++++++++++++- ds/iarm/IarmHostImpl.hpp | 21 +++++++--- ds/include/host.hpp | 14 +++++++ 4 files changed, 134 insertions(+), 6 deletions(-) diff --git a/ds/host.cpp b/ds/host.cpp index 91910d6d..9f4ba598 100644 --- a/ds/host.cpp +++ b/ds/host.cpp @@ -797,6 +797,28 @@ dsError_t Host::UnRegister(ICompositeInEvents *listener) return impl().UnRegister(listener); } +/** + * @fn void Host::Register(IDisplayEvents *Evtnotification) + * @brief This API is used to register the Events + * + * @return dsError_t + */ +dsError_t Host::Register(IDisplayEvents *listener) +{ + return impl().Register(listener); +} + +/** + * @fn void Host::UnRegister(IDisplayEvents *Evtnotification) + * @brief This API is used to UnRegister the Events + * + * @return dsError_t + */ +dsError_t Host::UnRegister(IDisplayEvents *listener) +{ + return impl().UnRegister(listener); +} + dsError_t Host::Register(IVideoDeviceEvents* listener) { return impl().Register(listener); diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 1205ddb6..82421a3d 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -12,7 +12,8 @@ using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; -using ICompositeInEvents = device::Host::ICompositeInEvents; +using ICompositeInEvents = device::Host::ICompositeInEvents; +using IDisplayEvents = device::Host::IDisplayEvents; namespace device { @@ -607,16 +608,77 @@ class IARMGroupComposite { }; +// static data + +class IARMGroupDisplay { +public: + static bool RegisterIarmEvents() + { + return registerIarmEvents(handlers); + } + + static bool UnRegisterIarmEvents() + { + return unregisterIarmEvents(handlers); + } + +private: + static void iarmDisplayDisplayRxSense(const char* owner, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_RX_SENSE received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsDisplayEvent_t displayStatusEvent = eventData->data.hdmi_rxsense.status; + IarmHostImpl::Dispatch([displayStatusEvent](IDisplayEvents* listener) { + listener->OnDisplayRxSense(displayStatusEvent); + }); + } else { + INT_ERROR("Invalid data received for Composite Status Handler in iarmDisplayDisplayRxSense"); + } + } + + static void iarmDisplayHDCPStatusChange(const char* owner, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_HDCP_STATUS received owner = %s, eventId = %d", owner, eventId); + if (!isValidOwner(owner)) { + return; + } + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsHdcpStatus_t hdcpStatus = eventData->data.hdmi_hdcp.hdcpStatus; + IarmHostImpl::Dispatch([hdcpStatus](IDisplayEvents* listener) { + /* To check Parameter Required or Not*/ + listener->OnHDCPStatusChange(); + }); + } else { + INT_ERROR("Invalid data received for Composite Video Mode Update in iarmDisplayHDCPStatusChange"); + } + } + +private: + static constexpr EventHandlerMapping handlers[] = { + { IARM_BUS_DSMGR_EVENT_RX_SENSE, &IARMGroupDisplay::iarmDisplayDisplayRxSense }, + { IARM_BUS_DSMGR_EVENT_HDCP_STATUS, &IARMGroupDisplay::iarmDisplayHDCPStatusChange }, + }; +}; + + constexpr EventHandlerMapping IARMGroupVideoDevice::handlers[]; constexpr EventHandlerMapping IARMGroupVideoOutputPort::handlers[]; constexpr EventHandlerMapping IARMGroupAudioOutputPort::handlers[]; constexpr EventHandlerMapping IARMGroupComposite::handlers[]; +constexpr EventHandlerMapping IARMGroupDisplay::handlers[]; std::mutex IarmHostImpl::s_mutex; IarmHostImpl::CallbackList IarmHostImpl::s_videoDeviceListeners; IarmHostImpl::CallbackList IarmHostImpl::s_videoOutputPortListeners; IarmHostImpl::CallbackList IarmHostImpl::s_audioOutputPortListeners; IarmHostImpl::CallbackList IarmHostImpl::s_compositeListeners; +IarmHostImpl::CallbackList IarmHostImpl::s_displayListeners; IarmHostImpl::~IarmHostImpl() { @@ -626,6 +688,7 @@ IarmHostImpl::~IarmHostImpl() s_videoOutputPortListeners.Release(); s_audioOutputPortListeners.Release(); s_compositeListeners.Release(); + s_displayListeners.Release(); } template @@ -719,4 +782,22 @@ dsError_t IarmHostImpl::UnRegister(ICompositeInEvents* listener) Dispatch(s_compositeListeners, std::move(fn)); } +dsError_t IarmHostImpl::Register(IDisplayEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_displayListeners.Register(listener); +} + +dsError_t IarmHostImpl::UnRegister(IDisplayEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_displayListeners.UnRegister(listener); +} + +// Dispatcher for IARMGroupComposite +/* static */ void IarmHostImpl::Dispatch(std::function&& fn) +{ + Dispatch(s_displayListeners, std::move(fn)); +} + } // namespace device diff --git a/ds/iarm/IarmHostImpl.hpp b/ds/iarm/IarmHostImpl.hpp index 38e89013..8924ee7c 100755 --- a/ds/iarm/IarmHostImpl.hpp +++ b/ds/iarm/IarmHostImpl.hpp @@ -34,6 +34,7 @@ class IARMGroupVideoDevice; class IARMGroupVideoOutputPort; class IARMGroupAudioOutputPort; class IARMGroupComposite; +class IARMGroupDisplay; class IarmHostImpl { @@ -141,8 +142,9 @@ class IarmHostImpl { using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; - using ICompositeInEvents = device::Host::ICompositeInEvents; - + using ICompositeInEvents = device::Host::ICompositeInEvents; + using IDisplayEvents = device::Host::IDisplayEvents; + IarmHostImpl() = default; ~IarmHostImpl(); @@ -178,6 +180,14 @@ class IarmHostImpl { // @param listener: class object implementing the listener dsError_t UnRegister(ICompositeInEvents* listener); + // @brief Register a listener for Composite events + // @param listener: class object implementing the listener + dsError_t Register(IDisplayEvents* listener); + + // @brief UnRegister a listener for Composite events + // @param listener: class object implementing the listener + dsError_t UnRegister(IDisplayEvents* listener); + private: static std::mutex s_mutex; @@ -185,19 +195,20 @@ class IarmHostImpl { static CallbackList s_videoOutputPortListeners; static CallbackList s_audioOutputPortListeners; static CallbackList s_compositeListeners; - + static CallbackList s_displayListeners; template static void Dispatch(const std::list& listeners, F&& fn); - static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); - + static void Dispatch(std::function&& fn); // Dispatch is private, so all IARMGroup implementations will need to be friends + friend class IARMGroupVideoDevice; friend class IARMGroupVideoOutputPort; friend class IARMGroupAudioOutputPort; friend class IARMGroupComposite; + friend class IARMGroupDisplay; }; } // namespace device diff --git a/ds/include/host.hpp b/ds/include/host.hpp index d7b0d524..7f774b78 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -92,6 +92,20 @@ class Host { dsError_t Register(ICompositeInEvents *listener); dsError_t UnRegister(ICompositeInEvents *listener); + struct IDisplayEvents{ + + // @brief Display RX Sense event + // @text onDisplayRxSense + // @param displayEvent: DS_DISPLAY_RXSENSE_ON or DS_DISPLAY_RXSENSE_OFF + virtual void OnDisplayRxSense(dsDisplayEvent_t displayEvent) { }; + + // @brief Display HDCP Status + // @text OnDisplayHDCPStatus + virtual void OnDisplayHDCPStatus() { }; + }; + uint32_t Register(IDisplayEvents *listener); + uint32_t UnRegister(IDisplayEvents *listener); + struct IVideoDeviceEvents { // @brief Display Frame rate Pre-change notification From e8a985fcd22c3f1c4a60cdb05f68ef8dd88634f3 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 19:06:12 +0530 Subject: [PATCH 21/29] topic/RDKEMW6161- Updated Display --- ds/include/host.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/ds/include/host.hpp b/ds/include/host.hpp index 7f774b78..74d693bc 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -36,6 +36,7 @@ #include "sleepMode.hpp" #include "videoDevice.hpp" #include "videoOutputPort.hpp" +#include "dsDisplay.h" /** * @file host.hpp From 050faa1a16995bed62d8cc23cf51890a9b935fcc Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 19:13:41 +0530 Subject: [PATCH 22/29] topic/RDKEMW6161- Updated Display --- ds/include/host.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ds/include/host.hpp b/ds/include/host.hpp index 74d693bc..75179185 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -104,8 +104,8 @@ class Host { // @text OnDisplayHDCPStatus virtual void OnDisplayHDCPStatus() { }; }; - uint32_t Register(IDisplayEvents *listener); - uint32_t UnRegister(IDisplayEvents *listener); + dsError_t Register(IDisplayEvents *listener); + dsError_t UnRegister(IDisplayEvents *listener); struct IVideoDeviceEvents { From 50042691fa930b0e70308cc74ec7143fbe387685 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 19:24:31 +0530 Subject: [PATCH 23/29] topic/RDKEMW6161- Updated Display --- ds/iarm/IarmHostImpl.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 82421a3d..f9bfe684 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -632,7 +632,7 @@ class IARMGroupDisplay { } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { - dsDisplayEvent_t displayStatusEvent = eventData->data.hdmi_rxsense.status; + dsDisplayEvent_t displayStatusEvent = static_cast eventData->data.hdmi_rxsense.status; IarmHostImpl::Dispatch([displayStatusEvent](IDisplayEvents* listener) { listener->OnDisplayRxSense(displayStatusEvent); }); @@ -652,7 +652,7 @@ class IARMGroupDisplay { dsHdcpStatus_t hdcpStatus = eventData->data.hdmi_hdcp.hdcpStatus; IarmHostImpl::Dispatch([hdcpStatus](IDisplayEvents* listener) { /* To check Parameter Required or Not*/ - listener->OnHDCPStatusChange(); + listener->OnHDCPStatusChange(); }); } else { INT_ERROR("Invalid data received for Composite Video Mode Update in iarmDisplayHDCPStatusChange"); @@ -687,7 +687,7 @@ IarmHostImpl::~IarmHostImpl() s_videoDeviceListeners.Release(); s_videoOutputPortListeners.Release(); s_audioOutputPortListeners.Release(); - s_compositeListeners.Release(); + s_compositeListeners.Release(); s_displayListeners.Release(); } From 28e70b8ccae22f156bddb4d270a33e38d29ed4c5 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 19:28:47 +0530 Subject: [PATCH 24/29] topic/RDKEMW6161- Updated Display --- ds/iarm/IarmHostImpl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index f9bfe684..71b8755f 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -632,7 +632,7 @@ class IARMGroupDisplay { } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { - dsDisplayEvent_t displayStatusEvent = static_cast eventData->data.hdmi_rxsense.status; + dsDisplayEvent_t displayStatusEvent = static_cast(eventData->data.hdmi_rxsense.status); IarmHostImpl::Dispatch([displayStatusEvent](IDisplayEvents* listener) { listener->OnDisplayRxSense(displayStatusEvent); }); From fafd5f86c923ba902264a246260b1a4df785d5e6 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 19:33:56 +0530 Subject: [PATCH 25/29] topic/RDKEMW6161- Updated Display --- ds/iarm/IarmHostImpl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 71b8755f..372cba9f 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -649,10 +649,10 @@ class IARMGroupDisplay { } IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { - dsHdcpStatus_t hdcpStatus = eventData->data.hdmi_hdcp.hdcpStatus; + dsHdcpStatus_t hdcpStatus = static_cast(eventData->data.hdmi_hdcp.hdcpStatus); IarmHostImpl::Dispatch([hdcpStatus](IDisplayEvents* listener) { /* To check Parameter Required or Not*/ - listener->OnHDCPStatusChange(); + listener->OnDisplayHDCPStatus(); }); } else { INT_ERROR("Invalid data received for Composite Video Mode Update in iarmDisplayHDCPStatusChange"); From 8c9a236e75ddebf054e728d63a65dafd32a823e9 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 21:31:50 +0530 Subject: [PATCH 26/29] topic/RDKEMW6161- Composite and Display Implementation: Sync from base to Ramesh --- ds/host.cpp | 16 ++++++-- ds/iarm/IarmHostImpl.cpp | 87 +++++++++++++++++++++++++++++++++------- ds/iarm/IarmHostImpl.hpp | 31 ++++++++++---- ds/include/host.hpp | 24 ++++++++--- 4 files changed, 126 insertions(+), 32 deletions(-) diff --git a/ds/host.cpp b/ds/host.cpp index 9f4ba598..b114f880 100644 --- a/ds/host.cpp +++ b/ds/host.cpp @@ -779,7 +779,7 @@ DefaultImpl& Host::impl() * @fn void Host::Register(ICompositeInEvents *Evtnotification) * @brief This API is used to register the Events * - * @return dsError_t + * @return dsError_t */ dsError_t Host::Register(ICompositeInEvents *listener) { @@ -790,7 +790,7 @@ dsError_t Host::Register(ICompositeInEvents *listener) * @fn void Host::UnRegister(ICompositeInEvents *Evtnotification) * @brief This API is used to UnRegister the Events * - * @return dsError_t + * @return dsError_t */ dsError_t Host::UnRegister(ICompositeInEvents *listener) { @@ -801,7 +801,7 @@ dsError_t Host::UnRegister(ICompositeInEvents *listener) * @fn void Host::Register(IDisplayEvents *Evtnotification) * @brief This API is used to register the Events * - * @return dsError_t + * @return dsError_t */ dsError_t Host::Register(IDisplayEvents *listener) { @@ -812,7 +812,7 @@ dsError_t Host::Register(IDisplayEvents *listener) * @fn void Host::UnRegister(IDisplayEvents *Evtnotification) * @brief This API is used to UnRegister the Events * - * @return dsError_t + * @return dsError_t */ dsError_t Host::UnRegister(IDisplayEvents *listener) { @@ -849,6 +849,14 @@ dsError_t Host::UnRegister(IAudioOutputPortEvents* listener) return impl().UnRegister(listener); } +dsError_t Host::Register(IDisplayDeviceEvents* listener) { + return impl().Register(listener); +} + +dsError_t Host::UnRegister(IDisplayDeviceEvents* listener) { + return impl().UnRegister(listener); +} + /** @} */ } // namespace device diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 372cba9f..4be671ef 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -9,12 +9,6 @@ #include "libIBus.h" -using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; -using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; -using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; -using ICompositeInEvents = device::Host::ICompositeInEvents; -using IDisplayEvents = device::Host::IDisplayEvents; - namespace device { struct EventHandlerMapping { @@ -225,7 +219,10 @@ class IARMGroupVideoOutputPort { IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { - // TODO + dsHdcpStatus_t hdcpStatus = static_cast(eventData->data.hdmi_hdcp.hdcpStatus); + IarmHostImpl::Dispatch([hdcpStatus](IVideoOutputPortEvents* listener) { + listener->OnHDCPStatusChange(hdcpStatus); + }); } else { INT_ERROR("Invalid data received for HDCP status change"); } @@ -503,8 +500,6 @@ class IARMGroupAudioOutputPort { }; }; -// static data - class IARMGroupComposite { public: static bool RegisterIarmEvents() @@ -590,8 +585,9 @@ class IARMGroupComposite { videoResolution.pixelResolution = eventData->data.composite_in_video_mode.resolution.pixelResolution; videoResolution.interlaced = eventData->data.composite_in_video_mode.resolution.interlaced; videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; - IarmHostImpl::Dispatch([compositePort,videoResolution](ICompositeInEvents* listener) { - listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); + videoResolution.name = nullptr; + IarmHostImpl::Dispatch([compositePort,videoResolution](ICompositeInEvents* listener) { + listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); }); } else { INT_ERROR("Invalid data received for Composite Video Mode Update in iarmCompositeInVideoModeUpdateHandler"); @@ -608,8 +604,6 @@ class IARMGroupComposite { }; -// static data - class IARMGroupDisplay { public: static bool RegisterIarmEvents() @@ -666,7 +660,51 @@ class IARMGroupDisplay { }; }; +class IARMGroupDisplayDevice { +public: + static bool RegisterIarmEvents() + { + IARM_Result_t result = IARM_Bus_RegisterEventHandler(IARM_BUS_DSMGR_NAME, IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG, + &IARMGroupDisplayDevice::iarmDisplayHDMIHotPlugHandler); + if (result != IARM_RESULT_SUCCESS) { + INT_ERROR("Failed to register IARM event handler for IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG"); + } + return (result == IARM_RESULT_SUCCESS); + } + + static bool UnRegisterIarmEvents() + { + IARM_Result_t result = IARM_Bus_UnRegisterEventHandler(IARM_BUS_DSMGR_NAME, IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG); + if (result != IARM_RESULT_SUCCESS) { + INT_ERROR("Failed to unregister IARM event handler for IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG"); + } + return (result == IARM_RESULT_SUCCESS); + } + +private: + static void iarmDisplayHDMIHotPlugHandler(const char* owner, IARM_EventId_t eventId, void* data, size_t len) + { + INT_INFO("IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG received owner = %s, eventId = %d", owner, eventId); + + if (!isValidOwner(owner)) { + return; + } + + IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; + if (eventData) { + dsDisplayEvent_t displayEvent = static_cast(eventData->data.hdmi_hpd.event); + + IarmHostImpl::Dispatch([displayEvent](IDisplayDeviceEvents* listener) { + listener->OnDisplayHDMIHotPlug(displayEvent); + }); + } else { + INT_ERROR("Invalid data received for HDMI hot plug change"); + } + }; +}; + +// static data constexpr EventHandlerMapping IARMGroupVideoDevice::handlers[]; constexpr EventHandlerMapping IARMGroupVideoOutputPort::handlers[]; constexpr EventHandlerMapping IARMGroupAudioOutputPort::handlers[]; @@ -679,6 +717,7 @@ IarmHostImpl::CallbackList Ia IarmHostImpl::CallbackList IarmHostImpl::s_audioOutputPortListeners; IarmHostImpl::CallbackList IarmHostImpl::s_compositeListeners; IarmHostImpl::CallbackList IarmHostImpl::s_displayListeners; +IarmHostImpl::CallbackList IarmHostImpl::s_displayDeviceListeners; IarmHostImpl::~IarmHostImpl() { @@ -689,6 +728,7 @@ IarmHostImpl::~IarmHostImpl() s_audioOutputPortListeners.Release(); s_compositeListeners.Release(); s_displayListeners.Release(); + s_displayDeviceListeners.Release(); } template @@ -740,7 +780,7 @@ dsError_t IarmHostImpl::UnRegister(IVideoOutputPortEvents* listener) return s_videoOutputPortListeners.UnRegister(listener); } -// Dispatcher for IARMGroupVideoPort +// Dispatcher for IVideoOutputPortEvents /* static */ void IarmHostImpl::Dispatch(std::function&& fn) { Dispatch(s_videoOutputPortListeners, std::move(fn)); @@ -758,7 +798,7 @@ dsError_t IarmHostImpl::UnRegister(IAudioOutputPortEvents* listener) return s_audioOutputPortListeners.UnRegister(listener); } -// Dispatcher for IARMGroupAudioPort +// Dispatcher for IAudioOutputPortEvents /* static */ void IarmHostImpl::Dispatch(std::function&& fn) { Dispatch(s_audioOutputPortListeners, std::move(fn)); @@ -799,5 +839,22 @@ dsError_t IarmHostImpl::UnRegister(IDisplayEvents* listener) { Dispatch(s_displayListeners, std::move(fn)); } +dsError_t IarmHostImpl::Register(IDisplayDeviceEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_displayDeviceListeners.Register(listener); +} + +dsError_t IarmHostImpl::UnRegister(IDisplayDeviceEvents* listener) +{ + std::lock_guard lock(s_mutex); + return s_displayDeviceListeners.UnRegister(listener); +} + +// Dispatcher for IDisplayDeviceEvents +/* static */ void IarmHostImpl::Dispatch(std::function&& fn) +{ + Dispatch(s_displayDeviceListeners, std::move(fn)); +} } // namespace device diff --git a/ds/iarm/IarmHostImpl.hpp b/ds/iarm/IarmHostImpl.hpp index 8924ee7c..5b27f8af 100755 --- a/ds/iarm/IarmHostImpl.hpp +++ b/ds/iarm/IarmHostImpl.hpp @@ -33,9 +33,17 @@ namespace device { class IARMGroupVideoDevice; class IARMGroupVideoOutputPort; class IARMGroupAudioOutputPort; +class IARMGroupDisplayDevice; class IARMGroupComposite; class IARMGroupDisplay; +using IVideoDeviceEvents = Host::IVideoDeviceEvents; +using IVideoOutputPortEvents = Host::IVideoOutputPortEvents; +using IAudioOutputPortEvents = Host::IAudioOutputPortEvents; +using IDisplayDeviceEvents = Host::IDisplayDeviceEvents; +using ICompositeInEvents = device::Host::ICompositeInEvents; +using IDisplayEvents = device::Host::IDisplayEvents; + class IarmHostImpl { // Manages a list of listeners and corresponding IARM Event Group operations. @@ -139,12 +147,6 @@ class IarmHostImpl { }; public: - using IVideoDeviceEvents = device::Host::IVideoDeviceEvents; - using IVideoOutputPortEvents = device::Host::IVideoOutputPortEvents; - using IAudioOutputPortEvents = device::Host::IAudioOutputPortEvents; - using ICompositeInEvents = device::Host::ICompositeInEvents; - using IDisplayEvents = device::Host::IDisplayEvents; - IarmHostImpl() = default; ~IarmHostImpl(); @@ -187,7 +189,15 @@ class IarmHostImpl { // @brief UnRegister a listener for Composite events // @param listener: class object implementing the listener dsError_t UnRegister(IDisplayEvents* listener); - + + // @brief Register a listener for display device events + // @param listener: class object implementing the listener + dsError_t Register(IDisplayDeviceEvents* listener); + + // @brief UnRegister a listener for display device events + // @param listener: class object implementing the listener + dsError_t UnRegister(IDisplayDeviceEvents* listener); + private: static std::mutex s_mutex; @@ -196,19 +206,24 @@ class IarmHostImpl { static CallbackList s_audioOutputPortListeners; static CallbackList s_compositeListeners; static CallbackList s_displayListeners; + static CallbackList s_displayDeviceListeners; + template static void Dispatch(const std::list& listeners, F&& fn); + static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); static void Dispatch(std::function&& fn); + static void Dispatch(std::function&& fn); + // Dispatch is private, so all IARMGroup implementations will need to be friends - friend class IARMGroupVideoDevice; friend class IARMGroupVideoOutputPort; friend class IARMGroupAudioOutputPort; friend class IARMGroupComposite; friend class IARMGroupDisplay; + friend class IARMGroupDisplayDevice; }; } // namespace device diff --git a/ds/include/host.hpp b/ds/include/host.hpp index 75179185..09346c71 100644 --- a/ds/include/host.hpp +++ b/ds/include/host.hpp @@ -31,12 +31,12 @@ #include "audioOutputPort.hpp" #include "dsAVDTypes.h" +#include "dsDisplay.h" #include "dsError.h" #include "list.hpp" #include "sleepMode.hpp" #include "videoDevice.hpp" #include "videoOutputPort.hpp" -#include "dsDisplay.h" /** * @file host.hpp @@ -69,13 +69,13 @@ class Host { // @param port: Port of the hotplug // @param isConnected: Is it connected (true) or not(false) virtual void OnCompositeInHotPlug(dsCompositeInPort_t port, bool isConnected) { }; - + // @brief Composite In Signal status // @text onCompositeInSignalStatus // @param port: Port of the hotplug // @param signalStatus: Signal status virtual void OnCompositeInSignalStatus(dsCompositeInPort_t port, dsCompInSignalStatus_t signalStatus) { }; - + // @brief Composite In status // @text onCompositeInStatus // @param activePort: Active port @@ -92,14 +92,14 @@ class Host { dsError_t Register(ICompositeInEvents *listener); dsError_t UnRegister(ICompositeInEvents *listener); - + struct IDisplayEvents{ // @brief Display RX Sense event // @text onDisplayRxSense // @param displayEvent: DS_DISPLAY_RXSENSE_ON or DS_DISPLAY_RXSENSE_OFF virtual void OnDisplayRxSense(dsDisplayEvent_t displayEvent) { }; - + // @brief Display HDCP Status // @text OnDisplayHDCPStatus virtual void OnDisplayHDCPStatus() { }; @@ -216,6 +216,20 @@ class Host { // @param listener: class object implementing the listener dsError_t UnRegister(IAudioOutputPortEvents* listener); + struct IDisplayDeviceEvents { + // @brief Display HDMI (out) Hot plug event + // @param displayEvent: display event type see dsDisplayEvent_t + virtual void OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent) { }; + }; + + // @brief Register a listener for display device events + // @param listener: class object implementing the listener + dsError_t Register(IDisplayDeviceEvents* listener); + + // @brief UnRegister a listener for display device events + // @param listener: class object implementing the listener + dsError_t UnRegister(IDisplayDeviceEvents* listener); + bool setPowerMode(int mode); int getPowerMode(); SleepMode getPreferredSleepMode(); From 09ed4dfe5f1c99dc141c0bbeca1bb9744c1828d3 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 21:37:52 +0530 Subject: [PATCH 27/29] topic/RDKEMW6161- Composite and Display Implementation: Sync from base to Ramesh --- ds/iarm/IarmHostImpl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 4be671ef..0522bf08 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -585,9 +585,9 @@ class IARMGroupComposite { videoResolution.pixelResolution = eventData->data.composite_in_video_mode.resolution.pixelResolution; videoResolution.interlaced = eventData->data.composite_in_video_mode.resolution.interlaced; videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; - videoResolution.name = nullptr; + memset(videoResolution.name, 0, sizeof(videoResolution.name)); IarmHostImpl::Dispatch([compositePort,videoResolution](ICompositeInEvents* listener) { - listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); + listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); }); } else { INT_ERROR("Invalid data received for Composite Video Mode Update in iarmCompositeInVideoModeUpdateHandler"); From 6da24535b196b104fac10a5ebbdf4061f391148d Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 21:41:26 +0530 Subject: [PATCH 28/29] topic/RDKEMW6161- Composite and Display Implementation: Sync from base to Ramesh --- ds/iarm/IarmHostImpl.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 0522bf08..5c23e309 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include "IarmHostImpl.hpp" From 7c190d60accc9bef8bc7e18bf9d072ee982b5225 Mon Sep 17 00:00:00 2001 From: Ramesh Babu H Date: Tue, 26 Aug 2025 21:57:12 +0530 Subject: [PATCH 29/29] topic/RDKEMW6161- Composite and Display Implementation: Sync from base to Ramesh --- ds/iarm/IarmHostImpl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ds/iarm/IarmHostImpl.cpp b/ds/iarm/IarmHostImpl.cpp index 5c23e309..a0107962 100755 --- a/ds/iarm/IarmHostImpl.cpp +++ b/ds/iarm/IarmHostImpl.cpp @@ -582,11 +582,11 @@ class IARMGroupComposite { IARM_Bus_DSMgr_EventData_t* eventData = (IARM_Bus_DSMgr_EventData_t*)data; if (eventData) { dsCompositeInPort_t compositePort = eventData->data.composite_in_video_mode.port; - dsVideoPortResolution_t videoResolution; + dsVideoPortResolution_t videoResolution{}; + memset(videoResolution.name, 0, sizeof(videoResolution.name)); videoResolution.pixelResolution = eventData->data.composite_in_video_mode.resolution.pixelResolution; videoResolution.interlaced = eventData->data.composite_in_video_mode.resolution.interlaced; videoResolution.frameRate = eventData->data.composite_in_video_mode.resolution.frameRate; - memset(videoResolution.name, 0, sizeof(videoResolution.name)); IarmHostImpl::Dispatch([compositePort,videoResolution](ICompositeInEvents* listener) { listener->OnCompositeInVideoModeUpdate(compositePort,videoResolution); });