/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2012-2019. All rights reserved.
 * Description: ai iapi function
 * Author: audio
 * Create: 2012-05-30
 */

#include "uapi_ai.h"
#include "mpi_ai_ext.h"
#include "mpi_ai_trans.h"
#include "securec.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

td_s32 uapi_ai_init(td_void)
{
    return ext_mpi_ai_init();
}

td_s32 uapi_ai_deinit(td_void)
{
    return ext_mpi_ai_deinit();
}

td_s32 uapi_ai_get_default_attr(uapi_ai_port ai_port, uapi_ai_attr *attr)
{
    td_s32 ret;
    ext_ai_attr mpi_ai_attr;
    (td_void)memset_s(&mpi_ai_attr, sizeof(mpi_ai_attr), 0, sizeof(ext_ai_attr));
    ret = trans_ai_attr_from_iapi_to_mpi((ext_ai_port)ai_port, attr, &mpi_ai_attr);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    ret = ext_mpi_ai_get_default_attr((ext_ai_port)ai_port, &mpi_ai_attr);
    trans_ai_attr_from_mpi_to_iapi((ext_ai_port)ai_port, attr, &mpi_ai_attr);
    return ret;
}

td_s32 uapi_ai_set_attr(td_handle ai, const uapi_ai_attr *attr)
{
    td_s32 ret;
    ext_ai_attr mpi_ai_attr;
    (td_void)memset_s(&mpi_ai_attr, sizeof(mpi_ai_attr), 0, sizeof(ext_ai_attr));
    ret = trans_ai_attr_from_iapi_to_mpi_with_ai(ai, attr, &mpi_ai_attr);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    return ext_mpi_ai_set_attr(ai, &mpi_ai_attr);
}

td_s32 uapi_ai_get_attr(td_handle ai, uapi_ai_attr *attr)
{
    td_s32 ret;
    ext_ai_attr mpi_ai_attr;

    check_ai_null_ptr(attr);

    (td_void)memset_s(&mpi_ai_attr, sizeof(mpi_ai_attr), 0, sizeof(ext_ai_attr));
    ret = ext_mpi_ai_get_attr(ai, &mpi_ai_attr);
    trans_ai_attr_from_mpi_to_iapi_with_ai(ai, attr, &mpi_ai_attr);
    return ret;
}

td_s32 uapi_ai_create(uapi_ai_port ai_port, uapi_ai_attr *attr, td_handle *ai)
{
    td_s32 ret;
    ext_ai_attr mpi_ai_attr;

    (td_void)memset_s(&mpi_ai_attr, sizeof(mpi_ai_attr), 0, sizeof(ext_ai_attr));
    ret = trans_ai_attr_from_iapi_to_mpi((ext_ai_port)ai_port, attr, &mpi_ai_attr);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    return ext_mpi_ai_create((ext_ai_port)ai_port, &mpi_ai_attr, ai);
}

td_s32 uapi_ai_destroy(td_handle ai)
{
    return ext_mpi_ai_destroy(ai);
}

td_s32 uapi_ai_set_enable(td_handle ai, td_bool enable)
{
    return ext_mpi_ai_set_enable(ai, enable);
}

td_s32 uapi_ai_get_enable(td_handle ai, td_bool *enable)
{
    return ext_mpi_ai_get_enable(ai, enable);
}

td_s32 uapi_ai_acquire_frame(td_handle ai, uapi_audio_frame *frame, td_u32 timeout_ms)
{
    td_s32 ret;
    ext_ao_frame mpi_ao_frame;
    (td_void)memset_s(&mpi_ao_frame, sizeof(mpi_ao_frame), 0, sizeof(ext_ao_frame));
    ret = trans_ao_frame_from_iapi_to_mpi(frame, &mpi_ao_frame);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    TD_UNUSED(timeout_ms);
    ret = ext_mpi_ai_acquire_frame(ai, &mpi_ao_frame);
    trans_ao_frame_from_mpi_to_iapi(frame, &mpi_ao_frame);
    return ret;
}

td_s32 uapi_ai_release_frame(td_handle ai, const uapi_audio_frame *frame)
{
    td_s32 ret;
    ext_ao_frame mpi_ao_frame;
    (td_void)memset_s(&mpi_ao_frame, sizeof(mpi_ao_frame), 0, sizeof(ext_ao_frame));
    ret = trans_ao_frame_from_iapi_to_mpi(frame, &mpi_ao_frame);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    return ext_mpi_ai_release_frame(ai, &mpi_ao_frame);
}

td_s32 uapi_ai_set_delay(td_handle ai, const uapi_ai_delay *delay)
{
    td_s32 ret;
    ext_ai_delay mpi_ai_delay;
    (td_void)memset_s(&mpi_ai_delay, sizeof(mpi_ai_delay), 0, sizeof(ext_ai_delay));
    ret = trans_ai_delay_from_iapi_to_mpi(delay, &mpi_ai_delay);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    return ext_mpi_ai_set_delay(ai, &mpi_ai_delay);
}

td_s32 uapi_ai_get_delay(td_handle ai, uapi_ai_delay *delay)
{
    td_s32 ret;
    ext_ai_delay mpi_ai_delay;
    (td_void)memset_s(&mpi_ai_delay, sizeof(mpi_ai_delay), 0, sizeof(ext_ai_delay));
    ret = trans_ai_delay_from_iapi_to_mpi(delay, &mpi_ai_delay);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    ret = ext_mpi_ai_get_delay(ai, &mpi_ai_delay);
    trans_ai_delay_from_mpi_to_iapi(delay, &mpi_ai_delay);
    return ret;
}

td_s32 uapi_ai_get_stream_type(td_handle ai, uapi_audio_format *stream_type)
{
    td_s32 ret;
    ext_audio_format mpi_audio_format;
    ret = trans_audio_format_from_iapi_to_mpi(stream_type, &mpi_audio_format);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    ret = ext_mpi_ai_get_stream_type(ai, &mpi_audio_format);
    trans_audio_format_from_mpi_to_iapi(stream_type, &mpi_audio_format);
    return ret;
}

td_s32 uapi_ai_set_nr_attr(td_handle ai, const uapi_ai_nr_attr *nr_attr)
{
    td_s32 ret;
    ext_ai_nr_attr mpi_ai_nr_attr;
    (td_void)memset_s(&mpi_ai_nr_attr, sizeof(mpi_ai_nr_attr), 0, sizeof(ext_ai_nr_attr));
    ret = trans_ai_nr_attr_from_iapi_to_mpi(nr_attr, &mpi_ai_nr_attr);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    return ext_mpi_ai_set_nr_attr(ai, &mpi_ai_nr_attr);
}

td_s32 uapi_ai_get_nr_attr(td_handle ai, uapi_ai_nr_attr *nr_attr)
{
    td_s32 ret;
    ext_ai_nr_attr mpi_ai_nr_attr;
    (td_void)memset_s(&mpi_ai_nr_attr, sizeof(mpi_ai_nr_attr), 0, sizeof(ext_ai_nr_attr));
    ret = trans_ai_nr_attr_from_iapi_to_mpi(nr_attr, &mpi_ai_nr_attr);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    ret = ext_mpi_ai_get_nr_attr(ai, &mpi_ai_nr_attr);
    trans_ai_nr_attr_from_mpi_to_iapi(nr_attr, &mpi_ai_nr_attr);
    return ret;
}

td_s32 uapi_ai_set_line_in_volume(td_handle ai, const uapi_ai_line_in_gain_attr *line_in_gain_attr)
{
    td_s32 ret;
    ext_ai_line_in_gain mpi_ai_line_in_gain;
    (td_void)memset_s(&mpi_ai_line_in_gain, sizeof(mpi_ai_line_in_gain), 0, sizeof(ext_ai_line_in_gain));
    ret = trans_ai_line_in_gain_from_iapi_to_mpi(line_in_gain_attr, &mpi_ai_line_in_gain);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    return ext_mpi_ai_set_line_in_volume(ai, &mpi_ai_line_in_gain);
}

td_s32 uapi_ai_get_line_in_volume(td_handle ai, uapi_ai_line_in_gain_attr *line_in_gain_attr)
{
    td_s32 ret;
    ext_ai_line_in_gain mpi_ai_line_in_gain;
    (td_void)memset_s(&mpi_ai_line_in_gain, sizeof(mpi_ai_line_in_gain), 0, sizeof(ext_ai_line_in_gain));
    ret = trans_ai_line_in_gain_from_iapi_to_mpi(line_in_gain_attr, &mpi_ai_line_in_gain);
    if (ret != TD_SUCCESS) {
        return ret;
    }
    ret = ext_mpi_ai_get_line_in_volume(ai, &mpi_ai_line_in_gain);
    trans_ai_line_in_gain_from_mpi_to_iapi(line_in_gain_attr, &mpi_ai_line_in_gain);
    return ret;
}

td_s32 uapi_ai_set_line_in_mute(td_handle ai, td_bool mute)
{
    return ext_mpi_ai_set_line_in_mute(ai, mute);
}

td_s32 uapi_ai_get_line_in_mute(td_handle ai, td_bool *mute)
{
    return ext_mpi_ai_get_line_in_mute(ai, mute);
}

#ifdef __cplusplus
}
#endif /* __cplusplus */