diff options
Diffstat (limited to 'exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp')
| -rw-r--r-- | exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp | 1524 |
1 files changed, 1524 insertions, 0 deletions
diff --git a/exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp b/exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp new file mode 100644 index 0000000..0a84d11 --- /dev/null +++ b/exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp @@ -0,0 +1,1524 @@ +/* + * 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) +{ + 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"); + } +} + +void dump_crop(struct v4l2_rect *rect) +{ + LOGI("crop l: %d", rect->left); + LOGI("crop t: %d", rect->top); + LOGI("crop w: %d", rect->width); + LOGI("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; + + LOGI("dumping driver state:"); + dump_pixfmt_mp(&format.fmt.pix_mp); + + crop.type = format.type; + if (ioctl(fd, VIDIOC_G_CROP, &crop) < 0) + return; + + LOGI("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; + + LOGI("output image crop:"); + dump_crop(&(sCrop.rect)); + +} + +int gsc_v4l2_querycap(int fd, char *node) +{ +#ifdef DEBUG_LIB_FIMC + LOGD("%s", __func__); +#endif + struct v4l2_capability v4l2cap; + + if (ioctl(fd, VIDIOC_QUERYCAP, &v4l2cap) < 0) { + LOGE("%s::VIDIOC_QUERYCAP failed", __func__); + return -1; + } + + if (!(v4l2cap.capabilities & V4L2_CAP_STREAMING)) { + LOGE("%s::%s is not support streaming", __func__, node); + return -1; + } + + if (!(v4l2cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) { + LOGE("%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 + LOGD("%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) { + 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; + buf.length = num_plane; + buf.m.planes = planes; + + if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) { + LOGE("%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) { + 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]); + return -1; + } + secBuf->size.extS[i] = buf.m.planes[i].length; + +#ifdef DEBUG_LIB_FIMC + LOGD("%s::vaddr[bufindex=%d][planeindex=%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]); + LOGD("%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 + LOGD("%s", __func__); +#endif + struct v4l2_requestbuffers reqbuf; + + reqbuf.type = type; + reqbuf.memory = memory; + reqbuf.count = num_bufs; + +#ifdef DEBUG_LIB_FIMC + LOGI("%d buffers needed", reqbuf.count); +#endif + + if (ioctl(fd, VIDIOC_REQBUFS, &reqbuf) < 0) { + LOGE("%s::VIDIOC_REQBUFS failed, reqbuf.count=%d", __func__, reqbuf.count); + return -1; + } + +#ifdef DEBUG_LIB_FIMC + LOGI("%d buffers allocated", reqbuf.count); +#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 gsc_v4l2_s_ctrl(int fd, int id, int value) +{ +#ifdef DEBUG_LIB_FIMC + LOGD("%s", __func__); +#endif + 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 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 + LOGD("%s", __func__); +#endif + struct v4l2_format fmt; + struct v4l2_crop crop; + + fmt.type = type; +#ifdef DEBUG_LIB_FIMC + LOGD("%s::fmt.type=%d", __func__, fmt.type); +#endif + 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; + 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: + LOGE("%s::invalid buffer type", __func__); + return -1; + break; + } + +#ifdef DEBUG_LIB_FIMC +for (int i = 0; i < 3; i++) { + LOGD("%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) { + LOGE("%s::VIDIOC_S_FMT failed", __func__); + return -1; + } + +#ifdef DEBUG_LIB_FIMC +for (int i = 0; i < 3; i++) { + LOGD("%s::pix_mp.pix_mp.plane_fmt[%d].sizeimage =0x%08x", __func__, i, fmt.fmt.pix_mp.plane_fmt[i].sizeimage); + LOGD("%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) { + 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; + } + +#ifdef DEBUG_LIB_FIMC + LOGD("%s::pix_mp pixelformat=0x%08x", __func__, fmt.fmt.pix_mp.pixelformat); + LOGD("%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); + LOGD("%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 + LOGD("%s", __func__); +#endif + if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) { + LOGE("%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 + LOGD("%s", __func__); + LOGD("%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 + LOGD("%s::buf.index=%d", __func__, buf.index); + LOGD("%s::buf.m.planes[%d].m.userptr=0x%08x", __func__, i, (unsigned int)buf.m.planes[i].m.userptr); + LOGD("%s::buf.m.planes[%d].length =0x%08x", __func__, i, buf.m.planes[i].length); + LOGD("%s::buf.m.planes[%d].bytesused=0x%08x", __func__, i, buf.m.planes[i].bytesused); +#endif + } + + if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) { + LOGE("%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 + LOGD("%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) { + LOGE("%s::VIDIOC_DQBUF failed", __func__); + return -1; + } + + *index = buf.index; + +#ifdef DEBUG_LIB_FIMC + LOGD("%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 + LOGD("%s", __func__); +#endif + if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) { + LOGE("%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 + LOGD("%s", __func__); +#endif + struct v4l2_requestbuffers req; + + req.count = 0; + req.type = type; + req.memory = memory; + + if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) { + LOGE("%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 + LOGD("%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) { + LOGE("%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 + LOGD("%s::pix_mp w=%d, h=%d", __func__, fmt.format.width, fmt.format.height); + LOGD("%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) { + LOGE("%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) { + LOGE("%s::this is not Destroyed fail", __func__); + + if (destroy() == false) + LOGE("%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 + LOGD("%s", __func__); +#endif + if (mFlagCreate == true) { + LOGE("%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: + LOGE("%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) { + LOGE("%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) { + LOGD("%s::MEDIA_IOC_ENUM_ENTITIES ended", __func__); + break; + } + LOGE("%s::MEDIA_IOC_ENUM_ENTITIES failed", __func__); + goto err; + } + +#ifdef DEBUG_LIB_FIMC + LOGD("%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) { + LOGE("%s::open(%s) failed", __func__, node); + goto err; + } + + sprintf(node, "%s%d", PFX_NODE_VIDEODEV, mVideoNodeNum); + mVideodevFd = open(node, O_RDWR); + if (mVideodevFd < 0) { + LOGE("%s::open(%s) failed", __func__, node); + goto err; + } + + /* check capability */ + if (gsc_v4l2_querycap(mVideodevFd, node) < 0 ) { + LOGE("%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) { + LOGE("%s::Already Destroyed", __func__); + return true; + } + + if (mFlagStreamOn == true) { + if (streamOff() == false) { + LOGE("%s::streamOff() failed", __func__); + return false; + } + + if (closeVideodevFd() == false) { + LOGE("%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) { + LOGE("%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) { + LOGE("%s::gsc_v4l2_clr_buf() failed", __func__); + return false; + } + } + + if (0 < mVideodevFd) { + if (close(mVideodevFd) < 0) { + LOGE("%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) { + LOGE("%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 + 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); + 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) { + LOGE("%s::::size align error!", __func__); + return 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; + 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: + LOGE("%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: + LOGE("%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) { + LOGE("%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) { + LOGE("%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) { + LOGE("%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) { + LOGE("%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) { + 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; + *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: + LOGE("%s::Invalid buffer type", __func__); + return false; + break; + } + + crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; + if (ioctl(mVideodevFd, 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 SecGscaler::setSrcAddr(unsigned int YAddr, + unsigned int CbAddr, + unsigned int CrAddr, + int colorFormat) +{ +#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", __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 + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%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) { + LOGE("%s::size align error!", __func__); + return 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 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) { + LOGE("%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) { + LOGE("%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) { + LOGE("%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 + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + return true; +} + +bool SecGscaler::setRotVal(unsigned int rotVal) +{ + struct v4l2_control vc; + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (gsc_v4l2_s_ctrl(mVideodevFd, V4L2_CID_ROTATE, rotVal) < 0) { + LOGE("%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) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagStreamOn == true) { + LOGE("%s::mFlagStreamOn == true", __func__); + return false; + } + + mFlagGlobalAlpha = enable; + mGlobalAlpha = alpha; + + return true; + +} + +bool SecGscaler::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 SecGscaler::setColorKey(bool enable, int colorKey) +{ + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagStreamOn == true) { + LOGE("%s::mFlagStreamOn == true", __func__); + return false; + } + + mFlagColorKey = enable; + mColorKey = colorKey; + + return true; +} + +bool SecGscaler::run() +{ +#ifdef DEBUG_LIB_FIMC + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagSetSrcParam == false) { + LOGE("%s::faild : Need to set source parameters of Gscaler", __func__); + return false; + } + + if (mFlagSetDstParam == false) { + LOGE("%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) { + LOGE("%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) { + LOGE("%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 + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagStreamOn == true) { + LOGE("%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) { + LOGE("%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) { + LOGE("%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 + LOGD("%s", __func__); +#endif + + if (mFlagCreate == false) { + LOGE("%s::Not yet created", __func__); + return false; + } + + if (mFlagStreamOn == false) { + LOGE("%s::already streamoff", __func__); + return true; + } + + if (gsc_v4l2_stream_off(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) { + LOGE("%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; +} |