diff options
Diffstat (limited to 'exynos4/hal/libfimc/SecFimc.cpp')
| -rw-r--r-- | exynos4/hal/libfimc/SecFimc.cpp | 1701 |
1 files changed, 1701 insertions, 0 deletions
diff --git a/exynos4/hal/libfimc/SecFimc.cpp b/exynos4/hal/libfimc/SecFimc.cpp new file mode 100644 index 0000000..ab744a2 --- /dev/null +++ b/exynos4/hal/libfimc/SecFimc.cpp @@ -0,0 +1,1701 @@ +/* + * 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. + */ + +/*! + * \file SecFimc.cpp + * \brief source file for Fimc HAL MODULE + * \author Hyunkyung, Kim(hk310.kim@samsung.com) + * \date 2010/10/13 + * + * <b>Revision History: </b> + * - 2010/10/13 : Hyunkyung, Kim(hk310.kim@samsung.com) \n + * Initial version + * + * - 2011/11/15 : Sunmi, Lee(carrotsm.lee@samsung.com) \n + * Adjust V4L2 architecture \n + */ + +#define LOG_TAG "libfimc" +#include <cutils/log.h> + +#include "SecFimc.h" + +#define FIMC2_DEV_NAME "/dev/video2" + +//#define DEBUG_LIB_FIMC + +#ifdef BOARD_USE_V4L2 +#define V4L2_BUF_TYPE_OUTPUT V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE +#define V4L2_BUF_TYPE_CAPTURE V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE +#define V4L2_ROTATE V4L2_CID_ROTATE +#else +#define V4L2_BUF_TYPE_OUTPUT V4L2_BUF_TYPE_VIDEO_OUTPUT +#define V4L2_BUF_TYPE_CAPTURE V4L2_BUF_TYPE_VIDEO_CAPTURE +#define V4L2_ROTATE V4L2_CID_ROTATION +#endif + +#define V4L2_BUF_TYPE_SRC V4L2_BUF_TYPE_OUTPUT +#define V4L2_MEMORY_TYPE_SRC V4L2_MEMORY_USERPTR +#ifdef BOARD_USE_V4L2 +#define V4L2_BUF_TYPE_DST V4L2_BUF_TYPE_CAPTURE +#define V4L2_MEMORY_TYPE_DST V4L2_MEMORY_MMAP +#else +#define V4L2_BUF_TYPE_DST V4L2_BUF_TYPE_VIDEO_OVERLAY +#define V4L2_MEMORY_TYPE_DST V4L2_MEMORY_USERPTR +#endif + +struct yuv_fmt_list yuv_list[] = { + { "V4L2_PIX_FMT_NV12", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12, 12, 2 }, +#ifdef BOARD_USE_V4L2 + { "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 }, +#endif + { "V4L2_PIX_FMT_NV12T", "YUV420/2P/LSB_CBCR", V4L2_PIX_FMT_NV12T, 12, 2 }, + { "V4L2_PIX_FMT_NV21", "YUV420/2P/LSB_CRCB", V4L2_PIX_FMT_NV21, 12, 2 }, + { "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 }, +#ifdef BOARD_USE_V4L2 + { "V4L2_PIX_FMT_YUV420M", "YUV420/3P", V4L2_PIX_FMT_YUV420M, 12, 3 }, +#endif + { "V4L2_PIX_FMT_YUV420", "YUV420/3P", V4L2_PIX_FMT_YUV420, 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 }, +}; + +#ifdef BOARD_USE_V4L2 +void dump_pixfmt_mp(struct v4l2_pix_format_mplane *pix_mp) +{ + LOGI("w: %d", pix_mp->width); + LOGI("h: %d", pix_mp->height); + LOGI("color: %x", pix_mp->colorspace); + + switch (pix_mp->pixelformat) { + case V4L2_PIX_FMT_YUYV: + LOGI ("YUYV"); + break; + case V4L2_PIX_FMT_UYVY: + LOGI ("UYVY"); + break; + case V4L2_PIX_FMT_RGB565: + LOGI ("RGB565"); + break; + case V4L2_PIX_FMT_RGB565X: + LOGI ("RGB565X"); + break; + default: + LOGI("not supported"); + } +} +#endif + +void dump_pixfmt(struct v4l2_pix_format *pix) +{ + LOGI("w: %d", pix->width); + LOGI("h: %d", pix->height); + LOGI("color: %x", pix->colorspace); + + switch (pix->pixelformat) { + case V4L2_PIX_FMT_YUYV: + LOGI ("YUYV"); + break; + case V4L2_PIX_FMT_UYVY: + LOGI ("UYVY"); + break; + case V4L2_PIX_FMT_RGB565: + LOGI ("RGB565"); + break; + case V4L2_PIX_FMT_RGB565X: + LOGI ("RGB565X"); + break; + default: + LOGI("not supported"); + } +} + +void dump_crop(struct v4l2_crop *crop) +{ + LOGI("crop l: %d", crop->c.left); + LOGI("crop t: %d", crop->c.top); + LOGI("crop w: %d", crop->c.width); + LOGI("crop h: %d", crop->c.height); +} + +void dump_window(struct v4l2_window *win) +{ + LOGI("window l: %d", win->w.left); + LOGI("window t: %d", win->w.top); + LOGI("window w: %d", win->w.width); + LOGI("window h: %d", win->w.height); +} + +void v4l2_overlay_dump_state(int fd) +{ + struct v4l2_format format; + struct v4l2_crop crop; + + format.type = V4L2_BUF_TYPE_OUTPUT; + if (ioctl(fd, VIDIOC_G_FMT, &format) < 0) + return; + + LOGI("dumping driver state:"); +#ifdef BOARD_USE_V4L2 + dump_pixfmt_mp(&format.fmt.pix_mp); +#else + dump_pixfmt(&format.fmt.pix); +#endif + + crop.type = format.type; + if (ioctl(fd, VIDIOC_G_CROP, &crop) < 0) + return; + + LOGI("input window(crop):"); + dump_crop(&crop); + + crop.type = V4L2_BUF_TYPE_CAPTURE; + if (ioctl(fd, VIDIOC_G_CROP, &crop) < 0) + return; + + LOGI("output crop:"); + dump_crop(&crop); + +} + +int fimc_v4l2_query_buf(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, int buf_index, int num_plane) +{ + struct v4l2_buffer buf; + memset(&buf, 0, sizeof(struct v4l2_buffer)); + +#ifdef BOARD_USE_V4L2 + struct v4l2_plane planes[MAX_PLANES]; + for (int i = 0; i < MAX_PLANES; i++) + memset(&planes[i], 0, sizeof(struct v4l2_plane)); +#endif + + if (MAX_DST_BUFFERS <= buf_index || MAX_PLANES <= num_plane) { + LOGE("%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; +#ifdef BOARD_USE_V4L2 + buf.m.planes = planes; + buf.length = num_plane; +#endif + + if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) { + LOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length); + return -1; + } + +#ifdef BOARD_USE_V4L2 + for (int i = 0; i < num_plane; i++) { + secBuf->phys.extP[i] = (unsigned int)buf.m.planes[i].cookie; + secBuf->size.extS[i] = buf.m.planes[i].length; + + 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) { + LOGE("%s::mmap failed", __func__); + LOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset); + LOGE("%s::Legnth = %d" , __func__, buf.m.planes[i].length); + LOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]); + LOGE("%s::paddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->phys.extP[i]); + return -1; + } + } +#else + secBuf->size.s = buf.length; + + if ((secBuf->virt.p = (char *)mmap(0, buf.length, + PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset)) < 0) { + LOGE("%s::mmap failed", __func__); + return -1; + } + LOGI("%s::buffers[%d] vaddr = 0x%x", __func__, buf_index, (unsigned int)secBuf->virt.p); +#endif + + return 0; +} + +int fimc_v4l2_req_buf(int fd, unsigned int num_bufs, enum v4l2_buf_type type, enum v4l2_memory memory) +{ + struct v4l2_requestbuffers reqbuf; + + reqbuf.type = type; + reqbuf.memory = memory; + reqbuf.count = num_bufs; + + if (ioctl(fd, VIDIOC_REQBUFS, &reqbuf) < 0) { + LOGE("%s::VIDIOC_REQBUFS failed", __func__); + return -1; + } + +#ifdef DEBUG_LIB_FIMC + LOGI("%d buffers allocated %d requested", reqbuf.count, 4); +#endif + + if (reqbuf.count < num_bufs) { + LOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))", + __func__, reqbuf.count, num_bufs); + return -1; + } + + return 0; +} + +int fimc_v4l2_s_ctrl(int fd, int id, int value) +{ + struct v4l2_control vc; + vc.id = id; + vc.value = value; + + if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) { + LOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value); + return -1; + } + + return 0; +} + +int fimc_v4l2_set_fmt(int fd, enum v4l2_buf_type type, enum v4l2_field field, s5p_fimc_img_info *img_info, unsigned int addr) +{ + struct v4l2_framebuffer fbuf; + struct v4l2_format fmt; + struct v4l2_crop crop; + struct fimc_buf fimc_dst_buf; + struct v4l2_control vc; + + fmt.type = type; + if (ioctl(fd, VIDIOC_G_FMT, &fmt) < 0) { + LOGE("%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; +#ifdef BOARD_USE_V4L2 + 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; +#endif + case V4L2_BUF_TYPE_VIDEO_OVERLAY: + if (ioctl(fd, VIDIOC_G_FBUF, &fbuf) < 0) { + LOGE("%s::VIDIOC_G_FBUF failed", __func__); + return -1; + } + + fbuf.base = (void *)addr; + fbuf.fmt.width = img_info->full_width; + fbuf.fmt.height = img_info->full_height; + fbuf.fmt.pixelformat = img_info->color_space; + + if (ioctl(fd, VIDIOC_S_FBUF, &fbuf) < 0) { + LOGE("%s::VIDIOC_S_FBUF (w=%d, h=%d, color=%d) failed", + __func__, + img_info->full_width, + img_info->full_height, + img_info->color_space); + return -1; + } + + fimc_dst_buf.base[0] = (unsigned int)img_info->buf_addr_phy_rgb_y; + fimc_dst_buf.base[1] = (unsigned int)img_info->buf_addr_phy_cb; + fimc_dst_buf.base[2] = (unsigned int)img_info->buf_addr_phy_cr; + + vc.id = V4L2_CID_DST_INFO; + vc.value = (unsigned int)&fimc_dst_buf.base[0]; + + if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) { + LOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, vc.id, vc.value); + return -1; + } + + fmt.fmt.win.w.left = img_info->start_x; + fmt.fmt.win.w.top = img_info->start_y; + fmt.fmt.win.w.width = img_info->width; + fmt.fmt.win.w.height = img_info->height; + break; + default: + LOGE("invalid buffer type"); + return -1; + break; + } + + if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) { + LOGE("%s::VIDIOC_S_FMT failed", __func__); + return -1; + } + + if (fmt.type != V4L2_BUF_TYPE_VIDEO_OVERLAY) { + 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) { + LOGE("%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; + } + } + + return 0; +} + +int fimc_v4l2_stream_on(int fd, enum v4l2_buf_type type) +{ + if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) { + LOGE("%s::VIDIOC_STREAMON failed", __func__); + return -1; + } + + return 0; +} + +int fimc_v4l2_queue(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, int index, int num_plane) +{ + struct v4l2_buffer buf; + memset(&buf, 0, sizeof(struct v4l2_buffer)); + +#ifdef BOARD_USE_V4L2 + struct v4l2_plane planes[MAX_PLANES]; + for (int i = 0; i < MAX_PLANES; i++) + memset(&planes[i], 0, sizeof(struct v4l2_plane)); +#else + struct fimc_buf fimcbuf; +#endif + + buf.type = type; + buf.memory = memory; + buf.length = num_plane; + buf.index = index; +#ifdef BOARD_USE_V4L2 + buf.m.planes = planes; + + for (unsigned int i = 0; i < buf.length; i++) { + buf.m.planes[i].length = secBuf->size.extS[i]; + buf.m.planes[i].m.userptr = (unsigned long)secBuf->phys.extP[i]; + } +#else + for (int i = 0; i < 3 ; i++) { + fimcbuf.base[i] = secBuf->phys.extP[i]; + fimcbuf.length[i] = secBuf->size.extS[i]; + } + + buf.m.userptr = (unsigned long)(&fimcbuf); + //buf.m.userptr = secBuf->phys.p; +#endif + + if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) { + LOGE("%s::VIDIOC_QBUF failed", __func__); + return -1; + } + + return 0; +} + +int fimc_v4l2_dequeue(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int *index, int num_plane) +{ + struct v4l2_buffer buf; + memset(&buf, 0, sizeof(struct v4l2_buffer)); + +#ifdef BOARD_USE_V4L2 + struct v4l2_plane planes[MAX_PLANES]; + for (int i = 0; i < MAX_PLANES; i++) + memset(&planes[i], 0, sizeof(struct v4l2_plane)); +#endif + + buf.type = type; + buf.memory = memory; + buf.length = num_plane; +#ifdef BOARD_USE_V4L2 + buf.m.planes = planes; +#endif + if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) { + LOGE("%s::VIDIOC_DQBUF failed", __func__); + return -1; + } + *index = buf.index; + + return 0; +} + +int fimc_v4l2_stream_off(int fd, enum v4l2_buf_type type) +{ + if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) { + LOGE("%s::VIDIOC_STREAMOFF failed", __func__); + return -1; + } + + return 0; +} + +int fimc_v4l2_clr_buf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory) +{ + struct v4l2_requestbuffers req; + + req.count = 0; + req.type = type; + req.memory = memory; + + if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) { + LOGE("%s::VIDIOC_REQBUFS", __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; +} + +extern "C" SecFimc* create_instance() +{ + return new SecFimc; +} + +extern "C" void destroy_instance(SecFimc* handle) +{ + if (handle != NULL) + delete handle; +} + +SecFimc::SecFimc() +: mFlagCreate(false) +{ + memset(&mFimcCap, 0, sizeof(struct v4l2_capability)); + memset(&mS5pFimc, 0, sizeof(s5p_fimc_t)); + + mRotVal = 0; + mRealDev = -1; + mNumOfBuf = 0; + mHwVersion = 0; + mGlobalAlpha = 0x0; + mFlagStreamOn = false; + mFlagSetSrcParam = false; + mFlagSetDstParam = false; + mFlagGlobalAlpha = false; + mFlagLocalAlpha = false; + mFlagColorKey = false; + mFimcMode = 0; + mFd = 0; + mDev = 0; + mColorKey = 0x0; +} + +SecFimc::~SecFimc() +{ + if (mFlagCreate == true) { + LOGE("%s::this is not Destroyed fail", __func__); + if (destroy() == false) + LOGE("%s::destroy failed", __func__); + } +} + +bool SecFimc::create(enum DEV dev, enum MODE mode, int numOfBuf) +{ + if (mFlagCreate == true) { + LOGE("%s::Already Created fail", __func__); + return false; + } + + char node[20]; + struct v4l2_format fmt; + struct v4l2_control vc; + SecBuffer zeroBuf; + + mDev = dev; + mRealDev = dev; + + switch (mode) { + case MODE_SINGLE_BUF: + mFimcMode = FIMC_OVLY_NONE_SINGLE_BUF; + break; + case MODE_MULTI_BUF: + mFimcMode = FIMC_OVLY_NONE_MULTI_BUF; + break; + case MODE_DMA_AUTO: + mFimcMode = FIMC_OVLY_DMA_AUTO; + break; + default: + LOGE("%s::Invalid mode(%d) fail", __func__, mode); + mFimcMode = FIMC_OVLY_NOT_FIXED; + goto err; + break; + } + + mNumOfBuf = numOfBuf; + + for (int i = 0; i < MAX_DST_BUFFERS; i++) + mDstBuffer[i] = zeroBuf; + +#ifdef BOARD_USE_V4L2 + switch(mDev) { + case DEV_0: + mRealDev = 0; + break; + case DEV_1: + mRealDev = 2; + break; + case DEV_2: + mRealDev = 4; + break; + case DEV_3: + mRealDev = 5; + break; + default: + LOGE("%s::invalid mDev(%d)", __func__, mDev); + goto err; + break; + } +#endif + + sprintf(node, "%s%d", PFX_NODE_FIMC, (int)mRealDev); + + mFd = open(node, O_RDWR); + if (mFd < 0) { + LOGE("%s::open(%s) failed", __func__, node); + mFd = 0; + goto err; + } + + /* check capability */ + if (ioctl(mFd, VIDIOC_QUERYCAP, &mFimcCap) < 0) { + LOGE("%s::VIDIOC_QUERYCAP failed", __func__); + goto err; + } + + if (!(mFimcCap.capabilities & V4L2_CAP_STREAMING)) { + LOGE("%s::%s has no streaming support", __func__, node); + goto err; + } + +#ifdef BOARD_USE_V4L2 + if (!(mFimcCap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) { + LOGE("%s::%s is no video output mplane", __func__, node); + goto err; + } + + if (!(mFimcCap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)) { + LOGE("%s::%s is no video capture mplane", __func__, node); + goto err; + } +#else + if (!(mFimcCap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) { + LOGE("%s::%s is no video output", __func__, node); + goto err; + } + + fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; + if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) { + LOGE("%s::VIDIOC_G_FMT failed", __func__); + goto err; + } + + vc.id = V4L2_CID_RESERVED_MEM_BASE_ADDR; + vc.value = 0; + if (ioctl(mFd, VIDIOC_G_CTRL, &vc) < 0) { + LOGE("%s::VIDIOC_G_CTRL - V4L2_CID_RESERVED_MEM_BAES_ADDR", __func__); + goto err; + } + + mDstBuffer[0].phys.p = (unsigned int)vc.value; + + mS5pFimc.out_buf.phys_addr = (void *)mDstBuffer[0].phys.p; + + vc.id = V4L2_CID_FIMC_VERSION; + vc.value = 0; + if (ioctl(mFd, VIDIOC_G_CTRL, &vc) < 0) { + LOGE("%s::VIDIOC_G_CTRL - V4L2_CID_FIMC_VERSION failed, FIMC version is set with default", __func__); + vc.value = 0x43; + } + + mHwVersion = vc.value; + + vc.id = V4L2_CID_OVLY_MODE; + vc.value = mFimcMode; + if (ioctl(mFd, VIDIOC_S_CTRL, &vc) < 0) { + LOGE("%s::VIDIOC_S_CTRL - V4L2_CID_OVLY_MODE failed", __func__); + goto err; + } +#endif + + mFlagCreate = true; + + return true; + +err : + if (0 < mFd) + close(mFd); + mFd = 0; + + return false; +} + +bool SecFimc::destroy() +{ + s5p_fimc_params_t *params = &(mS5pFimc.params); + + if (mFlagCreate == false) { + LOGE("%s::Already Destroyed fail", __func__); + return false; + } + + if (mFlagStreamOn == true) { + if (fimc_v4l2_stream_off(mFd, V4L2_BUF_TYPE_SRC) < 0) { + LOGE("%s::fimc_v4l2_stream_off() failed", __func__); + return false; + } +#ifdef BOARD_USE_V4L2 + if (fimc_v4l2_stream_off(mFd, V4L2_BUF_TYPE_DST) < 0) { + LOGE("%s::fimc_v4l2_stream_off() failed", __func__); + return false; + } +#endif + mFlagStreamOn = false; + } + + if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC) < 0) { + LOGE("%s::fimc_v4l2_clr_buf()[src] failed", __func__); + return false; + } + +#ifdef BOARD_USE_V4L2 + if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST) < 0) { + LOGE("%s::fimc_v4l2_clr_buf()[dst] failed", __func__); + return false; + } +#endif + if (mS5pFimc.out_buf.phys_addr != NULL) { + mS5pFimc.out_buf.phys_addr = NULL; + mS5pFimc.out_buf.length = 0; + } + + if (0 < mFd) + close(mFd); + mFd = 0; + + mFlagCreate = false; + + return true; +} + +bool SecFimc::flagCreate(void) +{ + return mFlagCreate; +} + +int SecFimc::getFd(void) +{ + return mFd; +} + +SecBuffer * SecFimc::getMemAddr(int index) +{ + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + return &mDstBuffer[index]; +} + +int SecFimc::getHWVersion(void) +{ + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + return mHwVersion; +} + +bool SecFimc::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 + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(colorFormat); + if (v4l2ColorFormat < 0) { + LOGE("%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); + + m_checkSrcSize(width, height, + cropX, cropY, + &fimcWidth, &fimcHeight, + v4l2ColorFormat, + false); + + if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) { + if (forceChange == true) { +#ifdef DEBUG_LIB_FIMC + LOGD("size is changed from [w = %d, h= %d] to [w = %d, h = %d]", + *cropWidth, *cropHeight, fimcWidth, fimcHeight); +#endif + } else { + LOGE("%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; + + if (mFlagSetSrcParam == true) { + if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC) < 0) { + LOGE("%s::fimc_v4l2_clr_buf_src() failed", __func__); + return false; + } + } + + if (fimc_v4l2_set_fmt(mFd, V4L2_BUF_TYPE_SRC, V4L2_FIELD_NONE, &(params->src), 0) < 0) { + LOGE("%s::fimc_v4l2_set_fmt()[src] failed", __func__); + return false; + } + + if (fimc_v4l2_req_buf(mFd, 1, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC) < 0) { + LOGE("%s::fimc_v4l2_req_buf()[src] failed", __func__); + return false; + } + + *cropWidth = fimcWidth; + *cropHeight = fimcHeight; + + mFlagSetSrcParam = true; + return true; +} + +bool SecFimc::getSrcParams(unsigned int *width, unsigned int *height, + unsigned int *cropX, unsigned int *cropY, + unsigned int *cropWidth, unsigned int *cropHeight, + int *colorFormat) +{ + struct v4l2_format fmt; + struct v4l2_crop crop; + + fmt.type = V4L2_BUF_TYPE_SRC; + + if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) { + LOGE("%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; + *colorFormat = fmt.fmt.pix.pixelformat; + break; +#ifdef BOARD_USE_V4L2 + 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; + *colorFormat = fmt.fmt.pix_mp.pixelformat; + break; +#endif + default: + LOGE("%s::Invalid buffer type", __func__); + return false; + break; + } + + crop.type = V4L2_BUF_TYPE_SRC; + if (ioctl(mFd, VIDIOC_G_CROP, &crop) < 0) { + LOGE("%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 SecFimc::setSrcAddr(unsigned int physYAddr, + unsigned int physCbAddr, + unsigned int physCrAddr, + int colorFormat) +{ +#ifdef DEBUG_LIB_FIMC + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + s5p_fimc_params_t *params = &(mS5pFimc.params); + int src_planes = m_getYuvPlanes(params->src.color_space); + int src_bpp = m_getYuvBpp(params->src.color_space); + unsigned int frame_size = params->src.full_width * params->src.full_height; + src_planes = (src_planes == -1) ? 1 : src_planes; + + mSrcBuffer.phys.extP[0] = physYAddr; + + if (colorFormat == HAL_PIXEL_FORMAT_YV12) { + mSrcBuffer.phys.extP[1] = physCrAddr; + mSrcBuffer.phys.extP[2] = physCbAddr; + } else { + mSrcBuffer.phys.extP[1] = physCbAddr; + mSrcBuffer.phys.extP[2] = physCrAddr; + } + + if (2 <= src_planes && mSrcBuffer.phys.extP[1] == 0) + mSrcBuffer.phys.extP[1] = mSrcBuffer.phys.extP[0] + frame_size; + + if (3 == src_planes && mSrcBuffer.phys.extP[2] == 0) { + if (colorFormat == HAL_PIXEL_FORMAT_YV12) { + if (12 == src_bpp) + mSrcBuffer.phys.extP[1] = mSrcBuffer.phys.extP[2] + (frame_size >> 2); + else + mSrcBuffer.phys.extP[1] = mSrcBuffer.phys.extP[2] + (frame_size >> 1); + } else { + if (12 == src_bpp) + mSrcBuffer.phys.extP[2] = mSrcBuffer.phys.extP[1] + (frame_size >> 2); + else + mSrcBuffer.phys.extP[2] = mSrcBuffer.phys.extP[1] + (frame_size >> 1); + } + } + + return true; +} + +bool SecFimc::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 + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(colorFormat); + if (v4l2ColorFormat < 0) { + LOGE("%s::not supported color format", __func__); + return false; + } + + s5p_fimc_params_t *params = &(mS5pFimc.params); + + unsigned int fimcWidth = *cropWidth; + unsigned int fimcHeight = *cropHeight; + int dst_planes = m_getYuvPlanes(v4l2ColorFormat); + + m_checkDstSize(width, height, + cropX, cropY, + &fimcWidth, &fimcHeight, + v4l2ColorFormat, + mRotVal, + true); + + if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) { + if (forceChange == true) { +#ifdef DEBUG_LIB_FIMC + LOGD("size is changed from [w = %d, h= %d] to [w = %d, h = %d]", + *cropWidth, *cropHeight, fimcWidth, fimcHeight); +#endif + } else { + LOGE("%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; + + if (0x50 != mHwVersion) + 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; + } + params->dst.color_space = v4l2ColorFormat; + dst_planes = (dst_planes == -1) ? 1 : dst_planes; + +#ifdef BOARD_USE_V4L2 + if (mFlagSetDstParam == true) { + if (fimc_v4l2_clr_buf(mFd, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST) < 0) { + LOGE("%s::fimc_v4l2_clr_buf_dst() failed", __func__); + return false; + } + } +#endif + + if (fimc_v4l2_s_ctrl(mFd, V4L2_ROTATE, mRotVal) < 0) { + LOGE("%s::fimc_v4l2_s_ctrl(V4L2_ROTATE)", __func__); + return false; + } + + if (fimc_v4l2_set_fmt(mFd, V4L2_BUF_TYPE_DST, V4L2_FIELD_ANY, &(params->dst), (unsigned int)mS5pFimc.out_buf.phys_addr) < 0) { + LOGE("%s::fimc_v4l2_set_fmt()[dst] failed", __func__); + return false; + } + +#ifdef BOARD_USE_V4L2 + if (fimc_v4l2_req_buf(mFd, mNumOfBuf, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST) < 0) { + LOGE("%s::fimc_v4l2_req_buf()[dst] failed", __func__); + return false; + } + + for (int i = 0; i < mNumOfBuf; i++) { + if (fimc_v4l2_query_buf(mFd, &(mDstBuffer[i]), + V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, i, dst_planes) < 0) { + LOGE("%s::fimc_v4l2_query_buf() failed", __func__); + } + } +#endif + + *cropWidth = fimcWidth; + *cropHeight = fimcHeight; + + mFlagSetDstParam = true; + return true; +} + +bool SecFimc::getDstParams(unsigned int *width, unsigned int *height, + unsigned int *cropX, unsigned int *cropY, + unsigned int *cropWidth, unsigned int *cropHeight, + int *colorFormat) +{ + struct v4l2_framebuffer fbuf; + struct v4l2_format fmt; + struct v4l2_crop crop; + + fmt.type = V4L2_BUF_TYPE_DST; + if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) { + LOGE("%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: + *width = fmt.fmt.pix.width; + *height = fmt.fmt.pix.height; + *colorFormat = fmt.fmt.pix.pixelformat; + break; +#ifdef BOARD_USE_V4L2 + 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; + *colorFormat = fmt.fmt.pix_mp.pixelformat; + break; +#endif + case V4L2_BUF_TYPE_VIDEO_OVERLAY: + *cropX = fmt.fmt.win.w.left; + *cropY = fmt.fmt.win.w.top; + *cropWidth = fmt.fmt.win.w.width; + *cropHeight = fmt.fmt.win.w.height; + + if (ioctl(mFd, VIDIOC_G_FBUF, &fbuf) < 0) { + LOGE("%s::VIDIOC_G_FBUF failed", __func__); + return false; + } + + *width = fbuf.fmt.width; + *height = fbuf.fmt.height; + *colorFormat = fbuf.fmt.pixelformat; + break; + default: + LOGE("%s::Invalid buffer type", __func__); + return false; + break; + } + + if (fmt.type != V4L2_BUF_TYPE_VIDEO_OVERLAY) { + + crop.type = V4L2_BUF_TYPE_DST; + if (ioctl(mFd, VIDIOC_G_CROP, &crop) < 0) { + LOGE("%s::VIDIOC_G_CROP(crop.type : %d) failed", __func__, crop.type); + return false; + } + + *cropX = crop.c.left; + *cropY = crop.c.top; + *cropWidth = crop.c.width; + *cropHeight = crop.c.height; + } + + return true; +} + +bool SecFimc::setDstAddr(unsigned int physYAddr, unsigned int physCbAddr, unsigned int physCrAddr, int buf_index) +{ +#ifdef DEBUG_LIB_FIMC + LOGD("%s", __func__); +#endif + + s5p_fimc_params_t *params = &(mS5pFimc.params); + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + mS5pFimc.out_buf.phys_addr = (void *)physYAddr; + + mDstBuffer[buf_index].phys.extP[0] = physYAddr; + mDstBuffer[buf_index].phys.extP[1] = physCbAddr; + mDstBuffer[buf_index].phys.extP[2] = physCrAddr; + +#ifdef BOARD_USE_V4L2 + if (physYAddr != 0) + mS5pFimc.use_ext_out_mem = 1; +#else + params->dst.buf_addr_phy_rgb_y = physYAddr; + params->dst.buf_addr_phy_cb = physCbAddr; + params->dst.buf_addr_phy_cr = physCrAddr; + + if ((physYAddr != 0) + && ((unsigned int)mS5pFimc.out_buf.phys_addr != mDstBuffer[0].phys.p)) + mS5pFimc.use_ext_out_mem = 1; + + if (fimc_v4l2_s_ctrl(mFd, V4L2_ROTATE, mRotVal) < 0) { + LOGE("%s::fimc_v4l2_s_ctrl(V4L2_ROTATE)", __func__); + return false; + } + + if (fimc_v4l2_set_fmt(mFd, V4L2_BUF_TYPE_DST, V4L2_FIELD_ANY, &(params->dst), (unsigned int)mS5pFimc.out_buf.phys_addr) < 0) { + LOGE("%s::fimc_v4l2_set_fmt()[dst] failed", __func__); + return false; + } +#endif + + return true; +} + +bool SecFimc::setRotVal(unsigned int rotVal) +{ + struct v4l2_control vc; + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (fimc_v4l2_s_ctrl(mFd, V4L2_ROTATE, rotVal) < 0) { + LOGE("%s::fimc_v4l2_s_ctrl(V4L2_ROTATE) failed", __func__); + return false; + } + + mRotVal = rotVal; + return true; +} + +bool SecFimc::setGlobalAlpha(bool enable, int alpha) +{ + struct v4l2_framebuffer fbuf; + struct v4l2_format fmt; + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagStreamOn == true) { + LOGE("%s::mFlagStreamOn == true", __func__); + return false; + } + + if (mFlagGlobalAlpha == enable && mGlobalAlpha == alpha) + return true; + + memset(&fbuf, 0, sizeof(fbuf)); + + if (ioctl(mFd, VIDIOC_G_FBUF, &fbuf) < 0) { + LOGE("%s::VIDIOC_G_FBUF failed", __func__); + return false; + } + + if (enable) + fbuf.flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA; + else + fbuf.flags &= ~V4L2_FBUF_FLAG_GLOBAL_ALPHA; + + if (ioctl(mFd, VIDIOC_S_FBUF, &fbuf) < 0) { + LOGE("%s::VIDIOC_S_FBUF failed", __func__); + return false; + } + + if (enable) { + memset(&fmt, 0, sizeof(fmt)); + fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; + + if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) { + LOGE("%s::VIDIOC_G_FMT failed", __func__); + return false; + } + + fmt.fmt.win.global_alpha = alpha & 0xFF; + if (ioctl(mFd, VIDIOC_S_FMT, &fmt) < 0) { + LOGE("%s::VIDIOC_S_FMT failed", __func__); + return false; + } + } + + mFlagGlobalAlpha = enable; + mGlobalAlpha = alpha; + + return true; + +} + +bool SecFimc::setLocalAlpha(bool enable) +{ + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagStreamOn == true) { + LOGE("%s::mFlagStreamOn == true", __func__); + return false; + } + + if (mFlagLocalAlpha == enable) + return true; + + return true; +} + +bool SecFimc::setColorKey(bool enable, int colorKey) +{ + struct v4l2_framebuffer fbuf; + struct v4l2_format fmt; + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagStreamOn == true) { + LOGE("%s::mFlagStreamOn == true", __func__); + return false; + } + + if (mFlagColorKey == enable && mColorKey == colorKey) + return true; + + memset(&fbuf, 0, sizeof(fbuf)); + + if (ioctl(mFd, VIDIOC_G_FBUF, &fbuf) < 0) { + LOGE("%s::VIDIOC_G_FBUF failed", __func__); + return false; + } + + if (enable) + fbuf.flags |= V4L2_FBUF_FLAG_CHROMAKEY; + else + fbuf.flags &= ~V4L2_FBUF_FLAG_CHROMAKEY; + + if (ioctl(mFd, VIDIOC_S_FBUF, &fbuf) < 0) { + LOGE("%s::VIDIOC_S_FBUF failed", __func__); + return false; + } + + if (enable) { + memset(&fmt, 0, sizeof(fmt)); + fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; + + if (ioctl(mFd, VIDIOC_G_FMT, &fmt) < 0) { + LOGE("%s::VIDIOC_G_FMT failed", __func__); + return false; + } + + fmt.fmt.win.chromakey = colorKey & 0xFFFFFF; + + if (ioctl(mFd, VIDIOC_S_FMT, &fmt) < 0) + LOGE("%s::VIDIOC_S_FMT failed", __func__); + } + mFlagColorKey = enable; + mColorKey = colorKey; + return true; +} + +bool SecFimc::draw(int src_index, int dst_index) +{ +#ifdef DEBUG_LIB_FIMC + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagSetSrcParam == false) { + LOGE("%s::mFlagSetSrcParam == false fail", __func__); + return false; + } + + if (mFlagSetDstParam == false) { + LOGE("%s::mFlagSetDstParam == false fail", __func__); + return false; + } + + s5p_fimc_params_t *params = &(mS5pFimc.params); + bool flagStreamOn = false; + int src_planes = m_getYuvPlanes(params->src.color_space); + int dst_planes = m_getYuvPlanes(params->dst.color_space); + src_planes = (src_planes == -1) ? 1 : src_planes; + dst_planes = (dst_planes == -1) ? 1 : dst_planes; + +#ifdef BOARD_USE_V4L2 + if (mFlagStreamOn == false) { + if (m_streamOn() == false) { + LOGE("%s::m_streamOn failed", __func__); + return false; + } + mFlagStreamOn = true; + } + if (fimc_v4l2_dequeue(mFd, V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, &dst_index, dst_planes) < 0) { + LOGE("%s::fimc_v4l2_dequeue[dst](mNumOfBuf : %d) failed", __func__, mNumOfBuf); + return false; + } + + if (fimc_v4l2_dequeue(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, &src_index, src_planes) < 0) { + LOGE("%s::fimc_v4l2_dequeue[src](mNumOfBuf : %d) failed", __func__, mNumOfBuf); + return false; + } + + if (fimc_v4l2_queue(mFd, &(mSrcBuffer), V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, src_index, src_planes) < 0) { + LOGE("%s::fimc_v4l2_queue[src](index : %d) (mNumOfBuf : %d) failed", __func__, 0, mNumOfBuf); + return false; + } + + if (fimc_v4l2_queue(mFd, &(mDstBuffer[dst_index]), V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, dst_index, dst_planes) < 0) { + LOGE("%s::fimc_v4l2_queue[dst](index : %d) (mNumOfBuf : %d) failed", __func__, dst_index, mNumOfBuf); + return false; + } +#else + if (fimc_v4l2_stream_on(mFd, V4L2_BUF_TYPE_SRC) < 0) { + LOGE("%s::fimc_v4l2_stream_on() failed", __func__); + goto err; + } + + flagStreamOn = true; + + if (fimc_v4l2_queue(mFd, &(mSrcBuffer), V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, src_index, src_planes) < 0) { + LOGE("%s::fimc_v4l2_queue(index : %d) (mNumOfBuf : %d) failed", __func__, 0, mNumOfBuf); + goto err; + } + + if (fimc_v4l2_dequeue(mFd, V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, &src_index, src_planes) < 0) { + LOGE("%s::fimc_v4l2_dequeue (mNumOfBuf : %d) failed", __func__, mNumOfBuf); + goto err; + } +#endif + +err : +#ifndef BOARD_USE_V4L2 + if (flagStreamOn == true) { + if (fimc_v4l2_stream_off(mFd, V4L2_BUF_TYPE_SRC) < 0) { + LOGE("%s::fimc_v4l2_stream_off() failed", __func__); + return false; + } + } +#endif + + return true; +} + +bool SecFimc::m_streamOn() +{ +#ifdef DEBUG_LIB_FIMC + LOGD("%s", __func__); +#endif + +#ifdef BOARD_USE_V4L2 + s5p_fimc_params_t *params = &(mS5pFimc.params); + int src_planes = m_getYuvPlanes(params->src.color_space); + int dst_planes = m_getYuvPlanes(params->dst.color_space); + src_planes = (src_planes == -1) ? 1 : src_planes; + dst_planes = (dst_planes == -1) ? 1 : dst_planes; + + if (params->src.color_space == V4L2_PIX_FMT_RGB32) { + mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width * 4; + + } else if ( (params->src.color_space == V4L2_PIX_FMT_NV12MT) + || (params->src.color_space == V4L2_PIX_FMT_NV12M)) { + mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width; + mSrcBuffer.size.extS[1] = params->src.full_height * params->src.full_width / 2; + } else if ( (params->src.color_space == V4L2_PIX_FMT_YUV420) + || (params->src.color_space == V4L2_PIX_FMT_YUV420M)) { + mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width; + mSrcBuffer.size.extS[1] = params->src.full_height * params->src.full_width / 4; + mSrcBuffer.size.extS[2] = params->src.full_height * params->src.full_width / 4; + } else { + mSrcBuffer.size.extS[0] = params->src.full_height * params->src.full_width * 2; + } + + if (fimc_v4l2_queue(mFd, &(mSrcBuffer), V4L2_BUF_TYPE_SRC, V4L2_MEMORY_TYPE_SRC, 0, src_planes) < 0) { + LOGE("%s::fimc_v4l2_queue(index : %d) (mSrcBufNum : %d) failed", __func__, 0, 1); + return false; + } + + for (int i = 0; i < mNumOfBuf; i++) { + if (fimc_v4l2_queue(mFd, &(mDstBuffer[i]), + V4L2_BUF_TYPE_DST, V4L2_MEMORY_TYPE_DST, i, dst_planes) < 0) { + LOGE("%s::fimc_v4l2_queue(index : %d) (mDstBufNum : %d) failed", __func__, i, mNumOfBuf); + return false; + } + } +#endif + if (fimc_v4l2_stream_on(mFd, V4L2_BUF_TYPE_SRC) < 0) { + LOGE("%s::fimc_v4l2_stream_on() failed", __func__); + return false; + } + +#ifdef BOARD_USE_V4L2 + if (fimc_v4l2_stream_on(mFd, V4L2_BUF_TYPE_DST) < 0) { + LOGE("%s::fimc_v4l2_stream_on() failed", __func__); + return false; + } +#endif + return true; +} + +bool SecFimc::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 (0x50 == mHwVersion) { + if (colorFormat == V4L2_PIX_FMT_YUV422P) { + if (*cropHeight % 2 != 0) { + if (forceChange) + *cropHeight = multipleOfN(*cropHeight, 2); + ret = false; + } + if (*cropWidth % 2 != 0) { + if (forceChange) + *cropWidth = multipleOfN(*cropWidth, 2); + ret = false; + } + } + } else { + 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 SecFimc::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: +#ifdef BOARD_USE_V4L2 + case V4L2_PIX_FMT_NV12M: + case V4L2_PIX_FMT_NV12MT: + case V4L2_PIX_FMT_YUV420M: +#endif + case V4L2_PIX_FMT_YUV420: + if (*rotCropHeight % 2 != 0) { + if (forceChange) + *rotCropHeight = multipleOfN(*rotCropHeight, 2); + ret = false; + } + } + return ret; +} + +int SecFimc::m_widthOfFimc(int v4l2ColorFormat, int width) +{ + int newWidth = width; + + if (0x50 == mHwVersion) { + switch (v4l2ColorFormat) { + /* 422 1/2/3 plane */ + case V4L2_PIX_FMT_YUYV: + case V4L2_PIX_FMT_UYVY: + case V4L2_PIX_FMT_NV61: + case V4L2_PIX_FMT_NV16: + case V4L2_PIX_FMT_YUV422P: + /* 420 2/3 plane */ + case V4L2_PIX_FMT_NV21: + case V4L2_PIX_FMT_NV12: + case V4L2_PIX_FMT_NV12T: +#ifdef BOARD_USE_V4L2 + case V4L2_PIX_FMT_NV12MT: + case V4L2_PIX_FMT_YUV420M: +#endif + case V4L2_PIX_FMT_YUV420: + + newWidth = multipleOfN(width, 2); + break; + default : + break; + } + } else { + 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_NV12T: +#ifdef BOARD_USE_V4L2 + case V4L2_PIX_FMT_NV12MT: +#endif + newWidth = multipleOfN(width, 8); + break; +#ifdef BOARD_USE_V4L2 + case V4L2_PIX_FMT_YUV420M: +#endif + case V4L2_PIX_FMT_YUV420: + newWidth = multipleOfN(width, 16); + break; + default : + break; + } + } + return newWidth; +} + +int SecFimc::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: +#ifdef BOARD_USE_V4L2 + case V4L2_PIX_FMT_NV12MT: + case V4L2_PIX_FMT_YUV420M: +#endif + case V4L2_PIX_FMT_YUV420: + newHeight = multipleOfN(height, 2); + break; + default : + break; + } + return newHeight; +} + +int SecFimc::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 SecFimc::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; +} |