exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp

/*
 * Copyright (C) 2008 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.
 */

//#define DEBUG_LIB_FIMC
#define LOG_TAG "libgscaler"
//#define USE_GSC_USERPTR
#include <cutils/log.h>
#include "../libhdmi/SecHdmi/SecGscaler.h"

#ifdef USE_GSC_USERPTR
#define V4L2_MEMORY_TYPE V4L2_MEMORY_USERPTR
#else
#define V4L2_MEMORY_TYPE V4L2_MEMORY_MMAP
#endif

struct yuv_fmt_list yuv_list[] = {
    { "V4L2_PIX_FMT_NV12",      "YUV420/2P/LSB_CBCR",   V4L2_PIX_FMT_NV12,      12, 1 },
    { "V4L2_PIX_FMT_NV12M",     "YUV420/2P/LSB_CBCR",   V4L2_PIX_FMT_NV12M,     12, 2 },
    { "V4L2_PIX_FMT_NV12MT",    "YUV420/2P/LSB_CBCR",   V4L2_PIX_FMT_NV12MT,    12, 2 },
    { "V4L2_PIX_FMT_NV21",      "YUV420/2P/LSB_CRCB",   V4L2_PIX_FMT_NV21,      12, 1 },
    { "V4L2_PIX_FMT_NV21X",     "YUV420/2P/MSB_CBCR",   V4L2_PIX_FMT_NV21X,     12, 2 },
    { "V4L2_PIX_FMT_NV12X",     "YUV420/2P/MSB_CRCB",   V4L2_PIX_FMT_NV12X,     12, 2 },
    { "V4L2_PIX_FMT_YUV420",    "YUV420/3P",            V4L2_PIX_FMT_YUV420,    12, 3 },
    { "V4L2_PIX_FMT_YUV420M",   "YUV420/3P",            V4L2_PIX_FMT_YUV420M,   12, 3 },
    { "V4L2_PIX_FMT_YUYV",      "YUV422/1P/YCBYCR",     V4L2_PIX_FMT_YUYV,      16, 1 },
    { "V4L2_PIX_FMT_YVYU",      "YUV422/1P/YCRYCB",     V4L2_PIX_FMT_YVYU,      16, 1 },
    { "V4L2_PIX_FMT_UYVY",      "YUV422/1P/CBYCRY",     V4L2_PIX_FMT_UYVY,      16, 1 },
    { "V4L2_PIX_FMT_VYUY",      "YUV422/1P/CRYCBY",     V4L2_PIX_FMT_VYUY,      16, 1 },
    { "V4L2_PIX_FMT_UV12",      "YUV422/2P/LSB_CBCR",   V4L2_PIX_FMT_NV16,      16, 2 },
    { "V4L2_PIX_FMT_UV21",      "YUV422/2P/LSB_CRCB",   V4L2_PIX_FMT_NV61,      16, 2 },
    { "V4L2_PIX_FMT_UV12X",     "YUV422/2P/MSB_CBCR",   V4L2_PIX_FMT_NV16X,     16, 2 },
    { "V4L2_PIX_FMT_UV21X",     "YUV422/2P/MSB_CRCB",   V4L2_PIX_FMT_NV61X,     16, 2 },
    { "V4L2_PIX_FMT_YUV422P",   "YUV422/3P",            V4L2_PIX_FMT_YUV422P,   16, 3 },
};

void dump_pixfmt_mp(struct v4l2_pix_format_mplane *pix_mp)
{
    ALOGI("w: %d", pix_mp->width);
    ALOGI("h: %d", pix_mp->height);
    ALOGI("color: %x", pix_mp->colorspace);

    switch (pix_mp->pixelformat) {
    case V4L2_PIX_FMT_YUYV:
        ALOGI ("YUYV");
        break;
    case V4L2_PIX_FMT_UYVY:
        ALOGI ("UYVY");
        break;
    case V4L2_PIX_FMT_RGB565:
        ALOGI ("RGB565");
        break;
    case V4L2_PIX_FMT_RGB565X:
        ALOGI ("RGB565X");
        break;
    default:
        ALOGI("not supported");
    }
}

void dump_crop(struct v4l2_rect *rect)
{
    ALOGI("crop l: %d", rect->left);
    ALOGI("crop t: %d", rect->top);
    ALOGI("crop w: %d", rect->width);
    ALOGI("crop h: %d", rect->height);
}

void gsc_v4l2_dump_state(int fd)
{
    struct v4l2_format format;
    struct v4l2_crop   crop;
    struct v4l2_subdev_crop sCrop;

    format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    if (ioctl(fd, VIDIOC_G_FMT, &format) < 0)
        return;

    ALOGI("dumping driver state:");
    dump_pixfmt_mp(&format.fmt.pix_mp);

    crop.type = format.type;
    if (ioctl(fd, VIDIOC_G_CROP, &crop) < 0)
        return;

    ALOGI("input image crop:");
    dump_crop(&(crop.c));

    sCrop.pad   = GSC_SUBDEV_PAD_SOURCE;
    sCrop.which = V4L2_SUBDEV_FORMAT_ACTIVE;
    if (ioctl(fd, VIDIOC_SUBDEV_G_CROP, &sCrop) < 0)
        return;

    ALOGI("output image crop:");
    dump_crop(&(sCrop.rect));

}

int gsc_v4l2_querycap(int fd, char *node)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_capability v4l2cap;

    if (ioctl(fd, VIDIOC_QUERYCAP, &v4l2cap) < 0) {
        ALOGE("%s::VIDIOC_QUERYCAP failed", __func__);
        return -1;
    }

    if (!(v4l2cap.capabilities & V4L2_CAP_STREAMING)) {
        ALOGE("%s::%s is not support streaming", __func__, node);
        return -1;
    }

    if (!(v4l2cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) {
        ALOGE("%s::%s is not support video output mplane", __func__, node);
        return -1;
    }

    return 0;
}

int gsc_v4l2_query_buf(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int buf_index, int num_plane)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_buffer buf;
    struct v4l2_plane  planes[MAX_PLANES_GSCALER];

    memset(&buf, 0, sizeof(struct v4l2_buffer));

    for (int i = 0; i < MAX_PLANES_GSCALER; i++)
        memset(&planes[i], 0, sizeof(struct v4l2_plane));

    if (MAX_BUFFERS_GSCALER <= buf_index || MAX_PLANES_GSCALER < num_plane) {
        ALOGE("%s::exceed MAX! : buf_index=%d, num_plane=%d", __func__, buf_index, num_plane);
        return -1;
    }

    buf.type     = type;
    buf.memory   = V4L2_MEMORY_MMAP;
    buf.index    = buf_index;
    buf.length   = num_plane;
    buf.m.planes = planes;

    if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
        ALOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length);
        return -1;
    }

    for (int i = 0; i < num_plane; i++) {
        if ((secBuf->virt.extP[i] = (char *)mmap(0, buf.m.planes[i].length,
                 PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.planes[i].m.mem_offset)) < 0) {
            ALOGE("%s::mmap failed", __func__);
            ALOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset);
            ALOGE("%s::Legnth = %d"  , __func__, buf.m.planes[i].length);
            ALOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
            return -1;
        }
        secBuf->size.extS[i] = buf.m.planes[i].length;

#ifdef DEBUG_LIB_FIMC
    ALOGD("%s::vaddr[bufindex=%d][planeindex=%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
    ALOGD("%s::Legnth = %d"  , __func__, buf.m.planes[i].length);
#endif
    }

    return 0;
}

int gsc_v4l2_req_buf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int num_bufs)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_requestbuffers reqbuf;

    reqbuf.type   = type;
    reqbuf.memory = memory;
    reqbuf.count  = num_bufs;

#ifdef DEBUG_LIB_FIMC
    ALOGI("%d buffers needed", reqbuf.count);
#endif

    if (ioctl(fd, VIDIOC_REQBUFS, &reqbuf) < 0) {
        ALOGE("%s::VIDIOC_REQBUFS failed, reqbuf.count=%d", __func__, reqbuf.count);
        return -1;
    }

#ifdef DEBUG_LIB_FIMC
    ALOGI("%d buffers allocated", reqbuf.count);
#endif

    if (reqbuf.count < num_bufs) {
        ALOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))",
            __func__, reqbuf.count, num_bufs);
        return -1;
    }

    return 0;
}

int gsc_v4l2_s_ctrl(int fd, int id, int value)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_control vc;

    vc.id    = id;
    vc.value = value;

    if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
        ALOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value);
        return -1;
    }

    return 0;
}

int gsc_v4l2_set_fmt(int fd, enum v4l2_buf_type type, enum v4l2_field field, s5p_fimc_img_info *img_info)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_format  fmt;
    struct v4l2_crop    crop;

    fmt.type = type;
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s::fmt.type=%d", __func__, fmt.type);
#endif
    if (ioctl(fd, VIDIOC_G_FMT, &fmt) < 0) {
        ALOGE("%s::VIDIOC_G_FMT failed", __func__);
        return -1;
    }

    switch (fmt.type) {
    case V4L2_BUF_TYPE_VIDEO_OUTPUT:
    case V4L2_BUF_TYPE_VIDEO_CAPTURE:
        fmt.fmt.pix.width       = img_info->full_width;
        fmt.fmt.pix.height      = img_info->full_height;
        fmt.fmt.pix.pixelformat = img_info->color_space;
        fmt.fmt.pix.field       = field;
        break;
    case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
    case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
        fmt.fmt.pix_mp.width       = img_info->full_width;
        fmt.fmt.pix_mp.height      = img_info->full_height;
        fmt.fmt.pix_mp.pixelformat = img_info->color_space;
        fmt.fmt.pix_mp.field       = field;
        fmt.fmt.pix_mp.num_planes  = img_info->planes;
        break;
    default:
        ALOGE("%s::invalid buffer type", __func__);
        return -1;
        break;
    }

#ifdef DEBUG_LIB_FIMC
for (int i = 0; i < 3; i++) {
    ALOGD("%s::fmt.fmt.pix_mp. w=%d, h=%d, pixelformat=0x%08x, filed=%d, num_planes=%d",
               __func__,
               fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
               fmt.fmt.pix_mp.pixelformat, fmt.fmt.pix_mp.field,
               fmt.fmt.pix_mp.num_planes);
}
#endif

    if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
        ALOGE("%s::VIDIOC_S_FMT failed", __func__);
        return -1;
    }

#ifdef DEBUG_LIB_FIMC
for (int i = 0; i < 3; i++) {
    ALOGD("%s::pix_mp.pix_mp.plane_fmt[%d].sizeimage   =0x%08x", __func__, i, fmt.fmt.pix_mp.plane_fmt[i].sizeimage);
    ALOGD("%s::pix_mp.pix_mp.plane_fmt[%d].bytesperline=0x%08x", __func__, i, fmt.fmt.pix_mp.plane_fmt[i].bytesperline);
}
#endif

    crop.type     = type;
    crop.c.left   = img_info->start_x;
    crop.c.top    = img_info->start_y;
    crop.c.width  = img_info->width;
    crop.c.height = img_info->height;

    if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
        ALOGE("%s::VIDIOC_S_CROP (x=%d, y=%d, w=%d, h=%d) failed",
            __func__,
            img_info->start_x,
            img_info->start_y,
            img_info->width,
            img_info->height);
        return -1;
    }

#ifdef DEBUG_LIB_FIMC
    ALOGD("%s::pix_mp pixelformat=0x%08x", __func__, fmt.fmt.pix_mp.pixelformat);
    ALOGD("%s::pix_mp w=%d, h=%d, planes=%d", __func__, fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height, fmt.fmt.pix_mp.num_planes);
    ALOGD("%s::crop   x=%d, y=%d, w=%d, h=%d", __func__, crop.c.left, crop.c.top, crop.c.width, crop.c.height);
#endif

    return 0;
}

int gsc_v4l2_stream_on(int fd, enum v4l2_buf_type type)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
        ALOGE("%s::VIDIOC_STREAMON failed", __func__);
        return -1;
    }

    return 0;
}

int gsc_v4l2_queue(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int index, int num_plane)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
    ALOGD("%s::num_plane=%d", __func__, num_plane);
#endif
    struct v4l2_buffer buf;
    struct v4l2_plane  planes[MAX_PLANES_GSCALER];

    memset(&buf, 0, sizeof(struct v4l2_buffer));

    for (int i = 0; i < MAX_PLANES_GSCALER; i++)
        memset(&planes[i], 0, sizeof(struct v4l2_plane));

    buf.type     = type;
    buf.memory   = memory;
    buf.length   = num_plane;
    buf.index    = index;
    buf.m.planes = planes;

    for (unsigned int i = 0; i < buf.length; i++) {
        buf.m.planes[i].m.userptr = (unsigned long)secBuf->virt.extP[i];
        buf.m.planes[i].length    = secBuf->size.extS[i];
        buf.m.planes[i].bytesused = buf.m.planes[i].length;
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s::buf.index=%d", __func__, buf.index);
    ALOGD("%s::buf.m.planes[%d].m.userptr=0x%08x", __func__, i, (unsigned int)buf.m.planes[i].m.userptr);
    ALOGD("%s::buf.m.planes[%d].length   =0x%08x", __func__, i, buf.m.planes[i].length);
    ALOGD("%s::buf.m.planes[%d].bytesused=0x%08x", __func__, i, buf.m.planes[i].bytesused);
#endif
    }

    if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
        ALOGE("%s::VIDIOC_QBUF failed", __func__);
        return -1;
    }

    return 0;
}

int gsc_v4l2_dequeue(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int *index, int num_plane)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_buffer buf;
    struct v4l2_plane  planes[MAX_PLANES_GSCALER];

    memset(&buf, 0, sizeof(struct v4l2_buffer));

    for (int i = 0; i < MAX_PLANES_GSCALER; i++)
        memset(&planes[i], 0, sizeof(struct v4l2_plane));


    buf.type     = type;
    buf.memory   = memory;
    buf.length   = num_plane;
    buf.m.planes = planes;

    if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) {
        ALOGE("%s::VIDIOC_DQBUF failed", __func__);
        return -1;
    }

    *index = buf.index;

#ifdef DEBUG_LIB_FIMC
    ALOGD("%s::buf.index=%d", __func__, buf.index);
#endif

    return 0;
}

int gsc_v4l2_stream_off(int fd, enum v4l2_buf_type type)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) {
        ALOGE("%s::VIDIOC_STREAMOFF failed", __func__);
        return -1;
    }

    return 0;
}

int gsc_v4l2_clr_buf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_requestbuffers req;

    req.count   = 0;
    req.type    = type;
    req.memory  = memory;

    if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
        ALOGE("%s::VIDIOC_REQBUFS failed", __func__);
        return -1;
    }

    return 0;
}

int gsc_subdev_set_fmt(int fd, unsigned int pad, enum v4l2_mbus_pixelcode code, s5p_fimc_img_info *img_info)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    struct v4l2_subdev_format fmt;
    struct v4l2_subdev_crop   crop;

    fmt.pad   = pad;
    fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
    fmt.format.width  = img_info->full_width;
    fmt.format.height = img_info->full_height;
    fmt.format.code   = code;

    if (ioctl(fd, VIDIOC_SUBDEV_S_FMT, &fmt) < 0) {
        ALOGE("%s::VIDIOC_SUBDEV_S_FMT failed", __func__);
        return -1;
    }

    crop.pad   = pad;
    crop.which = V4L2_SUBDEV_FORMAT_ACTIVE;
    crop.rect.left   = img_info->start_x;
    crop.rect.top    = img_info->start_y;
    crop.rect.width  = img_info->width;
    crop.rect.height = img_info->height;

#ifdef DEBUG_LIB_FIMC
    ALOGD("%s::pix_mp w=%d, h=%d", __func__, fmt.format.width, fmt.format.height);
    ALOGD("%s::crop   x=%d, y=%d, w=%d, h=%d", __func__, crop.rect.left, crop.rect.top, crop.rect.width, crop.rect.height);
#endif

    if (ioctl(fd, VIDIOC_SUBDEV_S_CROP, &crop) < 0) {
        ALOGE("%s::VIDIOC_SUBDEV_S_CROP failed", __func__);
        return -1;
    }

    return 0;
}

static inline int multipleOfN(int number, int N)
{
    int result = number;
    switch (N) {
    case 1:
    case 2:
    case 4:
    case 8:
    case 16:
    case 32:
    case 64:
    case 128:
    case 256:
        result = (number - (number & (N-1)));
        break;
    default:
        result = number - (number % N);
        break;
    }
    return result;
}

SecGscaler::SecGscaler()
:   mFlagCreate(false)
{
}

SecGscaler::~SecGscaler()
{
    if (mFlagCreate == true) {
        ALOGE("%s::this is not Destroyed fail", __func__);

        if (destroy() == false)
            ALOGE("%s::destroy failed", __func__);
    }
}

bool SecGscaler::create(enum DEV dev, enum MODE mode, unsigned int numOfBuf)
{
    create(dev, numOfBuf);
    return true;
}

bool SecGscaler::create(enum DEV dev, unsigned int numOfBuf)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif
    if (mFlagCreate == true) {
        ALOGE("%s::Already Created", __func__);
        return true;
    }

    char node[20];
    char subdevname[32];
    char videodevname[32];

    struct v4l2_capability   v4l2cap;
    struct media_entity_desc entity_desc;

    mDev = dev;
    mVideoNodeNum = dev;
    mNumOfBuf = numOfBuf;

    mVideodevFd = 0;
    mMediadevFd = 0;
    mSubdevFd = 0;

    mSrcIndex = 0;
    mRotVal = 0;
    mFlagGlobalAlpha = false;
    mGlobalAlpha = 0x0;
    mFlagLocalAlpha = false;
    mFlagColorKey = false;
    mColorKey = 0x0;
    mFlagSetSrcParam = false;
    mFlagSetDstParam = false;
    mFlagStreamOn = false;

    memset(&mS5pFimc, 0, sizeof(s5p_fimc_t));

    switch(mDev) {
    case DEV_0:
        mVideoNodeNum = 24;
        mSubdevNodeNum = 4;
        break;
    case DEV_1:
        mVideoNodeNum = 27;
        mSubdevNodeNum = 5;
        break;
    case DEV_2:
        mVideoNodeNum = 30;
        mSubdevNodeNum = 6;
        break;
    case DEV_3:
        mVideoNodeNum = 33;
        mSubdevNodeNum = 3; // need to modify //carrotsm
        break;
    default:
        ALOGE("%s::invalid mDev(%d)", __func__, mDev);
        goto err;
        break;
    }

    sprintf(node, "%s%d", PFX_NODE_MEDIADEV, 0);
    mMediadevFd = open(node, O_RDONLY);

    if (mMediadevFd < 0) {
        ALOGE("%s::open(%s) failed : O_RDONLY", __func__, node);
        goto err;
    }

    sprintf(subdevname,   PFX_ENTITY_SUBDEV_GSC, mDev);
    sprintf(videodevname, PFX_ENTITY_OUTPUTDEV_GSC, mDev);

    for (__u32 id = 0; ; id = entity_desc.id) {
        entity_desc.id = id | MEDIA_ENT_ID_FLAG_NEXT;

        if (ioctl(mMediadevFd, MEDIA_IOC_ENUM_ENTITIES, &entity_desc) < 0) {
            if (errno == EINVAL) {
                ALOGD("%s::MEDIA_IOC_ENUM_ENTITIES ended", __func__);
                break;
            }
            ALOGE("%s::MEDIA_IOC_ENUM_ENTITIES failed", __func__);
            goto err;
        }

#ifdef DEBUG_LIB_FIMC
    ALOGD("%s::entity_desc.id=%d, .minor=%d .name=%s", __func__, entity_desc.id, entity_desc.v4l.minor, entity_desc.name);
#endif

        if (strncmp(entity_desc.name, subdevname, strlen(subdevname)) == 0)
            mSubdevEntity = entity_desc.id;

        if (strncmp(entity_desc.name, videodevname, strlen(videodevname)) == 0)
            mVideodevEntity = entity_desc.id;
    }

    if (0 < mMediadevFd)
        close(mMediadevFd);
    mMediadevFd = -1;

    sprintf(node, "%s%d", PFX_NODE_SUBDEV, mSubdevNodeNum);
    mSubdevFd = open(node, O_RDWR);
    if (mSubdevFd < 0) {
        ALOGE("%s::open(%s) failed", __func__, node);
        goto err;
    }

    sprintf(node, "%s%d", PFX_NODE_VIDEODEV, mVideoNodeNum);
    mVideodevFd = open(node, O_RDWR);
    if (mVideodevFd < 0) {
        ALOGE("%s::open(%s) failed", __func__, node);
        goto err;
    }

    /* check capability */
    if (gsc_v4l2_querycap(mVideodevFd, node) < 0 ) {
        ALOGE("%s::tvout_std_v4l2_querycap failed", __func__);
        goto err;
    }

    mFlagCreate = true;

    return true;

err :
    if (0 < mVideodevFd)
        close(mVideodevFd);

    if (0 < mMediadevFd)
        close(mMediadevFd);

    if (0 < mSubdevFd)
        close(mSubdevFd);

    mVideodevFd = -1;
    mMediadevFd = -1;
    mSubdevFd = -1;

    return false;
}

bool SecGscaler::destroy()
{
    s5p_fimc_params_t *params = &(mS5pFimc.params);

    if (mFlagCreate == false) {
        ALOGE("%s::Already Destroyed", __func__);
        return true;
    }

    if (mFlagStreamOn == true) {
        if (streamOff() == false) {
            ALOGE("%s::streamOff() failed", __func__);
            return false;
        }

        if (closeVideodevFd() == false) {
            ALOGE("%s::closeVideodevFd() failed", __func__);
            return false;
        }

        mFlagStreamOn = false;
    }

    if (0 < mMediadevFd)
        close(mMediadevFd);

    if (0 < mSubdevFd)
        close(mSubdevFd);

    mVideodevFd = -1;
    mMediadevFd = -1;
    mSubdevFd = -1;

    mFlagCreate = false;

    return true;
}

bool SecGscaler::flagCreate(void)
{
    return mFlagCreate;
}

int SecGscaler::getFd(void)
{
    return getVideodevFd();
}

int SecGscaler::getVideodevFd(void)
{
    return mVideodevFd;
}

bool SecGscaler::openVideodevFd(void)
{
    char node[32];

    sprintf(node, "%s%d", PFX_NODE_VIDEODEV, mVideoNodeNum);
    mVideodevFd = open(node, O_RDWR);
    if (mVideodevFd < 0) {
        ALOGE("%s::open(%s) failed", __func__, node);
        return false;
    }

    return true;
}

bool SecGscaler::closeVideodevFd(void)
{
    if (mFlagSetSrcParam == true) {
        if (gsc_v4l2_clr_buf(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE) < 0) {
            ALOGE("%s::gsc_v4l2_clr_buf() failed", __func__);
            return false;
        }
    }

    if (0 < mVideodevFd) {
        if (close(mVideodevFd) < 0) {
            ALOGE("%s::close Videodev failed", __func__);
            return false;
        }
    }
    mVideodevFd = -1;

    return true;
}

int SecGscaler::getSubdevFd(void)
{
    return mSubdevFd;
}

__u32 SecGscaler::getSubdevEntity(void)
{
    return mSubdevEntity;
}

__u32 SecGscaler::getVideodevEntity(void)
{
    return mVideodevEntity;
}

bool  SecGscaler::getFlagSteamOn(void)
{
    return mFlagStreamOn;
}

SecBuffer * SecGscaler::getSrcBufferAddr(int index)
{
    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    return &mSrcBuffer[index];
}

bool SecGscaler::setSrcParams(unsigned int width, unsigned int height,
                              unsigned int cropX, unsigned int cropY,
                              unsigned int *cropWidth, unsigned int *cropHeight,
                              int colorFormat,
                              bool forceChange)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(colorFormat);
    if (v4l2ColorFormat < 0) {
        ALOGE("%s::not supported color format", __func__);
        return false;
    }

    s5p_fimc_params_t *params = &(mS5pFimc.params);

    unsigned int fimcWidth  = *cropWidth;
    unsigned int fimcHeight = *cropHeight;
    int src_planes = m_getYuvPlanes(v4l2ColorFormat);
    int src_bpp    = m_getYuvBpp(v4l2ColorFormat);
    unsigned int frame_size  = width * height;
    unsigned int frame_ratio = 8;

    if (m_checkSrcSize(width, height, cropX, cropY,
                   &fimcWidth, &fimcHeight, v4l2ColorFormat, false) == false) {
        ALOGE("%s::::size align error!", __func__);
        return false;
    }

    if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) {
        if (forceChange == true) {
#ifdef DEBUG_LIB_FIMC
            ALOGD("size is changed from [w=%d, h=%d] to [w=%d, h=%d]",
                    *cropWidth, *cropHeight, fimcWidth, fimcHeight);
#endif
        } else {
            ALOGE("%s::invalid source params", __func__);
            return false;
        }
    }

    if (   (params->src.full_width == width)
        && (params->src.full_height == height)
        && (params->src.start_x == cropX)
        && (params->src.start_y == cropY)
        && (params->src.width == fimcWidth)
        && (params->src.height == fimcHeight)
        && (params->src.color_space == (unsigned int)v4l2ColorFormat))
        return true;

    params->src.full_width  = width;
    params->src.full_height = height;
    params->src.start_x     = cropX;
    params->src.start_y     = cropY;
    params->src.width       = fimcWidth;
    params->src.height      = fimcHeight;
    params->src.color_space = v4l2ColorFormat;
    src_planes = (src_planes == -1) ? 1 : src_planes;
    params->src.planes = src_planes;

    mSrcBuffer[mSrcIndex].size.extS[0] = 0;
    mSrcBuffer[mSrcIndex].size.extS[1] = 0;
    mSrcBuffer[mSrcIndex].size.extS[2] = 0;

    frame_ratio = frame_ratio * (src_planes -1) / (src_bpp - 8);
#ifdef USE_GSC_USERPTR
    for (int buf_index = 0; buf_index < MAX_BUFFERS_GSCALER; buf_index++) {
        switch (src_planes) {
        case 1:
            switch (v4l2ColorFormat) {
            case V4L2_PIX_FMT_BGR32:
                params->src.color_space = V4L2_PIX_FMT_RGB32;
            case V4L2_PIX_FMT_RGB32:
                mSrcBuffer[buf_index].size.extS[0] = frame_size << 2;
                break;
            case V4L2_PIX_FMT_RGB565X:
            case V4L2_PIX_FMT_NV16:
            case V4L2_PIX_FMT_NV61:
            case V4L2_PIX_FMT_YUYV:
            case V4L2_PIX_FMT_UYVY:
            case V4L2_PIX_FMT_VYUY:
            case V4L2_PIX_FMT_YVYU:
                mSrcBuffer[buf_index].size.extS[0] = frame_size << 1;
                break;
            case V4L2_PIX_FMT_YUV420:
            case V4L2_PIX_FMT_NV12:
            case V4L2_PIX_FMT_NV21:
                mSrcBuffer[buf_index].size.extS[0] = (frame_size * 3) >> 1;
                break;
            default:
                ALOGE("%s::invalid color type", __func__);
                return false;
                break;
            }
            mSrcBuffer[buf_index].size.extS[1] = 0;
            mSrcBuffer[buf_index].size.extS[2] = 0;
            break;
        case 2:
        case 3:
            mSrcBuffer[buf_index].size.extS[0] = frame_size;
            mSrcBuffer[buf_index].size.extS[1] = frame_size / frame_ratio;
            mSrcBuffer[buf_index].size.extS[2] = frame_size / frame_ratio;
            break;
        default:
            ALOGE("%s::invalid color foarmt", __func__);
            return false;
            break;
        }
    }
#else
    if (v4l2ColorFormat == V4L2_PIX_FMT_BGR32)
        params->src.color_space = V4L2_PIX_FMT_RGB32;
#endif

    if (mFlagSetSrcParam == true) {
        if (gsc_v4l2_clr_buf(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE) < 0) {
            ALOGE("%s::gsc_v4l2_clr_buf() failed", __func__);
            return false;
        }
    }

    if (gsc_v4l2_set_fmt(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_NONE, &(params->src)) < 0) {
        ALOGE("%s::fimc_v4l2_set_fmt()[src] failed", __func__);
        return false;
    }

    if (gsc_v4l2_req_buf(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, mNumOfBuf) < 0) {
        ALOGE("%s::fimc_v4l2_req_buf()[src] failed", __func__);
        return false;
    }
#ifdef USE_GSC_USERPTR
#else
    for (unsigned int buf_index = 0; buf_index < MAX_BUFFERS_GSCALER; buf_index++) {
        if (gsc_v4l2_query_buf(mVideodevFd, &mSrcBuffer[buf_index], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_MMAP, buf_index, params->src.planes) < 0) {
            ALOGE("%s::gsc_v4l2_query_buf() failed", __func__);
            return false;
        }
    }
#endif

    *cropWidth  = fimcWidth;
    *cropHeight = fimcHeight;

    mFlagSetSrcParam = true;

    return true;
}

bool SecGscaler::getSrcParams(unsigned int *width, unsigned int *height,
                              unsigned int *cropX, unsigned int *cropY,
                              unsigned int *cropWidth, unsigned int *cropHeight,
                              int *v4l2colorFormat)
{
    struct v4l2_format fmt;
    struct v4l2_crop   crop;

    fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;

    if (ioctl(mVideodevFd, VIDIOC_G_FMT, &fmt) < 0) {
        ALOGE("%s::VIDIOC_G_FMT(fmt.type : %d) failed", __func__, fmt.type);
        return false;
    }

    switch (fmt.type) {
    case V4L2_BUF_TYPE_VIDEO_OUTPUT:
    case V4L2_BUF_TYPE_VIDEO_CAPTURE:
    case V4L2_BUF_TYPE_VIDEO_OVERLAY:
        *width       = fmt.fmt.pix.width;
        *height      = fmt.fmt.pix.height;
        *v4l2colorFormat = fmt.fmt.pix.pixelformat;
        break;
    case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
    case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
        *width       = fmt.fmt.pix_mp.width;
        *height      = fmt.fmt.pix_mp.height;
        *v4l2colorFormat = fmt.fmt.pix_mp.pixelformat;
        break;
    default:
        ALOGE("%s::Invalid buffer type", __func__);
        return false;
        break;
    }

    crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    if (ioctl(mVideodevFd, VIDIOC_G_CROP, &crop) < 0) {
        ALOGE("%s::VIDIOC_G_CROP failed", __func__);
        return false;
    }

    *cropX      = crop.c.left;
    *cropY      = crop.c.top;
    *cropWidth  = crop.c.width;
    *cropHeight = crop.c.height;

    return true;
}

bool SecGscaler::setSrcAddr(unsigned int YAddr,
                            unsigned int CbAddr,
                            unsigned int CrAddr,
                            int colorFormat)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (mFlagSetSrcParam == false) {
        ALOGE("%s::mFlagSetSrcParam == false", __func__);
        return false;
    }

#ifdef USE_GSC_USERPTR
    mSrcBuffer[mSrcIndex].virt.extP[0] = (char *)YAddr;
    mSrcBuffer[mSrcIndex].virt.extP[1] = (char *)CbAddr;
    mSrcBuffer[mSrcIndex].virt.extP[2] = (char *)CrAddr;
#else
    unsigned int srcAddr[MAX_PLANES_GSCALER];

    srcAddr[0] = YAddr;
    srcAddr[1] = CbAddr;
    srcAddr[2] = CrAddr;

    for (int plane_index = 0; plane_index < mS5pFimc.params.src.planes; plane_index++) {
        memcpy((void *)mSrcBuffer[mSrcIndex].virt.extP[plane_index], (void *)srcAddr[plane_index], mSrcBuffer[mSrcIndex].size.extS[plane_index]);
    }
#endif

    return true;
}

bool SecGscaler::setDstParams(unsigned int width, unsigned int height,
                              unsigned int cropX, unsigned int cropY,
                              unsigned int *cropWidth, unsigned int *cropHeight,
                              int colorFormat,
                              bool forceChange)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    int mbusFormat = V4L2_MBUS_FMT_YUV8_1X24;

    s5p_fimc_params_t *params = &(mS5pFimc.params);

    unsigned int fimcWidth  = *cropWidth;
    unsigned int fimcHeight = *cropHeight;

    if( m_checkDstSize(width, height, cropX, cropY,
                   &fimcWidth, &fimcHeight, V4L2_PIX_FMT_YUV444,
                   mRotVal, true) == false) {
        ALOGE("%s::size align error!", __func__);
        return false;
    }


    if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) {
        if (forceChange == true) {
#ifdef DEBUG_LIB_FIMC
            ALOGD("size is changed from [w = %d, h= %d] to [w = %d, h = %d]",
                    *cropWidth, *cropHeight, fimcWidth, fimcHeight);
#endif
        } else {
            ALOGE("%s::Invalid destination params", __func__);
            return false;
        }
    }

    if (90 == mRotVal || 270 == mRotVal) {
        params->dst.full_width  = height;
        params->dst.full_height = width;

        if (90 == mRotVal) {
            params->dst.start_x     = cropY;
            params->dst.start_y     = width - (cropX + fimcWidth);
        } else {
            params->dst.start_x = height - (cropY + fimcHeight);
            params->dst.start_y = cropX;
        }

        params->dst.width       = fimcHeight;
        params->dst.height      = fimcWidth;

        params->dst.start_y     += (fimcWidth - params->dst.height);

    } else {
        params->dst.full_width  = width;
        params->dst.full_height = height;

        if (180 == mRotVal) {
            params->dst.start_x = width - (cropX + fimcWidth);
            params->dst.start_y = height - (cropY + fimcHeight);
        } else {
            params->dst.start_x     = cropX;
            params->dst.start_y     = cropY;
        }

        params->dst.width       = fimcWidth;
        params->dst.height      = fimcHeight;
    }

    if (gsc_subdev_set_fmt(mSubdevFd, GSC_SUBDEV_PAD_SOURCE, V4L2_MBUS_FMT_YUV8_1X24, &(params->dst)) < 0) {
        ALOGE("%s::gsc_subdev_set_fmt()[dst] failed", __func__);
        return false;
    }

    mFlagSetDstParam = true;

    return true;
}

bool SecGscaler::getDstParams(unsigned int *width, unsigned int *height,
                              unsigned int *cropX, unsigned int *cropY,
                              unsigned int *cropWidth, unsigned int *cropHeight,
                              int *mbusColorFormat)
{
    struct v4l2_subdev_format fmt;
    struct v4l2_subdev_crop   crop;

    fmt.pad   = GSC_SUBDEV_PAD_SOURCE;
    fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;

    if (ioctl(mSubdevFd, VIDIOC_SUBDEV_G_FMT, &fmt) < 0) {
        ALOGE("%s::VIDIOC_SUBDEV_S_FMT", __func__);
        return -1;
    }

    *width  = fmt.format.width;
    *height = fmt.format.height;
    *mbusColorFormat = fmt.format.code;

    crop.pad   = GSC_SUBDEV_PAD_SOURCE;
    crop.which = V4L2_SUBDEV_FORMAT_ACTIVE;

    if (ioctl(mSubdevFd, VIDIOC_SUBDEV_G_CROP, &crop) < 0) {
        ALOGE("%s::VIDIOC_SUBDEV_S_CROP", __func__);
        return -1;
    }

    *cropX      = crop.rect.left;
    *cropY      = crop.rect.top;
    *cropWidth  = crop.rect.width;
    *cropHeight = crop.rect.height;

    return true;
}

bool SecGscaler::setDstAddr(unsigned int YAddr, unsigned int CbAddr, unsigned int CrAddr, int buf_index)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    return true;
}

bool SecGscaler::setRotVal(unsigned int rotVal)
{
    struct v4l2_control vc;

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (gsc_v4l2_s_ctrl(mVideodevFd, V4L2_CID_ROTATE, rotVal) < 0) {
        ALOGE("%s::fimc_v4l2_s_ctrl(V4L2_CID_ROTATE) failed", __func__);
        return false;
    }

    mRotVal = rotVal;
    return true;
}

bool SecGscaler::setGlobalAlpha(bool enable, int alpha)
{
    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (mFlagStreamOn == true) {
        ALOGE("%s::mFlagStreamOn == true", __func__);
        return false;
    }

    mFlagGlobalAlpha = enable;
    mGlobalAlpha     = alpha;

    return true;

}

bool SecGscaler::setLocalAlpha(bool enable)
{
    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (mFlagStreamOn == true) {
        ALOGE("%s::mFlagStreamOn == true", __func__);
        return false;
    }

    if (mFlagLocalAlpha == enable)
        return true;

    return true;
}

bool SecGscaler::setColorKey(bool enable, int colorKey)
{
    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (mFlagStreamOn == true) {
        ALOGE("%s::mFlagStreamOn == true", __func__);
        return false;
    }

    mFlagColorKey = enable;
    mColorKey = colorKey;

    return true;
}

bool SecGscaler::run()
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (mFlagSetSrcParam == false) {
        ALOGE("%s::faild : Need to set source parameters of Gscaler", __func__);
        return false;
    }

    if (mFlagSetDstParam == false) {
        ALOGE("%s::faild : Need to set destination parameters of Gscaler", __func__);
        return false;
    }

    s5p_fimc_params_t *params = &(mS5pFimc.params);
    int src_planes = m_getYuvPlanes(params->src.color_space);
    unsigned int dqIndex = 0;
    src_planes     = (src_planes == -1) ? 1 : src_planes;

    if (gsc_v4l2_queue(mVideodevFd, &(mSrcBuffer[mSrcIndex]), V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, mSrcIndex, src_planes) < 0) {
        ALOGE("%s::fimc_v4l2_queue[src](mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, mNumOfBuf, mSrcIndex);
        return false;
    }

    mSrcIndex++;
    if (mSrcIndex >= MAX_BUFFERS_GSCALER) {
        mSrcIndex = 0;
    }

    if (gsc_v4l2_dequeue(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, &dqIndex, src_planes) < 0) {
        ALOGE("%s::fimc_v4l2_dequeue[src](mNumOfBuf : %d, dqIndex=%d) failed", __func__, mNumOfBuf, dqIndex);
        return false;
    }

    return true;
}

bool SecGscaler::streamOn(void)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (mFlagStreamOn == true) {
        ALOGE("%s::already streamon", __func__);
        return true;
    }

    s5p_fimc_params_t *params = &(mS5pFimc.params);
    int src_planes = m_getYuvPlanes(params->src.color_space);
    src_planes     = (src_planes == -1) ? 1 : src_planes;

    if (gsc_v4l2_queue(mVideodevFd, &(mSrcBuffer[mSrcIndex]), V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, mSrcIndex, src_planes) < 0) {
        ALOGE("%s::fimc_v4l2_queue[src](mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, mNumOfBuf, mSrcIndex);
        return false;
    }

    mSrcIndex++;
    if (mSrcIndex == MAX_BUFFERS_GSCALER - 1) {
        if (gsc_v4l2_stream_on(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
            ALOGE("%s::fimc_v4l2_stream_on() failed", __func__);
            return false;
        }
        mFlagStreamOn = true;
    }

    if (mSrcIndex >= MAX_BUFFERS_GSCALER) {
        mSrcIndex = 0;
    }

    return true;
}

bool SecGscaler::streamOff(void)
{
#ifdef DEBUG_LIB_FIMC
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == false) {
        ALOGE("%s::Not yet created", __func__);
        return false;
    }

    if (mFlagStreamOn == false) {
        ALOGE("%s::already streamoff", __func__);
        return true;
    }

    if (gsc_v4l2_stream_off(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
        ALOGE("%s::fimc_v4l2_stream_off() failed", __func__);
        return false;
    }

    mSrcIndex = 0;
#ifdef USE_GSC_USERPTR
    SecBuffer zeroBuf;
    for (int buf_index = 0; buf_index < MAX_BUFFERS_GSCALER; buf_index++)
        mSrcBuffer[buf_index] = zeroBuf;
#else
    for (int buf_index = 0; buf_index < MAX_BUFFERS_GSCALER; buf_index++) {
        for (int plane_index = 0; plane_index < MAX_PLANES_GSCALER; plane_index++) {
            munmap((void *)mSrcBuffer[buf_index].virt.extP[plane_index], mSrcBuffer[buf_index].size.extS[plane_index]);
        }
    }
#endif

    mFlagStreamOn = false;

    return true;
}

bool SecGscaler::m_checkSrcSize(unsigned int width, unsigned int height,
                             unsigned int cropX, unsigned int cropY,
                             unsigned int *cropWidth, unsigned int *cropHeight,
                             int colorFormat,
                             bool forceChange)
{
    bool ret = true;

    if (8 <= height && *cropHeight < 8) {
        if (forceChange)
            *cropHeight = 8;
        ret = false;
    }

    if (16 <= width && *cropWidth < 16) {
        if (forceChange)
            *cropWidth = 16;
        ret = false;
    }

    if (height < 8)
        return false;

    if (width % 16 != 0)
        return false;

    if (*cropWidth % 16 != 0) {
        if (forceChange)
            *cropWidth = multipleOfN(*cropWidth, 16);
        ret = false;
    }

    return ret;
}

bool SecGscaler::m_checkDstSize(unsigned int width, unsigned int height,
                             unsigned int cropX, unsigned int cropY,
                             unsigned int *cropWidth, unsigned int *cropHeight,
                             int colorFormat, int rotVal,  bool forceChange)
{
    bool ret = true;
    unsigned int rotWidth;
    unsigned int rotHeight;
    unsigned int *rotCropWidth;
    unsigned int *rotCropHeight;

    if (rotVal == 90 || rotVal == 270) {
        rotWidth = height;
        rotHeight = width;
        rotCropWidth = cropHeight;
        rotCropHeight = cropWidth;
    } else {
        rotWidth = width;
        rotHeight = height;
        rotCropWidth = cropWidth;
        rotCropHeight = cropHeight;
    }

    if (rotHeight < 8)
        return false;

    if (rotWidth % 8 != 0)
        return false;

    switch (colorFormat) {
    case V4L2_PIX_FMT_NV21:
    case V4L2_PIX_FMT_NV12:
    case V4L2_PIX_FMT_NV12T:
    case V4L2_PIX_FMT_NV12M:
    case V4L2_PIX_FMT_NV12MT:
    case V4L2_PIX_FMT_YUV420M:
    case V4L2_PIX_FMT_YUV420:
        if (*rotCropHeight % 2 != 0) {
            if (forceChange)
                *rotCropHeight = multipleOfN(*rotCropHeight, 2);
            ret = false;
        }
    }
    return ret;
}

int SecGscaler::m_widthOfFimc(int v4l2ColorFormat, int width)
{
    int newWidth = width;

    switch (v4l2ColorFormat) {
    case V4L2_PIX_FMT_RGB565:
        newWidth = multipleOfN(width, 8);
        break;
    case V4L2_PIX_FMT_RGB32:
        newWidth = multipleOfN(width, 4);
        break;
    case V4L2_PIX_FMT_YUYV:
    case V4L2_PIX_FMT_UYVY:
        newWidth = multipleOfN(width, 4);
        break;
    case V4L2_PIX_FMT_NV61:
    case V4L2_PIX_FMT_NV16:
        newWidth = multipleOfN(width, 8);
        break;
    case V4L2_PIX_FMT_YUV422P:
        newWidth = multipleOfN(width, 16);
        break;
    case V4L2_PIX_FMT_NV21:
    case V4L2_PIX_FMT_NV12:
    case V4L2_PIX_FMT_NV12MT:
        newWidth = multipleOfN(width, 8);
        break;
    case V4L2_PIX_FMT_YUV420:
    case V4L2_PIX_FMT_YUV420M:
        newWidth = multipleOfN(width, 16);
        break;
    default :
        break;
    }

    return newWidth;
}

int SecGscaler::m_heightOfFimc(int v4l2ColorFormat, int height)
{
    int newHeight = height;

    switch (v4l2ColorFormat) {
    case V4L2_PIX_FMT_NV21:
    case V4L2_PIX_FMT_NV12:
    case V4L2_PIX_FMT_NV12T:
    case V4L2_PIX_FMT_NV12MT:
    case V4L2_PIX_FMT_YUV420:
    case V4L2_PIX_FMT_YUV420M:
        newHeight = multipleOfN(height, 2);
        break;
    default :
        break;
    }
    return newHeight;
}

int SecGscaler::m_getYuvBpp(unsigned int fmt)
{
    int i, sel = -1;

    for (i = 0; i < (int)(sizeof(yuv_list) / sizeof(struct yuv_fmt_list)); i++) {
        if (yuv_list[i].fmt == fmt) {
            sel = i;
            break;
        }
    }

    if (sel == -1)
        return sel;
    else
        return yuv_list[sel].bpp;
}

int SecGscaler::m_getYuvPlanes(unsigned int fmt)
{
    int i, sel = -1;

    for (i = 0; i < (int)(sizeof(yuv_list) / sizeof(struct yuv_fmt_list)); i++) {
        if (yuv_list[i].fmt == fmt) {
            sel = i;
            break;
        }
    }

    if (sel == -1)
        return sel;
    else
        return yuv_list[sel].planes;
}