Merge "st-hal: return success if session start failed due to ssr/pdr"
diff --git a/sml_model_parser.h b/sml_model_parser.h
index 8691709..3ff87c3 100644
--- a/sml_model_parser.h
+++ b/sml_model_parser.h
@@ -6,7 +6,7 @@
* big sound model version 3. These are used in STHAL to parse
* out the individual sound models' raw data.
*
- * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -112,7 +112,8 @@
} SML_HeaderTypeV3;
typedef struct _SML_BigSoundModelTypeV3 {
- uint32_t version; // version of sound model ( always 3 for now )
+ uint16_t versionMajor; // major version of sound model
+ uint16_t versionMinor; // minor version of sound model
uint32_t offset; // start address of model data
uint32_t size; // model size
listen_model_indicator_enum type; // type : Lower 1 byte : 1Stage KW model,
diff --git a/sound_trigger_hw.c b/sound_trigger_hw.c
index 69847b5..0c8bc26 100644
--- a/sound_trigger_hw.c
+++ b/sound_trigger_hw.c
@@ -1802,8 +1802,9 @@
* This function finds the first stage sound model raw data size and offset, and sets
* the sound_trigger_sound_model payload size and offset to these values.
*/
-static int get_gmm_model(struct sound_trigger_sound_model **common_sm,
- uint8_t *sm_payload, uint32_t num_models)
+static int get_first_stage_model(struct sound_trigger_sound_model **common_sm,
+ uint8_t *sm_payload, uint32_t num_models,
+ st_module_type_t *sm_version)
{
SML_BigSoundModelTypeV3 *big_sm = NULL;
uint32_t i = 0;
@@ -1813,6 +1814,10 @@
big_sm = (SML_BigSoundModelTypeV3 *)(sm_payload + sizeof(SML_GlobalHeaderType) +
sizeof(SML_HeaderTypeV3) + (i * sizeof(SML_BigSoundModelTypeV3)));
if (big_sm->type == ST_SM_ID_SVA_GMM) {
+ if (big_sm->versionMajor == ST_MODULE_TYPE_PDK5)
+ *sm_version = ST_MODULE_TYPE_PDK5;
+ else
+ *sm_version = ST_MODULE_TYPE_GMM;
(*common_sm)->data_size = big_sm->size;
(*common_sm)->data_offset += sizeof(SML_GlobalHeaderType) + sizeof(SML_HeaderTypeV3) +
(num_models * sizeof(SML_BigSoundModelTypeV3)) + big_sm->offset;
@@ -1875,7 +1880,8 @@
uint8_t *sm_payload;
SML_GlobalHeaderType *global_hdr;
SML_HeaderTypeV3 *hdr_v3;
- uint32_t num_models = 0, sm_version = SML_MODEL_V2;
+ uint32_t num_models = 0, sml_version = SML_MODEL_V2;
+ st_module_type_t sm_version = ST_MODULE_TYPE_GMM;
struct listnode *node = NULL, *tmp_node = NULL;
struct st_arm_second_stage *st_sec_stage = NULL;
@@ -1936,10 +1942,10 @@
sm_payload = (uint8_t *)common_sm + common_sm->data_offset;
global_hdr = (SML_GlobalHeaderType *)sm_payload;
if (global_hdr->magicNumber == SML_GLOBAL_HEADER_MAGIC_NUMBER) {
- sm_version = SML_MODEL_V3;
+ sml_version = SML_MODEL_V3;
hdr_v3 = (SML_HeaderTypeV3 *)(sm_payload + sizeof(SML_GlobalHeaderType));
num_models = hdr_v3->numModels;
- status = get_gmm_model(&common_sm, sm_payload, num_models);
+ status = get_first_stage_model(&common_sm, sm_payload, num_models, &sm_version);
if (status) {
ALOGE("%s: Failed to set the first stage sound modle offset and size",
__func__);
@@ -1972,6 +1978,8 @@
}
list_init(&st_session->second_stage_list);
+ st_session->f_stage_version = sm_version;
+
/* CPE takes time to become online, so parse for the pcm devices
here instead during boot time */
if (!CHECK_BIT(stdev->hw_type,
@@ -2011,7 +2019,7 @@
* Parse second stage sound models and populate the second stage list for
* this session.
*/
- if (sm_version == SML_MODEL_V3) {
+ if (sml_version == SML_MODEL_V3) {
status = check_and_configure_second_stage_models(st_session, sm_payload,
num_models, phrase_sm->phrases[0].recognition_mode);
if (status) {
diff --git a/sound_trigger_platform.c b/sound_trigger_platform.c
index 7439064..cded425 100644
--- a/sound_trigger_platform.c
+++ b/sound_trigger_platform.c
@@ -92,6 +92,7 @@
#define ST_PARAM_KEY_SM_VENDOR_UUID "vendor_uuid"
#define ST_PARAM_KEY_MERGE_FIRST_STAGE_SOUNDMODELS "merge_first_stage_sound_models"
#define ST_PARAM_KEY_APP_TYPE "app_type"
+#define ST_PARAM_KEY_PDK5_APP_TYPE "pdk5_app_type"
#define ST_PARAM_KEY_MAX_CPE_PHRASES "max_cpe_phrases"
#define ST_PARAM_KEY_MAX_APE_USERS "max_ape_users"
#define ST_PARAM_KEY_MAX_APE_PHRASES "max_ape_phrases"
@@ -105,6 +106,7 @@
#define ST_PARAM_KEY_OUT_CHANNELS "out_channels"
#define ST_PARAM_KEY_ADM_CFG_PROFILE "adm_cfg_profile"
#define ST_PARAM_KEY_CAPTURE_DEVICE "capture_device"
+#define ST_PARAM_KEY_MODULE_TYPE "module_type"
#define ST_PARAM_KEY_LOAD_SOUND_MODEL_IDS "load_sound_model_ids"
#define ST_PARAM_KEY_UNLOAD_SOUND_MODEL_IDS "unload_sound_model_ids"
#define ST_PARAM_KEY_CONFIDENCE_LEVELS_IDS "confidence_levels_ids"
@@ -342,7 +344,8 @@
TAG_ADM_CFG,
TAG_LPMA_CONFIG,
TAG_ACDB_METAINFO_KEY,
- TAG_LSM_SS_USECASE
+ TAG_LSM_SS_USECASE,
+ TAG_MODULE_PARAMS
} st_xml_tags_t;
typedef void (*st_xml_process_fn)(void *platform, const XML_Char **attr);
@@ -363,6 +366,7 @@
[TAG_LPMA_CONFIG] = platform_stdev_process_kv_params,
[TAG_ACDB_METAINFO_KEY] = process_stdev_acdb_metainfo_key,
[TAG_LSM_SS_USECASE] = platform_stdev_process_kv_params,
+ [TAG_MODULE_PARAMS] = platform_stdev_process_kv_params,
};
#define ST_ACDB_METAINFO_KEY_MODULE_NAME_LEN (100)
@@ -1966,6 +1970,200 @@
return ret;
}
+static int platform_stdev_set_module_params
+(
+ void *platform,
+ struct str_parms *parms
+)
+{
+ struct platform_data *my_data = (struct platform_data *)platform;
+ char str_value[ST_MAX_STRING_PARAM_SIZE];
+ char *kv_pairs = str_parms_to_str(parms);
+ int ret = 0, err = 0;
+ struct listnode *sm_info_node = NULL, *lsm_params_node = NULL;
+ struct st_vendor_info *sm_info = NULL;
+ struct st_lsm_params *lsm_params = NULL;
+ struct st_module_params *module_params = NULL;
+
+ if (kv_pairs == NULL) {
+ ALOGE("%s: key-value pair is NULL", __func__);
+ return -EINVAL;
+ }
+ ALOGV("%s: %s", __func__, kv_pairs);
+
+ if (my_data->xml_version < PLATFORM_XML_VERSION_0x0106) {
+ ALOGE("%s: Unexpected platform xml version 0x%x, exiting", __func__,
+ my_data->xml_version);
+ return -EINVAL;
+ }
+
+ /* Get the last added vendor_info node */
+ sm_info_node = list_tail(&my_data->stdev->vendor_uuid_list);
+ if (sm_info_node) {
+ sm_info = node_to_item(sm_info_node, struct st_vendor_info, list_node);
+ } else {
+ ALOGE("%s: found NULL sm_info", __func__);
+ ret = -EINVAL;
+ goto err_exit;
+ }
+
+ /* Get the last added lsm_params node */
+ lsm_params_node = list_tail(&sm_info->lsm_usecase_list);
+ if (lsm_params_node) {
+ lsm_params = node_to_item(lsm_params_node, struct st_lsm_params,
+ list_node);
+ } else {
+ ALOGE("%s: found NULL lsm_params", __func__);
+ ret = -EINVAL;
+ goto err_exit;
+ }
+
+ module_params = calloc(1, sizeof(struct st_module_params));
+ if (!module_params) {
+ ALOGE("%s: module_params allocation failed", __func__);
+ ret = -ENOMEM;
+ goto err_exit;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_MODULE_TYPE,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_MODULE_TYPE);
+ if (!strncmp(str_value, "GMM", sizeof("GMM")))
+ module_params->type = ST_MODULE_TYPE_GMM;
+ else if (!strncmp(str_value, "PDK5", sizeof("PDK5")))
+ module_params->type = ST_MODULE_TYPE_PDK5;
+ else {
+ ALOGE("%s: Unknown module type, exiting", __func__);
+ ret = -EINVAL;
+ goto err_exit;
+ }
+ } else {
+ module_params->type = ST_MODULE_TYPE_GMM;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_LOAD_SOUND_MODEL_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_LOAD_SOUND_MODEL_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[LOAD_SOUND_MODEL], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_LOAD_SOUND_MODEL_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_UNLOAD_SOUND_MODEL_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_UNLOAD_SOUND_MODEL_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[UNLOAD_SOUND_MODEL], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_UNLOAD_SOUND_MODEL_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_REQUEST_DETECTION_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_REQUEST_DETECTION_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[REQUEST_DETECTION], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_REQUEST_DETECTION_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_LAB_DAM_CFG_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_LAB_DAM_CFG_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[LAB_DAM_CFG], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_LAB_DAM_CFG_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_CONFIDENCE_LEVELS_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_CONFIDENCE_LEVELS_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[CONFIDENCE_LEVELS], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_CONFIDENCE_LEVELS_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_OPERATION_MODE_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_OPERATION_MODE_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[OPERATION_MODE], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_OPERATION_MODE_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_POLLING_ENABLE_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_POLLING_ENABLE_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[POLLING_ENABLE], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_POLLING_ENABLE_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_CUSTOM_CONFIG_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_CUSTOM_CONFIG_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[CUSTOM_CONFIG], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_CUSTOM_CONFIG_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_DET_EVENT_TYPE_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_DET_EVENT_TYPE_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[DET_EVENT_TYPE], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_DET_EVENT_TYPE_BIT;
+ }
+
+ err = str_parms_get_str(parms, ST_PARAM_KEY_LAB_CONTROL_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_LAB_CONTROL_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &module_params->params[LAB_CONTROL], str_value, false);
+ if (ret)
+ goto err_exit;
+ module_params->param_tag_tracker |= PARAM_LAB_CONTROL_BIT;
+ }
+
+ list_add_tail(&lsm_params->module_params_list,
+ &module_params->list_node);
+ free(kv_pairs);
+ return 0;
+
+err_exit:
+ if (module_params)
+ free(module_params);
+ free(kv_pairs);
+ return ret;
+}
+
static int platform_stdev_set_lsm_params
(
void *platform,
@@ -1976,9 +2174,11 @@
char str_value[ST_MAX_STRING_PARAM_SIZE];
char *kv_pairs = str_parms_to_str(parms);
int ret = 0, err = 0, value = 0;
- struct listnode *sm_info_node = NULL;
+ struct listnode *sm_info_node = NULL, *module_node = NULL;
+ struct listnode *tmp_node = NULL, *lsm_params_node = NULL;
struct st_vendor_info *sm_info = NULL;
struct st_lsm_params *lsm_params = NULL;
+ struct st_module_params *module_params = NULL;
st_exec_mode_t exec_mode = ST_EXEC_MODE_NONE;
bool is_legacy_params = true;
bool is_legacy_version = true;
@@ -1999,10 +2199,13 @@
goto err_exit;
}
- lsm_params = calloc(1, sizeof(*lsm_params));
- if (!lsm_params) {
- ALOGE("%s: lsm_params allocation failed", __func__);
- ret = -ENOMEM;
+ /* Get the last added lsm_params node */
+ lsm_params_node = list_tail(&sm_info->lsm_usecase_list);
+ if (lsm_params_node) {
+ lsm_params = node_to_item(lsm_params_node, struct st_lsm_params, list_node);
+ } else {
+ ALOGE("%s: found NULL lsm_params", __func__);
+ ret = -EINVAL;
goto err_exit;
}
@@ -2033,114 +2236,123 @@
ALOGV("%s: Process params for exec mode %x", __func__, exec_mode);
- err = str_parms_get_str(parms, ST_PARAM_KEY_LOAD_SOUND_MODEL_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_LOAD_SOUND_MODEL_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[LOAD_SOUND_MODEL], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_LOAD_SOUND_MODEL_BIT;
- }
+ if (my_data->xml_version <= PLATFORM_XML_VERSION_0x0105) {
+ err = str_parms_get_str(parms, ST_PARAM_KEY_LOAD_SOUND_MODEL_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_LOAD_SOUND_MODEL_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[LOAD_SOUND_MODEL], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_LOAD_SOUND_MODEL_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_UNLOAD_SOUND_MODEL_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_UNLOAD_SOUND_MODEL_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[UNLOAD_SOUND_MODEL], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_UNLOAD_SOUND_MODEL_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_UNLOAD_SOUND_MODEL_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_UNLOAD_SOUND_MODEL_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[UNLOAD_SOUND_MODEL], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_UNLOAD_SOUND_MODEL_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_REQUEST_DETECTION_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_REQUEST_DETECTION_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[REQUEST_DETECTION], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_REQUEST_DETECTION_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_REQUEST_DETECTION_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_REQUEST_DETECTION_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[REQUEST_DETECTION], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_REQUEST_DETECTION_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_LAB_DAM_CFG_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_LAB_DAM_CFG_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[LAB_DAM_CFG], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_LAB_DAM_CFG_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_LAB_DAM_CFG_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_LAB_DAM_CFG_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[LAB_DAM_CFG], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_LAB_DAM_CFG_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_CONFIDENCE_LEVELS_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_CONFIDENCE_LEVELS_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[CONFIDENCE_LEVELS], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_CONFIDENCE_LEVELS_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_CONFIDENCE_LEVELS_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_CONFIDENCE_LEVELS_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[CONFIDENCE_LEVELS], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_CONFIDENCE_LEVELS_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_OPERATION_MODE_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_OPERATION_MODE_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[OPERATION_MODE], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_OPERATION_MODE_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_OPERATION_MODE_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_OPERATION_MODE_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[OPERATION_MODE], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_OPERATION_MODE_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_POLLING_ENABLE_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_POLLING_ENABLE_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[POLLING_ENABLE], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_POLLING_ENABLE_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_POLLING_ENABLE_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_POLLING_ENABLE_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[POLLING_ENABLE], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_POLLING_ENABLE_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_CUSTOM_CONFIG_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_CUSTOM_CONFIG_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[CUSTOM_CONFIG], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_CUSTOM_CONFIG_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_CUSTOM_CONFIG_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_CUSTOM_CONFIG_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[CUSTOM_CONFIG], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_CUSTOM_CONFIG_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_DET_EVENT_TYPE_IDS,
- str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_DET_EVENT_TYPE_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[DET_EVENT_TYPE], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_DET_EVENT_TYPE_BIT;
- }
+ err = str_parms_get_str(parms, ST_PARAM_KEY_DET_EVENT_TYPE_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_DET_EVENT_TYPE_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[DET_EVENT_TYPE], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_DET_EVENT_TYPE_BIT;
+ }
- err = str_parms_get_str(parms, ST_PARAM_KEY_LAB_CONTROL_IDS,
+ err = str_parms_get_str(parms, ST_PARAM_KEY_LAB_CONTROL_IDS,
+ str_value, sizeof(str_value));
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_LAB_CONTROL_IDS);
+ ret = platform_stdev_set_module_param_ids(
+ &lsm_params->params[LAB_CONTROL], str_value, is_legacy_params);
+ if (ret)
+ goto err_exit;
+ lsm_params->param_tag_tracker |= PARAM_LAB_CONTROL_BIT;
+ }
+ } else {
+ err = str_parms_get_str(parms, ST_PARAM_KEY_PDK5_APP_TYPE,
str_value, sizeof(str_value));
- if (err >= 0) {
- str_parms_del(parms, ST_PARAM_KEY_LAB_CONTROL_IDS);
- ret = platform_stdev_set_module_param_ids(
- &lsm_params->params[LAB_CONTROL], str_value, is_legacy_params);
- if (ret)
- goto err_exit;
- lsm_params->param_tag_tracker |= PARAM_LAB_CONTROL_BIT;
+ if (err >= 0) {
+ str_parms_del(parms, ST_PARAM_KEY_PDK5_APP_TYPE);
+ lsm_params->pdk5_app_type = strtoul(str_value, NULL, 16);
+ }
}
if (is_legacy_version == false) {
@@ -2230,17 +2442,55 @@
}
}
- list_add_tail(&sm_info->lsm_usecase_list, &lsm_params->list_node);
free(kv_pairs);
return 0;
err_exit:
+ list_for_each_safe(module_node, tmp_node,
+ &lsm_params->module_params_list) {
+ module_params = node_to_item(module_node, struct st_module_params,
+ list_node);
+ list_remove(module_node);
+ free(module_params);
+ }
if (lsm_params)
free(lsm_params);
free(kv_pairs);
return ret;
}
+static int platform_stdev_create_lsm_params
+(
+ void *platform
+)
+{
+ struct platform_data *my_data = (struct platform_data *)platform;
+ struct st_vendor_info *sm_info = NULL;
+ struct st_lsm_params *lsm_params = NULL;
+ struct listnode *sm_info_node = NULL;
+
+ sm_info_node = list_tail(&my_data->stdev->vendor_uuid_list);
+ if (sm_info_node) {
+ sm_info = node_to_item(sm_info_node, struct st_vendor_info, list_node);
+ } else {
+ ALOGE("%s: found NULL sm_info", __func__);
+ return -EINVAL;
+ }
+
+ lsm_params = calloc(1, sizeof(struct st_lsm_params));
+ if (!lsm_params) {
+ ALOGE("%s: lsm_params allcoation failed", __func__);
+ return -ENOMEM;
+ }
+
+ if (my_data->xml_version > PLATFORM_XML_VERSION_0x0105)
+ list_init(&lsm_params->module_params_list);
+
+ list_add_tail(&sm_info->lsm_usecase_list, &lsm_params->list_node);
+
+ return 0;
+}
+
static int platform_stdev_create_sm_config_params
(
void *platform
@@ -2293,16 +2543,18 @@
{
struct platform_data *my_data = (struct platform_data *)platform;
sound_trigger_device_t *stdev = my_data->stdev;
- struct listnode *sm_info_node, *gcs_node, *arm_node, *lsm_node;
+ struct listnode *sm_info_node = NULL, *gcs_node = NULL;
+ struct listnode *arm_node = NULL, *lsm_node = NULL, *module_node = NULL;
+ struct listnode *tmp_node = NULL, *tmp_node1 = NULL;
struct st_vendor_info *sm_info = NULL;
char str_value[ST_MAX_STRING_PARAM_SIZE];
char *kv_pairs = str_parms_to_str(parms);
- int ret = 0, err, value;
- struct listnode *tmp_node;
- struct st_gcs_params *gcs_params;
- struct st_arm_ss_params *arm_params;
- struct st_lsm_ss_params *lsm_ss_params;
- struct st_lsm_params *lsm_params;
+ int ret = 0, err = 0, value = 0;
+ struct st_gcs_params *gcs_params = NULL;
+ struct st_arm_ss_params *arm_params = NULL;
+ struct st_lsm_ss_params *lsm_ss_params = NULL;
+ struct st_lsm_params *lsm_params = NULL;
+ struct st_module_params *module_params = NULL;
ALOGV("%s: enter: %s", __func__, kv_pairs);
if (kv_pairs == NULL) {
@@ -2575,6 +2827,13 @@
list_for_each_safe(lsm_node, tmp_node, &sm_info->lsm_usecase_list) {
lsm_params = node_to_item(lsm_node, struct st_lsm_params, list_node);
list_remove(lsm_node);
+ list_for_each_safe(module_node, tmp_node1,
+ &lsm_params->module_params_list) {
+ module_params = node_to_item(module_node, struct st_module_params,
+ list_node);
+ list_remove(module_node);
+ free(module_params);
+ }
free(lsm_params);
}
list_remove(sm_info_node);
@@ -2769,8 +3028,11 @@
my_data->st_xml_tag = TAG_GCS_USECASE;
} else if (!strcmp(tag_name, "lsm_usecase")) {
my_data->st_xml_tag = TAG_LSM_USECASE;
+ platform_stdev_create_lsm_params(my_data);
} else if (!strcmp(tag_name, "lsm_ss_usecase")) {
my_data->st_xml_tag = TAG_LSM_SS_USECASE;
+ } else if (!strcmp(tag_name, "module_params")) {
+ my_data->st_xml_tag = TAG_MODULE_PARAMS;
} else if (!strcmp(tag_name, "adm_config")) {
my_data->st_xml_tag = TAG_ADM_CFG;
} else if (!strcmp(tag_name, "backend_type")) {
@@ -2786,6 +3048,7 @@
(my_data->st_xml_tag != TAG_GCS_USECASE) &&
(my_data->st_xml_tag != TAG_LSM_USECASE) &&
(my_data->st_xml_tag != TAG_LSM_SS_USECASE) &&
+ (my_data->st_xml_tag != TAG_MODULE_PARAMS) &&
(my_data->st_xml_tag != TAG_ADM_CFG) &&
(my_data->st_xml_tag != TAG_BACKEND_TYPE) &&
(my_data->st_xml_tag != TAG_LPMA_CONFIG) &&
@@ -2844,6 +3107,9 @@
} else if (!strcmp(tag_name, "lsm_usecase")) {
platform->st_xml_tag = TAG_SOUND_MODEL;
platform_stdev_set_lsm_params(platform, platform->kvpairs);
+ } else if (!strcmp(tag_name, "module_params")) {
+ platform->st_xml_tag = TAG_LSM_USECASE;
+ platform_stdev_set_module_params(platform, platform->kvpairs);
} else if (!strcmp(tag_name, "sound_model_config")) {
platform->st_xml_tag = TAG_ROOT;
platform_stdev_set_sm_config_params(platform, platform->kvpairs);
@@ -3929,14 +4195,16 @@
void platform_stdev_deinit(void *platform)
{
struct platform_data *my_data = (struct platform_data *)platform;
- struct listnode *v_node, *temp_node, *gcs_node, *temp_node1;
- struct listnode *arm_node, *lsm_node, *mk_node;
- struct st_vendor_info* v_info;
- struct st_gcs_params *gcs_info;
- struct meta_key_list *key_info;
- struct st_arm_ss_params *arm_info;
- struct st_lsm_ss_params *lsm_ss_info;
- struct st_lsm_params *lsm_info;
+ struct listnode *v_node = NULL, *temp_node = NULL, *gcs_node = NULL;
+ struct listnode *temp_node1 = NULL, *temp_node2 = NULL, *module_node = NULL;
+ struct listnode *arm_node = NULL, *lsm_node = NULL, *mk_node = NULL;
+ struct st_vendor_info* v_info = NULL;
+ struct st_gcs_params *gcs_info = NULL;
+ struct meta_key_list *key_info = NULL;
+ struct st_arm_ss_params *arm_info = NULL;
+ struct st_lsm_ss_params *lsm_ss_info = NULL;
+ struct st_lsm_params *lsm_info = NULL;
+ struct st_module_params *module_info = NULL;
ALOGI("%s: Enter", __func__);
if (my_data) {
@@ -3962,6 +4230,13 @@
list_for_each_safe(lsm_node, temp_node1, &v_info->lsm_usecase_list) {
lsm_info = node_to_item(lsm_node, struct st_lsm_params, list_node);
list_remove(lsm_node);
+ list_for_each_safe(module_node, temp_node2,
+ &lsm_info->module_params_list) {
+ module_info = node_to_item(module_node, struct st_module_params,
+ list_node);
+ list_remove(module_node);
+ free(module_info);
+ }
free(lsm_info);
}
@@ -5092,13 +5367,37 @@
return ret;
}
+bool platform_get_module_params_for_lsm_usecase
+(
+ struct st_lsm_params *usecase,
+ st_module_type_t sm_version
+)
+{
+ struct listnode *module_node = NULL, *tmp_node = NULL;
+ struct st_module_params *module_info = NULL;
+
+ list_for_each_safe(module_node, tmp_node, &usecase->module_params_list) {
+ module_info = node_to_item(module_node, struct st_module_params,
+ list_node);
+ if (module_info->type == sm_version) {
+ memcpy((uint8_t *)usecase->params, (uint8_t *)module_info->params,
+ sizeof(struct st_module_param_info) * MAX_PARAM_IDS);
+ usecase->param_tag_tracker = module_info->param_tag_tracker;
+ return true;
+ }
+ }
+
+ return false;
+}
+
void platform_get_lsm_usecase
(
void* platform,
struct st_vendor_info* v_info,
struct st_lsm_params** lsm_usecase,
st_exec_mode_t exec_mode,
- bool lpi_enable
+ bool lpi_enable,
+ st_module_type_t sm_version
)
{
struct st_lsm_params *usecase = NULL;
@@ -5107,6 +5406,7 @@
audio_devices_t capture_device =
platform_stdev_get_capture_device(platform);
sound_trigger_device_t *stdev = my_data->stdev;
+ bool set_module_params = false;
ALOGV("%s: Enter", __func__);
@@ -5152,12 +5452,26 @@
(usecase->lpi_enable == ST_PLATFORM_LPI_DISABLE &&
!lpi_enable && !stdev->barge_in_mode))) {
*lsm_usecase = usecase;
+ if (my_data->xml_version == PLATFORM_XML_VERSION_0x0106) {
+ set_module_params =
+ platform_get_module_params_for_lsm_usecase(usecase,
+ sm_version);
+ if (!set_module_params) {
+ ALOGE("%s: Error. No matching module info params.",
+ __func__);
+ return;
+ }
+ }
v_info->in_channels = usecase->in_channels;
v_info->fluence_type = usecase->fluence_type;
v_info->profile_type = usecase->adm_cfg_profile;
v_info->shared_buf_fmt =
get_shared_buf_fmt(v_info->profile_type);
- v_info->app_type = usecase->app_type;
+ if (sm_version == ST_MODULE_TYPE_PDK5) {
+ v_info->app_type = usecase->pdk5_app_type;
+ } else {
+ v_info->app_type = usecase->app_type;
+ }
return;
}
} else {
diff --git a/sound_trigger_platform.h b/sound_trigger_platform.h
index 3686e5e..ffe3af8 100644
--- a/sound_trigger_platform.h
+++ b/sound_trigger_platform.h
@@ -76,6 +76,7 @@
#define PLATFORM_XML_VERSION_0x0102 0x0102
#define PLATFORM_XML_VERSION_0x0103 0x0103
#define PLATFORM_XML_VERSION_0x0105 0x0105
+#define PLATFORM_XML_VERSION_0x0106 0x0106
/* Default ACDB ids. TODO-V: can be removed as default xml is anyway hosting these */
#define DEVICE_HANDSET_APE_ACDB_ID (127)
@@ -279,13 +280,28 @@
ST_PLATFORM_LPI_DISABLE_AND_BARGE_IN
} st_platform_lpi_enable_t;
+typedef enum {
+ ST_MODULE_TYPE_CUSTOM = 1,
+ ST_MODULE_TYPE_GMM = 3,
+ ST_MODULE_TYPE_PDK5 = 5
+} st_module_type_t;
+
+struct st_module_params {
+ struct listnode list_node;
+ int type;
+ int param_tag_tracker;
+ struct st_module_param_info params[MAX_PARAM_IDS];
+};
+
struct st_lsm_params {
struct listnode list_node;
st_exec_mode_t exec_mode;
int app_type;
+ int pdk5_app_type;
int in_channels;
int in_channels_lpi;
int param_tag_tracker;
+ struct listnode module_params_list;
struct st_module_param_info params[MAX_PARAM_IDS];
st_profile_type_t adm_cfg_profile;
audio_devices_t capture_device;
@@ -682,7 +698,8 @@
struct st_vendor_info* v_info,
struct st_lsm_params** lsm_usecase,
st_exec_mode_t exec_mode,
- bool lpi_enable
+ bool lpi_enable,
+ st_module_type_t sm_version
);
int platform_stdev_get_xml_version(void* platform);
diff --git a/st_common_defs.h b/st_common_defs.h
index f9a88ca..3b0eb34 100644
--- a/st_common_defs.h
+++ b/st_common_defs.h
@@ -113,6 +113,8 @@
#define KEY_ID_CONFIDENCE_LEVELS (0x2000)
#define KEY_ID_KEYWORD_POSITION_STATS (0x2001)
+#define KEY_ID_TIMESTAMP_INFO (0x2002)
+#define KEY_ID_MULTI_MODEL_RESULT_INFO (0x2004)
#define DLSYM(handle, ptr, symbol, err) \
do {\
diff --git a/st_hw_common.c b/st_hw_common.c
index e0dab3d..1255c43 100644
--- a/st_hw_common.c
+++ b/st_hw_common.c
@@ -413,22 +413,21 @@
hist_buf = (struct st_hist_buffer_info *) payload_buf;
hist_buf->version = DEFAULT_CUSTOM_CONFIG_MINOR_VERSION;
-
- hist_buf->pre_roll_duration_msec = p_ses->sthw_cfg.client_req_preroll;
+ hist_buf->pre_roll_duration_msec = p_ses->max_preroll;
if (p_ses->is_generic_event &&
- p_ses->sthw_cfg.client_req_preroll < PREROLL_LEN_WARNING)
+ p_ses->max_preroll < PREROLL_LEN_WARNING)
ALOGW("%s: Client requested small preroll length %dms",
- __func__, p_ses->sthw_cfg.client_req_preroll);
+ __func__, p_ses->max_preroll);
- if (p_ses->sthw_cfg.client_req_hist_buf > 0) {
+ if (p_ses->max_hist_buf > 0) {
hist_buf->hist_buffer_duration_msec =
- p_ses->sthw_cfg.client_req_hist_buf;
+ p_ses->max_hist_buf;
if (p_ses->is_generic_event &&
- p_ses->sthw_cfg.client_req_hist_buf <= KW_LEN_WARNING)
- ALOGW("%s: Client requested small hist buf length %dms",
- __func__, p_ses->sthw_cfg.client_req_hist_buf);
+ p_ses->max_hist_buf <= KW_LEN_WARNING)
+ ALOGW("%s: Client requested small hist buf length %dms",
+ __func__, p_ses->max_hist_buf);
} else {
hist_buf->hist_buffer_duration_msec =
p_ses->vendor_uuid_info->kw_duration;
diff --git a/st_hw_session.h b/st_hw_session.h
index 6188d10..37f1dc9 100644
--- a/st_hw_session.h
+++ b/st_hw_session.h
@@ -71,12 +71,12 @@
typedef void (*hw_ses_event_callback_t)(st_hw_sess_event_t *event, void *cookie);
struct st_hw_ses_config {
+ struct listnode sthw_cfg_list_node;
+ unsigned int model_id;
unsigned int client_req_hist_buf;
unsigned int client_req_preroll;
unsigned char *conf_levels;
unsigned int num_conf_levels;
- char *custom_data;
- unsigned int custom_data_size;
};
struct st_hw_session {
@@ -115,8 +115,16 @@
uint64_t second_stage_det_event_time;
st_buffer_t *buffer;
- struct st_hw_ses_config sthw_cfg;
+ struct listnode sthw_cfg_list;
+ uint32_t max_hist_buf;
+ uint32_t max_preroll;
bool sthw_cfg_updated;
+ char *custom_data;
+ unsigned int custom_data_size;
+ unsigned int num_reg_sm;
+
+ st_module_type_t f_stage_version;
+ uint32_t detected_preroll;
};
typedef struct st_hw_session st_hw_session_t;
@@ -124,18 +132,16 @@
/* Function pointers to routing layers */
typedef void (*sound_trigger_init_session_t)(st_hw_session_t *);
typedef int (*sound_trigger_reg_sm_t)(st_hw_session_t *,
- void*, unsigned int, sound_trigger_sound_model_type_t sm_type);
+ void*, unsigned int, uint32_t);
typedef int (*sound_trigger_reg_sm_params_t)(st_hw_session_t *,
unsigned int recognition_mode, bool capture_requested,
- struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type, void * sm_data);
+ struct sound_trigger_recognition_config *rc_config);
-typedef int (*sound_trigger_dereg_sm_t)(st_hw_session_t *);
+typedef int (*sound_trigger_dereg_sm_t)(st_hw_session_t *, uint32_t);
typedef int (*sound_trigger_dereg_sm_params_t)(st_hw_session_t *);
typedef int (*sound_trigger_start_t)(st_hw_session_t *);
typedef int (*sound_trigger_restart_t)(st_hw_session_t *, unsigned int,
- struct sound_trigger_recognition_config *,
- sound_trigger_sound_model_type_t, void *);
+ struct sound_trigger_recognition_config *);
typedef int (*sound_trigger_stop_t)(st_hw_session_t *);
typedef int (*sound_trigger_stop_buffering_t)(st_hw_session_t *);
typedef int (*sound_trigger_set_device_t)(st_hw_session_t *, bool);
diff --git a/st_hw_session_gcs.c b/st_hw_session_gcs.c
index 5131651..7fa443d 100644
--- a/st_hw_session_gcs.c
+++ b/st_hw_session_gcs.c
@@ -57,24 +57,21 @@
static int reg_sm(st_hw_session_t *p_ses,
void *sm_data, unsigned int sm_size,
- sound_trigger_sound_model_type_t sm_type);
+ uint32_t model_id);
static int reg_sm_params(st_hw_session_t *p_ses,
unsigned int recognition_mode,
bool capture_requested,
- struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type,
- void *sm_data);
+ struct sound_trigger_recognition_config *rc_config);
static int read_pcm(st_hw_session_t *p_ses,
unsigned char *buf,
unsigned int bytes);
static void process_lab_capture(st_hw_session_t *p_ses);
-static int dereg_sm(st_hw_session_t *p_ses);
+static int dereg_sm(st_hw_session_t *p_ses, uint32_t model_id __unused);
static int dereg_sm_params(st_hw_session_t *p_ses);
static int start(st_hw_session_t *p_ses);
static int restart(st_hw_session_t *p_ses,
unsigned int recognition_mode,
- struct sound_trigger_recognition_config *rc_config __unused,
- sound_trigger_sound_model_type_t sm_type, void *sm_data);
+ struct sound_trigger_recognition_config *rc_config __unused);
static int stop(st_hw_session_t *p_ses);
static int stop_buffering(st_hw_session_t *p_ses);
static int set_device(st_hw_session_t *p_ses,
@@ -509,7 +506,7 @@
}
static int reg_sm(st_hw_session_t *p_ses, void *sm_data,
- unsigned int sm_size, sound_trigger_sound_model_type_t sm_type __unused)
+ unsigned int sm_size, uint32_t model_id __unused)
{
int status = 0;
uint8_t *load_sm_msg = NULL;
@@ -676,9 +673,7 @@
static int reg_sm_params(st_hw_session_t *p_ses,
unsigned int recognition_mode,
bool capture_requested,
- struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type __unused,
- void *sm_data __unused)
+ struct sound_trigger_recognition_config *rc_config)
{
st_hw_session_gcs_t *p_hw_ses = (st_hw_session_gcs_t *)p_ses;
uint8_t *msg_offset = NULL;
@@ -692,6 +687,8 @@
struct gcs_det_engine_start_custom_config *stcfg_msg = NULL;
struct gcs_det_event_type_custom_config *det_event_msg = NULL;
struct st_vendor_info *v_info = p_ses->vendor_uuid_info;
+ struct listnode *node = NULL;
+ struct st_hw_ses_config *sthw_cfg = NULL;
bool disable_custom_config = false;
if (NULL != p_hw_ses->nonpersistent_cal) {
@@ -717,13 +714,22 @@
* it is, and it is assumed that it is formatted from within.
*/
+ if (!list_empty(&p_ses->sthw_cfg_list)) {
+ node = list_head(&p_ses->sthw_cfg_list);
+ sthw_cfg = node_to_item(node, struct st_hw_ses_config,
+ sthw_cfg_list_node);
+ } else {
+ ALOGE("%s: Unexpected, sthw_cfg list is empty", __func__);
+ return -EINVAL;
+ }
+
if ((rc_config->data_size > CUSTOM_CONFIG_OPAQUE_DATA_SIZE) &&
v_info->is_qcva_uuid) {
if (!capture_requested)
disable_custom_config = true;
det_config_size = sizeof(struct gcs_det_engine_config_param) +
- p_ses->sthw_cfg.num_conf_levels;
+ sthw_cfg->num_conf_levels;
det_config_size = ALIGN(det_config_size, 4);
p_hw_ses->nonpersistent_cal_size += det_config_size;
@@ -749,7 +755,7 @@
if (v_info->is_qcva_uuid || v_info->is_qcmd_uuid) {
det_config_size = sizeof(struct gcs_det_engine_config_param) +
- p_ses->sthw_cfg.num_conf_levels;
+ sthw_cfg->num_conf_levels;
/* If not using custom config param, send opaque data as part of
* DETECTION_ENGINE_CONFIG. Opaque data will be put after confidence
* level payload data.
@@ -830,20 +836,20 @@
}
msg_offset += sizeof(struct gcs_det_engine_config_param);
- if (p_ses->sthw_cfg.conf_levels) {
- memcpy(msg_offset, (uint8_t *)p_ses->sthw_cfg.conf_levels,
- p_ses->sthw_cfg.num_conf_levels);
- msg_offset += p_ses->sthw_cfg.num_conf_levels;
- p_msg->custom_payload_sz = p_ses->sthw_cfg.num_conf_levels;
+ if (sthw_cfg->conf_levels) {
+ memcpy(msg_offset, (uint8_t *)sthw_cfg->conf_levels,
+ sthw_cfg->num_conf_levels);
+ msg_offset += sthw_cfg->num_conf_levels;
+ p_msg->custom_payload_sz = sthw_cfg->num_conf_levels;
/*
* The detection_engine_config struct has 2 bytes for minor
* version and num_active_models before the confidence levels.
* There is also 1 byte added for each confidence level as an
* enable/disable flag.
*/
- for (i = 0; i < (p_ses->sthw_cfg.num_conf_levels - 2) / 2; i++) {
+ for (i = 0; i < (sthw_cfg->num_conf_levels - 2) / 2; i++) {
ALOGD("%s: First stage conf_levels[%d] = %d",
- __func__, i, *(p_ses->sthw_cfg.conf_levels + 2 + i));
+ __func__, i, *(sthw_cfg->conf_levels + 2 + i));
}
}
}
@@ -992,7 +998,7 @@
return status;
}
-static int dereg_sm(st_hw_session_t *p_ses)
+static int dereg_sm(st_hw_session_t *p_ses, uint32_t model_id __unused)
{
int status = 0, rc = 0;
st_hw_session_gcs_t *p_gcs_ses = (st_hw_session_gcs_t *)p_ses;
@@ -1096,8 +1102,7 @@
static int restart(st_hw_session_t *p_ses,
unsigned int recognition_mode __unused,
- struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type, void *sm_data)
+ struct sound_trigger_recognition_config *rc_config)
{
st_hw_session_gcs_t *p_gcs_ses = (st_hw_session_gcs_t *)p_ses;
struct graphite_cal_header restart_cfg;
@@ -1139,7 +1144,7 @@
}
status = reg_sm_params(p_ses, recognition_mode, p_ses->lab_enabled,
- rc_config, sm_type, sm_data);
+ rc_config);
if (status) {
ALOGE("%s: failed to reg_sm_params err %d", __func__, status);
goto exit;
@@ -1521,9 +1526,9 @@
prepend_bytes =
convert_ms_to_bytes(p_ses->vendor_uuid_info->kw_start_tolerance,
&p_ses->config);
- if (p_ses->sthw_cfg.client_req_hist_buf) {
+ if (p_ses->max_hist_buf) {
kw_duration_bytes =
- convert_ms_to_bytes(p_ses->sthw_cfg.client_req_hist_buf, &p_ses->config);
+ convert_ms_to_bytes(p_ses->max_hist_buf, &p_ses->config);
} else {
kw_duration_bytes =
convert_ms_to_bytes(p_ses->vendor_uuid_info->kw_duration,
@@ -1592,7 +1597,7 @@
pthread_mutex_unlock(&st_sec_stage->ss_session->lock);
}
- if (p_ses->enable_second_stage && !p_ses->sthw_cfg.client_req_hist_buf)
+ if (p_ses->enable_second_stage && !p_ses->max_hist_buf)
p_hw_ses->move_client_ptr = true;
else
p_hw_ses->move_client_ptr = false;
diff --git a/st_hw_session_lsm.c b/st_hw_session_lsm.c
index 1407618..cde7e06 100644
--- a/st_hw_session_lsm.c
+++ b/st_hw_session_lsm.c
@@ -64,12 +64,11 @@
#define DOA_POLAR_ACTIVITY_INDICATORS 360
static int ape_reg_sm(st_hw_session_t* p_ses, void *sm_data,
- unsigned int sm_size, sound_trigger_sound_model_type_t sm_type);
+ unsigned int sm_size, uint32_t model_id);
static int ape_reg_sm_params(st_hw_session_t* p_ses, unsigned int recognition_mode,
- bool capture_requested, struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type, void *sm_data);
+ bool capture_requested, struct sound_trigger_recognition_config *rc_config);
-static int ape_dereg_sm(st_hw_session_t* p_ses);
+static int ape_dereg_sm(st_hw_session_t* p_ses, uint32_t model_id);
static int ape_dereg_sm_params(st_hw_session_t* p_ses);
static int ape_start(st_hw_session_t* p_ses);
static int ape_stop(st_hw_session_t* p_ses);
@@ -77,18 +76,15 @@
/* Routing layer functions */
static int route_reg_sm_ape(st_hw_session_t *p_ses,
- void *sm_data, unsigned int sm_size, sound_trigger_sound_model_type_t sm_type);
+ void *sm_data, unsigned int sm_size, uint32_t model_id);
static int route_reg_sm_params_ape(st_hw_session_t* p_ses,
unsigned int recognition_mode, bool capture_requested,
- struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type, void *sm_data);
-static int route_dereg_sm_ape(st_hw_session_t* p_ses);
+ struct sound_trigger_recognition_config *rc_config);
+static int route_dereg_sm_ape(st_hw_session_t* p_ses, uint32_t model_id);
static int route_dereg_sm_params_ape(st_hw_session_t* p_ses);
static int route_restart_ape(st_hw_session_t* p_ses,
unsigned int recognition_mode,
- struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type,
- void *sm_data);
+ struct sound_trigger_recognition_config *rc_config);
static int route_start_ape(st_hw_session_t* p_ses);
static int route_stop_ape(st_hw_session_t* p_ses);
static int route_stop_buffering_ape(st_hw_session_t* p_ses);
@@ -484,13 +480,19 @@
st_lsm_det_event_type_t *det_event_type,
lsm_param_info_t *det_event_type_params,
struct st_module_param_info *mparams,
- uint16_t stage_idx
+ uint16_t stage_idx,
+ st_module_type_t version
)
{
/* fill event type params */
det_event_type->event_type = LSM_DET_EVENT_TYPE_GENERIC;
/* request for confidence level and timestamp */
- det_event_type->mode = ACD_CONFIDENCE_LEVELS_BIT | ACD_TIME_STAMP_INFO_BIT;
+ if (version == ST_MODULE_TYPE_PDK5)
+ det_event_type->mode = DET_EVENT_MULTI_MODEL_RESULT_INFO_BIT;
+ else
+ det_event_type->mode =
+ DET_EVENT_CONFIDENCE_LEVELS_BIT | DET_EVENT_KEYWORD_INDEX_BIT |
+ DET_EVENT_TIMESTAMP_INFO_BIT;
det_event_type_params->param_size = sizeof(*det_event_type);
det_event_type_params->param_data = (unsigned char *)det_event_type;
@@ -504,7 +506,8 @@
st_lsm_det_event_type_t *det_event_type __unused,
lsm_param_info_t *det_event_type_params __unused,
struct st_module_param_info *mparams __unused,
- uint16_t stage_idx __unused
+ uint16_t stage_idx __unused,
+ st_module_type_t version __unused
)
{
return false;
@@ -628,7 +631,15 @@
* but the client did not request LAB. The client read pointer will be shifted
* to the keyword end index in this usecase.
*/
- delay_bytes = p_ses->common.kw_end_idx;
+
+ if (p_ses->common.enable_second_stage &&
+ !p_ses->common.max_hist_buf)
+ delay_bytes = p_ses->common.kw_end_idx;
+ else
+ delay_bytes = convert_ms_to_bytes(
+ (p_ses->common.max_preroll - p_ses->common.detected_preroll),
+ &p_ses->common.config);
+
move_bytes = MIN(delay_bytes, p_ses->unread_bytes);
ALOGD("%s: Moving client ptr by %d bytes", __func__, move_bytes);
st_buffer_flush(p_ses->common.buffer, move_bytes);
@@ -819,10 +830,10 @@
st_buffer_reset(p_lsm_ses->common.buffer);
if (p_lsm_ses->common.enable_second_stage) {
- if (p_lsm_ses->common.sthw_cfg.client_req_hist_buf) {
+ if (p_lsm_ses->common.max_hist_buf) {
kw_duration_bytes =
convert_ms_to_bytes(
- p_lsm_ses->common.sthw_cfg.client_req_hist_buf,
+ p_lsm_ses->common.max_hist_buf,
&p_lsm_ses->common.config);
} else {
kw_duration_bytes =
@@ -929,8 +940,10 @@
pthread_mutex_unlock(&st_sec_stage->ss_session->lock);
}
- if (p_lsm_ses->common.enable_second_stage &&
- !p_lsm_ses->common.sthw_cfg.client_req_hist_buf)
+ if ((p_lsm_ses->common.enable_second_stage &&
+ !p_lsm_ses->common.max_hist_buf) ||
+ (p_lsm_ses->common.detected_preroll <
+ p_lsm_ses->common.max_preroll))
p_lsm_ses->move_client_ptr = true;
else
p_lsm_ses->move_client_ptr = false;
@@ -1059,6 +1072,18 @@
ALOGI("%s:[%d] Received %s status=%d",
__func__, p_lsm_ses->common.sm_handle, st_lsm_event_cmd, status);
+
+ /*
+ * For Multi SM usecases, other keywords can get detected while
+ * LAB buffering is active for another keyword. This dual buffering
+ * is not supported, so the event will be ignored.
+ */
+ if (p_lsm_ses->lab_processing_active) {
+ ALOGI("%s: LAB buffering is active, ignore detection event",
+ __func__);
+ continue;
+ }
+
if (status < 0) {
if (errno == ENOMEM) {
payload_alloc_size = payload_alloc_size << 1;
@@ -1210,10 +1235,10 @@
p_lsm_ses->common.config.channels *
(pcm_format_to_bits(p_lsm_ses->common.config.format) >> 3));
- if ((p_lsm_ses->common.sthw_cfg.client_req_hist_buf +
- p_lsm_ses->common.sthw_cfg.client_req_preroll) > v_info->kw_duration) {
- circ_buff_sz = ((p_lsm_ses->common.sthw_cfg.client_req_hist_buf +
- p_lsm_ses->common.sthw_cfg.client_req_preroll +
+ if ((p_lsm_ses->common.max_hist_buf +
+ p_lsm_ses->common.max_preroll) > v_info->kw_duration) {
+ circ_buff_sz = ((p_lsm_ses->common.max_hist_buf +
+ p_lsm_ses->common.max_preroll +
v_info->client_capture_read_delay) * rt_bytes_one_sec) / 1000;
} else {
circ_buff_sz = ((v_info->kw_duration +
@@ -1267,7 +1292,7 @@
status = platform_stdev_check_and_set_codec_backend_cfg(
p_ses->stdev->platform, v_info, &backend_cfg_change,
p_ses->stdev->lpi_enable, p_ses->stdev->vad_enable,
- p_ses->sthw_cfg.client_req_preroll);
+ p_ses->max_preroll);
if (status) {
ALOGE("%s: ERROR. codec backend config update failed, status=%d",
@@ -1339,7 +1364,7 @@
update_hw_mad_exec_mode(p_ses->exec_mode, profile_type);
++(p_ses->stdev->dev_enable_cnt[ref_enable_idx]);
} else {
- ALOGD("%s: Device already enabled, no not re-enable",
+ ALOGD("%s: Device already enabled, do not re-enable",
__func__);
}
}
@@ -1390,8 +1415,53 @@
return status;
}
+static int set_param_reg_multi_sm(st_hw_session_lsm_t *p_ses, void *sm_data,
+ unsigned int sm_size, uint32_t model_id)
+{
+ st_lsm_reg_sm_header_t sm_header = {0};
+ unsigned int sm_payload_size =
+ sizeof(st_lsm_reg_sm_header_t) + sm_size;
+ uint8_t *sm_payload = NULL;
+ int status = 0;
+ lsm_param_info_t param_info = {0};
+ struct snd_lsm_module_params lsm_params = {0};
+ struct st_module_param_info *mparams = NULL;
+
+ mparams = p_ses->lsm_usecase->params;
+ sm_header.model_id = model_id;
+ sm_header.model_size = sm_size;
+ sm_payload = calloc(1, sm_payload_size);
+ if (!sm_payload) {
+ ALOGE("%s: ERROR. Cannot allocate memory for sm_payload", __func__);
+ return -ENOMEM;
+ }
+ memcpy(sm_payload, (uint8_t *)&sm_header, sizeof(sm_header));
+ memcpy(sm_payload + sizeof(sm_header), (uint8_t *)sm_data, sm_size);
+ param_info.param_data = sm_payload;
+ param_info.param_size = sm_payload_size;
+#if (SNDRV_LSM_VERSION >= SNDRV_PROTOCOL_VERSION(0, 3, 2))
+ param_info.model_id = model_id;
+ lsm_fill_param_info(LSM_REG_MULTI_SND_MODEL, ¶m_info,
+ &mparams[LOAD_SOUND_MODEL],
+ LSM_STAGE_INDEX_FIRST);
+#endif
+ lsm_params.params = (unsigned char*)¶m_info;
+ lsm_params.num_params = 1;
+ lsm_params.data_size = sizeof(lsm_param_info_t);
+ status = lsm_set_module_params(p_ses, &lsm_params);
+ if (status) {
+ ALOGE("%s: ERROR. registering sound model. status %d",
+ __func__, status);
+ }
+
+ free(sm_payload);
+ sm_payload = NULL;
+
+ return status;
+}
+
static int ape_reg_sm(st_hw_session_t *p_ses, void *sm_data,
- unsigned int sm_size, sound_trigger_sound_model_type_t sm_type __unused)
+ unsigned int sm_size, uint32_t model_id)
{
int status = 0, param_count = 0, stage_idx = 0;
st_hw_session_lsm_t *p_lsm_ses = (st_hw_session_lsm_t*)p_ses;
@@ -1399,7 +1469,7 @@
struct snd_lsm_session_data ses_data;
struct snd_lsm_module_params lsm_params;
lsm_param_info_t param_info[LSM_MAX_STAGES_PER_SESSION];
- st_lsm_det_event_type_t det_event_type;
+ st_lsm_det_event_type_t det_event_type = {0};
pthread_attr_t attr;
struct listnode *node = NULL;
st_lsm_ss_config_t *ss_cfg = NULL;
@@ -1408,18 +1478,37 @@
ALOGD("%s:[%d] Enter", __func__, p_ses->sm_handle);
- p_lsm_ses->pcm_id = platform_ape_get_pcm_device_id(p_ses->stdev->platform,
- &p_ses->use_case_idx);
- if (p_lsm_ses->pcm_id < 0)
- return -ENODEV;
+ memset((uint8_t *)param_info, 0, sizeof(lsm_param_info_t) *
+ LSM_MAX_STAGES_PER_SESSION);
platform_get_lsm_usecase(p_ses->stdev->platform, v_info,
- &p_lsm_ses->lsm_usecase, p_ses->exec_mode, p_ses->lpi_enable);
+ &p_lsm_ses->lsm_usecase, p_ses->exec_mode, p_ses->lpi_enable,
+ p_ses->f_stage_version);
if (!p_lsm_ses->lsm_usecase) {
ALOGE("%s: couldn't get lsm usecase", __func__);
+ status = -EINVAL;
goto sm_error;
}
+ if (p_ses->f_stage_version == ST_MODULE_TYPE_PDK5 &&
+ p_ses->num_reg_sm > 0) {
+
+ status = set_param_reg_multi_sm(p_lsm_ses, sm_data, sm_size, model_id);
+ if (status) {
+ ALOGE("%s: ERROR. registering multi sound model. status %d",
+ __func__, status);
+ return status;
+ }
+ p_ses->num_reg_sm++;
+
+ return 0;
+ } else {
+ p_lsm_ses->pcm_id = platform_ape_get_pcm_device_id(
+ p_ses->stdev->platform, &p_ses->use_case_idx);
+ if (p_lsm_ses->pcm_id < 0)
+ return -ENODEV;
+ }
+
p_lsm_ses->num_stages = 1;
list_for_each(node, &p_ses->lsm_ss_cfg_list) {
p_lsm_ses->num_stages++;
@@ -1428,6 +1517,7 @@
!st_hw_check_multi_stage_lsm_support()) {
ALOGE("%s: lsm driver/dsp support for mult-stage(%d) session is missing",
__func__, p_lsm_ses->num_stages);
+ status = -EINVAL;
goto sm_error;
}
@@ -1521,36 +1611,51 @@
}
}
- /* Send Reg SM param for each stages */
- param_count = 0;
- stage_idx = LSM_STAGE_INDEX_FIRST;
- lsm_params.params = (unsigned char*)¶m_info[0];
- mparams = p_lsm_ses->lsm_usecase->params;
- param_info[param_count].param_data = sm_data;
- param_info[param_count].param_size = sm_size;
-
- lsm_fill_param_info(LSM_REG_SND_MODEL, ¶m_info[param_count++],
- &mparams[LOAD_SOUND_MODEL], stage_idx);
-
- list_for_each(node, &p_ses->lsm_ss_cfg_list) {
- ss_cfg = node_to_item(node, st_lsm_ss_config_t, list_node);
- mparams = ss_cfg->params->params;
- stage_idx++;
-
- param_info[param_count].param_size = ss_cfg->sm_size;
- param_info[param_count].param_data = ss_cfg->sm_data;
+ if (p_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ if (!LSM_MULTI_SM_SUPPORT) {
+ ALOGE("%s: Multi SM not supported in LSM, exiting",
+ __func__);
+ status = -EINVAL;
+ goto sm_error;
+ }
+ status = set_param_reg_multi_sm(p_lsm_ses, sm_data, sm_size, model_id);
+ if (status) {
+ ALOGE("%s: ERROR. registering multi sound model. status %d",
+ __func__, status);
+ goto sm_error;
+ }
+ p_ses->num_reg_sm++;
+ } else {
+ /* Send Reg SM param for each stages */
+ param_count = 0;
+ stage_idx = LSM_STAGE_INDEX_FIRST;
+ lsm_params.params = (unsigned char*)¶m_info[0];
+ mparams = p_lsm_ses->lsm_usecase->params;
+ param_info[param_count].param_data = sm_data;
+ param_info[param_count].param_size = sm_size;
lsm_fill_param_info(LSM_REG_SND_MODEL, ¶m_info[param_count++],
&mparams[LOAD_SOUND_MODEL], stage_idx);
- }
- lsm_params.num_params = param_count;
- lsm_params.data_size =
- lsm_params.num_params * sizeof(lsm_param_info_t);
- status = lsm_set_module_params(p_lsm_ses, &lsm_params);
- if (status) {
- ALOGE("%s: ERROR. registering sound models. status %d",
- __func__, status);
- goto sm_error;
+ list_for_each(node, &p_ses->lsm_ss_cfg_list) {
+ ss_cfg = node_to_item(node, st_lsm_ss_config_t, list_node);
+ mparams = ss_cfg->params->params;
+ stage_idx++;
+
+ param_info[param_count].param_size = ss_cfg->sm_size;
+ param_info[param_count].param_data = ss_cfg->sm_data;
+ lsm_fill_param_info(LSM_REG_SND_MODEL, ¶m_info[param_count++],
+ &mparams[LOAD_SOUND_MODEL], stage_idx);
+ }
+
+ lsm_params.num_params = param_count;
+ lsm_params.data_size =
+ lsm_params.num_params * sizeof(lsm_param_info_t);
+ status = lsm_set_module_params(p_lsm_ses, &lsm_params);
+ if (status) {
+ ALOGE("%s: ERROR. registering sound models. status %d",
+ __func__, status);
+ goto sm_error;
+ }
}
/* Send detection event type for last stage only, if params set in config */
@@ -1567,7 +1672,8 @@
if (mparams) {
stage_idx = LSM_STAGE_INDEX_FIRST + p_lsm_ses->num_stages - 1;
if (fill_lsm_det_event_type_params(&det_event_type,
- ¶m_info[0], mparams, stage_idx)) {
+ ¶m_info[0], mparams, stage_idx,
+ p_ses->f_stage_version)) {
p_ses->is_generic_event = true;
lsm_params.num_params = 1;
@@ -1605,7 +1711,35 @@
return status;
}
-static int ape_dereg_sm(st_hw_session_t *p_ses)
+static int set_param_dereg_multi_sm(st_hw_session_lsm_t *p_ses,
+ uint32_t model_id)
+{
+ int status = 0;
+ lsm_param_info_t param_info = {0};
+ struct snd_lsm_module_params lsm_params = {0};
+ struct st_module_param_info *mparams = NULL;
+
+ mparams = p_ses->lsm_usecase->params;
+ param_info.param_size = sizeof(model_id);
+ param_info.param_data = (uint8_t *)&model_id;
+#if (SNDRV_LSM_VERSION >= SNDRV_PROTOCOL_VERSION(0, 3, 2))
+ param_info.model_id = model_id;
+ lsm_fill_param_info(LSM_DEREG_MULTI_SND_MODEL, ¶m_info,
+ &mparams[UNLOAD_SOUND_MODEL],
+ LSM_STAGE_INDEX_FIRST);
+#endif
+ lsm_params.params = (uint8_t *)¶m_info;
+ lsm_params.num_params = 1;
+ lsm_params.data_size = sizeof(lsm_param_info_t);
+ status = lsm_set_module_params(p_ses, &lsm_params);
+ if (status)
+ ALOGE("%s: ERROR. dereg multi sound model, status %d",
+ __func__, status);
+
+ return status;
+}
+
+static int ape_dereg_sm(st_hw_session_t *p_ses, uint32_t model_id)
{
int status = 0, buf_en = 0;
struct snd_lsm_module_params lsm_params;
@@ -1618,11 +1752,26 @@
ALOGD("%s:[%d] Enter", __func__, p_lsm_ses->common.sm_handle);
+ memset((uint8_t *)param_info, 0, sizeof(lsm_param_info_t) *
+ LSM_MAX_STAGES_PER_SESSION);
+
if (!p_lsm_ses->pcm) {
ALOGV("%s: pcm NULL", __func__);
return status;
}
+ if (p_ses->f_stage_version == ST_MODULE_TYPE_PDK5 &&
+ p_ses->num_reg_sm > 1) {
+
+ status = set_param_dereg_multi_sm(p_lsm_ses, model_id);
+ if (status) {
+ ALOGE("%s: ERROR. deregistering multi sound model. status %d",
+ __func__, status);
+ }
+ p_ses->num_reg_sm--;
+ return status;
+ }
+
/* Exit the callback thread waiting on event detection */
request_exit_callback_thread(p_lsm_ses);
@@ -1692,31 +1841,41 @@
}
/* Dereg Sound Models */
- stage_idx = LSM_STAGE_INDEX_FIRST;
- param_count = 0;
- lsm_params.params = (unsigned char*)¶m_info[0];
- mparams = p_lsm_ses->lsm_usecase->params;
+ if (p_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
- param_info[param_count].param_size = 0;
- lsm_fill_param_info(LSM_DEREG_SND_MODEL, ¶m_info[param_count++],
- &mparams[UNLOAD_SOUND_MODEL], stage_idx);
-
- list_for_each(node, &p_ses->lsm_ss_cfg_list) {
- stage_idx++;
- ss_cfg = node_to_item(node, st_lsm_ss_config_t, list_node);
- mparams = ss_cfg->params->params;
+ status = set_param_dereg_multi_sm(p_lsm_ses, model_id);
+ if (status) {
+ ALOGE("%s: ERROR. deregistering multi sound model. status %d",
+ __func__, status);
+ }
+ p_ses->num_reg_sm--;
+ } else {
+ stage_idx = LSM_STAGE_INDEX_FIRST;
+ param_count = 0;
+ lsm_params.params = (unsigned char*)¶m_info[0];
+ mparams = p_lsm_ses->lsm_usecase->params;
param_info[param_count].param_size = 0;
+
lsm_fill_param_info(LSM_DEREG_SND_MODEL, ¶m_info[param_count++],
&mparams[UNLOAD_SOUND_MODEL], stage_idx);
- }
- lsm_params.num_params = param_count;
- lsm_params.data_size =
- lsm_params.num_params * sizeof(lsm_param_info_t);
- status = lsm_set_module_params(p_lsm_ses, &lsm_params);
- if (status)
- ALOGE("%s: ERROR. dereg sound model module params, status %d",
- __func__, status);
+ list_for_each(node, &p_ses->lsm_ss_cfg_list) {
+ stage_idx++;
+ ss_cfg = node_to_item(node, st_lsm_ss_config_t, list_node);
+ mparams = ss_cfg->params->params;
+ param_info[param_count].param_size = 0;
+ lsm_fill_param_info(LSM_DEREG_SND_MODEL, ¶m_info[param_count++],
+ &mparams[UNLOAD_SOUND_MODEL], stage_idx);
+ }
+
+ lsm_params.num_params = param_count;
+ lsm_params.data_size =
+ lsm_params.num_params * sizeof(lsm_param_info_t);
+ status = lsm_set_module_params(p_lsm_ses, &lsm_params);
+ if (status)
+ ALOGE("%s: ERROR. dereg sound model module params, status %d",
+ __func__, status);
+ }
ATRACE_BEGIN("sthal:lsm: pcm_close");
pcm_close(p_lsm_ses->pcm);
@@ -1732,8 +1891,7 @@
static int ape_reg_sm_params(st_hw_session_t* p_ses,
unsigned int recognition_mode, bool capture_requested,
- struct sound_trigger_recognition_config *rc_config __unused,
- sound_trigger_sound_model_type_t sm_type __unused, void *sm_data __unused)
+ struct sound_trigger_recognition_config *rc_config __unused)
{
int status = 0, buf_en = 1, retry_num = 0, offset = 0;
int param_tag_tracker;
@@ -1747,22 +1905,24 @@
struct st_vendor_info *v_info = p_lsm_ses->common.vendor_uuid_info;
struct snd_lsm_module_params lsm_params;
lsm_param_info_t param_info[LSM_SM_PARAMS_INFO_MAX];
- lsm_param_info_t *cfl_params;
- lsm_param_info_t *op_params;
- lsm_param_info_t *cus_params;
- lsm_param_info_t *poll_en_params;
- lsm_param_info_t *lab_params;
- lsm_param_info_t *lab_dam_cfg_params;
+ lsm_param_info_t *cfl_params = NULL;
+ lsm_param_info_t *op_params = NULL;
+ lsm_param_info_t *cus_params = NULL;
+ lsm_param_info_t *poll_en_params = NULL;
+ lsm_param_info_t *lab_params = NULL;
+ lsm_param_info_t *lab_dam_cfg_params = NULL;
struct snd_lsm_detect_mode det_mode;
+ st_lsm_conf_levels_t conf_levels_payload[MAX_MULTI_SOUND_MODELS] = {0};
st_lsm_poll_enable_t poll_enable;
bool disable_custom_config = false;
struct listnode *node = NULL;
struct st_module_param_info *mparams = NULL;
st_lsm_ss_config_t *ss_cfg = NULL;
- int param_count = 0, stage_idx = 0;
+ int param_count = 0, stage_idx = 0, sm_count = 0;
struct lsm_param_custom_config custom_conf_params;
lsm_param_payload_t custom_conf_params_v2 = {0};
lsm_param_payload_t cus_dam_cfg_params = {0};
+ struct st_hw_ses_config *sthw_cfg = NULL;
ALOGD("%s:[%d] Enter", __func__, p_lsm_ses->common.sm_handle);
if (!p_lsm_ses->pcm) {
@@ -1770,6 +1930,9 @@
return status;
}
+ memset((uint8_t *)param_info, 0, sizeof(lsm_param_info_t) *
+ LSM_SM_PARAMS_INFO_MAX);
+
/*
* While dynamically switching ports,
* port info needs to be sent to driver before enabling usecase.
@@ -1796,7 +1959,7 @@
if (status)
goto error_exit;
- if ((p_ses->sthw_cfg.custom_data_size > CUSTOM_CONFIG_OPAQUE_DATA_SIZE) &&
+ if ((p_ses->custom_data_size > CUSTOM_CONFIG_OPAQUE_DATA_SIZE) &&
v_info->is_qcva_uuid && !capture_requested)
disable_custom_config = true;
@@ -1835,6 +1998,7 @@
det_mode.mode = LSM_MODE_USER_KEYWORD_DETECTION;
} else {
ALOGE("%s: Unknown recognition mode %d", __func__, recognition_mode);
+ status = -EINVAL;
goto error_exit_1;
}
ALOGD("%s: st_recogntion_mode %d, det_mode %d, lab %d", __func__,
@@ -1856,17 +2020,68 @@
det_mode.mode, det_mode.detect_failure, capture_requested);
if (param_tag_tracker & PARAM_CONFIDENCE_LEVELS_BIT) {
/* fill confidence level params */
- cfl_params = ¶m_info[param_count++];
- cfl_params->param_size = p_ses->sthw_cfg.num_conf_levels;
- cfl_params->param_data = p_ses->sthw_cfg.conf_levels;
- lsm_fill_param_info(LSM_MIN_CONFIDENCE_LEVELS, cfl_params,
- &mparams[CONFIDENCE_LEVELS], stage_idx);
- {
- unsigned int i;
- ALOGV("%s: ncl %d", __func__, cfl_params->param_size);
- for (i = 0; i < cfl_params->param_size; i++) {
- ALOGD("%s: First stage conf_levels[%d] = %d",
- __func__, i, cfl_params->param_data[i]);
+ if (p_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ list_for_each(node, &p_ses->sthw_cfg_list) {
+ sthw_cfg = node_to_item(node, struct st_hw_ses_config,
+ sthw_cfg_list_node);
+
+ conf_levels_payload[sm_count].model_id =
+ sthw_cfg->model_id;
+ conf_levels_payload[sm_count].num_conf_levels =
+ sthw_cfg->num_conf_levels;
+ /*
+ * If a sound model is in loaded state while another
+ * is active, its num_conf_levels will be 0 and the
+ * conf levels array will have the max value. Set the
+ * num to 1 so that it can get sent properly to DSP.
+ */
+ if (!conf_levels_payload[sm_count].num_conf_levels)
+ conf_levels_payload[sm_count].num_conf_levels = 1;
+ ALOGV("%s: ncl %d", __func__,
+ conf_levels_payload[sm_count].num_conf_levels);
+ for (int i = 0;
+ i < conf_levels_payload[sm_count].num_conf_levels;
+ i++) {
+ conf_levels_payload[sm_count].conf_levels[i] =
+ *(sthw_cfg->conf_levels + i);
+ ALOGD("%s: 1st stage cl for m_id[%d], kw_id[%d] = %d",
+ __func__, sthw_cfg->model_id, i,
+ conf_levels_payload[sm_count].conf_levels[i]);
+ }
+ cfl_params = ¶m_info[param_count++];
+ cfl_params->param_size =
+ conf_levels_payload[sm_count].num_conf_levels;
+ cfl_params->param_data =
+ (uint8_t *)&conf_levels_payload[sm_count].conf_levels;
+#if (SNDRV_LSM_VERSION >= SNDRV_PROTOCOL_VERSION(0, 3, 2))
+ cfl_params->model_id = sthw_cfg->model_id;
+ lsm_fill_param_info(LSM_MULTI_SND_MODEL_CONFIDENCE_LEVELS,
+ cfl_params, &mparams[CONFIDENCE_LEVELS], stage_idx);
+#endif
+ sm_count++;
+ }
+ } else {
+ if (!list_empty(&p_ses->sthw_cfg_list)) {
+ node = list_head(&p_ses->sthw_cfg_list);
+ sthw_cfg = node_to_item(node, struct st_hw_ses_config,
+ sthw_cfg_list_node);
+ } else {
+ ALOGE("%s: Unexpected, sthw_cfg list is empty", __func__);
+ status = -EINVAL;
+ goto error_exit_1;
+ }
+ cfl_params = ¶m_info[param_count++];
+ cfl_params->param_size = sthw_cfg->num_conf_levels;
+ cfl_params->param_data = sthw_cfg->conf_levels;
+ lsm_fill_param_info(LSM_MIN_CONFIDENCE_LEVELS, cfl_params,
+ &mparams[CONFIDENCE_LEVELS], stage_idx);
+ {
+ unsigned int i;
+ ALOGV("%s: ncl %d", __func__, cfl_params->param_size);
+ for (i = 0; i < cfl_params->param_size; i++) {
+ ALOGD("%s: First stage conf_levels[%d] = %d",
+ __func__, i, cfl_params->param_data[i]);
+ }
}
}
}
@@ -1890,7 +2105,7 @@
* Custom config is mandatory for adsp multi-stage session,
* Default config would be sent if not explicitly set from client applicaiton.
*/
- if ((p_ses->sthw_cfg.custom_data_size && !disable_custom_config) ||
+ if ((p_ses->custom_data_size && !disable_custom_config) ||
!list_empty(&p_ses->lsm_ss_cfg_list)) {
/* fill opaque data as custom params */
cus_params = ¶m_info[param_count++];
@@ -1950,8 +2165,8 @@
/* copy opaque data from recognition config to payload */
if (v_info->is_qcva_uuid &&
- ((p_ses->sthw_cfg.custom_data_size == 0) ||
- (p_ses->sthw_cfg.custom_data_size >
+ ((p_ses->custom_data_size == 0) ||
+ (p_ses->custom_data_size >
CUSTOM_CONFIG_OPAQUE_DATA_SIZE))) {
st_hw_ses_get_hist_buff_payload(p_ses,
(uint8_t *)custom_payload + offset,
@@ -1959,8 +2174,8 @@
} else {
/* copy opaque data from recognition config to payload */
memcpy((char *)custom_payload + offset,
- p_ses->sthw_cfg.custom_data,
- p_ses->sthw_cfg.custom_data_size);
+ p_ses->custom_data,
+ p_ses->custom_data_size);
}
} else {
/*
@@ -1968,15 +2183,15 @@
* Using legacy custom param where app needs to form appropriate
* payload.
*/
- custom_payload_size = p_ses->sthw_cfg.custom_data_size;
+ custom_payload_size = p_ses->custom_data_size;
custom_payload = calloc(1, custom_payload_size);
if (!custom_payload) {
ALOGE("%s: ERROR. Cannot allocate memory for custom_payload",
__func__);
goto error_exit_1;
}
- memcpy(custom_payload, p_ses->sthw_cfg.custom_data,
- p_ses->sthw_cfg.custom_data_size);
+ memcpy(custom_payload, p_ses->custom_data,
+ p_ses->custom_data_size);
}
cus_params->param_size = custom_payload_size;
cus_params->param_data = (unsigned char *)custom_payload;
@@ -2334,18 +2549,17 @@
}
static int route_reg_sm_ape(st_hw_session_t *p_ses,void *sm_data,
- unsigned int sm_size, sound_trigger_sound_model_type_t sm_type)
+ unsigned int sm_size, uint32_t model_id)
{
- return ape_reg_sm(p_ses, sm_data, sm_size, sm_type);
+ return ape_reg_sm(p_ses, sm_data, sm_size, model_id);
}
static int route_reg_sm_params_ape(st_hw_session_t* p_ses,
unsigned int recognition_mode, bool capture_requested,
- struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type, void *sm_data)
+ struct sound_trigger_recognition_config *rc_config)
{
return ape_reg_sm_params(p_ses, recognition_mode, capture_requested,
- rc_config, sm_type, sm_data);
+ rc_config);
}
static int route_dereg_sm_params_ape(st_hw_session_t* p_ses)
@@ -2353,11 +2567,11 @@
return ape_dereg_sm_params(p_ses);
}
-static int route_dereg_sm_ape(st_hw_session_t* p_ses)
+static int route_dereg_sm_ape(st_hw_session_t* p_ses, uint32_t model_id)
{
int status = 0;
- status = ape_dereg_sm(p_ses);
+ status = ape_dereg_sm(p_ses, model_id);
return status;
}
@@ -2370,9 +2584,7 @@
static int route_restart_ape(st_hw_session_t* p_ses,
unsigned int recognition_mode __unused,
- struct sound_trigger_recognition_config *rc_config __unused,
- sound_trigger_sound_model_type_t sm_type __unused,
- void *sm_data __unused)
+ struct sound_trigger_recognition_config *rc_config __unused)
{
st_hw_session_lsm_t *p_lsm_ses = (st_hw_session_lsm_t *)p_ses;
@@ -2531,7 +2743,8 @@
capture_device = platform_stdev_get_capture_device(p_ses->stdev->platform);
platform_get_lsm_usecase(p_ses->stdev->platform, v_info,
- &p_lsm_ses->lsm_usecase, p_ses->exec_mode, p_ses->lpi_enable);
+ &p_lsm_ses->lsm_usecase, p_ses->exec_mode, p_ses->lpi_enable,
+ p_ses->f_stage_version);
if (!p_lsm_ses->lsm_usecase) {
ALOGE("%s: failed to allocate lsm usecase for the session", __func__);
return -ENODEV;
@@ -2843,6 +3056,7 @@
p_lsm_ses->exit_lab_processing = false;
p_lsm_ses->lab_processing_active = false;
list_init(&p_ses->lsm_ss_cfg_list);
+ list_init(&p_ses->sthw_cfg_list);
pthread_condattr_init(&c_attr);
pthread_condattr_setclock(&c_attr, CLOCK_MONOTONIC);
diff --git a/st_hw_session_lsm.h b/st_hw_session_lsm.h
index d99a7bc..7fd914a 100644
--- a/st_hw_session_lsm.h
+++ b/st_hw_session_lsm.h
@@ -31,6 +31,7 @@
#include <tinyalsa/asoundlib.h>
#include <audio_route/audio_route.h>
#include <sound/lsm_params.h>
+#include <sound/asound.h>
#include "sound_trigger_platform.h"
#include "st_hw_session.h"
@@ -40,8 +41,12 @@
#define SOUND_TRIGGER_MAX_EVNT_PAYLOAD_SIZE (256)
-/* Add extra to accomodate multiple LSM_CUSTOM_PARAMS */
-#define LSM_SM_PARAMS_INFO_MAX (LSM_PARAMS_MAX + 4)
+/*
+ * Add extra to accomodate multiple LSM_CUSTOM_PARAMS and also
+ * multiple LSM_MULTI_SND_MODEL_CONFIDENCE_LEVELS params for
+ * multi SM usecase.
+ */
+#define LSM_SM_PARAMS_INFO_MAX (LSM_PARAMS_MAX * 2)
#define SOUND_TRIGGER_PCM_MAX_RETRY (10)
#define SOUND_TRIGGER_PCM_SLEEP_WAIT (1000)
@@ -66,6 +71,9 @@
#define LSM_ABORT_RETRY_COUNT (5)
#define LSM_ABORT_WAIT_TIMEOUT_NS (30 * NSECS_PER_MSEC)
+#define MAX_MULTI_SOUND_MODELS (8)
+#define MAX_MULTI_SM_CONF_LEVELS (8)
+
#ifdef LSM_EVENT_TIMESTAMP_MODE_SUPPORT
typedef struct snd_lsm_event_status_v3 st_lsm_event_status_t;
#else
@@ -84,8 +92,35 @@
typedef void* st_lsm_det_event_type_t;
#endif
-#define ACD_CONFIDENCE_LEVELS_BIT (1 << 0)
-#define ACD_TIME_STAMP_INFO_BIT (1 << 1)
+struct multi_sm_conf_levels {
+ uint32_t model_id;
+ uint32_t num_conf_levels;
+ uint32_t conf_levels[MAX_MULTI_SM_CONF_LEVELS];
+};
+
+struct multi_sm_reg_sm {
+ uint32_t model_id;
+ uint32_t model_size;
+};
+
+#if (SNDRV_LSM_VERSION >= SNDRV_PROTOCOL_VERSION(0, 3, 2))
+#define LSM_MULTI_SM_SUPPORT (1)
+#else
+#define LSM_MULTI_SM_SUPPORT (0)
+#endif
+
+#ifdef LSM_MULTI_SM_SUPPORT
+ typedef struct multi_sm_reg_sm st_lsm_reg_sm_header_t;
+ typedef struct multi_sm_conf_levels st_lsm_conf_levels_t;
+#else
+ typedef void* st_lsm_reg_sm_header_t;
+ typedef void* st_lsm_conf_levels_t;
+#endif
+
+#define DET_EVENT_CONFIDENCE_LEVELS_BIT (1 << 0)
+#define DET_EVENT_KEYWORD_INDEX_BIT (1 << 1)
+#define DET_EVENT_TIMESTAMP_INFO_BIT (1 << 2)
+#define DET_EVENT_MULTI_MODEL_RESULT_INFO_BIT (1 << 4)
struct lsm_param_smm_th_config {
uint32_t minor_version;
diff --git a/st_hw_session_pcm.c b/st_hw_session_pcm.c
index 7fee392..284b647 100644
--- a/st_hw_session_pcm.c
+++ b/st_hw_session_pcm.c
@@ -73,13 +73,11 @@
} st_get_param_payload_t;
static int reg_sm(st_hw_session_t* p_ses, void *sm_data,
- unsigned int sm_size,
- sound_trigger_sound_model_type_t sm_type);
+ unsigned int sm_size, uint32_t model_id);
static int reg_sm_params(st_hw_session_t* p_ses, unsigned int recognition_mode,
- bool capture_requested, struct sound_trigger_recognition_config *rc_config,
- sound_trigger_sound_model_type_t sm_type, void *sm_data);
+ bool capture_requested, struct sound_trigger_recognition_config *rc_config);
-static int dereg_sm(st_hw_session_t* p_ses);
+static int dereg_sm(st_hw_session_t* p_ses,uint32_t model_id __unused);
static int dereg_sm_params(st_hw_session_t* p_ses);
static int start(st_hw_session_t* p_ses);
static int stop(st_hw_session_t* p_ses);
@@ -90,8 +88,7 @@
static int enable_device(st_hw_session_t *p_ses, bool setting_device);
static void process_lab_capture(st_hw_session_t *p_ses);
static int restart(st_hw_session_t* p_ses, unsigned int recognition_mode,
- struct sound_trigger_recognition_config *rc_config __unused,
- sound_trigger_sound_model_type_t sm_type, void *sm_data __unused);
+ struct sound_trigger_recognition_config *rc_config __unused);
static int read_pcm(st_hw_session_t *p_ses,
unsigned char *buf,
unsigned int bytes);
@@ -1237,7 +1234,7 @@
}
static int reg_sm(st_hw_session_t *p_ses, void *sm_data,
- unsigned int sm_size, sound_trigger_sound_model_type_t sm_type __unused)
+ unsigned int sm_size, uint32_t model_id __unused)
{
int status = 0;
st_hw_session_pcm_t *p_pcm_ses =
@@ -1418,7 +1415,7 @@
return status;
}
-static int dereg_sm(st_hw_session_t *p_ses)
+static int dereg_sm(st_hw_session_t *p_ses, uint32_t model_id __unused)
{
int status = 0;
st_hw_session_pcm_t *p_pcm_ses =
@@ -1476,8 +1473,7 @@
}
static int reg_sm_params(st_hw_session_t* p_ses, unsigned int recognition_mode __unused,
- bool capture_requested, struct sound_trigger_recognition_config *rc_config __unused,
- sound_trigger_sound_model_type_t sm_type __unused, void *sm_data __unused)
+ bool capture_requested, struct sound_trigger_recognition_config *rc_config __unused)
{
int status = 0;
st_hw_session_pcm_t *p_pcm_ses =
@@ -1719,8 +1715,7 @@
}
static int restart(st_hw_session_t* p_ses, unsigned int recognition_mode __unused,
- struct sound_trigger_recognition_config *rc_config __unused,
- sound_trigger_sound_model_type_t sm_type __unused, void *sm_data __unused)
+ struct sound_trigger_recognition_config *rc_config __unused)
{
st_hw_session_pcm_t *p_pcm_ses =
(st_hw_session_pcm_t *)p_ses;
diff --git a/st_session.c b/st_session.c
index 156bfb9..f62bbda 100644
--- a/st_session.c
+++ b/st_session.c
@@ -257,6 +257,46 @@
};
}
+static inline struct st_proxy_ses_sm_info_wrapper *get_sm_info_for_model_id
+(
+ st_proxy_session_t *st_ses,
+ uint32_t model_id
+)
+{
+ struct listnode *node = NULL;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
+
+ list_for_each(node, &st_ses->sm_info_list) {
+ p_info = node_to_item(node, struct st_proxy_ses_sm_info_wrapper,
+ sm_list_node);
+
+ if (p_info->sm_info.model_id == model_id)
+ return p_info;
+ }
+
+ return NULL;
+}
+
+static inline struct st_hw_ses_config *get_sthw_cfg_for_model_id
+(
+ st_hw_session_t *hw_ses,
+ uint32_t model_id
+)
+{
+ struct listnode *node = NULL;
+ struct st_hw_ses_config *sthw_cfg = NULL;
+
+ list_for_each(node, &hw_ses->sthw_cfg_list) {
+ sthw_cfg = node_to_item(node, struct st_hw_ses_config,
+ sthw_cfg_list_node);
+
+ if (sthw_cfg->model_id == model_id)
+ return sthw_cfg;
+ }
+
+ return NULL;
+}
+
static inline void free_array_ptrs(char **arr, unsigned int arr_len)
{
int i = 0;
@@ -667,7 +707,8 @@
st_session_t *c_ses = NULL;
listen_model_type **in_models = NULL;
listen_model_type out_model = {0};
- struct sound_model_info sm_info = {0};
+ struct sound_model_info sm_info = {0};
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
int status = 0, num_models = 0;
ALOGV("%s:[c%d]", __func__, stc_ses->sm_handle);
@@ -675,13 +716,46 @@
ALOGD("%s:[c%d] Already added", __func__, stc_ses->sm_handle);
return 0;
}
- if (!st_ses->vendor_uuid_info->merge_fs_soundmodels) {
+ if (!st_ses->vendor_uuid_info->merge_fs_soundmodels ||
+ stc_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
stc_ses->sm_info.sm_data = sm_data;
stc_ses->sm_info.sm_size = sm_size;
- st_ses->sm_info.sm_data = sm_data;
- st_ses->sm_info.sm_size = sm_size;
- st_ses->sm_info.sm_type = stc_ses->sm_type;
- ALOGD("%s:[c%d] no merge", __func__, stc_ses->sm_handle);
+ stc_ses->sm_info.sm_type = stc_ses->sm_type;
+ stc_ses->sm_info.model_id =
+ (stc_ses->f_stage_version == ST_MODULE_TYPE_PDK5) ?
+ stc_ses->sm_handle : 0;
+
+ p_info = calloc(1, sizeof(struct st_proxy_ses_sm_info_wrapper));
+ if (!p_info) {
+ ALOGE("%s: failed to alloc struct st_proxy_ses_sm_info_wrapper",
+ __func__);
+ return -ENOMEM;
+ }
+
+ memcpy((uint8_t *)&p_info->sm_info, (uint8_t *)&stc_ses->sm_info,
+ sizeof(struct sound_model_info));
+
+ if (stc_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ st_ses->recognition_mode |= stc_ses->recognition_mode;
+ p_info->sm_info.cf_levels = calloc(1, 2 * MAX_MULTI_SM_CONF_LEVELS);
+ if (!p_info->sm_info.cf_levels) {
+ ALOGE("%s: failed to alloc cf_levels",
+ __func__);
+ free(p_info);
+ return -ENOMEM;
+ }
+ memset(p_info->sm_info.cf_levels, MAX_CONF_LEVEL_VALUE,
+ MAX_MULTI_SM_CONF_LEVELS);
+ p_info->sm_info.det_cf_levels = p_info->sm_info.cf_levels +
+ MAX_MULTI_SM_CONF_LEVELS;
+ memset(p_info->sm_info.det_cf_levels, 0,
+ MAX_MULTI_SM_CONF_LEVELS);
+ stc_ses->sm_info.cf_levels = p_info->sm_info.cf_levels;
+ stc_ses->sm_info.det_cf_levels = p_info->sm_info.det_cf_levels;
+ }
+ list_add_tail(&st_ses->sm_info_list, &p_info->sm_list_node);
+ if (stc_ses->f_stage_version == ST_MODULE_TYPE_GMM)
+ ALOGD("%s:[c%d] no merge", __func__, stc_ses->sm_handle);
return 0;
}
/* get sound model header information for client model */
@@ -703,15 +777,20 @@
num_models++;
}
if (!num_models) {
- if (st_ses->sm_info.sm_merged && st_ses->sm_info.sm_data) {
- free(st_ses->sm_info.sm_data);
+ p_info = calloc(1, sizeof(struct st_proxy_ses_sm_info_wrapper));
+ if (!p_info) {
+ ALOGE("%s: failed to alloc struct st_proxy_ses_sm_info_wrapper",
+ __func__);
+ return -ENOMEM;
}
- /* Only one current client model, just re-use it */
st_ses->recognition_mode = stc_ses->recognition_mode;
stc_ses->sm_info.sm_type = stc_ses->sm_type;
- st_ses->sm_info = stc_ses->sm_info;
- st_ses->sm_info.sm_merged = false;
- ALOGD("%s: re-use single client c%d model, size %d", __func__,
+ stc_ses->sm_info.model_id = 0;
+ memcpy((uint8_t *)&p_info->sm_info, (uint8_t *)&stc_ses->sm_info,
+ sizeof(struct sound_model_info));
+ st_ses->sm_merged = false;
+ list_add_tail(&st_ses->sm_info_list, &p_info->sm_list_node);
+ ALOGD("%s: Copy from single client c%d model, size %d", __func__,
stc_ses->sm_handle, stc_ses->sm_info.sm_size);
return 0;
}
@@ -720,19 +799,27 @@
* Merge this client model with already existing merged model due to other
* clients models.
*/
- if (!st_ses->sm_info.sm_data) {
+ p_info = get_sm_info_for_model_id(st_ses, 0);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching model_id in sm_info list,"
+ "num current models %d", __func__, num_models);
+ status = -EINVAL;
+ goto cleanup;
+ }
+
+ if (!p_info->sm_info.sm_data) {
if (num_models == 1) {
/*
- * Its not a merged model yet, but proxy ses sm_data is valid and
- * must be pointing to client sm_data
+ * Its not a merged model yet, but proxy ses sm_data is valid
+ * and must be pointing to client sm_data
*/
- ALOGE("%s: Unexpected, sm_info.sm_data NULL, num current"
+ ALOGE("%s: Unexpected, sm_data NULL, num current"
"models %d", __func__, num_models);
status = -EINVAL;
goto cleanup;
- } else if (!st_ses->sm_info.sm_merged) {
- ALOGE("%s: Unexpected, no pre-existing merged model, num current"
- "models %d", __func__, num_models);
+ } else if (!st_ses->sm_merged) {
+ ALOGE("%s: Unexpected, no pre-existing merged model,"
+ "num current models %d", __func__, num_models);
status = -EINVAL;
goto cleanup;
}
@@ -747,8 +834,8 @@
goto cleanup;
}
/* Add existing model */
- in_models[0]->data = st_ses->sm_info.sm_data;
- in_models[0]->size = st_ses->sm_info.sm_size;
+ in_models[0]->data = p_info->sm_info.sm_data;
+ in_models[0]->size = p_info->sm_info.sm_size;
/* Add this client model */
in_models[1]->data = sm_data;
in_models[1]->size = sm_size;
@@ -759,16 +846,16 @@
sm_info.sm_data = out_model.data;
sm_info.sm_size = out_model.size;
- sm_info.sm_merged = true;
+ sm_info.model_id = 0;
status = query_sound_model(st_ses->stdev, &sm_info,
out_model.data, out_model.size);
if (status)
goto cleanup;
- if (out_model.size < st_ses->sm_info.sm_size) {
+ if (out_model.size < p_info->sm_info.sm_size) {
ALOGE("%s: Unexpected, merged model sz %d < current sz %d",
- __func__, out_model.size, st_ses->sm_info.sm_size);
+ __func__, out_model.size, p_info->sm_info.sm_size);
release_sound_model_info(&sm_info);
status = -EINVAL;
goto cleanup;
@@ -777,13 +864,15 @@
in_models = NULL;
/* Update the new merged model */
- if (st_ses->sm_info.sm_merged && st_ses->sm_info.sm_data) {
- release_sound_model_info(&st_ses->sm_info);
- free(st_ses->sm_info.sm_data);
+ if (st_ses->sm_merged && p_info->sm_info.sm_data) {
+ release_sound_model_info(&p_info->sm_info);
+ free(p_info->sm_info.sm_data);
}
ALOGD("%s: Updated sound model: current size %d, new size %d", __func__,
- st_ses->sm_info.sm_size, out_model.size);
- st_ses->sm_info = sm_info;
+ p_info->sm_info.sm_size, out_model.size);
+ memcpy((uint8_t *)&p_info->sm_info, (uint8_t *)&sm_info,
+ sizeof(struct sound_model_info));
+ st_ses->sm_merged = true;
/*
* If any of the clients has user identificaiton enabled, underlying
@@ -815,6 +904,8 @@
listen_model_type in_model = {0};
listen_model_type out_model = {0};
struct sound_model_info sm_info = {0};
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
+ struct st_hw_ses_config *sthw_cfg = NULL;
int status = 0, num_models = 0;
unsigned int rec_mode = RECOGNITION_MODE_VOICE_TRIGGER;
@@ -823,14 +914,42 @@
ALOGD("%s:[c%d] Already deleted", __func__, stc_ses->sm_handle);
return 0;
}
- if (!st_ses->vendor_uuid_info->merge_fs_soundmodels) {
+
+ p_info = get_sm_info_for_model_id(st_ses, stc_ses->sm_info.model_id);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ return -EINVAL;
+ }
+
+ if (!st_ses->vendor_uuid_info->merge_fs_soundmodels ||
+ stc_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ list_remove(&p_info->sm_list_node);
/*
- * As it directly points to client model, just set as NULL
- * without freeing
+ * As it directly points to client model, just set sm_data
+ * as NULL without freeing
*/
- st_ses->sm_info.sm_data = NULL;
+ if (stc_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ /* Update overall recogniton mode from remaining clients */
+ list_for_each(node, &st_ses->clients_list) {
+ c_ses = node_to_item(node, st_session_t, hw_list_node);
+ if ((c_ses != stc_ses) && c_ses->sm_info.sm_data) {
+ if (c_ses->recognition_mode &
+ RECOGNITION_MODE_USER_IDENTIFICATION)
+ rec_mode |= RECOGNITION_MODE_USER_IDENTIFICATION;
+ }
+ }
+ st_ses->recognition_mode = rec_mode;
+
+ if (p_info->sm_info.cf_levels) {
+ free(p_info->sm_info.cf_levels);
+ p_info->sm_info.cf_levels = NULL;
+ }
+ }
+ p_info->sm_info.sm_data = NULL;
+ free(p_info);
stc_ses->sm_info.sm_data = NULL;
- ALOGD("%s:[c%d] no merge", __func__, stc_ses->sm_handle);
+ if (stc_ses->f_stage_version == ST_MODULE_TYPE_GMM)
+ ALOGD("%s:[c%d] no merge", __func__, stc_ses->sm_handle);
return 0;
}
@@ -846,10 +965,14 @@
num_models++;
}
}
+
if (num_models == 0) {
ALOGD("%s: No remaining models", __func__);
/* Delete current client model */
- release_sound_model_info(&stc_ses->sm_info);
+ release_sound_model_info(&p_info->sm_info);
+ list_remove(&p_info->sm_list_node);
+ p_info->sm_info.sm_data = NULL;
+ free(p_info);
stc_ses->sm_info.sm_data = NULL;
return 0;
}
@@ -858,17 +981,24 @@
ALOGD("%s: reuse only remaining client model, size %d", __func__,
c_ses_rem->sm_info.sm_size);
/* If only one remaining client model exists, re-use it */
- if (st_ses->sm_info.sm_merged) {
- release_sound_model_info(&st_ses->sm_info);
- if (st_ses->sm_info.sm_data)
- free(st_ses->sm_info.sm_data);
+ if (st_ses->sm_merged) {
+ release_sound_model_info(&p_info->sm_info);
+ if (p_info->sm_info.sm_data)
+ free(p_info->sm_info.sm_data);
}
- st_ses->sm_info = c_ses_rem->sm_info;
- st_ses->sm_info.sm_merged = false;
- st_ses->hw_ses_current->sthw_cfg.conf_levels =
- st_ses->sm_info.cf_levels;
- st_ses->hw_ses_current->sthw_cfg.num_conf_levels =
- st_ses->sm_info.cf_levels_size;
+ memcpy((uint8_t *)&p_info->sm_info, (uint8_t *)&c_ses_rem->sm_info,
+ sizeof(struct sound_model_info));
+ st_ses->sm_merged = false;
+
+ sthw_cfg = get_sthw_cfg_for_model_id(st_ses->hw_ses_current, 0);
+ if (!sthw_cfg) {
+ ALOGE("%s: Unexpected, no matching sthw_cfg", __func__);
+ return -EINVAL;
+ }
+
+ sthw_cfg->conf_levels = p_info->sm_info.cf_levels;
+ sthw_cfg->num_conf_levels =
+ p_info->sm_info.cf_levels_size;
st_ses->recognition_mode = c_ses_rem->recognition_mode;
/* Delete current client model */
release_sound_model_info(&stc_ses->sm_info);
@@ -888,15 +1018,15 @@
* Delete this client model with already existing merged model due to other
* clients models.
*/
- if (!st_ses->sm_info.sm_merged || !st_ses->sm_info.sm_data) {
+ if (!st_ses->sm_merged || !p_info->sm_info.sm_data) {
ALOGE("%s: Unexpected, no pre-existing merged model to delete from,"
"num current models %d", __func__, num_models);
goto cleanup;
}
/* Existing merged model from which the current client model to be deleted */
- in_model.data = st_ses->sm_info.sm_data;
- in_model.size = st_ses->sm_info.sm_size;
+ in_model.data = p_info->sm_info.sm_data;
+ in_model.size = p_info->sm_info.sm_size;
status = delete_from_merged_sound_model(st_ses->stdev,
stc_ses->sm_info.keyphrases, stc_ses->sm_info.num_keyphrases,
@@ -907,7 +1037,7 @@
sm_info.sm_data = out_model.data;
sm_info.sm_size = out_model.size;
- sm_info.sm_merged = true;
+ sm_info.model_id = 0;
/* Update existing merged model info with new merged model */
status = query_sound_model(st_ses->stdev, &sm_info, out_model.data,
@@ -915,22 +1045,24 @@
if (status)
goto cleanup;
- if (out_model.size > st_ses->sm_info.sm_size) {
+ if (out_model.size > p_info->sm_info.sm_size) {
ALOGE("%s: Unexpected, merged model sz %d > current sz %d",
- __func__, out_model.size, st_ses->sm_info.sm_size);
+ __func__, out_model.size, p_info->sm_info.sm_size);
release_sound_model_info(&sm_info);
status = -EINVAL;
goto cleanup;
}
- if (st_ses->sm_info.sm_merged && st_ses->sm_info.sm_data) {
- release_sound_model_info(&st_ses->sm_info);
- free(st_ses->sm_info.sm_data);
+ if (st_ses->sm_merged && p_info->sm_info.sm_data) {
+ release_sound_model_info(&p_info->sm_info);
+ free(p_info->sm_info.sm_data);
}
ALOGD("%s: Updated sound model: current size %d, new size %d", __func__,
- st_ses->sm_info.sm_size, out_model.size);
- st_ses->sm_info = sm_info;
+ p_info->sm_info.sm_size, out_model.size);
+ memcpy((uint8_t *)&p_info->sm_info, (uint8_t *)&sm_info,
+ sizeof(struct sound_model_info));
+ st_ses->sm_merged = true;
/*
* If any of the remaining clients has user identificaiton enabled,
* underlying hw session has to operate with user identificaiton enabled.
@@ -989,19 +1121,26 @@
unsigned int src_size, bool set)
{
int i = 0, j = 0;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
if (!st_ses || !src) {
ALOGE("%s: NULL pointer", __func__);
return -EINVAL;
}
- if (!st_ses->sm_info.sm_merged)
+ if (!st_ses->sm_merged)
return 0;
- if (src_size > st_ses->sm_info.cf_levels_size) {
+ p_info = get_sm_info_for_model_id(st_ses, 0);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ return -EINVAL;
+ }
+
+ if (src_size > p_info->sm_info.cf_levels_size) {
ALOGE("%s:[%d] Unexpected, client conf levels %d > "
"merged conf levels %d", __func__, st_ses->sm_handle,
- src_size, st_ses->sm_info.cf_levels_size);
+ src_size, p_info->sm_info.cf_levels_size);
return -EINVAL;
}
@@ -1010,17 +1149,17 @@
/* Populate DSP merged sound model conf levels */
for (i = 0; i < src_size; i++) {
- for (j = 0; j < st_ses->sm_info.cf_levels_size; j++) {
- if (!strcmp(st_ses->sm_info.cf_levels_kw_users[j],
+ for (j = 0; j < p_info->sm_info.cf_levels_size; j++) {
+ if (!strcmp(p_info->sm_info.cf_levels_kw_users[j],
src_sm_info->cf_levels_kw_users[i])) {
if (set) {
- st_ses->sm_info.cf_levels[j] = src[i];
- ALOGV("%s: set: sm_info.cf_levels[%d]=%d", __func__,
- j, st_ses->sm_info.cf_levels[j]);
+ p_info->sm_info.cf_levels[j] = src[i];
+ ALOGV("%s: set: cf_levels[%d]=%d", __func__,
+ j, p_info->sm_info.cf_levels[j]);
} else {
- st_ses->sm_info.cf_levels[j] = MAX_CONF_LEVEL_VALUE;
- ALOGV("%s: reset: sm_info.cf_levels[%d]=%d", __func__,
- j, st_ses->sm_info.cf_levels[j]);
+ p_info->sm_info.cf_levels[j] = MAX_CONF_LEVEL_VALUE;
+ ALOGV("%s: reset: cf_levels[%d]=%d", __func__,
+ j, p_info->sm_info.cf_levels[j]);
}
}
}
@@ -1056,21 +1195,29 @@
unsigned char **dst, unsigned int *dst_size)
{
st_session_t *stc_ses = st_ses->det_stc_ses;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
int i = 0, j = 0;
*dst = src;
*dst_size = src_size;
if (!st_ses->vendor_uuid_info->merge_fs_soundmodels ||
- !st_ses->sm_info.sm_merged) {
+ !st_ses->sm_merged ||
+ stc_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
ALOGV("%s:[%d] not merged", __func__, st_ses->sm_handle);
return;
}
- if (src_size < st_ses->sm_info.cf_levels_size) {
+ p_info = get_sm_info_for_model_id(st_ses, 0);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ return;
+ }
+
+ if (src_size < p_info->sm_info.cf_levels_size) {
ALOGE("%s:[%d] Unexpected, detection conf payload size %d < %d",
__func__, st_ses->sm_handle, src_size,
- st_ses->sm_info.cf_levels_size);
+ p_info->sm_info.cf_levels_size);
return;
}
@@ -1078,12 +1225,12 @@
memset(stc_ses->sm_info.det_cf_levels, 0, stc_ses->sm_info.cf_levels_size);
/* Extract the client conf level values from DSP payload */
- for(i = 0; i < st_ses->sm_info.cf_levels_size; i++) {
+ for(i = 0; i < p_info->sm_info.cf_levels_size; i++) {
if (!src[i])
continue;
for(j = 0; j < stc_ses->sm_info.cf_levels_size; j++) {
if (!strcmp(stc_ses->sm_info.cf_levels_kw_users[j],
- st_ses->sm_info.cf_levels_kw_users[i])) {
+ p_info->sm_info.cf_levels_kw_users[i])) {
stc_ses->sm_info.det_cf_levels[j] = src[i];
}
}
@@ -1202,16 +1349,12 @@
st_session_t *stc_ses)
{
st_hw_session_t *hw_ses = st_ses->hw_ses_current;
- struct st_hw_ses_config *sthw_cfg = &hw_ses->sthw_cfg;
+ struct st_hw_ses_config *sthw_cfg = NULL;
struct listnode *node = NULL;
st_session_t *c_ses = NULL;
int hb_sz = 0, pr_sz = 0;
bool enable_lab = false;
- if (!st_ses->vendor_uuid_info->merge_fs_soundmodels ||
- !st_ses->sm_info.sm_merged)
- return;
-
/*
* Adjust history buffer and preroll durations to highest of
* all clients, including current restarting client.
@@ -1233,14 +1376,48 @@
}
}
- sthw_cfg->client_req_hist_buf = hb_sz;
- sthw_cfg->client_req_preroll = pr_sz;
- st_ses->lab_enabled = enable_lab;
+ sthw_cfg = get_sthw_cfg_for_model_id(hw_ses, stc_ses->sm_info.model_id);
+ if (!sthw_cfg) {
+ ALOGE("%s: Unexpected, no matching sthw_cfg", __func__);
+ return;
+ }
- update_merge_conf_levels_payload(st_ses, &stc_ses->sm_info,
- stc_ses->sm_info.cf_levels,
- stc_ses->sm_info.cf_levels_size,
- true);
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ if (!st_ses->vendor_uuid_info->merge_fs_soundmodels ||
+ !st_ses->sm_merged)
+ return;
+
+ sthw_cfg->client_req_hist_buf = hb_sz;
+ hw_ses->max_hist_buf = hb_sz;
+ sthw_cfg->client_req_preroll = pr_sz;
+ hw_ses->max_preroll = pr_sz;
+ st_ses->lab_enabled = enable_lab;
+
+ update_merge_conf_levels_payload(st_ses, &stc_ses->sm_info,
+ stc_ses->sm_info.cf_levels,
+ stc_ses->sm_info.cf_levels_size,
+ true);
+ } else {
+ sthw_cfg->client_req_hist_buf = stc_ses->hist_buf_duration;
+ hw_ses->max_hist_buf = hb_sz;
+ sthw_cfg->client_req_preroll = stc_ses->preroll_duration;
+ hw_ses->max_preroll = pr_sz;
+ st_ses->lab_enabled = enable_lab;
+
+ /*
+ * During stop, the conf levels get set to the max value
+ * to prevent detections while its client state is loaded
+ * and another sound model's client state is active. So
+ * during restart, the conf levels need to be reset from
+ * the cached stc_values to enable detections again.
+ */
+ memset(sthw_cfg->conf_levels, MAX_CONF_LEVEL_VALUE,
+ MAX_MULTI_SM_CONF_LEVELS);
+ memcpy(sthw_cfg->conf_levels, stc_ses->sm_info.cf_levels,
+ stc_ses->sm_info.cf_levels_size);
+ sthw_cfg->num_conf_levels = stc_ses->sm_info.cf_levels_size;
+ }
+
hw_ses->sthw_cfg_updated = true;
ALOGV("%s:[%d] lab_enabled %d, hb_sz %d, pr_sz %d", __func__,
@@ -1252,13 +1429,21 @@
st_session_t *stc_ses)
{
st_hw_session_t *hw_ses = st_ses->hw_ses_current;
- struct st_hw_ses_config *sthw_cfg = &hw_ses->sthw_cfg;
+ struct st_hw_ses_config *sthw_cfg = NULL;
struct listnode *node = NULL;
st_session_t *c_ses = NULL;
int hb_sz = 0, pr_sz = 0;
bool active = false, enable_lab = false;
- if (!st_ses->vendor_uuid_info->merge_fs_soundmodels) {
+ sthw_cfg = get_sthw_cfg_for_model_id(hw_ses, stc_ses->sm_info.model_id);
+ if (!sthw_cfg) {
+ ALOGE("%s: Unexpected, no matching sthw_cfg", __func__);
+ return false;
+ }
+
+ if (!st_ses->vendor_uuid_info->merge_fs_soundmodels &&
+ stc_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+
if (sthw_cfg->conf_levels) {
ALOGV("%s: free hw conf_levels", __func__);
free(sthw_cfg->conf_levels);
@@ -1286,26 +1471,54 @@
!list_empty(&c_ses->second_stage_list);
}
}
- if (!active) {
+
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ if (!active) {
+ sthw_cfg->client_req_hist_buf = 0;
+ hw_ses->max_hist_buf = 0;
+ sthw_cfg->client_req_preroll = 0;
+ hw_ses->max_preroll = 0;
+ st_ses->lab_enabled = false;
+ hw_ses->custom_data = NULL;
+ hw_ses->custom_data_size = 0;
+ hw_ses->sthw_cfg_updated = true;
+ ALOGV("%s:[%d] no active client hw cfg is reset", __func__,
+ st_ses->sm_handle);
+ return false;
+ }
+
+ sthw_cfg->client_req_hist_buf = hb_sz;
+ hw_ses->max_hist_buf = hb_sz;
+ sthw_cfg->client_req_preroll = pr_sz;
+ hw_ses->max_preroll = pr_sz;
+ st_ses->lab_enabled = enable_lab;
+
+ update_merge_conf_levels_payload(st_ses, &stc_ses->sm_info,
+ stc_ses->sm_info.cf_levels,
+ stc_ses->sm_info.cf_levels_size,
+ false);
+ } else {
+ if (!active) {
+ hw_ses->max_hist_buf = 0;
+ hw_ses->max_preroll = 0;
+ st_ses->lab_enabled = false;
+ hw_ses->custom_data = NULL;
+ hw_ses->custom_data_size = 0;
+ hw_ses->sthw_cfg_updated = true;
+ return false;
+ }
+
sthw_cfg->client_req_hist_buf = 0;
+ hw_ses->max_hist_buf = hb_sz;
sthw_cfg->client_req_preroll = 0;
- st_ses->lab_enabled = 0;
- sthw_cfg->custom_data = NULL;
- sthw_cfg->custom_data_size = 0;
- hw_ses->sthw_cfg_updated = true;
- ALOGV("%s:[%d] no active client hw cfg is reset", __func__,
- st_ses->sm_handle);
- return false;
+ hw_ses->max_preroll = pr_sz;
+ st_ses->lab_enabled = enable_lab;
+
+ memset(sthw_cfg->conf_levels, MAX_CONF_LEVEL_VALUE,
+ MAX_MULTI_SM_CONF_LEVELS);
+ sthw_cfg->num_conf_levels = 0;
}
- sthw_cfg->client_req_hist_buf = hb_sz;
- sthw_cfg->client_req_preroll = pr_sz;
- st_ses->lab_enabled = enable_lab;
-
- update_merge_conf_levels_payload(st_ses, &stc_ses->sm_info,
- stc_ses->sm_info.cf_levels,
- stc_ses->sm_info.cf_levels_size,
- false);
hw_ses->sthw_cfg_updated = true;
ALOGV("%s:[%d] lab_enabled %d, hb_sz %d, pr_sz %d", __func__,
@@ -1336,7 +1549,7 @@
break;
}
i += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
- payload += i;
+ payload += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
}
} else {
if (st_ses->exec_mode == ST_EXEC_MODE_CPE) {
@@ -1355,70 +1568,116 @@
struct listnode *node = NULL;
st_session_t *c_ses = NULL;
unsigned char *conf_levels = NULL;
- unsigned int conf_levels_size = 0;
+ unsigned int conf_levels_size = 0, key_id = 0, key_payload_size = 0;
int i = 0, j = 0;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
+ multi_model_result_info_t *result_info = NULL;
- if (list_empty(&st_ses->clients_list)) {
- ALOGE("%s:[%d] no clients attached!!", __func__, st_ses->sm_handle);
- return NULL;
- }
- /*
- * If only single client exist, this detection is not for merged
- * sound model, hence return this as only available client
- */
- if (!check_for_multi_clients(st_ses)) {
- ALOGV("%s:[%d] single client detection", __func__, st_ses->sm_handle);
- node = list_head(&st_ses->clients_list);
- c_ses = node_to_item(node, st_session_t, hw_list_node);
- if (c_ses->state == ST_STATE_ACTIVE) {
- ALOGD("%s: detected c%d", __func__, c_ses->sm_handle);
- return c_ses;
- } else {
- ALOGE("%s: detected c%d is not active", __func__, c_ses->sm_handle);
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ p_info = get_sm_info_for_model_id(st_ses, 0);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
return NULL;
}
- }
- get_conf_levels_from_dsp_payload(st_ses, payload, payload_size,
- &conf_levels, &conf_levels_size);
- if (!conf_levels) {
- ALOGE("%s:[%d] no conf levels payload found!!", __func__,
- st_ses->sm_handle);
- return NULL;
- }
- if (conf_levels_size < st_ses->sm_info.num_keyphrases) {
- ALOGE("%s:[%d] detection conf levels size %d < num of keywords %d",
- __func__, st_ses->sm_handle, conf_levels_size,
- st_ses->sm_info.num_keyphrases);
- return NULL;
- }
-
- /*
- * The DSP payload contains the keyword conf levels from the beginning.
- * Only one keyword conf level is expected to be non-zero from keyword
- * detection. Find non-zero conf level up to number of keyphrases and if
- * one is found, match it to the corresponding keyphrase from list of
- * clients to obtain the detected client.
- */
- for (i = 0; i < st_ses->sm_info.num_keyphrases; i++) {
- if (!conf_levels[i])
- continue;
- list_for_each(node, &st_ses->clients_list) {
+ if (list_empty(&st_ses->clients_list)) {
+ ALOGE("%s:[%d] no clients attached!!", __func__,
+ st_ses->sm_handle);
+ return NULL;
+ }
+ /*
+ * If only single client exist, this detection is not for merged
+ * sound model, hence return this as only available client
+ */
+ if (!check_for_multi_clients(st_ses)) {
+ ALOGV("%s:[%d] single client detection", __func__,
+ st_ses->sm_handle);
+ node = list_head(&st_ses->clients_list);
c_ses = node_to_item(node, st_session_t, hw_list_node);
- for (j = 0; j < c_ses->sm_info.num_keyphrases; j++) {
- if (!strcmp(st_ses->sm_info.keyphrases[i],
- c_ses->sm_info.keyphrases[j])) {
- if (c_ses->state == ST_STATE_ACTIVE) {
- ALOGV("%s: detected c%d", __func__, c_ses->sm_handle);
- return c_ses;
- } else {
- ALOGE("%s: detected c%d is not active", __func__,
- c_ses->sm_handle);
- return NULL;
+ if (c_ses->state == ST_STATE_ACTIVE) {
+ ALOGD("%s: detected c%d", __func__, c_ses->sm_handle);
+ return c_ses;
+ } else {
+ ALOGE("%s: detected c%d is not active", __func__,
+ c_ses->sm_handle);
+ return NULL;
+ }
+ }
+
+ get_conf_levels_from_dsp_payload(st_ses, payload, payload_size,
+ &conf_levels, &conf_levels_size);
+ if (!conf_levels) {
+ ALOGE("%s:[%d] no conf levels payload found!!", __func__,
+ st_ses->sm_handle);
+ return NULL;
+ }
+ if (conf_levels_size < p_info->sm_info.num_keyphrases) {
+ ALOGE("%s:[%d] detection conf levels size %d < num of keywords %d",
+ __func__, st_ses->sm_handle, conf_levels_size,
+ p_info->sm_info.num_keyphrases);
+ return NULL;
+ }
+
+ /*
+ * The DSP payload contains the keyword conf levels from the beginning.
+ * Only one keyword conf level is expected to be non-zero from keyword
+ * detection. Find non-zero conf level up to number of keyphrases and
+ * if one is found, match it to the corresponding keyphrase from list
+ * of clients to obtain the detected client.
+ */
+ for (i = 0; i < p_info->sm_info.num_keyphrases; i++) {
+ if (!conf_levels[i])
+ continue;
+ list_for_each(node, &st_ses->clients_list) {
+ c_ses = node_to_item(node, st_session_t, hw_list_node);
+ for (j = 0; j < c_ses->sm_info.num_keyphrases; j++) {
+ if (!strcmp(p_info->sm_info.keyphrases[i],
+ c_ses->sm_info.keyphrases[j])) {
+ if (c_ses->state == ST_STATE_ACTIVE) {
+ ALOGV("%s: detected c%d", __func__,
+ c_ses->sm_handle);
+ return c_ses;
+ } else {
+ ALOGE("%s: detected c%d is not active", __func__,
+ c_ses->sm_handle);
+ return NULL;
+ }
}
}
}
}
+ } else {
+ while (i < payload_size) {
+ key_id = *(uint32_t *)payload;
+ key_payload_size = *((uint32_t *)payload + 1);
+
+ if (key_id == KEY_ID_MULTI_MODEL_RESULT_INFO) {
+ result_info = (multi_model_result_info_t *)(payload +
+ GENERIC_DET_EVENT_HEADER_SIZE);
+ list_for_each(node, &st_ses->clients_list) {
+ c_ses = node_to_item(node, st_session_t, hw_list_node);
+ if (c_ses->sm_info.model_id ==
+ result_info->detected_model_id) {
+ if (c_ses->state == ST_STATE_ACTIVE) {
+ ALOGV("%s: detected c%d", __func__,
+ c_ses->sm_handle);
+ return c_ses;
+ } else {
+ ALOGE("%s: detected c%d is not active", __func__,
+ c_ses->sm_handle);
+ return NULL;
+ }
+ }
+ }
+ break;
+ } else {
+ ALOGE("%s: Unexpected key id for PDK5 0x%x", __func__,
+ key_id);
+ break;
+ }
+ i += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
+ payload += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
+ }
}
return c_ses;
}
@@ -2201,6 +2460,7 @@
unsigned int opaque_size = 0, conf_levels_payload_size = 0;
int status = 0;
bool enable_lab = false;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
if (st_ses->stdev->enable_debug_dumps) {
ST_DBG_DECLARE(FILE *rc_opaque_fd = NULL;
@@ -2324,100 +2584,152 @@
}
}
- sthw_cfg = &st_hw_ses->sthw_cfg;
enable_lab = stc_ses->rc_config->capture_requested ||
!list_empty(&stc_ses->second_stage_list);
- if (v_info->merge_fs_soundmodels) {
- /* merge_fs_soundmodels is true only for QC SVA UUID */
+ sthw_cfg = get_sthw_cfg_for_model_id(st_hw_ses,
+ stc_ses->sm_info.model_id);
+ if (!sthw_cfg) {
+ ALOGE("%s: Unexpected, no matching sthw_cfg", __func__);
+ return -EINVAL;
+ }
- /*
- * Note:
- * For ADSP case, the generated conf levles size must be equal to
- * SML queried conf levels.
- * For WDSP gcs case, there is additional payload for KW enable
- * fields in generated conf_levels. If merge sound model is supported
- * on WDSP case, update logic here accordingly.
- */
- if (num_conf_levels != stc_ses->sm_info.cf_levels_size) {
- ALOGE("%s: Unexpected, client cf levels %d != sm_info cf levels %d",
- __func__, num_conf_levels, stc_ses->sm_info.cf_levels_size);
- return -EINVAL;
+ if (stc_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ if (v_info->merge_fs_soundmodels) {
+ /* merge_fs_soundmodels is true only for QC SVA UUID */
+
+ /*
+ * Note:
+ * For ADSP case, the generated conf levles size must be equal to
+ * SML queried conf levels.
+ * For WDSP gcs case, there is additional payload for KW enable
+ * fields in generated conf_levels. If merge sound model is supported
+ * on WDSP case, update logic here accordingly.
+ */
+ if (num_conf_levels != stc_ses->sm_info.cf_levels_size) {
+ ALOGE("%s: Unexpected, client cf levels %d != sm_info cf levels %d",
+ __func__, num_conf_levels, stc_ses->sm_info.cf_levels_size);
+ return -EINVAL;
+ }
+
+ /*
+ * If any of the active clients requested capture or enabled the
+ * second stage, the underlying hw session buffering needs to
+ * be enabled. Ignore if it is already enabled.
+ */
+ if (!st_ses->lab_enabled && enable_lab)
+ st_ses->lab_enabled = true;
+
+ /* Aggregate DSP configuration for highest client configuration */
+
+ /* SVA2.0 sound models */
+ if (!stc_ses->hist_buf_duration &&
+ stc_ses->rc_config->capture_requested &&
+ (stc_ses->rc_config->data_size > 0)) {
+ stc_ses->hist_buf_duration = st_ses->vendor_uuid_info->kw_duration;
+ stc_ses->preroll_duration = 0;
+ }
+
+ if (stc_ses->hist_buf_duration > sthw_cfg->client_req_hist_buf) {
+ sthw_cfg->client_req_hist_buf = stc_ses->hist_buf_duration;
+ st_hw_ses->max_hist_buf = stc_ses->hist_buf_duration;
+ }
+ if (stc_ses->preroll_duration > sthw_cfg->client_req_preroll) {
+ sthw_cfg->client_req_preroll = stc_ses->preroll_duration;
+ st_hw_ses->max_preroll = stc_ses->preroll_duration;
+ }
+
+ ALOGV("%s: client hb_sz %d pr_sz %d, sthw lab %d hb_sz %d "
+ "pr_sz %d", __func__, stc_ses->hist_buf_duration,
+ stc_ses->preroll_duration, st_ses->lab_enabled,
+ sthw_cfg->client_req_hist_buf, sthw_cfg->client_req_preroll);
+
+ /* Cache it to use when client restarts without config update or
+ * during only one remaining client model as there won't be a
+ * merged model yet.
+ */
+ memcpy(stc_ses->sm_info.cf_levels, conf_levels,
+ stc_ses->sm_info.cf_levels_size);
+
+ status = update_merge_conf_levels_payload(st_ses, &stc_ses->sm_info,
+ conf_levels, num_conf_levels, true);
+ free(conf_levels); /* Merged model conf levels will be used further */
+ if (status)
+ return status;
+
+ p_info = get_sm_info_for_model_id(st_ses, 0);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ status = -EINVAL;
+ return status;
+ }
+
+ sthw_cfg->conf_levels = p_info->sm_info.cf_levels;
+ sthw_cfg->num_conf_levels = p_info->sm_info.cf_levels_size;
+ sthw_cfg->model_id = 0;
+ st_hw_ses->sthw_cfg_updated = true;
+
+ /*
+ * Merging further unknown custom data is not needed, as
+ * SVA doesn't support unkown custom data. if required in future,
+ * handle here.
+ * For now just copy the the current client data which is same
+ * across SVA engines.
+ * Update the custom data for the case in which one client session
+ * does not have custom data and another one does.
+ */
+ if (rc_config->data_size > st_hw_ses->custom_data_size) {
+ st_hw_ses->custom_data = (char *)rc_config + rc_config->data_offset;
+ st_hw_ses->custom_data_size = rc_config->data_size;
+ }
+ } else {
+ st_ses->recognition_mode = stc_ses->recognition_mode;
+ st_ses->lab_enabled = enable_lab;
+ sthw_cfg->client_req_hist_buf = stc_ses->hist_buf_duration;
+ st_hw_ses->max_hist_buf = stc_ses->hist_buf_duration;
+ sthw_cfg->client_req_preroll = stc_ses->preroll_duration;
+ st_hw_ses->max_preroll = stc_ses->preroll_duration;
+
+ if (sthw_cfg->conf_levels)
+ free(sthw_cfg->conf_levels);
+ sthw_cfg->conf_levels = conf_levels;
+ sthw_cfg->num_conf_levels = num_conf_levels;
+
+ st_hw_ses->custom_data = (char *)rc_config + rc_config->data_offset;
+ st_hw_ses->custom_data_size = rc_config->data_size;
}
- /*
- * If any of the active clients requested capture or enabled the
- * second stage, the underlying hw session buffering needs to
- * be enabled. Ignore if it is already enabled.
- */
+
+ } else {
if (!st_ses->lab_enabled && enable_lab)
st_ses->lab_enabled = true;
- /* Aggregate DSP configuration for highest client configuration */
+ sthw_cfg->client_req_hist_buf = stc_ses->hist_buf_duration;
+ if (st_hw_ses->max_hist_buf < stc_ses->hist_buf_duration)
+ st_hw_ses->max_hist_buf = stc_ses->hist_buf_duration;
- /* SVA2.0 sound models */
- if (!stc_ses->hist_buf_duration &&
- stc_ses->rc_config->capture_requested &&
- (stc_ses->rc_config->data_size > 0)) {
- stc_ses->hist_buf_duration = st_ses->vendor_uuid_info->kw_duration;
- stc_ses->preroll_duration = 0;
- }
-
- if (stc_ses->hist_buf_duration > sthw_cfg->client_req_hist_buf)
- sthw_cfg->client_req_hist_buf = stc_ses->hist_buf_duration;
- if (stc_ses->preroll_duration > sthw_cfg->client_req_preroll)
- sthw_cfg->client_req_preroll = stc_ses->preroll_duration;
-
- ALOGV("%s: client hb_sz %d pr_sz %d, sthw lab %d hb_sz %d "
- "pr_sz %d", __func__, stc_ses->hist_buf_duration,
- stc_ses->preroll_duration, st_ses->lab_enabled,
- sthw_cfg->client_req_hist_buf, sthw_cfg->client_req_preroll);
-
- /* Cache it to use when client restarts without config update or
- * during only one remaining client model as there won't be a
- * merged model yet.
- */
- memcpy(stc_ses->sm_info.cf_levels, conf_levels,
- stc_ses->sm_info.cf_levels_size);
-
- status = update_merge_conf_levels_payload(st_ses, &stc_ses->sm_info,
- conf_levels, num_conf_levels, true);
- free(conf_levels); /* Merged model conf levels will be used further */
- if (status)
- return status;
-
- sthw_cfg->conf_levels = st_ses->sm_info.cf_levels;
- sthw_cfg->num_conf_levels = st_ses->sm_info.cf_levels_size;
- st_hw_ses->sthw_cfg_updated = true;
+ sthw_cfg->client_req_preroll = stc_ses->preroll_duration;
+ if (st_hw_ses->max_preroll < stc_ses->preroll_duration)
+ st_hw_ses->max_preroll = stc_ses->preroll_duration;
/*
- * Merging further unknown custom data is not needed, as
- * SVA doesn't support unkown custom data. if required in future,
- * handle here.
- * For now just copy the the current client data which is same
- * across SVA engines.
- * Update the custom data for the case in which one client session
- * does not have custom data and another one does.
+ * Cache it to use when client restarts without
+ * config update
*/
- if (rc_config->data_size > sthw_cfg->custom_data_size) {
- sthw_cfg->custom_data = (char *)rc_config + rc_config->data_offset;
- sthw_cfg->custom_data_size = rc_config->data_size;
- }
+ memcpy(stc_ses->sm_info.cf_levels, conf_levels,
+ num_conf_levels);
+ stc_ses->sm_info.cf_levels_size = num_conf_levels;
- } else {
- st_ses->recognition_mode = stc_ses->recognition_mode;
- st_ses->lab_enabled = enable_lab;
-
- sthw_cfg->client_req_hist_buf = stc_ses->hist_buf_duration;
- sthw_cfg->client_req_preroll = stc_ses->preroll_duration;
-
- if (sthw_cfg->conf_levels)
- free(sthw_cfg->conf_levels);
- sthw_cfg->conf_levels = conf_levels;
+ memcpy(sthw_cfg->conf_levels, conf_levels,
+ num_conf_levels);
sthw_cfg->num_conf_levels = num_conf_levels;
+ free(conf_levels);
- sthw_cfg->custom_data = (char *)rc_config + rc_config->data_offset;
- sthw_cfg->custom_data_size = rc_config->data_size;
+ if (rc_config->data_size >= st_hw_ses->custom_data_size) {
+ st_hw_ses->custom_data = (char *)rc_config + rc_config->data_offset;
+ st_hw_ses->custom_data_size = rc_config->data_size;
+ }
+ st_hw_ses->sthw_cfg_updated = true;
}
ALOGD("%s:[%d] lab enabled %d", __func__, st_ses->sm_handle,
st_ses->lab_enabled);
@@ -2425,6 +2737,47 @@
return status;
}
+static int reg_all_sm(st_proxy_session_t *st_ses, st_hw_session_t *hw_ses)
+{
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
+ struct listnode *node = NULL;
+ int status = 0;
+
+ list_for_each(node, &st_ses->sm_info_list) {
+ p_info = node_to_item(node, struct st_proxy_ses_sm_info_wrapper,
+ sm_list_node);
+ status = hw_ses->fptrs->reg_sm(hw_ses, p_info->sm_info.sm_data,
+ p_info->sm_info.sm_size, p_info->sm_info.model_id);
+ if (status) {
+ ALOGE("%s:[%d] reg_sm failed, model_id = %d, status = %d", __func__,
+ st_ses->sm_handle, p_info->sm_info.model_id, status);
+ return status;
+ }
+ }
+
+ return 0;
+}
+
+static int dereg_all_sm(st_proxy_session_t *st_ses, st_hw_session_t *hw_ses)
+{
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
+ struct listnode *node = NULL;
+ int status = 0, ret = 0;
+
+ list_for_each(node, &st_ses->sm_info_list) {
+ p_info = node_to_item(node, struct st_proxy_ses_sm_info_wrapper,
+ sm_list_node);
+ status = hw_ses->fptrs->dereg_sm(hw_ses, p_info->sm_info.model_id);
+ if (status) {
+ ALOGE("%s:[%d] dereg_sm failed, model_id = %d, status = %d", __func__,
+ st_ses->sm_handle, p_info->sm_info.model_id, status);
+ ret = status;
+ }
+ }
+
+ return ret;
+}
+
static void do_hw_sess_cleanup(st_proxy_session_t *st_ses,
st_hw_session_t *hw_ses, enum hw_session_err_mask err)
{
@@ -2443,7 +2796,7 @@
hw_ses->fptrs->set_device(hw_ses, false);
if (err & HW_SES_ERR_MASK_REG_SM)
- hw_ses->fptrs->dereg_sm(hw_ses);
+ dereg_all_sm(st_ses, hw_ses);
}
static void reg_hal_event_session(st_session_t *stc_ses,
@@ -2564,7 +2917,7 @@
if (do_unload) {
if (!load_sm) {
load_sm = true;
- status = hw_ses->fptrs->dereg_sm(hw_ses);
+ status = dereg_all_sm(st_ses, hw_ses);
if (status)
ALOGW("%s:[%d] failed to dereg_sm err %d", __func__,
st_ses->sm_handle, status);
@@ -2572,8 +2925,7 @@
}
if (load_sm) {
- status = hw_ses->fptrs->reg_sm(hw_ses, st_ses->sm_info.sm_data,
- st_ses->sm_info.sm_size, st_ses->sm_info.sm_type);
+ status = reg_all_sm(st_ses, hw_ses);
if (status) {
ALOGE("%s:[%d] failed to reg_sm err %d", __func__,
st_ses->sm_handle, status);
@@ -2591,8 +2943,7 @@
err |= HW_SES_ERR_MASK_DEVICE_SET;
status = hw_ses->fptrs->reg_sm_params(hw_ses, st_ses->recognition_mode,
- st_ses->lab_enabled, st_ses->rc_config, st_ses->sm_info.sm_type,
- st_ses->sm_info.sm_data);
+ st_ses->lab_enabled, st_ses->rc_config);
if (status) {
ALOGE("%s:[%d] failed to reg_sm_params err %d", __func__,
st_ses->sm_handle, status);
@@ -2643,7 +2994,7 @@
rc = status;
}
if (unload_sm) {
- status = hw_ses->fptrs->dereg_sm(hw_ses);
+ status = dereg_all_sm(st_ses, hw_ses);
if (status) {
ALOGE("%s:[%d] failed to dereg_sm, err %d", __func__,
st_ses->sm_handle, status);
@@ -2679,8 +3030,7 @@
int status = 0;
status = hw_ses->fptrs->restart(hw_ses, st_ses->recognition_mode,
- st_ses->rc_config, st_ses->sm_info.sm_type,
- st_ses->sm_info.sm_data);
+ st_ses->rc_config);
if (status == 0) {
st_ses->hw_session_started = true;
} else {
@@ -2727,6 +3077,7 @@
st_arm_second_stage_t *st_sec_stage = NULL;
st_session_t *stc_ses = st_ses->det_stc_ses;
bool is_active_vop_session = false;
+ multi_model_result_info_t *result_info = NULL;
list_for_each(node, &stc_ses->second_stage_list) {
st_sec_stage = node_to_item(node, st_arm_second_stage_t, list_node);
@@ -2748,13 +3099,20 @@
key_payload_size = *((uint32_t *)payload_ptr + 1);
switch (key_id) {
+ case KEY_ID_MULTI_MODEL_RESULT_INFO:
+ result_info = (multi_model_result_info_t *)(payload_ptr +
+ GENERIC_DET_EVENT_HEADER_SIZE);
+ hw_ses->kw_start_idx = result_info->keyword_start_idx_bytes;
+ hw_ses->kw_end_idx = result_info->keyword_end_idx_bytes;
+ break;
+
case KEY_ID_CONFIDENCE_LEVELS:
if (is_active_vop_session) {
/*
* It is expected that VoP is supported with single KW/user
* SVA3.0 model, hence get it directly with hard offset.
*/
- if (!st_ses->sm_info.sm_merged) {
+ if (!st_ses->sm_merged) {
hw_ses->user_level = (int32_t)(*(payload_ptr +
GENERIC_DET_EVENT_USER_LEVEL_OFFSET));
} else {
@@ -2779,13 +3137,17 @@
GENERIC_DET_EVENT_KW_END_OFFSET);
break;
+ case KEY_ID_TIMESTAMP_INFO:
+ /* No op */
+ break;
+
default:
ALOGW("%s: Unsupported generic detection event key id",
__func__);
break;
}
count_size += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
- payload_ptr += count_size;
+ payload_ptr += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
}
} else {
/*
@@ -2796,9 +3158,9 @@
* duration from platform xml will be used.
*/
hw_ses->kw_start_idx = 0;
- if (hw_ses->sthw_cfg.client_req_hist_buf) {
+ if (hw_ses->max_hist_buf) {
hw_ses->kw_end_idx =
- convert_ms_to_bytes(hw_ses->sthw_cfg.client_req_hist_buf,
+ convert_ms_to_bytes(hw_ses->max_hist_buf,
&hw_ses->config);
} else {
hw_ses->kw_end_idx =
@@ -2935,6 +3297,22 @@
key_payload_size = *((uint32_t *)payload + 1);
switch (key_id) {
+ case KEY_ID_MULTI_MODEL_RESULT_INFO:
+ opaque_size += sizeof(struct st_param_header);
+ if (version != CONF_LEVELS_INTF_VERSION_0002) {
+ opaque_size +=
+ sizeof(struct st_confidence_levels_info);
+ } else {
+ opaque_size +=
+ sizeof(struct st_confidence_levels_info_v2);
+ }
+
+ opaque_size += sizeof(struct st_param_header) +
+ sizeof(struct st_keyword_indices_info);
+ opaque_size += sizeof(struct st_param_header) +
+ sizeof(struct st_timestamp_info);
+ break;
+
case KEY_ID_CONFIDENCE_LEVELS:
opaque_size += sizeof(struct st_param_header);
if (version != CONF_LEVELS_INTF_VERSION_0002) {
@@ -2944,25 +3322,26 @@
opaque_size +=
sizeof(struct st_confidence_levels_info_v2);
}
- count_size += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
- payload += count_size;
break;
case KEY_ID_KEYWORD_POSITION_STATS:
opaque_size += sizeof(struct st_param_header) +
sizeof(struct st_keyword_indices_info);
- count_size += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
- payload += count_size;
+ break;
+
+ case KEY_ID_TIMESTAMP_INFO:
+ opaque_size += sizeof(struct st_param_header) +
+ sizeof(struct st_timestamp_info);
break;
default:
ALOGE("%s: Unsupported generic detection event key id", __func__);
+ break;
}
+ count_size += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
+ payload += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
}
- opaque_size += sizeof(struct st_param_header) +
- sizeof(struct st_timestamp_info);
-
return opaque_size;
}
@@ -3139,6 +3518,7 @@
struct sound_trigger_phrase_recognition_event *local_event)
{
uint32_t key_id = 0, key_payload_size = 0;
+ uint32_t timestamp_msw = 0, timestamp_lsw = 0;
struct st_param_header *param_hdr = NULL;
struct st_keyword_indices_info *kw_indices = NULL;
struct st_timestamp_info *timestamps = NULL;
@@ -3149,15 +3529,91 @@
int status = 0;
unsigned char *cf_levels = NULL;
unsigned int cf_levels_size = 0;
+ multi_model_result_info_t *result_info = NULL;
while (count_size < payload_size) {
key_id = *(uint32_t *)payload;
key_payload_size = *((uint32_t *)payload + 1);
switch (key_id) {
+ case KEY_ID_MULTI_MODEL_RESULT_INFO:
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ ALOGE("%s: Error. Multi sm result info supported on PDK5 only",
+ __func__);
+ status = -EINVAL;
+ goto exit;
+ }
+ /* Set confidence levels */
+ param_hdr = (struct st_param_header *)opaque_data;
+ param_hdr->key_id = ST_PARAM_KEY_CONFIDENCE_LEVELS;
+ opaque_data += sizeof(struct st_param_header);
+ if (stc_ses->conf_levels_intf_version !=
+ CONF_LEVELS_INTF_VERSION_0002) {
+ param_hdr->payload_size =
+ sizeof(struct st_confidence_levels_info);
+ } else {
+ param_hdr->payload_size =
+ sizeof(struct st_confidence_levels_info_v2);
+ }
+ result_info = (multi_model_result_info_t *)(payload +
+ GENERIC_DET_EVENT_HEADER_SIZE);
+
+ memset(stc_ses->sm_info.det_cf_levels, 0,
+ MAX_MULTI_SM_CONF_LEVELS);
+
+ cf_levels = stc_ses->sm_info.det_cf_levels;
+ cf_levels_size = stc_ses->sm_info.cf_levels_size;
+ memcpy(opaque_data, stc_ses->st_conf_levels,
+ param_hdr->payload_size);
+ *(cf_levels + result_info->detected_keyword_id) =
+ result_info->best_confidence_level;
+ pack_opaque_data_conf_levels(st_ses, opaque_data,
+ cf_levels, cf_levels_size);
+ pack_recognition_event_conf_levels(st_ses, cf_levels,
+ cf_levels_size, local_event);
+ opaque_data += param_hdr->payload_size;
+
+ /* Set keyword indices */
+ param_hdr = (struct st_param_header *)opaque_data;
+ param_hdr->key_id = ST_PARAM_KEY_KEYWORD_INDICES;
+ param_hdr->payload_size = sizeof(struct st_keyword_indices_info);
+ opaque_data += sizeof(struct st_param_header);
+ kw_indices = (struct st_keyword_indices_info *)opaque_data;
+ kw_indices->version = 0x1;
+ kw_indices->start_index = result_info->keyword_start_idx_bytes;
+ kw_indices->end_index = result_info->keyword_end_idx_bytes;
+
+ list_for_each(node, &stc_ses->second_stage_list) {
+ st_sec_stage = node_to_item(node, st_arm_second_stage_t,
+ list_node);
+ if (IS_KEYWORD_DETECTION_MODEL(st_sec_stage->ss_info->sm_id)) {
+ kw_indices->start_index =
+ st_sec_stage->ss_session->kw_start_idx;
+ kw_indices->end_index =
+ st_sec_stage->ss_session->kw_end_idx;
+ }
+ }
+ opaque_data += sizeof(struct st_keyword_indices_info);
+
+ /* Set timestamp */
+ param_hdr = (struct st_param_header *)opaque_data;
+ param_hdr->key_id = ST_PARAM_KEY_TIMESTAMP;
+ param_hdr->payload_size = sizeof(struct st_timestamp_info);
+ opaque_data += sizeof(struct st_param_header);
+ timestamps = (struct st_timestamp_info *)opaque_data;
+ timestamps->version = 0x1;
+ timestamps->first_stage_det_event_time =
+ (uint64_t)result_info->timestamp_msw_us << 32 |
+ result_info->timestamp_lsw_us;
+ if (!list_empty(&stc_ses->second_stage_list))
+ timestamps->second_stage_det_event_time =
+ st_ses->hw_ses_current->second_stage_det_event_time;
+ opaque_data += sizeof(struct st_timestamp_info);
+ break;
+
case KEY_ID_CONFIDENCE_LEVELS:
/* Pack the opaque data confidence levels structure */
- param_hdr = (struct st_param_header *)(opaque_data);
+ param_hdr = (struct st_param_header *)opaque_data;
param_hdr->key_id = ST_PARAM_KEY_CONFIDENCE_LEVELS;
opaque_data += sizeof(struct st_param_header);
if (stc_ses->conf_levels_intf_version !=
@@ -3186,11 +3642,11 @@
case KEY_ID_KEYWORD_POSITION_STATS:
/* Pack the opaque data keyword indices structure */
- param_hdr = (struct st_param_header *)(opaque_data);
+ param_hdr = (struct st_param_header *)opaque_data;
param_hdr->key_id = ST_PARAM_KEY_KEYWORD_INDICES;
param_hdr->payload_size = sizeof(struct st_keyword_indices_info);
opaque_data += sizeof(struct st_param_header);
- kw_indices = (struct st_keyword_indices_info *)(opaque_data);
+ kw_indices = (struct st_keyword_indices_info *)opaque_data;
kw_indices->version = 0x1;
kw_indices->start_index = *((uint32_t *)payload + 3);
kw_indices->end_index = *((uint32_t *)payload + 4);
@@ -3208,29 +3664,33 @@
opaque_data += sizeof(struct st_keyword_indices_info);
break;
+ case KEY_ID_TIMESTAMP_INFO:
+ /* Pack the opaque data detection timestamp structure */
+ param_hdr = (struct st_param_header *)opaque_data;
+ param_hdr->key_id = ST_PARAM_KEY_TIMESTAMP;
+ param_hdr->payload_size = sizeof(struct st_timestamp_info);
+ opaque_data += sizeof(struct st_param_header);
+ timestamp_lsw = *((uint32_t *)payload + 3);
+ timestamp_msw = *((uint32_t *)payload + 4);
+ timestamps = (struct st_timestamp_info *)opaque_data;
+ timestamps->version = 0x1;
+ timestamps->first_stage_det_event_time =
+ (uint64_t)timestamp_msw << 32 | timestamp_lsw;
+ if (!list_empty(&stc_ses->second_stage_list))
+ timestamps->second_stage_det_event_time =
+ st_ses->hw_ses_current->second_stage_det_event_time;
+ opaque_data += sizeof(struct st_timestamp_info);
+ break;
+
default:
ALOGE("%s: Unsupported generic detection event key id", __func__);
status = -EINVAL;
goto exit;
}
count_size += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
- payload += count_size;
+ payload += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
}
- /* Pack the opaque data detection timestamp structure */
- param_hdr = (struct st_param_header *)(opaque_data);
- param_hdr->key_id = ST_PARAM_KEY_TIMESTAMP;
- param_hdr->payload_size = sizeof(struct st_timestamp_info);
- opaque_data += sizeof(struct st_param_header);
- timestamps = (struct st_timestamp_info *)(opaque_data);
- timestamps->version = 0x1;
- timestamps->first_stage_det_event_time =
- st_ses->hw_ses_current->first_stage_det_event_time;
- if (!list_empty(&stc_ses->second_stage_list))
- timestamps->second_stage_det_event_time =
- st_ses->hw_ses_current->second_stage_det_event_time;
- opaque_data += sizeof(struct st_timestamp_info);
-
exit:
return status;
}
@@ -3243,7 +3703,7 @@
size_t count_size = 0;
int status = 0;
unsigned char *cf_levels = NULL;
- unsigned int cf_levels_size = 0;;
+ unsigned int cf_levels_size = 0;
while (count_size < payload_size) {
key_id = *(uint32_t *)payload;
@@ -3264,7 +3724,12 @@
case KEY_ID_KEYWORD_POSITION_STATS:
count_size += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
- payload += count_size;
+ payload += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
+ break;
+
+ case KEY_ID_TIMESTAMP_INFO:
+ count_size += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
+ payload += GENERIC_DET_EVENT_HEADER_SIZE + key_payload_size;
break;
default:
@@ -3682,7 +4147,7 @@
struct sound_trigger_phrase_recognition_event *phrase_event = NULL;
*event = NULL;
- if (st_ses->sm_info.sm_type == SOUND_MODEL_TYPE_KEYPHRASE) {
+ if (st_ses->det_stc_ses->sm_type == SOUND_MODEL_TYPE_KEYPHRASE) {
if (sthw_extn_check_process_det_ev_support())
ret = sthw_extn_process_detection_event_keyphrase(st_ses,
timestamp, detect_status, payload, payload_size, &phrase_event);
@@ -3977,11 +4442,74 @@
st_ses->aggregator_thread_created = false;
}
+static int init_st_hw_config(st_hw_session_t *hw_ses, uint32_t model_id)
+{
+ struct st_hw_ses_config *sthw_cfg = NULL;
+ int status;
+
+ sthw_cfg = calloc(1, sizeof(struct st_hw_ses_config));
+ if (!sthw_cfg) {
+ ALOGE("%s: Failed to allocate struct st_hw_ses_config, exiting",
+ __func__);
+ return -ENOMEM;
+ }
+ sthw_cfg->model_id = model_id;
+
+ if (hw_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ sthw_cfg->conf_levels = calloc(1, MAX_MULTI_SM_CONF_LEVELS);
+ if (!sthw_cfg->conf_levels) {
+ ALOGE("%s: Failed to allocate conf_levels, exiting",
+ __func__);
+ status = -ENOMEM;
+ goto exit;
+ }
+ memset(sthw_cfg->conf_levels, MAX_CONF_LEVEL_VALUE,
+ MAX_MULTI_SM_CONF_LEVELS);
+ }
+
+ list_add_tail(&hw_ses->sthw_cfg_list,
+ &sthw_cfg->sthw_cfg_list_node);
+
+ return 0;
+
+exit:
+ if (sthw_cfg) {
+ free(sthw_cfg);
+ sthw_cfg = NULL;
+ }
+ return status;
+}
+
+static int deinit_st_hw_config(st_hw_session_t *hw_ses, uint32_t model_id)
+{
+ struct st_hw_ses_config *sthw_cfg = NULL;
+
+ sthw_cfg = get_sthw_cfg_for_model_id(hw_ses, model_id);
+ if (!sthw_cfg) {
+ ALOGE("%s: Unexpected, no matching sthw_cfg", __func__);
+ return -EINVAL;
+ }
+
+ if (hw_ses->f_stage_version == ST_MODULE_TYPE_PDK5 &&
+ sthw_cfg->conf_levels) {
+ free(sthw_cfg->conf_levels);
+ sthw_cfg->conf_levels = NULL;
+ }
+
+ list_remove(&sthw_cfg->sthw_cfg_list_node);
+ free(sthw_cfg);
+ sthw_cfg = NULL;
+
+ return 0;
+}
+
/* This function is called for multi-client */
static int handle_load_sm(st_proxy_session_t *st_ses, st_session_t *stc_ses)
{
st_hw_session_t *hw_ses = st_ses->hw_ses_current;
st_proxy_session_state_fn_t curr_state = st_ses->current_state;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
+ struct st_hw_ses_config *sthw_cfg = NULL;
int status = 0;
ALOGV("%s:[c%d-%d]", __func__, stc_ses->sm_handle, st_ses->sm_handle);
@@ -4010,10 +4538,12 @@
STATE_TRANSITION(st_ses, loaded_state_fn);
}
- status = hw_ses->fptrs->dereg_sm(hw_ses);
- if (status) {
- ALOGE("%s:[%d] dereg_sm failed %d", __func__,
- st_ses->sm_handle, status);
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ status = hw_ses->fptrs->dereg_sm(hw_ses, 0);
+ if (status) {
+ ALOGE("%s:[%d] dereg_sm failed %d", __func__,
+ st_ses->sm_handle, status);
+ }
}
/* Continue updating sound model resulting in merged model */
status = update_sound_model(stc_ses, true);
@@ -4022,20 +4552,40 @@
stc_ses->sm_handle, status);
goto exit;
}
- hw_ses->sthw_cfg.conf_levels = st_ses->sm_info.cf_levels;
- hw_ses->sthw_cfg.num_conf_levels = st_ses->sm_info.cf_levels_size;
- hw_ses->sthw_cfg_updated = true;
- /*
- * Sound model merge would have changed the order of merge conf levels,
- * which need to be re-updated for all current active clients, if any.
- */
- status = update_merge_conf_levels_payload_with_active_clients(st_ses);
- if (status)
- goto exit_1;
- /* Load merged sound model */
- status = hw_ses->fptrs->reg_sm(hw_ses, st_ses->sm_info.sm_data,
- st_ses->sm_info.sm_size, st_ses->sm_info.sm_type);
+ p_info = get_sm_info_for_model_id(st_ses, stc_ses->sm_info.model_id);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ status = -EINVAL;
+ goto exit_1;
+ }
+
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ sthw_cfg = get_sthw_cfg_for_model_id(hw_ses, 0);
+ if (!sthw_cfg) {
+ ALOGE("%s: Unexpected, no matching sthw_cfg", __func__);
+ status = -EINVAL;
+ goto exit_1;
+ }
+
+ sthw_cfg->conf_levels = p_info->sm_info.cf_levels;
+ sthw_cfg->num_conf_levels = p_info->sm_info.cf_levels_size;
+ /*
+ * Sound model merge would have changed the order of merge conf levels,
+ * which need to be re-updated for all current active clients, if any.
+ */
+ status = update_merge_conf_levels_payload_with_active_clients(st_ses);
+ if (status)
+ goto exit_1;
+ } else {
+ status = init_st_hw_config(hw_ses, stc_ses->sm_info.model_id);
+ if (status)
+ goto exit_1;
+ }
+ hw_ses->sthw_cfg_updated = true;
+
+ status = hw_ses->fptrs->reg_sm(hw_ses, p_info->sm_info.sm_data,
+ p_info->sm_info.sm_size, p_info->sm_info.model_id);
if (status) {
ALOGE("%s:[%d] reg_sm failed %d", __func__,
st_ses->sm_handle, status);
@@ -4056,16 +4606,18 @@
exit_2:
if (!st_ses->stdev->ssr_offline_received)
- hw_ses->fptrs->dereg_sm(hw_ses);
+ hw_ses->fptrs->dereg_sm(hw_ses, p_info->sm_info.model_id);
exit_1:
if (!st_ses->stdev->ssr_offline_received) {
update_sound_model(stc_ses, false);
- update_merge_conf_levels_payload_with_active_clients(st_ses);
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM)
+ update_merge_conf_levels_payload_with_active_clients(st_ses);
}
exit:
if (st_ses->stdev->ssr_offline_received) {
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, ssr_state_fn);
status = 0;
}
@@ -4077,6 +4629,8 @@
{
st_hw_session_t *hw_ses = st_ses->hw_ses_current;
st_proxy_session_state_fn_t curr_state = st_ses->current_state;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
+ struct st_hw_ses_config *sthw_cfg = NULL;
int status = 0;
ALOGV("%s:[c%d-%d]", __func__, stc_ses->sm_handle, st_ses->sm_handle);
@@ -4100,7 +4654,7 @@
STATE_TRANSITION(st_ses, loaded_state_fn);
}
- status = hw_ses->fptrs->dereg_sm(hw_ses);
+ status = hw_ses->fptrs->dereg_sm(hw_ses, stc_ses->sm_info.model_id);
if (status)
ALOGE("%s:[%d] dereg_sm failed %d", __func__, st_ses->sm_handle, status);
@@ -4110,23 +4664,43 @@
ALOGE("%s:[c%d] update_sound_model delete failed %d", __func__,
stc_ses->sm_handle, status);
- hw_ses->sthw_cfg.conf_levels = st_ses->sm_info.cf_levels;
- hw_ses->sthw_cfg.num_conf_levels = st_ses->sm_info.cf_levels_size;
- hw_ses->sthw_cfg_updated = true;
- /*
- * Sound model merge would have changed the order of merge conf levels,
- * which need to be re-updated for all current active clients, if any.
- */
- update_merge_conf_levels_payload_with_active_clients(st_ses);
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
+ p_info = get_sm_info_for_model_id(st_ses, 0);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ status = -EINVAL;
+ goto exit;
+ }
- /* Load remaining merged sound model */
- status = hw_ses->fptrs->reg_sm(hw_ses, st_ses->sm_info.sm_data,
- st_ses->sm_info.sm_size, st_ses->sm_info.sm_type);
- if (status) {
- ALOGE("%s:[%d] reg_sm failed %d", __func__,
- st_ses->sm_handle, status);
- goto exit;
+ sthw_cfg = get_sthw_cfg_for_model_id(hw_ses, 0);
+ if (!sthw_cfg) {
+ ALOGE("%s: Unexpected, no matching sthw_cfg", __func__);
+ status = -EINVAL;
+ goto exit;
+ }
+
+ sthw_cfg->conf_levels = p_info->sm_info.cf_levels;
+ sthw_cfg->num_conf_levels = p_info->sm_info.cf_levels_size;
+ /*
+ * Sound model merge would have changed the order of merge conf levels,
+ * which need to be re-updated for all current active clients, if any.
+ */
+ update_merge_conf_levels_payload_with_active_clients(st_ses);
+
+ /* Load remaining merged sound model */
+ status = hw_ses->fptrs->reg_sm(hw_ses, p_info->sm_info.sm_data,
+ p_info->sm_info.sm_size, 0);
+ if (status) {
+ ALOGE("%s:[%d] reg_sm failed %d", __func__,
+ st_ses->sm_handle, status);
+ goto exit;
+ }
+ } else {
+ status = deinit_st_hw_config(hw_ses, stc_ses->sm_handle);
+ if (status)
+ goto exit;
}
+ hw_ses->sthw_cfg_updated = true;
if (curr_state == active_state_fn ||
curr_state == detected_state_fn ||
@@ -4141,6 +4715,8 @@
exit:
if (st_ses->stdev->ssr_offline_received) {
+ if (st_ses->f_stage_version == ST_MODULE_TYPE_PDK5)
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, ssr_state_fn);
status = 0;
}
@@ -4153,6 +4729,7 @@
int ret = 0;
st_session_t *stc_ses = ev->stc_ses;
st_hw_session_t *hw_ses = st_ses->hw_ses_current;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
/* skip parameter check as this is an internal funciton */
ALOGD("%s:[c%d-%d] handle event id %d", __func__, stc_ses->sm_handle,
@@ -4173,6 +4750,20 @@
break;
}
+ p_info = get_sm_info_for_model_id(st_ses, stc_ses->sm_info.model_id);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ status = -EINVAL;
+ break;
+ }
+
+ status = init_st_hw_config(hw_ses, p_info->sm_info.model_id);
+ if (status) {
+ ALOGE("%s:[%d] failed to init sthw_cfg, exiting",
+ __func__, st_ses->sm_handle);
+ break;
+ }
+
/*
* Do retry to handle a corner case that when ADSP SSR ONLINE is
* received, sometimes ADSP is still not ready to receive cmd from HLOS
@@ -4180,8 +4771,8 @@
* state.
*/
for (int i = 0; i < REG_SM_RETRY_CNT; i++) {
- status = ret = hw_ses->fptrs->reg_sm(hw_ses, st_ses->sm_info.sm_data,
- st_ses->sm_info.sm_size, st_ses->sm_info.sm_type);
+ status = ret = hw_ses->fptrs->reg_sm(hw_ses, p_info->sm_info.sm_data,
+ p_info->sm_info.sm_size, p_info->sm_info.model_id);
if (ret) {
if (st_ses->stdev->ssr_offline_received) {
STATE_TRANSITION(st_ses, ssr_state_fn);
@@ -4196,6 +4787,7 @@
break;
}
}
+
if (ret)
break;
@@ -4258,6 +4850,7 @@
st_hw_session_t *hw_ses = st_ses->hw_ses_current;
st_hw_session_t *new_hw_ses = NULL;
st_exec_mode_t new_exec_mode = 0;
+ struct st_proxy_ses_sm_info_wrapper *p_info = NULL;
/* skip parameter check as this is an internal function */
ALOGD("%s:[c%d-%d] handle event id %d", __func__, stc_ses->sm_handle,
@@ -4275,7 +4868,7 @@
break;
}
- status = hw_ses->fptrs->dereg_sm(hw_ses);
+ status = hw_ses->fptrs->dereg_sm(hw_ses, stc_ses->sm_info.model_id);
if (status)
ALOGE("%s:[%d] dereg_sm failed %d", __func__,
st_ses->sm_handle, status);
@@ -4285,6 +4878,11 @@
ALOGE("%s:[c%d] update_sound_model failed %d", __func__,
stc_ses->sm_handle, status);
+ status = deinit_st_hw_config(hw_ses, stc_ses->sm_info.model_id);
+ if (status)
+ ALOGE("%s:[c%d] failed to deinit sthw_cfg",
+ __func__, stc_ses->sm_handle);
+
/* since this is a teardown scenario dont fail here */
status = 0;
STATE_TRANSITION(st_ses, idle_state_fn);
@@ -4304,18 +4902,18 @@
hw_ses->lpi_enable = hw_ses->stdev->lpi_enable;
hw_ses->barge_in_mode = hw_ses->stdev->barge_in_mode;
- status = hw_ses->fptrs->dereg_sm(hw_ses);
+ status = dereg_all_sm(st_ses, hw_ses);
if (status) {
ALOGE("%s:[%d] failed to dereg_sm err %d", __func__,
st_ses->sm_handle, status);
break;
}
- status = hw_ses->fptrs->reg_sm(hw_ses, st_ses->sm_info.sm_data,
- st_ses->sm_info.sm_size, st_ses->sm_info.sm_type);
+ status = reg_all_sm(st_ses, hw_ses);
if (status) {
ALOGE("%s:[%d] failed to reg_sm err %d", __func__,
st_ses->sm_handle, status);
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, idle_state_fn);
}
}
@@ -4338,7 +4936,7 @@
status = start_session(st_ses, hw_ses, false);
if (status) {
if (st_ses->stdev->ssr_offline_received) {
- hw_ses->fptrs->dereg_sm(hw_ses);
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, ssr_state_fn);
status = 0;
} else {
@@ -4362,7 +4960,7 @@
case ST_SES_EV_SSR_OFFLINE:
/* exec mode can be none if ssr occurs during a transition */
if (st_ses->exec_mode != ST_EXEC_MODE_NONE)
- hw_ses->fptrs->dereg_sm(hw_ses);
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, ssr_state_fn);
break;
@@ -4385,7 +4983,7 @@
c_ses->exec_mode = ST_EXEC_MODE_NONE;
}
/* unload sm for current hw session */
- status = hw_ses->fptrs->dereg_sm(hw_ses);
+ status = hw_ses->fptrs->dereg_sm(hw_ses, 0);
if (status) {
ALOGE("%s:[%d] dereg_sm failed with err %d", __func__,
st_ses->sm_handle, status);
@@ -4408,9 +5006,15 @@
break;
}
+ p_info = get_sm_info_for_model_id(st_ses, 0);
+ if (!p_info) {
+ ALOGE("%s: Unexpected, no matching sm_info" , __func__);
+ status = -EINVAL;
+ break;
+ }
+
status = new_hw_ses->fptrs->reg_sm(new_hw_ses,
- st_ses->sm_info.sm_data, st_ses->sm_info.sm_size,
- st_ses->sm_info.sm_type);
+ p_info->sm_info.sm_data, p_info->sm_info.sm_size, 0);
if (status) {
ALOGE("%s:[%d] reg_sm failed with err %d", __func__,
st_ses->sm_handle, status);
@@ -4532,7 +5136,7 @@
st_ses->sm_handle, status);
}
if (status & st_ses->stdev->ssr_offline_received) {
- hw_ses->fptrs->dereg_sm(hw_ses);
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, ssr_state_fn);
status = 0;
}
@@ -4618,7 +5222,7 @@
if (status) {
if (st_ses->stdev->ssr_offline_received) {
STATE_TRANSITION(st_ses, ssr_state_fn);
- hw_ses->fptrs->dereg_sm(hw_ses);
+ dereg_all_sm(st_ses, hw_ses);
status = 0;
} else {
ALOGE("%s:[%d] failed to stop session, err %d", __func__,
@@ -4661,7 +5265,7 @@
if (status) {
if (st_ses->stdev->ssr_offline_received) {
- hw_ses->fptrs->dereg_sm(hw_ses);
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, ssr_state_fn);
status = 0;
} else {
@@ -4698,6 +5302,7 @@
st_ses->det_stc_ses = stc_ses;
st_ses->hw_ses_current->enable_second_stage = false; /* Initialize */
stc_ses->detection_sent = false;
+ hw_ses->detected_preroll = stc_ses->preroll_duration;
if (list_empty(&stc_ses->second_stage_list) ||
st_ses->detection_requested) {
@@ -5252,7 +5857,7 @@
if (status) {
if (st_ses->stdev->ssr_offline_received) {
- hw_ses->fptrs->dereg_sm(hw_ses);
+ dereg_all_sm(st_ses, hw_ses);
STATE_TRANSITION(st_ses, ssr_state_fn);
status = 0;
} else {
@@ -5987,7 +6592,7 @@
st_proxy_session_t *st_ses = stc_ses->hw_proxy_ses;
pthread_mutex_lock(&st_ses->lock);
- val = st_ses->hw_ses_current->sthw_cfg.client_req_preroll;
+ val = st_ses->hw_ses_current->max_preroll;
pthread_mutex_unlock(&st_ses->lock);
return val;
@@ -6242,45 +6847,71 @@
* Check for merge sound model support and return the existing hw
* session. If any other clients have already created it.
*/
- if (v_info->merge_fs_soundmodels) {
+ if (v_info->merge_fs_soundmodels &&
+ stc_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
if (!v_info->is_qcva_uuid) {
- ALOGE("%s: merge sound model not supported for non SVA engines",
- __func__);
- status = -ENOSYS;
- goto cleanup;
+ ALOGE("%s: merge sound model not supported for non SVA engines",
+ __func__);
+ status = -ENOSYS;
+ goto cleanup;
}
list_for_each(node, &stdev->sound_model_list) {
c_ses = node_to_item(node, st_session_t, list_node);
if ((c_ses != stc_ses) &&
c_ses->vendor_uuid_info->is_qcva_uuid &&
- c_ses->vendor_uuid_info->merge_fs_soundmodels) {
+ c_ses->vendor_uuid_info->merge_fs_soundmodels &&
+ c_ses->f_stage_version == ST_MODULE_TYPE_GMM) {
stc_ses->hw_proxy_ses = c_ses->hw_proxy_ses;
list_add_tail(&stc_ses->hw_proxy_ses->clients_list,
&stc_ses->hw_list_node);
- ALOGD("%s: another client attached: h%d <-- c%d", __func__,
- stc_ses->hw_proxy_ses->sm_handle, sm_handle);
+ ALOGD("%s: another client attached, merge SM: h%d <-- c%d",
+ __func__, stc_ses->hw_proxy_ses->sm_handle, sm_handle);
free(st_ses);
st_ses = NULL;
break;
}
}
- }
- if (st_ses) { /* If no other client exist */
- st_ses->hw_ses_adsp =
- (st_hw_session_t *)calloc(1, sizeof(st_hw_session_lsm_t));
- if (!st_ses->hw_ses_adsp) {
- status = -ENOMEM;
- goto cleanup;
- }
- status = st_hw_sess_lsm_init(st_ses->hw_ses_adsp, hw_sess_cb,
- (void *)st_ses, exec_mode, v_info, sm_handle, stdev);
- if (status) {
- ALOGE("%s: initializing lsm hw session failed %d",
- __func__, status);
- goto cleanup;
- }
- st_ses->hw_ses_current = st_ses->hw_ses_adsp;
- }
+ } else if (stc_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ if (!v_info->is_qcva_uuid) {
+ ALOGE("%s: multi sound model not supported for non SVA engines",
+ __func__);
+ status = -ENOSYS;
+ goto cleanup;
+ }
+ list_for_each(node, &stdev->sound_model_list) {
+ c_ses = node_to_item(node, st_session_t, list_node);
+ if ((c_ses != stc_ses) &&
+ c_ses->vendor_uuid_info->is_qcva_uuid &&
+ c_ses->f_stage_version == ST_MODULE_TYPE_PDK5) {
+ stc_ses->hw_proxy_ses = c_ses->hw_proxy_ses;
+ list_add_tail(&stc_ses->hw_proxy_ses->clients_list,
+ &stc_ses->hw_list_node);
+ ALOGD("%s: another client attached, multi SM: h%d <-- c%d",
+ __func__, stc_ses->hw_proxy_ses->sm_handle, sm_handle);
+ free(st_ses);
+ st_ses = NULL;
+ break;
+ }
+ }
+ }
+ if (st_ses) { /* If no other client exist */
+ st_ses->hw_ses_adsp =
+ (st_hw_session_t *)calloc(1, sizeof(st_hw_session_lsm_t));
+ if (!st_ses->hw_ses_adsp) {
+ status = -ENOMEM;
+ goto cleanup;
+ }
+ status = st_hw_sess_lsm_init(st_ses->hw_ses_adsp, hw_sess_cb,
+ (void *)st_ses, exec_mode, v_info, sm_handle, stdev);
+ if (status) {
+ ALOGE("%s: initializing lsm hw session failed %d",
+ __func__, status);
+ goto cleanup;
+ }
+ st_ses->hw_ses_current = st_ses->hw_ses_adsp;
+ st_ses->f_stage_version = stc_ses->f_stage_version;
+ st_ses->hw_ses_current->f_stage_version = stc_ses->f_stage_version;
+ }
} else if (v_info && (EXEC_MODE_CFG_ARM == v_info->exec_mode_cfg)) {
st_ses->enable_trans = false;
st_ses->hw_ses_arm = calloc(1, sizeof(st_hw_session_pcm_t));
@@ -6330,6 +6961,7 @@
pthread_mutex_init(&st_ses->lock, (const pthread_mutexattr_t *)&attr);
stc_ses->hw_proxy_ses = st_ses;
+ list_init(&st_ses->sm_info_list);
list_init(&st_ses->clients_list);
list_add_tail(&st_ses->clients_list, &stc_ses->hw_list_node);
ALOGD("%s: client attached: h%d <-- c%d", __func__,
diff --git a/st_session.h b/st_session.h
index e779aa6..fe0816f 100644
--- a/st_session.h
+++ b/st_session.h
@@ -4,7 +4,7 @@
* abstraction represents a single st session from the application/framework
* point of view.
*
- * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -83,8 +83,23 @@
typedef struct st_proxy_session st_proxy_session_t;
typedef int (*st_proxy_session_state_fn_t)(st_proxy_session_t*,
st_session_ev_t *ev);
+typedef struct multi_model_result_info multi_model_result_info_t;
+
+struct multi_model_result_info {
+ uint32_t minor_version;
+ uint32_t num_detected_models;
+ uint32_t detected_model_id;
+ uint32_t detected_keyword_id;
+ uint32_t best_channel_idx;
+ int32_t best_confidence_level;
+ int32_t keyword_start_idx_bytes;
+ int32_t keyword_end_idx_bytes;
+ uint32_t timestamp_lsw_us;
+ uint32_t timestamp_msw_us;
+};
struct sound_model_info {
+ unsigned int model_id;
unsigned char *sm_data;
unsigned int sm_size;
sound_trigger_sound_model_type_t sm_type;
@@ -96,7 +111,11 @@
unsigned char *cf_levels;
unsigned char *det_cf_levels;
unsigned int cf_levels_size;
- bool sm_merged;
+};
+
+struct st_proxy_ses_sm_info_wrapper {
+ struct listnode sm_list_node;
+ struct sound_model_info sm_info;
};
struct st_session {
@@ -139,6 +158,8 @@
st_proxy_session_t *hw_proxy_ses;
struct sound_model_info sm_info;
+
+ st_module_type_t f_stage_version;
};
struct st_proxy_session {
@@ -151,7 +172,6 @@
bool enable_trans;
struct sound_trigger_recognition_config *rc_config;
- sound_trigger_sound_model_type_t sm_type;
sound_model_handle_t sm_handle;
bool lab_enabled;
unsigned int recognition_mode;
@@ -186,9 +206,12 @@
int rc_config_update_counter;
bool detection_requested;
- struct sound_model_info sm_info;
+ struct listnode sm_info_list;
+ bool sm_merged;
FILE *lab_fp;
uint64_t detection_event_time;
+
+ st_module_type_t f_stage_version;
};
/*