/*
 * Copyright 2015 - 2017 Rockchip Electronics Co. LTD
 *
 * 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 MODULE_TAG "hal_bufs"

#include <string.h>

#include "mpp_env.h"
#include "mpp_mem.h"
#include "mpp_debug.h"
#include "mpp_common.h"

#include "hal_bufs.h"

#define HAL_BUFS_DBG_FUNCTION           (0x00000001)

#define hal_bufs_dbg(flag, fmt, ...)    _mpp_dbg(hal_bufs_debug, flag, fmt, ## __VA_ARGS__)
#define hal_bufs_dbg_f(flag, fmt, ...)  _mpp_dbg_f(hal_bufs_debug, flag, fmt, ## __VA_ARGS__)

#define hal_bufs_dbg_func(fmt, ...)     hal_bufs_dbg_f(HAL_BUFS_DBG_FUNCTION, fmt, ## __VA_ARGS__)

#define hal_bufs_enter()                hal_bufs_dbg_func("enter\n");
#define hal_bufs_leave()                hal_bufs_dbg_func("leave\n");

#define MAX_HAL_BUFS_CNT                40
#define MAX_HAL_BUFS_SIZE_CNT           8

typedef struct HalBufsImpl_t {
    MppBufferGroup  group;

    RK_S32          max_cnt;
    RK_S32          size_cnt;
    RK_S32          size_sum;
    RK_S32          slot_sum;
    RK_S32          elem_size;

    RK_U32          valid;
    size_t          sizes[MAX_HAL_BUFS_SIZE_CNT];
    RK_U8           *bufs;
} HalBufsImpl;

static RK_U32 hal_bufs_debug = 0;

static HalBuf *hal_bufs_pos(HalBufsImpl *impl, RK_S32 idx)
{
    RK_S32 elem_size = impl->elem_size;

    return (HalBuf *)(impl->bufs + idx * elem_size);
}

static MPP_RET hal_bufs_clear(HalBufsImpl *impl)
{
    MPP_RET ret = MPP_OK;

    if (impl->valid && impl->size_sum) {
        RK_S32 i;

        for (i = 0; i < impl->max_cnt; i++) {
            RK_U32 mask = 1 << i;

            if (impl->valid & mask) {
                HalBuf *buf = hal_bufs_pos(impl, i);
                RK_S32 j = 0;

                for (j = 0; j < impl->size_cnt; j++) {
                    if (buf->buf[j]) {
                        impl->size_sum -= impl->sizes[j];
                        ret |= mpp_buffer_put(buf->buf[j]);
                        buf->buf[j] = NULL;
                    }
                }
                impl->valid &= ~mask;
            }
        }

        mpp_assert(impl->valid == 0);
        mpp_assert(impl->size_sum == 0);
    }

    impl->max_cnt = 0;
    impl->size_cnt = 0;
    impl->size_sum = 0;
    impl->slot_sum = 0;
    impl->valid = 0;
    memset(impl->sizes, 0, sizeof(impl->sizes));
    MPP_FREE(impl->bufs);

    return ret;
}

MPP_RET hal_bufs_init(HalBufs *bufs)
{
    MPP_RET ret = MPP_OK;

    if (NULL == bufs) {
        mpp_err_f("invalid NULL input\n");
        return MPP_ERR_NULL_PTR;
    }

    mpp_env_get_u32("hal_bufs_debug", &hal_bufs_debug, 0);

    hal_bufs_enter();

    HalBufsImpl *impl = mpp_calloc(HalBufsImpl, 1);
    if (impl) {
        ret = mpp_buffer_group_get_internal(&impl->group, MPP_BUFFER_TYPE_ION);
    } else {
        mpp_err_f("failed to malloc HalBufs\n");
        ret = MPP_ERR_MALLOC;
    }

    *bufs = impl;

    hal_bufs_leave();

    return ret;
}

MPP_RET hal_bufs_deinit(HalBufs bufs)
{
    HalBufsImpl *impl = (HalBufsImpl *)bufs;
    MPP_RET ret = MPP_OK;

    if (NULL == bufs) {
        mpp_err_f("invalid NULL input\n");
        return MPP_ERR_NULL_PTR;
    }

    hal_bufs_enter();

    ret = hal_bufs_clear(impl);

    if (impl->group) {
        ret |= mpp_buffer_group_put(impl->group);
        impl->group = NULL;
    }

    memset(impl, 0, sizeof(*impl));
    MPP_FREE(impl);

    hal_bufs_leave();

    return ret;
}

MPP_RET hal_bufs_setup(HalBufs bufs, RK_S32 max_cnt, RK_S32 size_cnt, size_t sizes[])
{
    HalBufsImpl *impl = (HalBufsImpl *)bufs;
    MPP_RET ret = MPP_OK;
    RK_S32 elem_size = 0;
    RK_S32 impl_size = 0;

    if (NULL == bufs || NULL == sizes) {
        mpp_err_f("invalid NULL input bufs %p sizes %p\n", bufs, sizes);
        return MPP_ERR_NULL_PTR;
    }

    if (max_cnt <= 0 || max_cnt > MAX_HAL_BUFS_CNT ||
        size_cnt <= 0 || size_cnt > MAX_HAL_BUFS_SIZE_CNT) {
        mpp_err_f("invalid max cnt %d size cnt %d\n", max_cnt, size_cnt);
        return MPP_ERR_VALUE;
    }

    hal_bufs_enter();

    hal_bufs_clear(impl);

    if (impl->group)
        ret = mpp_buffer_group_clear(impl->group);
    else
        ret = mpp_buffer_group_get_internal(&impl->group, MPP_BUFFER_TYPE_ION);

    mpp_assert(impl->group);

    elem_size = sizeof(HalBuf) + sizeof(MppBuffer) * size_cnt;
    impl_size = elem_size * max_cnt;

    impl->elem_size = elem_size;
    impl->bufs = mpp_calloc_size(void, impl_size);
    if (impl->bufs) {
        RK_S32 slot_sum = 0;
        RK_S32 i;

        for (i = 0; i < size_cnt; i++) {
            slot_sum += sizes[i];
            impl->sizes[i] = sizes[i];
        }

        impl->slot_sum = slot_sum;

        for (i = 0; i < max_cnt; i++) {
            HalBuf *buf = hal_bufs_pos(impl, i);

            buf->cnt = size_cnt;
            buf->buf = (MppBuffer)(buf + 1);
        }

        impl->max_cnt = max_cnt;
        impl->size_cnt = size_cnt;
    } else {
        mpp_err_f("failed to malloc size %d for impl\n", impl_size);
        ret = MPP_ERR_MALLOC;
    }

    hal_bufs_leave();

    return ret;
}

HalBuf *hal_bufs_get_buf(HalBufs bufs, RK_S32 buf_idx)
{
    HalBufsImpl *impl = (HalBufsImpl *)bufs;

    if (NULL == impl || buf_idx < 0 || buf_idx >= impl->max_cnt) {
        mpp_err_f("invalid input impl %p buf_idx %d\n", impl, buf_idx);
        return NULL;
    }

    hal_bufs_enter();

    HalBuf *hal_buf = hal_bufs_pos(impl, buf_idx);
    RK_U32 mask = 1 << buf_idx;

    if (!(impl->valid & mask)) {
        MppBufferGroup group = impl->group;
        RK_S32 i;

        for (i = 0; i < impl->size_cnt; i++) {
            size_t size = impl->sizes[i];
            MppBuffer buf = hal_buf->buf[i];

            if (size && NULL == buf) {
                mpp_buffer_get(group, &buf, size);
                impl->size_sum += size;
            }

            mpp_assert(buf);
            hal_buf->buf[i] = buf;
        }

        impl->valid |= mask;
    }

    hal_bufs_leave();

    return hal_buf;
}