Piteball/android_hardware_samsung
1
0
Fork 0
mirror of https://github.com/team-infusion-developers/android_hardware_samsung.git synced 2024-11-01 07:47:55 +00:00
Code Issues Projects Releases Packages Wiki Activity
android_hardware_samsung/exynos3/s5pc110/libhdmi/fimc.c
Petr Havlena c9288149a3 exynos3: libhdmi: initial commit 
Change-Id: Iee23cf3b6e746c3a20adf7b90ab930a3cba50d5c
2012-11-16 05:12:41 -08:00

722 lines
19 KiB
C
Raw Blame History

/*
* Copyright (C) 2010 The Android Open Source Project
*
* 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.
*/
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <linux/videodev.h>
#include <hardware/hwcomposer.h>
#include <cutils/log.h>
#include "fimc.h"
typedef struct sec_img sec_img;
typedef struct sec_rect sec_rect;
int fimc_v4l2_set_src(int fd, unsigned int hw_ver, s5p_fimc_img_info *src)
{
struct v4l2_format fmt;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_requestbuffers req;
/*
* To set size & format for source image (DMA-INPUT)
*/
fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
fmt.fmt.pix.width = src->full_width;
fmt.fmt.pix.height = src->full_height;
fmt.fmt.pix.pixelformat = src->color_space;
fmt.fmt.pix.field = V4L2_FIELD_NONE;
if (ioctl (fd, VIDIOC_S_FMT, &fmt) < 0) {
ALOGE("VIDIOC_S_FMT failed : errno=%d (%s) : fd=%d", errno,
strerror(errno), fd);
return -1;
}
/*
* crop input size
*/
crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
if (0x50 == hw_ver) {
crop.c.left = src->start_x;
crop.c.top = src->start_y;
} else {
crop.c.left = 0;
crop.c.top = 0;
}
crop.c.width = src->width;
crop.c.height = src->height;
if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
ALOGE("Error in video VIDIOC_S_CROP (%d, %d, %d, %d)",
crop.c.left, crop.c.top, crop.c.width, crop.c.height);
return -1;
}
/*
* input buffer type
*/
req.count = 1;
req.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
req.memory = V4L2_MEMORY_USERPTR;
if (ioctl (fd, VIDIOC_REQBUFS, &req) < 0) {
ALOGE("Error in VIDIOC_REQBUFS");
return -1;
}
return 0;
}
int fimc_v4l2_set_dst(int fd,
s5p_fimc_img_info *dst,
int rotation,
int flag_h_flip,
int flag_v_flip,
unsigned int addr)
{
struct v4l2_format fmt;
struct v4l2_control vc;
struct v4l2_framebuffer fbuf;
/*
* set rotation configuration
*/
vc.id = V4L2_CID_HFLIP;
vc.value = flag_h_flip;
if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
ALOGE("Error in video VIDIOC_S_CTRL - flag_h_flip (%d)", flag_h_flip);
return -1;
}
vc.id = V4L2_CID_VFLIP;
vc.value = flag_v_flip;
if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
ALOGE("Error in video VIDIOC_S_CTRL - flag_v_flip (%d)", flag_v_flip);
return -1;
}
vc.id = V4L2_CID_ROTATION;
vc.value = rotation;
if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
ALOGE("Error in video VIDIOC_S_CTRL - rotation (%d)", rotation);
return -1;
}
/*
* set size, format & address for destination image (DMA-OUTPUT)
*/
if (ioctl (fd, VIDIOC_G_FBUF, &fbuf) < 0) {
ALOGE("Error in video VIDIOC_G_FBUF");
return -1;
}
fbuf.base = (void *)addr;
fbuf.fmt.width = dst->full_width;
fbuf.fmt.height = dst->full_height;
fbuf.fmt.pixelformat = dst->color_space;
if (ioctl (fd, VIDIOC_S_FBUF, &fbuf) < 0) {
ALOGE("Error in video VIDIOC_S_FBUF 0x%x %d %d %d",
(void *)addr, dst->full_width, dst->full_height,
dst->color_space);
return -1;
}
/*
* set destination window
*/
fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
fmt.fmt.win.w.left = dst->start_x;
fmt.fmt.win.w.top = dst->start_y;
fmt.fmt.win.w.width = dst->width;
fmt.fmt.win.w.height = dst->height;
if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
ALOGE("Error in video VIDIOC_S_FMT %d %d %d %d",
dst->start_x, dst->start_y, dst->width, dst->height);
return -1;
}
return 0;
}
static int fimc_v4l2_stream_on(int fd, enum v4l2_buf_type type)
{
if (ioctl (fd, VIDIOC_STREAMON, &type) < 0) {
ALOGE("Error in VIDIOC_STREAMON");
return -1;
}
return 0;
}
static int fimc_v4l2_queue(int fd, struct fimc_buf *fimc_buf)
{
struct v4l2_buffer buf;
buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
buf.memory = V4L2_MEMORY_USERPTR;
buf.m.userptr = (unsigned long)fimc_buf;
buf.length = 0;
buf.index = 0;
if (ioctl (fd, VIDIOC_QBUF, &buf) < 0) {
ALOGE("Error in VIDIOC_QBUF");
return -1;
}
return 0;
}
static int fimc_v4l2_dequeue(int fd)
{
struct v4l2_buffer buf;
buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
buf.memory = V4L2_MEMORY_USERPTR;
if (ioctl (fd, VIDIOC_DQBUF, &buf) < 0) {
ALOGE("Error in VIDIOC_DQBUF");
return -1;
}
return buf.index;
}
static int fimc_v4l2_stream_off(int fd)
{
enum v4l2_buf_type type;
type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
if (ioctl (fd, VIDIOC_STREAMOFF, &type) < 0) {
ALOGE("Error in VIDIOC_STREAMOFF");
return -1;
}
return 0;
}
static int fimc_v4l2_clr_buf(int fd)
{
struct v4l2_requestbuffers req;
req.count = 0;
req.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
req.memory = V4L2_MEMORY_USERPTR;
if (ioctl (fd, VIDIOC_REQBUFS, &req) < 0) {
ALOGE("Error in VIDIOC_REQBUFS");
}
return 0;
}
static int fimc_handle_oneshot(int fd, struct fimc_buf *fimc_buf)
{
int ret =0;
if (fimc_v4l2_stream_on(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT) < 0) {
ALOGE("Fail : v4l2_stream_on()");
return -1;
}
if (fimc_v4l2_queue(fd, fimc_buf) < 0) {
ALOGE("Fail : v4l2_queue()");
ret = -1;
goto stream_off;
}
if (fimc_v4l2_dequeue(fd) < 0) {
ALOGE("Fail : v4l2_dequeue()");
ret = -1;
goto stream_off;
}
stream_off:
if (fimc_v4l2_stream_off(fd) < 0) {
ALOGE("Fail : v4l2_stream_off()");
return -1;
}
if (fimc_v4l2_clr_buf(fd) < 0) {
ALOGE("Fail : v4l2_clr_buf()");
return -1;
}
return ret;
}
static int get_src_phys_addr(s5p_fimc_t *fimc,
sec_img *src_img,
unsigned int *phyAddr)
{
if(src_img->mem_type == FIMC_MEM_TYPE_PHYS) {
switch(src_img->format) {
case HAL_PIXEL_FORMAT_YCbCr_420_SP:
fimc->params.src.buf_addr_phy_rgb_y = phyAddr[0];
fimc->params.src.buf_addr_phy_cb = phyAddr[1];
break;
default:
ALOGE("%s format error (format=0x%x)", __func__,
src_img->format);
return -1;
}
} else {
ALOGE("%s mem_type error (mem_type=%d)", __func__, src_img->mem_type);
return -1;
}
return 0;
}
static int get_dst_phys_addr(s5p_fimc_t *fimc,
sec_img *dst_img)
{
unsigned int dst_phys_addr = 0;
if (FIMC_MEM_TYPE_PHYS == dst_img->mem_type && 0 != dst_img->base)
dst_phys_addr = dst_img->base;
else {
ALOGE("%s::get_dst_phys_addr fail ", __func__);
dst_phys_addr = 0;
}
return dst_phys_addr;
}
static inline int rotateValueHAL2PP(unsigned char transform,
int *flag_h_flip,
int *flag_v_flip)
{
int rotate_result = 0;
int rotate_flag = transform & 0x7;
switch (rotate_flag) {
case HAL_TRANSFORM_ROT_90:
rotate_result = 90;
break;
case HAL_TRANSFORM_ROT_180:
rotate_result = 180;
break;
case HAL_TRANSFORM_ROT_270:
rotate_result = 270;
break;
}
switch (rotate_flag) {
case HAL_TRANSFORM_FLIP_H:
*flag_h_flip = 1;
*flag_v_flip = 0;
break;
case HAL_TRANSFORM_FLIP_V:
*flag_h_flip = 0;
*flag_v_flip = 1;
break;
default:
*flag_h_flip = 0;
*flag_v_flip = 0;
break;
}
return rotate_result;
}
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;
}
static inline int widthOfPP(unsigned int ver,
int pp_color_format,
int number)
{
if (0x50 == ver) {
switch(pp_color_format) {
/* 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:
case V4L2_PIX_FMT_YUV420:
return multipleOfN(number, 2);
default :
return number;
}
} else {
switch(pp_color_format) {
case V4L2_PIX_FMT_RGB565:
return multipleOfN(number, 8);
case V4L2_PIX_FMT_RGB32:
return multipleOfN(number, 4);
case V4L2_PIX_FMT_YUYV:
case V4L2_PIX_FMT_UYVY:
return multipleOfN(number, 4);
case V4L2_PIX_FMT_NV61:
case V4L2_PIX_FMT_NV16:
return multipleOfN(number, 8);
case V4L2_PIX_FMT_YUV422P:
return multipleOfN(number, 16);
case V4L2_PIX_FMT_NV21:
case V4L2_PIX_FMT_NV12:
case V4L2_PIX_FMT_NV12T:
return multipleOfN(number, 8);
case V4L2_PIX_FMT_YUV420:
return multipleOfN(number, 16);
default :
return number;
}
}
return number;
}
static inline int heightOfPP(int pp_color_format,
int number)
{
switch(pp_color_format) {
case V4L2_PIX_FMT_NV21:
case V4L2_PIX_FMT_NV12:
case V4L2_PIX_FMT_NV12T:
case V4L2_PIX_FMT_YUV420:
return multipleOfN(number, 2);
default :
return number;
}
return number;
}
static int fimc_core(s5p_fimc_t *fimc,
sec_img *src_img,
sec_rect *src_rect,
uint32_t src_color_space,
unsigned int dst_phys_addr,
sec_img *dst_img,
sec_rect *dst_rect,
uint32_t dst_color_space,
int transform)
{
s5p_fimc_params_t * params = &(fimc->params);
unsigned int frame_size = 0;
struct fimc_buf fimc_src_buf;
int src_bpp, src_planes;
int flag_h_flip = 0;
int flag_v_flip = 0;
int rotate_value = rotateValueHAL2PP(transform, &flag_h_flip, &flag_v_flip);
/* set post processor configuration */
params->src.full_width = src_img->w;
params->src.full_height = src_img->h;
params->src.start_x = src_rect->x;
params->src.start_y = src_rect->y;
params->src.width = widthOfPP(fimc->hw_ver, src_color_space, src_rect->w);
params->src.height = heightOfPP(src_color_space, src_rect->h);
params->src.color_space = src_color_space;
/* check minimum */
if (src_rect->w < 16 || src_rect->h < 8) {
ALOGE("%s src size is not supported by fimc : f_w=%d f_h=%d x=%d y=%d \
w=%d h=%d (ow=%d oh=%d) format=0x%x", __func__,
params->src.full_width, params->src.full_height,
params->src.start_x, params->src.start_y, params->src.width,
params->src.height, src_rect->w, src_rect->h,
params->src.color_space);
return -1;
}
switch (rotate_value) {
case 0:
params->dst.full_width = dst_img->w;
params->dst.full_height = dst_img->h;
params->dst.start_x = dst_rect->x;
params->dst.start_y = dst_rect->y;
params->dst.width =
widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
params->dst.height = heightOfPP(dst_color_space, dst_rect->h);
break;
case 90:
params->dst.full_width = dst_img->h;
params->dst.full_height = dst_img->w;
params->dst.start_x = dst_rect->y;
params->dst.start_y = dst_img->w - (dst_rect->x + dst_rect->w);
params->dst.width =
widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->h);
params->dst.height =
widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
if (0x50 > fimc->hw_ver)
params->dst.start_y += (dst_rect->w - params->dst.height);
break;
case 180:
params->dst.full_width = dst_img->w;
params->dst.full_height = dst_img->h;
params->dst.start_x = dst_img->w - (dst_rect->x + dst_rect->w);
params->dst.start_y = dst_img->h - (dst_rect->y + dst_rect->h);
params->dst.width =
widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
params->dst.height = heightOfPP(dst_color_space, dst_rect->h);
break;
case 270:
params->dst.full_width = dst_img->h;
params->dst.full_height = dst_img->w;
params->dst.start_x = dst_img->h - (dst_rect->y + dst_rect->h);
params->dst.start_y = dst_rect->x;
params->dst.width =
widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->h);
params->dst.height =
widthOfPP(fimc->hw_ver, dst_color_space, dst_rect->w);
if (0x50 > fimc->hw_ver)
params->dst.start_y += (dst_rect->w - params->dst.height);
break;
}
params->dst.color_space = dst_color_space;
/* check minimum */
if (dst_rect->w < 8 || dst_rect->h < 4) {
ALOGE("%s dst size is not supported by fimc : \
f_w=%d f_h=%d x=%d y=%d w=%d h=%d (ow=%d oh=%d) format=0x%x",
__func__, params->dst.full_width, params->dst.full_height,
params->dst.start_x, params->dst.start_y, params->dst.width,
params->dst.height, dst_rect->w, dst_rect->h,
params->dst.color_space);
return -1;
}
/* check scaling limit
* the scaling limie must not be more than MAX_RESIZING_RATIO_LIMIT
*/
if (((src_rect->w > dst_rect->w) &&
((src_rect->w / dst_rect->w) > MAX_RESIZING_RATIO_LIMIT)) ||
((dst_rect->w > src_rect->w) &&
((dst_rect->w / src_rect->w) > MAX_RESIZING_RATIO_LIMIT))) {
ALOGE("%s over scaling limit : src.w=%d dst.w=%d (limit=%d)",
__func__, src_rect->w, dst_rect->w, MAX_RESIZING_RATIO_LIMIT);
return -1;
}
/* set configuration related to destination (DMA-OUT)
* - set input format & size
* - crop input size
* - set input buffer
* - set buffer type (V4L2_MEMORY_USERPTR)
*/
if (fimc_v4l2_set_dst(fimc->dev_fd,
&params->dst,
rotate_value,
flag_h_flip,
flag_v_flip,
dst_phys_addr) < 0) {
return -1;
}
/* set configuration related to source (DMA-INPUT)
* - set input format & size
* - crop input size
* - set input buffer
* - set buffer type (V4L2_MEMORY_USERPTR)
*/
if (fimc_v4l2_set_src(fimc->dev_fd, fimc->hw_ver, &params->src) < 0)
return -1;
/* set input dma address (Y/RGB, Cb, Cr) */
switch (src_img->format) {
case HAL_PIXEL_FORMAT_YCbCr_420_SP:
/* for video display zero copy case */
fimc_src_buf.base[0] = params->src.buf_addr_phy_rgb_y;
fimc_src_buf.base[1] = params->src.buf_addr_phy_cb;
break;
default:
/* set source image */
fimc_src_buf.base[0] = params->src.buf_addr_phy_rgb_y;
break;
}
if (fimc_handle_oneshot(fimc->dev_fd, &fimc_src_buf) < 0) {
fimc_v4l2_clr_buf(fimc->dev_fd);
return -1;
}
return 0;
}
static
void* fimc_get_reserved_mem_addr(s5p_fimc_t *fimc)
{
int ret;
struct v4l2_control vc;
vc.id = V4L2_CID_RESERVED_MEM_BASE_ADDR;
vc.value = 0;
ret = ioctl(fimc->dev_fd, VIDIOC_G_CTRL, &vc);
if (ret < 0) {
ALOGE("Err(%s) in video VIDIOC_G_CTRL (%d)",ret);
return NULL;
}
return vc.value;
}
int fimc_open(s5p_fimc_t *fimc, const char* dev)
{
struct v4l2_capability cap;
struct v4l2_format fmt;
struct v4l2_control vc;
/* open device file */
if(fimc->dev_fd < 0) {
fimc->dev_fd = open(dev, O_RDWR);
if (fimc->dev_fd < 0) {
ALOGE("%s::Post processor open error (%d)", __func__, errno);
goto err;
}
}
/* check capability */
if (ioctl(fimc->dev_fd, VIDIOC_QUERYCAP, &cap) < 0) {
ALOGE("VIDIOC_QUERYCAP failed");
goto err;
}
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
ALOGE("%d has no streaming support", fimc->dev_fd);
goto err;
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
ALOGE("%d is no video output", fimc->dev_fd);
goto err;
}
/*
* malloc fimc_outinfo structure
*/
fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
if (ioctl(fimc->dev_fd, VIDIOC_G_FMT, &fmt) < 0) {
ALOGE("%s::Error in video VIDIOC_G_FMT", __func__);
goto err;
}
fimc->out_buf.phys_addr = fimc_get_reserved_mem_addr(fimc);
vc.id = V4L2_CID_FIMC_VERSION;
vc.value = 0;
if (ioctl(fimc->dev_fd, VIDIOC_G_CTRL, &vc) < 0) {
ALOGE("%s::Error in video VIDIOC_G_CTRL", __func__);
goto err;
}
fimc->hw_ver = vc.value;
return 0;
err:
if (0 <= fimc->dev_fd)
close(fimc->dev_fd);
fimc->dev_fd = -1;
return -1;
}
void fimc_close(s5p_fimc_t *fimc)
{
/* close */
if (0 <= fimc->dev_fd)
close(fimc->dev_fd);
fimc->dev_fd = -1;
}
int fimc_flush(s5p_fimc_t *fimc,
struct sec_img *src_img,
struct sec_rect *src_rect,
struct sec_img *dst_img,
struct sec_rect *dst_rect,
unsigned int *phyAddr,
uint32_t transform)
{
unsigned int dst_phys_addr = 0;
int32_t src_color_space;
int32_t dst_color_space;
/* 1 : source address and size */
if(0 > get_src_phys_addr(fimc, src_img, phyAddr))
return -1;
/* 2 : destination address and size */
if(0 == (dst_phys_addr = get_dst_phys_addr(fimc, dst_img)))
return -2;
/* check whether fimc supports the src format */
if (0 > (src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format)))
return -3;
if (0 > (dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format)))
return -4;
if(fimc_core(fimc, src_img, src_rect, (uint32_t)src_color_space,
dst_phys_addr, dst_img, dst_rect, (uint32_t)dst_color_space, transform) < 0)
return -5;
return 0;
}
Reference in a new issue View git blame Copy permalink