RDKEMW-17086: Enable or Disable MS12 cont audio output mode.

ds/audioOutputPort.cpp

@@ -364,7 +364,6 @@ void AudioOutputPort::setEnablePersist (bool isEnabled)
     return;
 }
 
-
 /**
  * @fn const int AudioOutputPort::getStereoAuto()
  * @brief This API is used to get the current auto mode.

ds/host.cpp

@@ -521,6 +521,91 @@ Host::~Host()
        }
    }
 
+/**
+ * @brief Sets the application-specific audio configuration.
+ *
+ * Some applications may require custom audio settings, such as enabling
+ * continuous audio output to prevent audio glitches, muting, or format
+ * re-lock events on downstream devices when the input stream to MS12 is
+ * temporarily interrupted.
+ *
+ * This interface is designed to be extensible and can accommodate additional
+ * application-specific audio configuration requirements in the future.
+ *
+ * Applications should call getApplicationAudioConfigList() to retrieve the list of supported audio configurations
+ * and then call setApplicationAudioConfig() with a supported audioConfig name.
+ *
+ * @param[in] audioConfig  - Configuration name entry.
+ * @param[in] enable       - enable/disable audio configuration ( @a true to enable, @a false to disable)
+ *
+ * @return None
+ *
+ */
+void Host::setApplicationAudioConfig (const std::string &audioConfig, bool enable)
+{
+    dsApplicationAudioConfig_t config;
+    memset(config.configName, 0, DS_MAX_APPLICATION_AUDIO_CONFIG_NAME_LEN);
+    strncpy(config.configName, audioConfig.c_str(), (DS_MAX_APPLICATION_AUDIO_CONFIG_NAME_LEN - 1));
+    dsError_t ret = dsSetApplicationAudioConfig (NULL, &config, enable);
+    if (ret != dsERR_NONE) {
+        INT_ERROR("Failed to set Host::setApplicationAudioConfig\n");
+        throw Exception(ret);
+    }
+    return;
+}
+
+/**
+ * @brief Gets the application-specific audio configuration.
+ * Returns whether the requested specific audio configuration (see setApplicationAudioConfig())
+ * is currently enabled or disabled.
+ *
+ * @param[in] audioConfig  - Configuration name entry
+ * @param[out] enable      - True if audio configuration is enabled, false otherwise.
+ *
+ * @return None
+ *
+ */
+void Host::getApplicationAudioConfig (const std::string &audioConfig, bool *enable)
+{
+    dsError_t ret;
+    if (enable == NULL) {
+	INT_ERROR("Invalid parameter\n");
+	ret = dsERR_INVALID_PARAM;
+        throw Exception(ret);
+    }
+    dsApplicationAudioConfig_t config;
+    memset(config.configName, 0, DS_MAX_APPLICATION_AUDIO_CONFIG_NAME_LEN);
+    strncpy(config.configName, audioConfig.c_str(), (DS_MAX_APPLICATION_AUDIO_CONFIG_NAME_LEN -1 ));
+    ret = dsGetApplicationAudioConfig (NULL, &config, enable);
+    if (ret != dsERR_NONE) {
+        INT_ERROR("Failed to get Host::getApplicationAudioConfig\n");
+        throw Exception(ret);
+    }
+    return;
+}
+
+/**
+ * @brief Gets the list of supported audio configurations.
+ *
+ * @param[out] audioConfigList  - pointer to List of supported audio configurations
+ *
+ * @return None
+ *
+ */
+void Host::getApplicationAudioConfigList (std::vector<std::string>& configList)
+{
+    dsApplicationAudioConfigList_t appAudioConfigList;
+    memset(&appAudioConfigList, 0, sizeof(appAudioConfigList));
+    dsError_t ret = dsGetApplicationAudioConfigList(NULL, &appAudioConfigList);
+    if (ret != dsERR_NONE) {
+        INT_ERROR("Failed to set Host::getApplicationAudioConfigList\n");
+        throw Exception(ret);
+    }
+    for (int count =0; count < appAudioConfigList.returnedCount; count++) {
+        configList.push_back(appAudioConfigList.config[count].configName);
+    }
+    return;
+}
 
     /**
      * @fn Host::setAssociatedAudioMixing(const bool mixing)

ds/include/host.hpp

@@ -437,7 +437,9 @@ class Host {
     void getCurrentAudioFormat(dsAudioFormat_t& audioFormat);
     void getMS12ConfigDetails(std::string& configType);
     void setAudioMixerLevels(dsAudioInput_t aInput, int volume);
-
+    void setApplicationAudioConfig (const std::string &audioConfig, bool enable);
+    void getApplicationAudioConfig (const std::string &audioConfig, bool *enable);
+    void getApplicationAudioConfigList (std::vector<std::string>& configList);
 private:
     std::unique_ptr<DefaultImpl> m_impl;
 

rpc/cli/dsAudio.c

@@ -396,6 +396,96 @@ dsError_t dsSetEnablePersist(intptr_t handle, const char* portName, bool enabled
 	return dsERR_GENERAL ;
 }
 
+dsError_t dsSetApplicationAudioConfig(intptr_t handle, const dsApplicationAudioConfig_t* audioConfig, bool enable)
+{
+    _DEBUG_ENTER();
+    if (audioConfig == NULL) {
+	INT_ERROR("%s:Invalid parameter", __func__);
+	return dsERR_INVALID_PARAM;
+    }
+    dsApplicationAudioConfigParam_t param;
+    memset(&param, 0, sizeof(param));
+    param.handle = handle;
+    param.enable = enable;
+    IARM_Result_t rpcRet = IARM_RESULT_SUCCESS;
+    memset(&param.audioConfig, '\0', sizeof(param.audioConfig));
+    strncpy(param.audioConfig.configName, audioConfig->configName, (DS_MAX_APPLICATION_AUDIO_CONFIG_NAME_LEN  -1));
+    rpcRet = IARM_Bus_Call(IARM_BUS_DSMGR_NAME,
+                                              (char *)IARM_BUS_DSMGR_API_dsSetApplicationAudioConfig,
+                                              (void *)&param,
+                                             sizeof(param));
+
+    if (IARM_RESULT_SUCCESS == rpcRet && param.result == dsERR_NONE)
+    {
+        return dsERR_NONE;
+    }
+    INT_ERROR("%s: Failed to set application audio config\n", __func__);
+    return dsERR_GENERAL;
+}
+
+dsError_t dsGetApplicationAudioConfigList(intptr_t handle, dsApplicationAudioConfigList_t* appAudioConfigList)
+{
+    IARM_Result_t rpcRet = IARM_RESULT_SUCCESS;
+    if (appAudioConfigList == NULL) {
+        INT_ERROR("%s:Invalid parameter", __func__);
+	return dsERR_INVALID_PARAM;
+    }
+    dsApplicationAudioConfigListParam_t param;
+    memset(&param, 0, sizeof(param));
+    param.handle = handle;
+    param.appAudioConfigList.size = sizeof(param.appAudioConfigList);
+
+    rpcRet = IARM_Bus_Call(IARM_BUS_DSMGR_NAME,
+                                            (char *)IARM_BUS_DSMGR_API_dsGetApplicationAudioConfigList,
+                                            (void *)&param,
+                                            sizeof(param));
+
+    if (IARM_RESULT_SUCCESS != rpcRet || param.result != dsERR_NONE)
+    {
+        INT_ERROR("%s: (GET) GENERAL ERROR\n", __func__);
+        return dsERR_GENERAL;
+    }
+
+    appAudioConfigList->size = param.appAudioConfigList.size;
+    appAudioConfigList->returnedCount = param.appAudioConfigList.returnedCount;
+    appAudioConfigList->totalCount = param.appAudioConfigList.totalCount;
+    for (int count=0; count <  param.appAudioConfigList.returnedCount; count++) {
+        strncpy(appAudioConfigList->config[count].configName, param.appAudioConfigList.config[count].configName, 
+			    (DS_MAX_APPLICATION_AUDIO_CONFIG_NAME_LEN -1) );
+    }
+    return dsERR_NONE;
+}
+
+dsError_t dsGetApplicationAudioConfig(intptr_t handle, const dsApplicationAudioConfig_t* audioConfig, bool* enable)
+{
+    _DEBUG_ENTER();
+    if (audioConfig == NULL || enable == NULL) {
+        INT_ERROR("%s:Invalid parameter", __func__);
+        return dsERR_INVALID_PARAM;
+    }
+    dsApplicationAudioConfigParam_t param;
+    memset(&param, 0, sizeof(param));
+    param.handle = handle;
+    // By default enable will be false.
+    param.enable = false;
+    IARM_Result_t rpcRet = IARM_RESULT_SUCCESS;
+    memset(&param.audioConfig, 0, sizeof(param.audioConfig));
+    strncpy(param.audioConfig.configName, audioConfig->configName, (DS_MAX_APPLICATION_AUDIO_CONFIG_NAME_LEN  -1));
+    rpcRet = IARM_Bus_Call(IARM_BUS_DSMGR_NAME,
+                                            (char *)IARM_BUS_DSMGR_API_dsGetApplicationAudioConfig,
+                                            (void *)&param,
+                                          sizeof(param));
+
+    if (IARM_RESULT_SUCCESS == rpcRet && param.result == dsERR_NONE)
+    {
+        *enable = param.enable;
+       return dsERR_NONE;
+    }
+    INT_ERROR("%s: Failed to get application audio config\n", __func__);
+    return dsERR_GENERAL ;
+}
+
+
 dsError_t dsSetAudioEncoding(intptr_t handle, dsAudioEncoding_t encoding)
 {
 	dsError_t ret = dsERR_NONE;

rpc/include/dsRpc.h

@@ -73,6 +73,9 @@ extern "C" {
 #define  IARM_BUS_DSMGR_API_dsGetAudioDelay            "dsGetAudioDelay"
 #define  IARM_BUS_DSMGR_API_dsGetSinkDeviceAtmosCapability "dsGetSinkDeviceAtmosCapability"
 #define  IARM_BUS_DSMGR_API_dsSetAudioAtmosOutputMode "dsSetAudioAtmosOutputMode"
+#define  IARM_BUS_DSMGR_API_dsSetApplicationAudioConfig "dsSetApplicationAudioConfig"
+#define  IARM_BUS_DSMGR_API_dsGetApplicationAudioConfig "dsGetApplicationAudioConfig"
+#define  IARM_BUS_DSMGR_API_dsGetApplicationAudioConfigList "dsGetApplicationAudioConfigList"
 #define  IARM_BUS_DSMGR_API_dsSetAudioDucking    "dsSetAudioDucking"
 #define  IARM_BUS_DSMGR_API_dsSetAudioLevel            "dsSetAudioLevel"
 #define  IARM_BUS_DSMGR_API_dsGetAudioLevel            "dsGetAudioLevel"
@@ -1082,6 +1085,21 @@ typedef struct _dsHdmiVersionParam_t
     dsHdmiMaxCapabilityVersion_t iCapVersion;
 }dsHdmiVersionParam_t;
 
+typedef struct _dsApplicationAudioConfigParam_t
+{
+    dsError_t result;
+    intptr_t handle;
+    dsApplicationAudioConfig_t audioConfig ;
+    bool enable;
+}dsApplicationAudioConfigParam_t;
+
+typedef struct _dsApplicationAudioConfigListParam_t {
+    dsError_t result;
+    intptr_t handle;
+    dsApplicationAudioConfigList_t appAudioConfigList;
+} dsApplicationAudioConfigListParam_t;
+
+
 #ifdef __cplusplus
 }
 #endif