/*
 * Copyright (C) 2013 The Android Open Source Project
 * Copyright@ Samsung 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.
 */

/*!
 * \file      libgscaler.cpp
 * \brief     source file for Gscaler HAL
 * \author    Sungchun Kang (sungchun.kang@samsung.com)
 * \date      2013/06/01
 *
 * <b>Revision History: </b>
 * - 2013.06.01 : Sungchun Kang (sungchun.kang@samsung.com) \n
 *   Create
 */

#include <linux/v4l2-subdev.h>

#include "libgscaler_obj.h"
#include "libgscaler_media.h"

void *exynos_gsc_create(void)
{
    CGscaler *gsc = new CGscaler(GSC_M2M_MODE);
    if (!gsc) {
        ALOGE("%s:: failed to allocate Gscaler handle", __func__);
        return NULL;
    }
    if (gsc->m_gsc_find_and_create(gsc) == false) {
        ALOGE("%s::m_exynos_gsc_find_and_create() fail", __func__);
        delete gsc;
        return NULL;
    }

    return reinterpret_cast<void *>(gsc);
}

void *exynos_gsc_create_exclusive(
    int dev_num,
    int mode,
    int out_mode,
    int allow_drm)
{
    Exynos_gsc_In();

    if ((dev_num < 0) || (dev_num >= HW_SCAL_MAX)) {
        ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num);
        return NULL;
    }

    if ((dev_num >= NUM_OF_GSC_HW) && (dev_num < HW_SCAL_MAX)) {
        CGscaler *gsc = new CGscaler(mode, out_mode, dev_num, allow_drm);
        if (!gsc) {
            ALOGE("%s:: failed to allocate Gscaler handle", __func__);
            return NULL;
        }

        gsc->scaler = exynos_sc_create_exclusive(dev_num - HW_SCAL0,
            allow_drm);
        if (!gsc->scaler) {
            delete(gsc);
            ALOGE("%s::exynos_sc_create fail", __func__);
            return NULL;
        }
        Exynos_gsc_Out();
        return reinterpret_cast<void *>(gsc);
    }

    if ((mode < 0) || (mode >= NUM_OF_GSC_HW)) {
        ALOGE("%s::fail:: mode is not valid(%d) ", __func__, mode);
        return NULL;
    }

    CGscaler *gsc = new CGscaler(mode, out_mode, dev_num, allow_drm);
    if (!gsc) {
        ALOGE("%s:: failed to allocate Gscaler handle", __func__);
        return NULL;
    }

    if (mode == GSC_M2M_MODE) {
        gsc->gsc_fd = gsc->m_gsc_m2m_create(dev_num);
        if (gsc->gsc_fd < 0) {
            ALOGE("%s::m_gsc_m2m_create(%i) fail", __func__, dev_num);
            goto err;
        }
    } else {
            ALOGE("%s::Unsupported Mode(%i) fail", __func__, dev_num);
	    goto err;
    }

    Exynos_gsc_Out();

    return reinterpret_cast<void *>(gsc);
err:
    switch (mode) {
    case GSC_M2M_MODE:
        gsc->m_gsc_m2m_destroy(gsc);
        break;
    }

    delete(gsc);

    Exynos_gsc_Out();

    return NULL;
}

void exynos_gsc_destroy(void *handle)
{
    Exynos_gsc_In();

    CGscaler* gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return;
    }

    if (gsc->mode == GSC_M2M_MODE)
        gsc->m_gsc_m2m_destroy(gsc);

    delete(gsc);

    Exynos_gsc_Out();
}

int exynos_gsc_set_csc_property(
    void        *handle,
    unsigned int eq_auto,
    unsigned int range_full,
    unsigned int v4l2_colorspace)
{
    Exynos_gsc_In();

    CGscaler *gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    if (gsc->gsc_id >= HW_SCAL0) {
        int ret;
        ret = exynos_sc_csc_exclusive(gsc->scaler,
                            range_full, v4l2_colorspace);
        Exynos_gsc_Out();
        return ret;
    }
    gsc->eq_auto = eq_auto;
    gsc->range_full = range_full;
    gsc->v4l2_colorspace = v4l2_colorspace;

    Exynos_gsc_Out();

    return 0;
}

int exynos_gsc_set_src_format(
    void        *handle,
    unsigned int width,
    unsigned int height,
    unsigned int crop_left,
    unsigned int crop_top,
    unsigned int crop_width,
    unsigned int crop_height,
    unsigned int v4l2_colorformat,
    unsigned int cacheable,
    unsigned int mode_drm)
{
    Exynos_gsc_In();

    CGscaler *gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }
    gsc->src_info.width            = width;
    gsc->src_info.height           = height;
    gsc->src_info.crop_left        = crop_left;
    gsc->src_info.crop_top         = crop_top;
    gsc->src_info.crop_width       = crop_width;
    gsc->src_info.crop_height      = crop_height;
    gsc->src_info.v4l2_colorformat = v4l2_colorformat;
    gsc->src_info.cacheable        = cacheable;
    gsc->src_info.mode_drm         = mode_drm;
    gsc->src_info.dirty            = true;

    Exynos_gsc_Out();

    return 0;
}

int exynos_gsc_set_dst_format(
    void        *handle,
    unsigned int width,
    unsigned int height,
    unsigned int crop_left,
    unsigned int crop_top,
    unsigned int crop_width,
    unsigned int crop_height,
    unsigned int v4l2_colorformat,
    unsigned int cacheable,
    unsigned int mode_drm)
{
    Exynos_gsc_In();

    CGscaler *gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    gsc->dst_info.width            = width;
    gsc->dst_info.height           = height;
    gsc->dst_info.crop_left        = crop_left;
    gsc->dst_info.crop_top         = crop_top;
    gsc->dst_info.crop_width       = crop_width;
    gsc->dst_info.crop_height      = crop_height;
    gsc->dst_info.v4l2_colorformat = v4l2_colorformat;
    gsc->dst_info.dirty            = true;
    gsc->dst_info.cacheable        = cacheable;
    gsc->dst_info.mode_drm         = mode_drm;

    Exynos_gsc_Out();

    return 0;
}

int exynos_gsc_set_rotation(
    void *handle,
    int   rotation,
    int   flip_horizontal,
    int   flip_vertical)
{
    CGscaler *gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    int new_rotation = rotation % 360;

    if (new_rotation % 90 != 0) {
        ALOGE("%s::rotation(%d) cannot be acceptable fail", __func__,
            rotation);
        return -1;
    }

    if(new_rotation < 0)
        new_rotation = -new_rotation;

    gsc->dst_info.rotation        = new_rotation;
    gsc->dst_info.flip_horizontal = flip_horizontal;
    gsc->dst_info.flip_vertical   = flip_vertical;

    return 0;
}

int exynos_gsc_set_src_addr(
    void *handle,
    void *addr[3],
    int mem_type,
    int acquireFenceFd)
{
    Exynos_gsc_In();

    CGscaler* gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    gsc->src_info.buf.addr[0] = addr[0];
    gsc->src_info.buf.addr[1] = addr[1];
    gsc->src_info.buf.addr[2] = addr[2];
    gsc->src_info.acquireFenceFd = acquireFenceFd;
    gsc->src_info.buf.mem_type = (enum v4l2_memory)mem_type;

    Exynos_gsc_Out();

    return 0;
}

int exynos_gsc_set_dst_addr(
    void *handle,
    void *addr[3],
    int mem_type,
    int acquireFenceFd)
{
    Exynos_gsc_In();

    CGscaler* gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    gsc->dst_info.buf.addr[0] = addr[0];
    gsc->dst_info.buf.addr[1] = addr[1];
    gsc->dst_info.buf.addr[2] = addr[2];
    gsc->dst_info.acquireFenceFd = acquireFenceFd;
    gsc->dst_info.buf.mem_type = (enum v4l2_memory)mem_type;

    Exynos_gsc_Out();

    return 0;
}

int exynos_gsc_convert(void *handle)
{
    Exynos_gsc_In();

    int ret    = -1;
    CGscaler* gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return ret;
    }

    if (gsc->m_gsc_m2m_run_core(handle) < 0) {
        ALOGE("%s::exynos_gsc_run_core fail", __func__);
        goto done;
    }

    if (gsc->m_gsc_m2m_wait_frame_done(handle) < 0) {
        ALOGE("%s::exynos_gsc_m2m_wait_frame_done", __func__);
        goto done;
    }

    if (gsc->src_info.releaseFenceFd >= 0) {
        close(gsc->src_info.releaseFenceFd);
        gsc->src_info.releaseFenceFd = -1;
    }

    if (gsc->dst_info.releaseFenceFd >= 0) {
        close(gsc->dst_info.releaseFenceFd);
        gsc->dst_info.releaseFenceFd = -1;
    }

    if (gsc->m_gsc_m2m_stop(handle) < 0) {
        ALOGE("%s::m_gsc_m2m_stop", __func__);
        goto done;
    }

    ret = 0;

done:
    Exynos_gsc_Out();

    return ret;
}

int exynos_gsc_subdev_s_crop(void *handle,
        exynos_mpp_img __UNUSED__ *src_img, exynos_mpp_img *dst_img)
{
    struct v4l2_subdev_crop sd_crop;
    CGscaler *gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    sd_crop.pad = GSCALER_SUBDEV_PAD_SOURCE;
    sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE;
    sd_crop.rect.left = dst_img->x;
    sd_crop.rect.top = dst_img->y;
    sd_crop.rect.width = dst_img->w;
    sd_crop.rect.height = dst_img->h;

    return exynos_subdev_s_crop(gsc->mdev.gsc_sd_entity->fd, &sd_crop);
}

int exynos_gsc_config_exclusive(void *handle,
    exynos_mpp_img *src_img, exynos_mpp_img *dst_img)
{
    Exynos_gsc_In();

    int ret = 0;
    CGscaler* gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }
    if (gsc->gsc_id >= HW_SCAL0) {
        ret = exynos_sc_config_exclusive(gsc->scaler,
            (exynos_sc_img *)src_img, (exynos_sc_img *)dst_img);
        Exynos_gsc_Out();
        return ret;
    }

    switch (gsc->mode) {
    case GSC_M2M_MODE:
        ret = gsc->m_gsc_m2m_config(handle, src_img, dst_img);
        break;
    case GSC_OUTPUT_MODE:
        ret = gsc->m_gsc_out_config(handle, src_img, dst_img);
        break;
    case GSC_CAPTURE_MODE:
        ret = gsc->m_gsc_cap_config(handle, src_img, dst_img);
        break;
    default:
        break;
    }

    Exynos_gsc_Out();

    return ret;
}

int exynos_gsc_run_exclusive(void *handle,
    exynos_mpp_img *src_img, exynos_mpp_img *dst_img)
{
    Exynos_gsc_In();

    int ret = 0;
    CGscaler* gsc = GetGscaler(handle);
    if (handle == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    if (gsc->gsc_id >= HW_SCAL0) {
        ret = exynos_sc_run_exclusive(gsc->scaler,
            (exynos_sc_img *)src_img, (exynos_sc_img *)dst_img);
        Exynos_gsc_Out();
        return ret;
    }

    switch (gsc->mode) {
    case GSC_M2M_MODE:
        ret = gsc->m_gsc_m2m_run(handle, src_img, dst_img);
        break;
    case GSC_OUTPUT_MODE:
        ret = gsc->m_gsc_out_run(handle, src_img);
        break;
    case GSC_CAPTURE_MODE:
        ret = gsc->m_gsc_cap_run(handle, dst_img);
        break;
    default:
        break;
    }

    Exynos_gsc_Out();

    return ret;
}

void *exynos_gsc_create_blend_exclusive(int dev_num, int mode, int out_mode,
                                                                int allow_drm)
{
    Exynos_gsc_In();

    if ((dev_num < 0) || (dev_num >= HW_SCAL_MAX)) {
        ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num);
        return NULL;
    }

    if ((dev_num >= NUM_OF_GSC_HW) && (dev_num < HW_SCAL_MAX)) {
        CGscaler *gsc = new CGscaler(mode, out_mode, dev_num, allow_drm);
        if (!gsc) {
            ALOGE("%s:: failed to allocate Gscaler handle", __func__);
            return NULL;
        }

        gsc->scaler = exynos_sc_create_blend_exclusive(dev_num - HW_SCAL0, allow_drm);
        if (!gsc->scaler) {
            Exynos_gsc_Out();
            delete(gsc);
            ALOGE("%s::exynos_sc_create_blend_exclusive failed", __func__);
            return NULL;
        }
        Exynos_gsc_Out();

        return reinterpret_cast<void *>(gsc);
    }

    Exynos_gsc_Out();

    return NULL;
}

int exynos_gsc_config_blend_exclusive(void *handle,
    exynos_mpp_img *src_img, exynos_mpp_img *dst_img,
    struct SrcBlendInfo  *srcblendinfo)
{
    Exynos_gsc_In();

    int ret = 0;
    CGscaler* gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }
    if (gsc->gsc_id >= HW_SCAL0) {
        ret = exynos_sc_config_blend_exclusive(gsc->scaler,
                                               (exynos_sc_img *)src_img,
                                               (exynos_sc_img *)dst_img,
                                               srcblendinfo);
        Exynos_gsc_Out();
        return ret;
    }
        Exynos_gsc_Out();
        return ret;
}

int exynos_gsc_wait_frame_done_exclusive(void *handle)
{
    Exynos_gsc_In();

    int ret = 0;
    CGscaler* gsc = GetGscaler(handle);
    if (handle == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    if (gsc->gsc_id >= HW_SCAL0) {
        ret = exynos_sc_wait_frame_done_exclusive(gsc->scaler);
        Exynos_gsc_Out();
        return ret;
    }

    if (gsc->mode == GSC_M2M_MODE)
        ret = gsc->m_gsc_m2m_wait_frame_done(handle);

    Exynos_gsc_Out();

    return ret;
}

int exynos_gsc_stop_exclusive(void *handle)
{
    Exynos_gsc_In();

    int ret = 0;
    CGscaler* gsc = GetGscaler(handle);
    if (handle == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }

    if (gsc->gsc_id >= HW_SCAL0) {
        ret = exynos_sc_stop_exclusive(gsc->scaler);
        Exynos_gsc_Out();
        return ret;
    }

    switch (gsc->mode) {
    case GSC_M2M_MODE:
        ret = gsc->m_gsc_m2m_stop(handle);
        break;
    default:
        break;
    }

    Exynos_gsc_Out();

    return ret;
}

int exynos_gsc_free_and_close(void *handle)
{
    Exynos_gsc_In();

    struct v4l2_requestbuffers reqbuf;
    int ret = 0;
    CGscaler* gsc = GetGscaler(handle);
    if (gsc == NULL) {
        ALOGE("%s::handle == NULL() fail", __func__);
        return -1;
    }


    if (gsc->gsc_id >= HW_SCAL0) {
        ret = exynos_sc_free_and_close(gsc->scaler);
        Exynos_gsc_Out();
        return ret;
    }

    memset(&reqbuf, 0, sizeof(struct v4l2_requestbuffers));
    if (gsc->mode == GSC_OUTPUT_MODE)
	    reqbuf.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    else
	    reqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;

    reqbuf.memory = V4L2_MEMORY_DMABUF;
    reqbuf.count  = 0;

    if (ioctl(gsc->mdev.gsc_vd_entity->fd, VIDIOC_REQBUFS, &reqbuf) < 0) {
        ALOGE("%s::request buffers failed", __func__);
        return -1;
    }

    exynos_gsc_destroy(gsc);
    Exynos_gsc_Out();

    return 0;
}