/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2009-2019. All rights reserved.
 * Description: Defines avplay hal function
 * Author: Hisilicon
 * Create: 2009-12-21
 * History:
 */
#include "avplay_hal.h"

#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include "soc_module.h"
#include "avplay_common.h"
#include "avplay_config.h"

static int g_avplay_fd = -1;

td_s32 avplay_hal_init(void)
{
    if (g_avplay_fd == -1) {
        g_avplay_fd = open("/dev/soc_avplay", O_RDWR | O_NONBLOCK, 0);
    }

    if (g_avplay_fd < 0) {
        ext_err_avplay("Open avplay device failed, error: %s\n", strerror(errno));
        return SOC_ERR_AVPLAY_DEV_OPEN_ERR;
    }

    return TD_SUCCESS;
}

td_s32 avplay_hal_deinit(void)
{
    check_dev(g_avplay_fd);
    td_s32 ret;

    ret = close(g_avplay_fd);
    if (ret < 0) {
        ext_err_avplay("Close avplay device failed, error: %s\n", strerror(errno));
        return SOC_ERR_AVPLAY_DEV_CLOSE_ERR;
    }

    g_avplay_fd = -1;
    return TD_SUCCESS;
}

td_s32 avplay_hal_create(td_handle *avplay)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_create_param param;
    param.avplay = TD_INVALID_HANDLE;
    check_null(avplay);

    ret = ioctl(g_avplay_fd, CMD_AVPLAY_CREATE, &param);
    return_when_error(ret, avplay_ioctl_create);

    *avplay = param.avplay;
    return TD_SUCCESS;
}

td_s32 avplay_hal_destroy(td_handle avplay)
{
    check_dev(g_avplay_fd);

    return ioctl(g_avplay_fd, CMD_AVPLAY_DESTROY, &avplay);
}

td_s32 avplay_hal_reset(td_handle avplay, avplay_channel_type chn)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_reset_param param;
    param.avplay = avplay;
    param.chn = chn;

    ret = ioctl(g_avplay_fd, CMD_AVPLAY_RESET, &param);
    return_when_error(ret, avplay_ioctl_reset);

    return TD_SUCCESS;
}

td_s32 avplay_hal_set_channel_state(td_handle avplay, avplay_channel_type chn, avplay_channel_state state)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_channel_state_param param;
    param.avplay = avplay;
    param.chn = chn;
    param.state = state;

    ret = ioctl(g_avplay_fd, CMD_AVPLAY_SET_CHANNEL_STATE, &param);
    return_when_error(ret, avplay_ioctl_set_channel_state);

    return TD_SUCCESS;
}

td_s32 avplay_hal_set_resource(td_handle avplay, avplay_resource_type type, td_handle handle, const td_u32 *priv)
{
    check_dev(g_avplay_fd);

    avplay_resource_param param;
    param.src = avplay;
    param.type = type;
    param.dst = handle;
    param.param = (priv == TD_NULL) ? 0 : *priv;

    return ioctl(g_avplay_fd, CMD_AVPLAY_SET_RESOURCE, &param);
}

td_s32 avplay_hal_get_resource(td_handle src, avplay_resource_type type, td_handle *dst)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_resource_param param;
    param.src = src;
    param.type = type;
    param.dst = TD_INVALID_HANDLE;
    param.param = 0;

    ret = ioctl(g_avplay_fd, CMD_AVPLAY_GET_RESOURCE, &param);
    *dst = param.dst;

    return ret;
}

td_s32 avplay_hal_wait_event(td_handle avplay, td_u64 event_mask, avplay_event_type *event,
                             td_u64 *event_param, td_s64 timeout)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_wait_event_param param;
    param.avplay = avplay;
    param.timeout = timeout;
    param.event_mask = event_mask;
    param.event = AVPLAY_EVENT_TYPE_MAX;
    param.param = 0;

    ret = ioctl(g_avplay_fd, CMD_AVPLAY_WAIT_EVENT, &param);
    *event = param.event;
    *event_param = param.param;

    return ret;
}

td_s32 avplay_hal_wakeup_event(td_handle avplay)
{
    check_dev(g_avplay_fd);

    return ioctl(g_avplay_fd, CMD_AVPLAY_WAKEUP, &avplay);
}

td_s32 avplay_hal_get_event_param(td_handle avplay, avplay_event_param *event_param)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_get_event_param param = {0};

    param.avplay = avplay;
    ret = ioctl(g_avplay_fd, CMD_AVPLAY_GET_EVENT_PARAM, &param);
    if (memcpy_s(event_param, sizeof(avplay_event_param), &param.param, sizeof(avplay_event_param)) != EOK) {
        ext_err_avplay("Execute memcpy_s failed!\n");
        return TD_FAILURE;
    }

    return ret;
}

td_s32 avplay_hal_get_video_info(td_handle avplay, avplay_video_info *info)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_video_info_param param = {0};
    param.avplay = avplay;
    ret = ioctl(g_avplay_fd, CMD_AVPLAY_GET_VIDEO_INFO, &param);
    if (ret != TD_SUCCESS) {
        return ret;
    }

    if (memcpy_s(info, sizeof(avplay_video_info), &param.param, sizeof(avplay_video_info)) != EOK) {
        ext_err_avplay("Execute memcpy_s failed!\n");
        return TD_FAILURE;
    }

    return TD_SUCCESS;
}

td_s32 avplay_hal_get_global_play_info(td_handle avplay, avplay_global_play_info *info)
{
    check_dev(g_avplay_fd);

    td_s32 ret;
    avplay_global_play_info_param param = {0};
    param.avplay = avplay;
    ret = ioctl(g_avplay_fd, CMD_AVPLAY_GET_GLOBAL_PLAY_INFO, &param);
    if (ret != TD_SUCCESS) {
        return ret;
    }

    if (memcpy_s(info, sizeof(avplay_global_play_info), &param.param, sizeof(avplay_global_play_info)) != EOK) {
        ext_err_avplay("Execute memcpy_s failed!\n");
        return TD_FAILURE;
    }

    return TD_SUCCESS;
}