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

#include "adec_common.h"
#include <sys/time.h>
#include "mpi_system_ext.h"
#include "mpi_memory_ext.h"
#include "mpi_adec_debug.h"
#include "mpi_adec_imple.h"

#define TIME_RATION 1000

td_void adec_sleep(td_ulong ms)
{
    struct timespec ts;

    if (ms == 0) {
        return;
    }

    ts.tv_sec  = (td_slong)(ms / TIME_RATION);
    ts.tv_nsec = (ms % TIME_RATION) * TIME_RATION * TIME_RATION;

    if (nanosleep(&ts, TD_NULL) != 0) {
        soc_log_err("call nanosleep failed\n");
        return;
    }
}

td_u32 adec_get_time_stamp(td_void)
{
    td_s32 ret;
    td_u32 time_ms = 0;

    ret = ext_mpi_sys_get_time_stamp_ms(&time_ms);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(ext_mpi_sys_get_time_stamp_ms, ret);
        return 0;
    }

    return time_ms;
}

td_u64 adec_get_time64(td_void)
{
    td_s32 ret;
    td_u64 us;
    struct timespec ts;

    ret = clock_gettime(CLOCK_MONOTONIC, &ts);
    if (ret != 0) {
        soc_log_err("clock_gettime return err %d, errno=%d\n", ret, errno);
        return 0;
    }
    /* use 1000000ULL to covert seconds to us && use 1000 to covert nsec to us */
    us = (td_u64)((ts.tv_sec * 1000000ULL) + ts.tv_nsec / 1000);
    return us;
}

td_void adec_mutex_init(pthread_mutex_t *mutex)
{
    if (mutex == TD_NULL) {
        return;
    }

    if (pthread_mutex_init(mutex, TD_NULL) != 0) {
        soc_log_err("init mutex failed\n");
    }
}

td_void adec_mutex_deinit(pthread_mutex_t *mutex)
{
    if (mutex == TD_NULL) {
        return;
    }

    if (pthread_mutex_destroy(mutex) != 0) {
        soc_log_err("destory mutex failed\n");
    }
}

td_void adec_mutex_lock(pthread_mutex_t *mutex)
{
    if (mutex == TD_NULL) {
        return;
    }

    if (pthread_mutex_lock(mutex) != 0) {
        soc_log_err("Lock mutex failed\n");
    }
}

td_void adec_mutex_unlock(pthread_mutex_t *mutex)
{
    if (mutex == TD_NULL) {
        return;
    }

    if (pthread_mutex_unlock(mutex) != 0) {
        soc_log_err("Unlock mutex failed\n");
    }
}

td_void adec_free(td_void *buf)
{
    if (buf == TD_NULL) {
        return;
    }

    free(buf);
}

td_void *adec_malloc(td_u32 size)
{
    td_s32 ret;
    td_void *buf = TD_NULL;

    if (size == 0) {
        soc_log_err("invalid size\n");
        return TD_NULL;
    }

    buf = malloc(size);
    if (buf == TD_NULL) {
        soc_log_err("call malloc( failed\n");
        return TD_NULL;
    }

    ret = memset_s(buf, size, 0, size);
    if (ret != EOK) {
        soc_err_print_call_fun_err(memset_s, ret);
        free(buf);
        return TD_NULL;
    }

    return buf;
}

td_u32 adec_get_max_pcm_out_size(const uapi_acodec_decode *codec, td_void *decoder)
{
    td_s32 ret;
    td_u32 size = 0;

    if ((decoder == TD_NULL) ||
        (codec == TD_NULL) ||
        (codec->get_max_pcm_out_size == TD_NULL)) {
        return 0;
    }

    ret = codec->get_max_pcm_out_size(decoder, &size);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(codec->get_max_pcm_out_size, ret);
        return 0;
    }

    return size;
}

td_u32 adec_get_max_bits_out_size(const uapi_acodec_decode *codec, td_void *decoder)
{
    td_s32 ret;
    td_u32 size = 0;

    if ((decoder == TD_NULL) ||
        (codec == TD_NULL) ||
        (codec->get_max_bits_out_size == TD_NULL)) {
        return 0;
    }

    ret = codec->get_max_bits_out_size(decoder, &size);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(codec->get_max_bits_out_size, ret);
        return 0;
    }

    return size;
}

/* @decoder is allowed to be NULL */
td_s32 adec_set_config(const uapi_acodec_decode *codec, td_void *decoder, td_void *codec_cfg)
{
    td_s32 ret;

    check_adec_null_ptr(codec);
    check_adec_null_ptr(codec_cfg);
    check_adec_null_ptr(codec->set_config);

    ret = codec->set_config(decoder, codec_cfg);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(codec->set_config, ret);
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 adec_decode_frame(const uapi_acodec_decode *codec, td_void *decoder,
    uapi_acodec_dec_in_packet *in_pkt, uapi_acodec_dec_out_packet *out_pkt)
{
    check_adec_null_ptr(codec);
    check_adec_null_ptr(decoder);
    check_adec_null_ptr(in_pkt);
    check_adec_null_ptr(out_pkt);
    check_adec_null_ptr(codec->decode_frame);

    return codec->decode_frame(decoder, in_pkt, out_pkt);
}

td_s32 adec_register_decoder(const td_char *codec_name)
{
    return adec_register_decoder_imple(codec_name);
}

td_s32 adec_get_codec_id(uapi_acodec_format format, td_u32 *codec_id)
{
    return adec_find_support_decoder_imple(format, codec_id);
}

td_s32 adec_set_config_decoder(const td_u32 codec_id, td_void *cfg)
{
    uapi_acodec_decode *codec = adec_find_ha_decoder_imple(codec_id);
    if (codec == TD_NULL) {
        soc_err_print_h32(codec_id);
        soc_err_print_str(adec_get_decoder_lib_name_imple(codec_id));
        return SOC_ERR_ADEC_NOT_SUPPORT;
    }

    return adec_set_config(codec, TD_NULL, cfg);
}

uapi_acodec_decode *adec_get_decoder_list(td_void)
{
    return adec_get_decoder_list_imple();
}