/*
 * Copyright (C) 2025 Amlogic Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#define LOG_TAG "audio_mpegh"
//#define LOG_NDEBUG 0

#include <stdint.h>
#include <stddef.h>
#include <cutils/str_parms.h>
#include <cutils/properties.h>

#include "audio_buffer.h"
#include "audio_hw.h"
#include "audio_mpegh.h"
#include "aml_mpegh_uimanager.h"
#include "aml_audio_log.h"
#include "aml_dump_debug.h"
#include "aml_malloc_debug.h"
#include "aml_audio_stream.h"

#define AML_MPEGH_BASE64_BUFSIZE ((AML_MPEGH_PERSISTENCE_BUFSIZE + 2) / 3) * 4
#define AML_MPEGH_UIMANAGER_PROP_DUMP_FLAG                    "vendor.media.audio.mpegh.uimanager.dump"
#define AML_MPEGH_UIMANAGER_PROP_DEBUG_FLAG                   "vendor.media.audio.mpegh.uimanager.debug"

typedef struct ActionEventNode {
    char* event;
    struct ActionEventNode* next;
} ActionEventNode;

typedef struct {
    ActionEventNode* head;
    ActionEventNode* tail;
    size_t size;
} ActionEventQueue;

typedef struct KeyValue {
    char* key;
    char* value;
    struct KeyValue* next;
} KeyValue;

static KeyValue* uiManagerSystemSetting = NULL;
static ActionEventQueue g_actionQueue = {NULL, NULL, 0};
int str_parms_has_key(struct str_parms *str_parms, const char *key);

static KeyValue* findKey(const char* key) {
    if (key == NULL || *key == '\0') {
        AM_LOGE("findKey: invalid key (NULL or empty)!");
        return NULL;
    }
    KeyValue* current = uiManagerSystemSetting;
    while (current != NULL) {
        if (strcmp(current->key, key) == 0) {
            return current;
        }
        current = current->next;
    }
    return NULL;
}

static void freeKeyValue(KeyValue* kv) {
    if (kv == NULL) return;
    aml_audio_free(kv->key);
    aml_audio_free(kv->value);
    aml_audio_free(kv);
}

int saveMpeghSysActioneventXml(const char* key, const char* value) {
    if (key == NULL || key[0] == '\0' || value == NULL) {
        return -1;
    }

    KeyValue* existing = findKey(key);
    if (existing != NULL) {
        aml_audio_free(existing->value);
        existing->value = strdup(value);
        if (existing->value == NULL) {
            return -1;
        }
        return 0;
    } else {
        KeyValue* newNode = (KeyValue*)aml_audio_malloc(sizeof(KeyValue));
        if (newNode == NULL) {
            return -1;
        }
        newNode->key = strdup(key);
        newNode->value = strdup(value);
        if (newNode->key == NULL || newNode->value == NULL) {
            freeKeyValue(newNode);
            return -1;
        }
        newNode->next = uiManagerSystemSetting;
        uiManagerSystemSetting = newNode;
        return 0;
    }
}

void freeUiManagerSystemSetting() {
    KeyValue* current = uiManagerSystemSetting;
    while (current != NULL) {
        KeyValue* next = current->next;
        freeKeyValue(current);
        current = next;
    }
    uiManagerSystemSetting = NULL;
}

const char *mpeghSystemActionEventXml[] = {
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"70\" paramInt=\"0\" paramText=\"%s\"/>",
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"71\" paramInt=\"0\" paramText=\"%s\"/>",
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"12\" paramFloat=\"%s\"/>",
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"31\" paramInt=\"%s\"/>",
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"10\" paramInt=\"%s\"/>",
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"21\" paramBool=\"%s\"/>",
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"11\" paramFloat=\"%s\"/>",
    "<ActionEvent uuid=\"00000000-0000-0000-0000-000000000000\" version=\"11.0\" actionType=\"20\" paramFloat=\"%s\"/>"
};

static const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int aml_mpegh_base64_encode(const unsigned char* input, int input_length, struct aml_audio_device *adev) {
    if (!input || !input_length || !adev) {
        ALOGE("%s parameters invalid", __func__);
        return -1;
    }
    int enc_len = 4 * ((input_length + 2) / 3);
    adev->mpegh_base64_encode_mem = aml_audio_realloc(adev->mpegh_base64_encode_mem, enc_len + 1);
    char * enc_buf = (char*)adev->mpegh_base64_encode_mem;
    int i, j = 0;

    for (i = 0; i < input_length; i += 3) {
        int val = (input[i] << 16);
        if (i + 1 < input_length) {
            val |= (input[i + 1] << 8);
        }
        if (i + 2 < input_length) {
            val |= input[i + 2];
        }

        enc_buf[j++] = base64_table[(val >> 18) & 0x3F];
        enc_buf[j++] = base64_table[(val >> 12) & 0x3F];
        enc_buf[j++] = (i + 1 < input_length) ? base64_table[(val >> 6) & 0x3F] : '=';
        enc_buf[j++] = (i + 2 < input_length) ? base64_table[val & 0x3F] : '=';
    }
    enc_buf[j] = '\0';

    return 0;
}

int base64_decode(char* input, int input_length, struct aml_audio_device *adev) {
    if (!input || !input_length || !adev) {
        ALOGE("%s input param invalid", __func__);
        return -1;
    }
    if (input_length % 4 != 0) {
        ALOGE("%s input length not a multiple of 4", __func__);
        return -1;
    }

    int output_len = input_length / 4 * 3;
    if (input_length > 0 && input[input_length - 1] == '=') output_len--;
    if (input_length > 1 && input[input_length - 2] == '=') output_len--;

    //The size of the persistencemem must be a multiple of 1024.
    if (output_len % 1024) {
        output_len -= (output_len % 1024);
    }
    ALOGI("%s input_length = %d, output_len = %d", __func__, input_length, output_len);

    unsigned char* decoded_data = (unsigned char*)adev->mpegh_ui_persistencemem;

    unsigned char decoding_table[256];
    memset(decoding_table, 0xFF, 256);
    for (int i = 0; i < 64; i++) {
        decoding_table[(unsigned char)base64_table[i]] = i;
    }

    for (int i = 0, j = 0; i < input_length;) {
        unsigned char a = input[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)input[i++]];
        unsigned char b = input[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)input[i++]];
        unsigned char c = input[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)input[i++]];
        unsigned char d = input[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)input[i++]];

        if (a == 0xFF || b == 0xFF || c == 0xFF || d == 0xFF) {
            return -1;
        }

        uint32_t triple = (a << 3 * 6) | (b << 2 * 6) | (c << 1 * 6) | (d << 0 * 6);

        if (j < output_len) decoded_data[j++] = (unsigned char)((triple >> 2 * 8) & 0xFF);
        if (j < output_len) decoded_data[j++] = (unsigned char)((triple >> 1 * 8) & 0xFF);
        if (j < output_len) decoded_data[j++] = (unsigned char)((triple >> 0 * 8) & 0xFF);
    }
    return 0;
}

int aml_mpegh_applyxmlaction(struct aml_audio_device *adev, char *xmlstr, int xmlsize)
{
    struct aml_stream_out *aml_out = NULL;
    int ret = -1;
    AM_LOGI("enter:xmlsize:%d", xmlsize);
    AM_LOGV("xmlinstr::\r\n%s\r\n", xmlstr);

    for (int i = 0 ; i < STREAM_NUM_MAX; i++) {
        aml_out = adev->active_outputs[i];
        if (aml_out && (AUDIO_FORMAT_MPEGH == aml_out->hal_internal_format)) {
            AM_LOGI("got mpegh stream: aml_out:%p format:0x%x", aml_out, aml_out->hal_internal_format);
            mpegh_uimanager_oper_t *uioper = aml_out->mpegh_uimanager_handle;
            int flagsout = 0;
            ret = aml_mpegh_uimanager_applyxmlaction(uioper, xmlstr, xmlsize, &flagsout);
            break;
        }
    }
    return ret;
}

int assembleMpeghSystemActionEventXml(int key, char* value, char **xmlbuf)
{
    if (key < 0 || key > 7 || !value || !xmlbuf) {
        AM_LOGI("Invalid param key:%d, value:%p, xmlbuf:%p\n", key, value, (void *)xmlbuf);
        return -1;
    }

    int len = snprintf(NULL, 0, mpeghSystemActionEventXml[key], value) + 1;
    *xmlbuf = (char *)aml_audio_malloc(len);
    if (!*xmlbuf) return -1;

    snprintf(*xmlbuf, len, mpeghSystemActionEventXml[key], value);
    return 0;
}

void initActionEventQueue() {
    g_actionQueue.head = NULL;
    g_actionQueue.tail = NULL;
    g_actionQueue.size = 0;
}

void addNewActionEvent(char* event) {
    if (event == NULL) {
        return;
    }
    ActionEventNode* newNode = (ActionEventNode*)aml_audio_malloc(sizeof(ActionEventNode));
    if (newNode == NULL) {
        AM_LOGI("no memory for new node.");
        return;
    }

    newNode->event = (char*)aml_audio_malloc(strlen(event) + 1);
    if (newNode->event == NULL) {
        AM_LOGI("event memory alloc fail.");
        aml_audio_free(newNode);
        return;
    }
    strcpy(newNode->event, event);
    newNode->next = NULL;
    if (g_actionQueue.tail == NULL) {
        g_actionQueue.head = newNode;
        g_actionQueue.tail = newNode;
    } else {
        g_actionQueue.tail->next = newNode;
        g_actionQueue.tail = newNode;
    }
    g_actionQueue.size++;
    AM_LOGI("ActionEventQueue size = %zu", g_actionQueue.size);
}

int isActionEventQueueEmpty() {
    return (g_actionQueue.size == 0) ? 1 : 0;
}

char* getActionEventQueueFront() {
    if (isActionEventQueueEmpty()) {
        return NULL;
    }
    return g_actionQueue.head->event;
}

void popActionEventQueue() {
    if (isActionEventQueueEmpty()) {
        return;
    }
    ActionEventNode* temp = g_actionQueue.head;
    g_actionQueue.head = g_actionQueue.head->next;
    if (!g_actionQueue.head) {
        g_actionQueue.tail = NULL;
    }
    aml_audio_free(temp->event);
    aml_audio_free(temp);
    g_actionQueue.size--;
}

void destroyActionEventQueue() {
    ActionEventNode* current = g_actionQueue.head;
    while (current != NULL) {
        ActionEventNode* next = current->next;
        aml_audio_free(current->event);
        aml_audio_free(current);
        current = next;
    }
    initActionEventQueue();
}

int aml_mpegh_savepersistencememory(struct aml_audio_device *adev, void *persistencemem, int persistencememsize)
{
    if (!persistencemem || persistencememsize <= 0)
        return -1;
    memset(adev->mpegh_ui_persistencemem, 0, adev->mpegh_ui_persistencememsize);
    int ret = base64_decode((char *)persistencemem, persistencememsize, adev);
    if (ret < 0) {
        AM_LOGE("base64 decode error");
        return -1;
    }
    return 0;
}

bool aml_get_is_exist_active_mpegh_stream(struct aml_audio_device *adev)
{
    struct aml_stream_out *aml_out = NULL;
    bool retValue = false;
    for (int i = 0 ; i < STREAM_NUM_MAX; i++) {
        aml_out = adev->active_outputs[i];
        if (aml_out && !(aml_out->standby) && is_mpegh_format(aml_out->hal_internal_format)) {
            retValue = true;
            break;
        }
    }
    AM_LOGI("aml_out:%p, retValue:%d", aml_out, retValue);
    return retValue;
}

static int getActionType(const char* xml) {
    if (xml == NULL || *xml == '\0') {
        AM_LOGE("XML string is NULL or empty");
        return -1;
    }
    const char* key = "actionType=\"";
    const char* pos = strstr(xml, key);
    if (pos == NULL) {
        AM_LOGE("Not found actionType");
        return -1;
    }

    pos += strlen(key);
    const char* end = strchr(pos, '"');
    if (end == NULL) {
        AM_LOGE("Actionevent format error (missing end quote)");
        return -1;
    }

    size_t val_len = end - pos;
    char* valueStr = (char*)malloc(val_len + 1); // +1 用于 '\0'
    if (valueStr == NULL) {
        AM_LOGE("Malloc failed (out of memory)");
        return -1;
    }

    strncpy(valueStr, pos, val_len);
    valueStr[val_len] = '\0';

    char* converted = NULL;
    errno = 0;
    long value = strtol(valueStr, &converted, 10);

    int ret = -1;
    if (valueStr == converted) {
        AM_LOGE("actionType is not a valid number");
    } else if (errno == ERANGE) {
        AM_LOGE("actionType out of range (overflow)");
    } else if (value < 0 || value > 90) {
        AM_LOGE("actionType invalid (value=%ld, must be 0-90)", value);
    } else {
        ret = (int)value;
        AM_LOGE("actionType = %d", ret);
    }
    free(valueStr);
    valueStr = NULL;

    return ret;
}


int aml_mpegh_process(void **mpegh_uimanager_handle,
                                               struct audio_buffer *abuffer, int *asiupdate)
{
    struct audio_buffer *abuffer_out = abuffer;
    struct aml_audio_device *adev = adev_get_handle();
    void *mpegh_uiop = *mpegh_uimanager_handle;
    int ret = -1;
    int isupdate = 0;

    AM_LOGV("enter");
    if (NULL == mpegh_uimanager_handle) {
        AM_LOGE("mpegh_uimanager_handle:%p, error!", mpegh_uimanager_handle);
        goto exit;
    }
    if (false == check_audio_buffer_valid(abuffer)) {
        AM_LOGE("audio buffer checked fail");
        goto exit;
    }

    if (!mpegh_uiop) {
        ret = aml_mpegh_uimanager_open(&mpegh_uiop);
        if (ret != 0) {
            AM_LOGE(" aml_mpegh_uimanager_open fail, ret:%d, mpegh_uimanager_handle:%p", ret, mpegh_uiop);
            goto exit;
        }
        *mpegh_uimanager_handle = mpegh_uiop;
        //set persistency ctx
        if (adev->mpegh_ui_persistencemem && adev->mpegh_ui_persistencememsize > 0) {
            ret = aml_mpegh_uimanager_setpersistencememory(mpegh_uiop, (char*)adev->mpegh_ui_persistencemem, adev->mpegh_ui_persistencememsize);
            if (ret != 0) {
                AM_LOGE(" aml_mpegh_uimanager_setpersistencememory fail, ret:%d", ret);
            }
        }
        //set system setting
        KeyValue *current = uiManagerSystemSetting;
        while (current != NULL) {
            char *system_setting_xml = current->value;
            aml_mpegh_applyxmlaction(adev, system_setting_xml, strlen(system_setting_xml));
            current = current->next;
        }
    }

    while (!isActionEventQueueEmpty()) {
        char* xml = getActionEventQueueFront();
        if (xml) {
            aml_mpegh_applyxmlaction(adev, xml, strlen(xml));
        }
        popActionEventQueue();
    }

    ret = aml_mpegh_uimanager_feedmhas(mpegh_uiop, abuffer_out->buffer, abuffer_out->size);
    if (ret != 0) {
        AM_LOGE(" aml_mpegh_uimanager_feedmhas fail, ret:%d", ret);
        goto exit;
    }

    void *outbuf = NULL;
    int outlen   = 0;
    ret = aml_mpegh_uimanager_updatemhas(mpegh_uiop,
                                         abuffer_out->buffer, abuffer_out->size, &outbuf, &outlen);
    if (ret > 0 && ret != MPEGH_UI_NOT_ALLOWED) {
        AM_LOGE(" aml_mpegh_uimanager_updatemhas fail, ret:%d", ret);
        goto exit;
    }

    abuffer_out->buffer = outbuf;
    abuffer_out->size   = outlen;
    if (MPEGH_UI_OK == ret) {
        ret = aml_mpegh_uimanager_getxmlscenestate(mpegh_uiop, &isupdate);
        if ((0 == ret) && (1 == isupdate)) {
            mpegh_uimanager_oper_t *uioper = mpegh_uiop;
            AM_LOGI("getxml::::\r\n%s \r\n ::::end", uioper->xmloutbuf);
            *asiupdate = 1;
            if (get_debug_value(AML_DUMP_AUDIOHAL_IN)) {
                static int count = 0;
                aml_dump_audio_bitstreams_with_id("xmlscenestate.txt", uioper->xmloutbuf, strlen(uioper->xmloutbuf), count++);
            }
        }
    }

exit:
    return ret;
}

int aml_mpegh_close(struct aml_audio_device *adev, void *handle)
{
    AM_LOGI("enter!");
    if (!handle || !adev) {
        AM_LOGE("NULL handle or adev");
        return -1;
    }
    mpegh_uimanager_oper_t * uioper = (mpegh_uimanager_oper_t *) handle;
    aml_mpegh_uimanager_getpersistencememory(uioper, &adev->mpegh_ui_persistencemem, &adev->mpegh_ui_persistencememsize);

    if (property_get_bool(AML_MPEGH_UIMANAGER_PROP_DUMP_FLAG, 0) && adev->mpegh_ui_persistencememsize) {
        aml_dump_audio_bitstreams("mpegh_ui_persistency.txt", adev->mpegh_ui_persistencemem, adev->mpegh_ui_persistencememsize);
    }
    aml_mpegh_uimanager_close(uioper);
    return 0;
}

char *aml_mpegh_getxmlsceneinfo(struct aml_audio_device *adev)
{
    struct aml_stream_out *aml_out = NULL;
    mpegh_uimanager_oper_t *uioper = NULL;
    AM_LOGI("enter");

    for (int i = 0 ; i < STREAM_NUM_MAX; i++) {
        aml_out = adev->active_outputs[i];
        if (aml_out && (AUDIO_FORMAT_MPEGH == aml_out->hal_internal_format)) {
            uioper = aml_out->mpegh_uimanager_handle;
            AM_LOGI("got mpegh stream:aml_out:%p format:0x%x, uioper:%p", aml_out, aml_out->hal_internal_format, uioper);
            break;
        }
    }

    if ((NULL == uioper) || (NULL == uioper->xmloutbuf)) {
        return NULL;
    }

    AM_LOGV("xmloutstr::\r\n%s\r\n", uioper->xmloutbuf);

    return uioper->xmloutbuf;
}

int set_mpegh_parameters(struct aml_audio_device *adev, struct str_parms *parms)
{
    int ret = -1;
    int actionType = -1;
    char value[128] = {'\0'};
    //view setting
    ret = str_parms_get_str(parms, "mpegh_action_event", value, sizeof(value));
    if (ret >= 0) {
        actionType = getActionType(value);
        if (actionType == 0) {
            memset(adev->mpegh_audioscenexml, 0, adev->mpegh_audioscenexmlsize);
            AM_LOGI("mpegh reset, clear mpegh_audioscenexml!");
        }
        //save event to queue
        addNewActionEvent(value);
        return ret;
    }
    //set persistency ctx
    if (str_parms_has_key(parms, "mpegh_persistency_ctx")) {
        char *mpegh_persictency_buf = (char *)aml_audio_calloc(1, (AML_MPEGH_BASE64_BUFSIZE + 1));
        ret = str_parms_get_str(parms, "mpegh_persistency_ctx", mpegh_persictency_buf, (AML_MPEGH_BASE64_BUFSIZE + 1));
        if (ret >= 0) {
            ret = aml_mpegh_savepersistencememory(adev, (void*)mpegh_persictency_buf, AML_MPEGH_BASE64_BUFSIZE);
            AM_LOGD("set mpegh persistency ctx:, ret:%d", ret);
        }
        aml_audio_free(mpegh_persictency_buf);
        mpegh_persictency_buf = NULL;
        return ret;
    }
    //system setting
    ret = str_parms_get_str(parms, "mpegh_audio_lang", value, sizeof(value));
    if (ret >= 0) {
        //Splicing system actionevent XML
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_AUDIO_LANG, value, &mpegh_action_event);
        //store system setting to queue when exist active mpegh stream.
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        //store or update system setting
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_audio_lang", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }
    ret = str_parms_get_str(parms, "mpegh_label_lang", value, sizeof(value));
    if (ret >= 0) {
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_LABEL_LANG, value, &mpegh_action_event);
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_label_lang", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }

    ret = str_parms_get_str(parms, "mpegh_drc_att", value, sizeof(value));
    if (ret >= 0) {
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_DRC_ATT, value, &mpegh_action_event);
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_drc_att", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }

    ret = str_parms_get_str(parms, "mpegh_accessibility", value, sizeof(value));
    if (ret >= 0) {
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_ACCESSIBILITY, value, &mpegh_action_event);
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_accessibility", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }

    ret = str_parms_get_str(parms, "mpegh_drc_effect", value, sizeof(value));
    if (ret >= 0) {
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_DRC_EFFECT, value, &mpegh_action_event);
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_drc_effect", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }

    ret = str_parms_get_str(parms, "mpegh_drc_album", value, sizeof(value));
    if (ret >= 0) {
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_DRC_ALBUM, value, &mpegh_action_event);
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_drc_album", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }

    ret = str_parms_get_str(parms, "mpegh_drc_boost", value, sizeof(value));
    if (ret >= 0) {
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_DRC_BOOST, value, &mpegh_action_event);
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_drc_boost", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }

    ret = str_parms_get_str(parms, "mpegh_tl", value, sizeof(value));
    if (ret >= 0) {
        char * mpegh_action_event = NULL;
        ret = assembleMpeghSystemActionEventXml(AML_MPEGH_TL, value, &mpegh_action_event);
        if (aml_get_is_exist_active_mpegh_stream(adev)) {
            addNewActionEvent(mpegh_action_event);
        }
        if (mpegh_action_event) {
            saveMpeghSysActioneventXml("mpegh_tl", mpegh_action_event);
        }
        aml_audio_free(mpegh_action_event);
        mpegh_action_event = NULL;
        return ret;
    }
    return ret;
}