/*
* 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 exynos_gscaler.c
* \brief header file for Gscaler HAL
* \author ShinWon Lee (shinwon.lee@samsung.com)
* \date 2012/01/09
*
* <b>Revision History: </b>
* - 2012.01.09 : ShinWon Lee(shinwon.lee@samsung.com) \n
* Create
*
* - 2012.02.07 : ShinWon Lee(shinwon.lee@samsung.com) \n
* Change file name to exynos_gscaler.h
*
* - 2012.02.09 : Sangwoo, Parkk(sw5771.park@samsung.com) \n
* Use Multiple Gscaler by Multiple Process
*
* - 2012.02.20 : Sangwoo, Park(sw5771.park@samsung.com) \n
* Add exynos_gsc_set_rotation() API
*
* - 2012.02.20 : ShinWon Lee(shinwon.lee@samsung.com) \n
* Add size constrain
*
*/
//#define LOG_NDEBUG 0
#include "exynos_gsc_utils.h"
#include "content_protect.h"
static int exynos_gsc_m2m_wait_frame_done(void *handle);
static int exynos_gsc_m2m_stop(void *handle);
static unsigned int m_gsc_get_plane_count(
int v4l_pixel_format)
{
int plane_count = 0;
switch (v4l_pixel_format) {
case V4L2_PIX_FMT_RGB32:
case V4L2_PIX_FMT_BGR32:
case V4L2_PIX_FMT_RGB24:
case V4L2_PIX_FMT_RGB565:
case V4L2_PIX_FMT_RGB555X:
case V4L2_PIX_FMT_RGB444:
case V4L2_PIX_FMT_YUYV:
case V4L2_PIX_FMT_UYVY:
case V4L2_PIX_FMT_NV16:
case V4L2_PIX_FMT_NV61:
plane_count = 1;
break;
case V4L2_PIX_FMT_NV12M:
case V4L2_PIX_FMT_NV12MT_16X16:
case V4L2_PIX_FMT_NV12:
case V4L2_PIX_FMT_NV21:
case V4L2_PIX_FMT_NV21M:
plane_count = 2;
break;
case V4L2_PIX_FMT_YVU420M:
case V4L2_PIX_FMT_YUV422P:
case V4L2_PIX_FMT_YUV420M:
plane_count = 3;
break;
default:
ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)\n",
__func__, v4l_pixel_format);
plane_count = -1;
break;
}
return plane_count;
}
static unsigned int m_gsc_get_plane_size(
unsigned int *plane_size,
unsigned int width,
unsigned int height,
int v4l_pixel_format)
{
switch (v4l_pixel_format) {
/* 1 plane */
case V4L2_PIX_FMT_RGB32:
case V4L2_PIX_FMT_BGR32:
plane_size[0] = width * height * 4;
plane_size[1] = 0;
plane_size[2] = 0;
break;
case V4L2_PIX_FMT_RGB24:
plane_size[0] = width * height * 3;
plane_size[1] = 0;
plane_size[2] = 0;
break;
case V4L2_PIX_FMT_RGB565:
case V4L2_PIX_FMT_RGB555X:
case V4L2_PIX_FMT_RGB444:
case V4L2_PIX_FMT_YUYV:
case V4L2_PIX_FMT_UYVY:
plane_size[0] = width * height * 2;
plane_size[1] = 0;
plane_size[2] = 0;
break;
/* 2 planes */
case V4L2_PIX_FMT_NV12M:
case V4L2_PIX_FMT_NV12:
case V4L2_PIX_FMT_NV21:
case V4L2_PIX_FMT_NV21M:
plane_size[0] = width * height;
plane_size[1] = width * (height / 2);
plane_size[2] = 0;
break;
case V4L2_PIX_FMT_NV16:
case V4L2_PIX_FMT_NV61:
plane_size[0] = width * height * 2;
plane_size[1] = 0;
plane_size[2] = 0;
break;
case V4L2_PIX_FMT_NV12MT_16X16:
plane_size[0] = ALIGN(width, 16) * ALIGN(height, 16);
plane_size[1] = ALIGN(width, 16) * ALIGN(height / 2, 8);
plane_size[2] = 0;
break;
/* 3 planes */
case V4L2_PIX_FMT_YVU420M:
case V4L2_PIX_FMT_YUV422P:
plane_size[0] = width * height;
plane_size[1] = (width / 2) * (height / 2);
plane_size[2] = (width / 2) * (height / 2);
break;
default:
ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)\n",
__func__, v4l_pixel_format);
return -1;
break;
}
return 0;
}
static int m_exynos_gsc_multiple_of_n(
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 bool m_exynos_gsc_check_src_size(
unsigned int *w, unsigned int *h,
unsigned int *crop_x, unsigned int *crop_y,
unsigned int *crop_w, unsigned int *crop_h,
int v4l2_colorformat)
{
if (*w < GSC_MIN_W_SIZE || *h < GSC_MIN_H_SIZE) {
ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)",
__func__, GSC_MIN_W_SIZE, *w, GSC_MIN_H_SIZE, *h);
return false;
}
if (*crop_w < GSC_MIN_W_SIZE || *crop_h < GSC_MIN_H_SIZE) {
ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)",
__func__, GSC_MIN_W_SIZE,* crop_w, GSC_MIN_H_SIZE, *crop_h);
return false;
}
switch (v4l2_colorformat) {
// YUV420
case V4L2_PIX_FMT_YUV420M:
case V4L2_PIX_FMT_YVU420M:
case V4L2_PIX_FMT_NV12M:
case V4L2_PIX_FMT_NV12MT:
case V4L2_PIX_FMT_NV21:
case V4L2_PIX_FMT_NV21M:
*w = (*w + 15) & ~15;
*h = (*h + 15) & ~15;
//*w = m_exynos_gsc_multiple_of_n(*w, 16);
//*h = m_exynos_gsc_multiple_of_n(*h, 16);
*crop_w = m_exynos_gsc_multiple_of_n(*crop_w, 4);
*crop_h = m_exynos_gsc_multiple_of_n(*crop_h, 4);
break;
// YUV422
case V4L2_PIX_FMT_YUYV:
case V4L2_PIX_FMT_YUV422P:
case V4L2_PIX_FMT_UYVY:
case V4L2_PIX_FMT_NV16:
case V4L2_PIX_FMT_YVYU:
case V4L2_PIX_FMT_VYUY:
*h = (*h + 7) & ~7;
//*h = m_exynos_gsc_multiple_of_n(*h, 8);
*crop_w = m_exynos_gsc_multiple_of_n(*crop_w, 4);
*crop_h = m_exynos_gsc_multiple_of_n(*crop_h, 2);
break;
// RGB
case V4L2_PIX_FMT_RGB32:
case V4L2_PIX_FMT_RGB24:
case V4L2_PIX_FMT_RGB565:
case V4L2_PIX_FMT_BGR32:
case V4L2_PIX_FMT_RGB555X:
case V4L2_PIX_FMT_RGB444:
default:
*h = (*h + 7) & ~7;
//*h = m_exynos_gsc_multiple_of_n(*h, 8);
*crop_w = m_exynos_gsc_multiple_of_n(*crop_w, 2);
*crop_h = m_exynos_gsc_multiple_of_n(*crop_h, 2);
break;
}
return true;
}
static bool m_exynos_gsc_check_dst_size(
unsigned int *w, unsigned int *h,
unsigned int *crop_x, unsigned int *crop_y,
unsigned int *crop_w, unsigned int *crop_h,
int v4l2_colorformat,
int rotation)
{
unsigned int *new_w;
unsigned int *new_h;
unsigned int *new_crop_w;
unsigned int *new_crop_h;
new_w = w;
new_h = h;
new_crop_w = crop_w;
new_crop_h = crop_h;
if (*w < GSC_MIN_W_SIZE || *h < GSC_MIN_H_SIZE) {
ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)",
__func__, GSC_MIN_W_SIZE, *w, GSC_MIN_H_SIZE, *h);
return false;
}
if (*crop_w < GSC_MIN_W_SIZE || *crop_h < GSC_MIN_H_SIZE) {
ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)",
__func__, GSC_MIN_W_SIZE,* crop_w, GSC_MIN_H_SIZE, *crop_h);
return false;
}
switch (v4l2_colorformat) {
// YUV420
case V4L2_PIX_FMT_NV12M:
case V4L2_PIX_FMT_NV12MT:
case V4L2_PIX_FMT_NV21:
case V4L2_PIX_FMT_NV21M:
case V4L2_PIX_FMT_YUV420M:
case V4L2_PIX_FMT_YVU420M:
*new_w = m_exynos_gsc_multiple_of_n(*new_w, 2);
*new_h = m_exynos_gsc_multiple_of_n(*new_h, 2);
break;
// YUV422
case V4L2_PIX_FMT_YUYV:
case V4L2_PIX_FMT_YUV422P:
case V4L2_PIX_FMT_UYVY:
case V4L2_PIX_FMT_NV16:
case V4L2_PIX_FMT_YVYU:
case V4L2_PIX_FMT_VYUY:
*new_w = m_exynos_gsc_multiple_of_n(*new_w, 2);
break;
// RGB
case V4L2_PIX_FMT_RGB32:
case V4L2_PIX_FMT_RGB24:
case V4L2_PIX_FMT_RGB565:
case V4L2_PIX_FMT_BGR32:
case V4L2_PIX_FMT_RGB555X:
case V4L2_PIX_FMT_RGB444:
default:
break;
}
return true;
}
static int m_exynos_gsc_output_create(
struct GSC_HANDLE *gsc_handle,
int dev_num,
int out_mode)
{
struct media_device *media0;
struct media_entity *gsc_sd_entity;
struct media_entity *gsc_vd_entity;
struct media_entity *sink_sd_entity;
struct media_link *links;
char node[32];
char devname[32];
unsigned int cap;
int i;
int fd = 0;
Exynos_gsc_In();
if ((out_mode != GSC_OUT_FIMD) &&
(out_mode != GSC_OUT_TV))
return -1;
gsc_handle->out_mode = out_mode;
/* GSCX => FIMD_WINX : arbitrary linking is not allowed */
if ((out_mode == GSC_OUT_FIMD) &&
(dev_num > 2))
return -1;
/* media0 */
sprintf(node, "%s%d", PFX_NODE_MEDIADEV, 0);
media0 = exynos_media_open(node);
if (media0 == NULL) {
ALOGE("%s::exynos_media_open failed (node=%s)", __func__, node);
return false;
}
/* Get the sink subdev entity by name and make the node of sink subdev*/
if (out_mode == GSC_OUT_FIMD)
sprintf(devname, PFX_FIMD_ENTITY, dev_num);
else
sprintf(devname, PFX_MXR_ENTITY, 0);
sink_sd_entity = exynos_media_get_entity_by_name(media0, devname, strlen(devname));
sink_sd_entity->fd = exynos_subdev_open_devname(devname, O_RDWR);
if ( sink_sd_entity->fd < 0) {
ALOGE("%s:: failed to open sink subdev node", __func__);
goto gsc_output_err;
}
/* get GSC video dev & sub dev entity by name*/
sprintf(devname, PFX_GSC_VIDEODEV_ENTITY, dev_num);
gsc_vd_entity= exynos_media_get_entity_by_name(media0, devname, strlen(devname));
sprintf(devname, PFX_GSC_SUBDEV_ENTITY, dev_num);
gsc_sd_entity= exynos_media_get_entity_by_name(media0, devname, strlen(devname));
/* gsc sub-dev open */
sprintf(devname, PFX_GSC_SUBDEV_ENTITY, dev_num);
gsc_sd_entity->fd = exynos_subdev_open_devname(devname, O_RDWR);
/* setup link : GSC : video device --> sub device */
for (i = 0; i < (int) gsc_vd_entity->num_links; i++) {
links = &gsc_vd_entity->links[i];
if (links == NULL ||
links->source->entity != gsc_vd_entity ||
links->sink->entity != gsc_sd_entity) {
continue;
} else if (exynos_media_setup_link(media0, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
ALOGE("%s::exynos_media_setup_link [src.entity=%d->sink.entity=%d] failed",
__func__, links->source->entity->info.id, links->sink->entity->info.id);
return -1;
}
}
/* setup link : GSC: sub device --> sink device */
for (i = 0; i < (int) gsc_sd_entity->num_links; i++) {
links = &gsc_sd_entity->links[i];
if (links == NULL || links->source->entity != gsc_sd_entity ||
links->sink->entity != sink_sd_entity) {
continue;
} else if (exynos_media_setup_link(media0, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
ALOGE("%s::exynos_media_setup_link [src.entity=%d->sink.entity=%d] failed",
__func__, links->source->entity->info.id, links->sink->entity->info.id);
return -1;
}
}
/* gsc video-dev open */
sprintf(devname, PFX_GSC_VIDEODEV_ENTITY, dev_num);
gsc_vd_entity->fd = exynos_v4l2_open_devname(devname, O_RDWR);
cap = V4L2_CAP_STREAMING |
V4L2_CAP_VIDEO_OUTPUT_MPLANE;
if (exynos_v4l2_querycap(gsc_vd_entity->fd, cap) == false) {
ALOGE("%s::exynos_v4l2_querycap() fail", __func__);
goto gsc_output_err;
}
gsc_handle->gsc_sd_entity = gsc_sd_entity;
gsc_handle->gsc_vd_entity = gsc_vd_entity;
gsc_handle->sink_sd_entity = sink_sd_entity;
gsc_handle->media0 = media0;
Exynos_gsc_Out();
return 0;
gsc_output_err:
/* to do */
return -1;
}
static int m_exynos_gsc_m2m_create(
int dev)
{
int fd = 0;
int video_node_num;
unsigned int cap;
char node[32];
Exynos_gsc_In();
switch(dev) {
case 0:
video_node_num = NODE_NUM_GSC_0;
break;
case 1:
video_node_num = NODE_NUM_GSC_1;
break;
case 2:
video_node_num = NODE_NUM_GSC_2;
break;
case 3:
video_node_num = NODE_NUM_GSC_3;
break;
default:
ALOGE("%s::unexpected dev(%d) fail", __func__, dev);
return -1;
break;
}
sprintf(node, "%s%d", PFX_NODE_GSC, video_node_num);
fd = exynos_v4l2_open(node, O_RDWR);
if (fd < 0) {
ALOGE("%s::exynos_v4l2_open(%s) fail", __func__, node);
return -1;
}
cap = V4L2_CAP_STREAMING |
V4L2_CAP_VIDEO_OUTPUT_MPLANE |
V4L2_CAP_VIDEO_CAPTURE_MPLANE;
if (exynos_v4l2_querycap(fd, cap) == false) {
ALOGE("%s::exynos_v4l2_querycap() fail", __func__);
if (0 < fd)
close(fd);
fd = 0;
return -1;
}
Exynos_gsc_Out();
return fd;
}
static bool m_exynos_gsc_out_destroy(struct GSC_HANDLE *gsc_handle)
{
struct media_link * links;
int i;
Exynos_gsc_In();
if (gsc_handle == NULL) {
ALOGE("%s::gsc_handle is NULL", __func__);
return false;
}
if (gsc_handle->src.stream_on == true) {
if (exynos_gsc_out_stop((void *)gsc_handle) < 0)
ALOGE("%s::exynos_gsc_out_stop() fail", __func__);
gsc_handle->src.stream_on = false;
}
/* unlink : gscaler-out --> fimd */
for (i = 0; i < (int) gsc_handle->gsc_sd_entity->num_links; i++) {
links = &gsc_handle->gsc_sd_entity->links[i];
if (links == NULL || links->source->entity != gsc_handle->gsc_sd_entity ||
links->sink->entity != gsc_handle->sink_sd_entity) {
continue;
} else if (exynos_media_setup_link(gsc_handle->media0, links->source,
links->sink, 0) < 0) {
ALOGE("%s::exynos_media_setup_unlink [src.entity=%d->sink.entity=%d] failed",
__func__, links->source->entity->info.id, links->sink->entity->info.id);
}
}
close(gsc_handle->gsc_vd_entity->fd);
close(gsc_handle->gsc_sd_entity->fd);
gsc_handle->gsc_vd_entity->fd = -1;
gsc_handle->gsc_vd_entity->fd = -1;
Exynos_gsc_Out();
return true;
}
static bool m_exynos_gsc_destroy(
struct GSC_HANDLE *gsc_handle)
{
Exynos_gsc_In();
/* just in case, we call stop here because we cannot afford to leave
* secure side protection on if things failed.
*/
exynos_gsc_m2m_stop(gsc_handle);
if (0 < gsc_handle->gsc_fd)
close(gsc_handle->gsc_fd);
gsc_handle->gsc_fd = 0;
Exynos_gsc_Out();
return true;
}
bool m_exynos_gsc_find_and_trylock_and_create(
struct GSC_HANDLE *gsc_handle)
{
int i = 0;
bool flag_find_new_gsc = false;
unsigned int total_sleep_time = 0;
Exynos_gsc_In();
do {
for (i = 0; i < NUM_OF_GSC_HW; i++) {
// HACK : HWComposer, HDMI uses gscaler with their own code.
// So, This obj_mutex cannot defense their open()
if (i == 0 || i == 3)
continue;
if (exynos_mutex_trylock(gsc_handle->obj_mutex[i]) == true) {
// destroy old one.
m_exynos_gsc_destroy(gsc_handle);
// create new one.
gsc_handle->gsc_id = i;
gsc_handle->gsc_fd = m_exynos_gsc_m2m_create(i);
if (gsc_handle->gsc_fd < 0) {
gsc_handle->gsc_fd = 0;
exynos_mutex_unlock(gsc_handle->obj_mutex[i]);
continue;
}
if (gsc_handle->cur_obj_mutex)
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
gsc_handle->cur_obj_mutex = gsc_handle->obj_mutex[i];
flag_find_new_gsc = true;
break;
}
}
// waiting for another process doesn't use gscaler.
// we need to make decision how to do.
if (flag_find_new_gsc == false) {
usleep(GSC_WAITING_TIME_FOR_TRYLOCK);
total_sleep_time += GSC_WAITING_TIME_FOR_TRYLOCK;
ALOGV("%s::waiting for anthere process doens't use gscaler", __func__);
}
} while( flag_find_new_gsc == false
&& total_sleep_time < MAX_GSC_WAITING_TIME_FOR_TRYLOCK);
if (flag_find_new_gsc == false)
ALOGE("%s::we don't have no available gsc.. fail", __func__);
Exynos_gsc_Out();
return flag_find_new_gsc;
}
static bool m_exynos_gsc_set_format(
int fd,
struct gsc_info *info)
{
Exynos_gsc_In();
struct v4l2_requestbuffers req_buf;
int plane_count;
plane_count = m_gsc_get_plane_count(info->v4l2_colorformat);
if (plane_count < 0) {
ALOGE("%s::not supported v4l2_colorformat", __func__);
return false;
}
if (exynos_v4l2_s_ctrl(fd, V4L2_CID_ROTATE, info->rotation) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_ROTATE) fail", __func__);
return false;
}
if (exynos_v4l2_s_ctrl(fd, V4L2_CID_VFLIP, info->flip_horizontal) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_VFLIP) fail", __func__);
return false;
}
if (exynos_v4l2_s_ctrl(fd, V4L2_CID_HFLIP, info->flip_vertical) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_HFLIP) fail", __func__);
return false;
}
if (exynos_v4l2_s_ctrl(fd, V4L2_CID_CSC_RANGE, info->csc_range) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_RANGE) fail", __func__);
return false;
}
info->format.type = info->buf_type;
info->format.fmt.pix_mp.width = info->width;
info->format.fmt.pix_mp.height = info->height;
info->format.fmt.pix_mp.pixelformat = info->v4l2_colorformat;
info->format.fmt.pix_mp.field = V4L2_FIELD_ANY;
info->format.fmt.pix_mp.num_planes = plane_count;
if (exynos_v4l2_s_fmt(fd, &info->format) < 0) {
ALOGE("%s::exynos_v4l2_s_fmt() fail", __func__);
return false;
}
info->crop.type = info->buf_type;
info->crop.c.left = info->crop_left;
info->crop.c.top = info->crop_top;
info->crop.c.width = info->crop_width;
info->crop.c.height = info->crop_height;
if (exynos_v4l2_s_crop(fd, &info->crop) < 0) {
ALOGE("%s::exynos_v4l2_s_crop() fail", __func__);
return false;
}
if (exynos_v4l2_s_ctrl(fd, V4L2_CID_CACHEABLE, info->cacheable) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl() fail", __func__);
return false;
}
req_buf.count = 1;
req_buf.type = info->buf_type;
req_buf.memory = V4L2_MEMORY_DMABUF;
if (exynos_v4l2_reqbufs(fd, &req_buf) < 0) {
ALOGE("%s::exynos_v4l2_reqbufs() fail", __func__);
return false;
}
Exynos_gsc_Out();
return true;
}
static bool m_exynos_gsc_set_addr(
int fd,
struct gsc_info *info)
{
unsigned int i;
unsigned int plane_size[NUM_OF_GSC_PLANES];
m_gsc_get_plane_size(plane_size,
info->width,
info->height,
info->v4l2_colorformat);
info->buffer.index = 0;
info->buffer.flags = V4L2_BUF_FLAG_USE_SYNC;
info->buffer.type = info->buf_type;
info->buffer.memory = V4L2_MEMORY_DMABUF;
info->buffer.m.planes = info->planes;
info->buffer.length = info->format.fmt.pix_mp.num_planes;
info->buffer.reserved = info->acquireFenceFd;
for (i = 0; i < info->format.fmt.pix_mp.num_planes; i++) {
info->buffer.m.planes[i].m.fd = (int)info->addr[i];
info->buffer.m.planes[i].length = plane_size[i];
info->buffer.m.planes[i].bytesused = 0;
}
if (exynos_v4l2_qbuf(fd, &info->buffer) < 0) {
ALOGE("%s::exynos_v4l2_qbuf() fail", __func__);
return false;
}
info->buffer_queued = true;
info->releaseFenceFd = info->buffer.reserved;
return true;
}
void *exynos_gsc_create(
void)
{
int i = 0;
int op_id = 0;
char mutex_name[32];
Exynos_gsc_In();
struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)malloc(sizeof(struct GSC_HANDLE));
if (gsc_handle == NULL) {
ALOGE("%s::malloc(struct GSC_HANDLE) fail", __func__);
goto err;
}
gsc_handle->gsc_fd = 0;
memset(&gsc_handle->src, 0, sizeof(struct gsc_info));
memset(&gsc_handle->dst, 0, sizeof(struct gsc_info));
gsc_handle->src.buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
gsc_handle->dst.buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
gsc_handle->op_mutex = NULL;
for (i = 0; i < NUM_OF_GSC_HW; i++)
gsc_handle->obj_mutex[i] = NULL;
gsc_handle->cur_obj_mutex = NULL;
gsc_handle->flag_local_path = false;
gsc_handle->flag_exclusive_open = false;
srand(time(NULL));
op_id = rand() % 1000000; // just make random id
sprintf(mutex_name, "%sOp%d", LOG_TAG, op_id);
gsc_handle->op_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_PRIVATE, mutex_name);
if (gsc_handle->op_mutex == NULL) {
ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name);
goto err;
}
exynos_mutex_lock(gsc_handle->op_mutex);
// check if it is available
for (i = 0; i < NUM_OF_GSC_HW; i++) {
sprintf(mutex_name, "%sObject%d", LOG_TAG, i);
gsc_handle->obj_mutex[i] = exynos_mutex_create(EXYNOS_MUTEX_TYPE_SHARED, mutex_name);
if (gsc_handle->obj_mutex[i] == NULL) {
ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name);
goto err;
}
}
if (m_exynos_gsc_find_and_trylock_and_create(gsc_handle) == false) {
ALOGE("%s::m_exynos_gsc_find_and_trylock_and_create() fail", __func__);
goto err;
}
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
exynos_mutex_unlock(gsc_handle->op_mutex);
return (void *)gsc_handle;
err:
if (gsc_handle) {
m_exynos_gsc_destroy(gsc_handle);
if (gsc_handle->cur_obj_mutex)
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
for (i = 0; i < NUM_OF_GSC_HW; i++) {
if ((gsc_handle->obj_mutex[i] != NULL) &&
(exynos_mutex_get_created_status(gsc_handle->obj_mutex[i]) == true)) {
if (exynos_mutex_destroy(gsc_handle->obj_mutex[i]) == false)
ALOGE("%s::exynos_mutex_destroy() fail", __func__);
}
}
if (gsc_handle->op_mutex)
exynos_mutex_unlock(gsc_handle->op_mutex);
if (exynos_mutex_destroy(gsc_handle->op_mutex) == false)
ALOGE("%s::exynos_mutex_destroy(op_mutex) fail", __func__);
free(gsc_handle);
}
Exynos_gsc_Out();
return NULL;
}
void *exynos_gsc_reserve(int dev_num)
{
char mutex_name[32];
unsigned int total_sleep_time = 0;
bool gsc_flag = false;
if ((dev_num < 0) || (dev_num >= NUM_OF_GSC_HW)) {
ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num);
return NULL;
}
struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)malloc(sizeof(struct GSC_HANDLE));
if (gsc_handle == NULL) {
ALOGE("%s::malloc(struct GSC_HANDLE) fail", __func__);
goto err;
}
gsc_handle->gsc_fd = -1;
gsc_handle->op_mutex = NULL;
gsc_handle->cur_obj_mutex = NULL;
sprintf(mutex_name, "%sObject%d", LOG_TAG, dev_num);
gsc_handle->cur_obj_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_SHARED, mutex_name);
if (gsc_handle->cur_obj_mutex == NULL) {
ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name);
goto err;
}
do {
if (exynos_mutex_trylock(gsc_handle->cur_obj_mutex) == true) {
gsc_flag = true;
break;
}
usleep(GSC_WAITING_TIME_FOR_TRYLOCK);
total_sleep_time += GSC_WAITING_TIME_FOR_TRYLOCK;
ALOGV("%s::waiting for another process to release the requested gscaler", __func__);
} while(total_sleep_time < MAX_GSC_WAITING_TIME_FOR_TRYLOCK);
if (gsc_flag == true)
return (void *)gsc_handle;
err:
if (gsc_handle) {
free(gsc_handle);
}
return NULL;
}
void exynos_gsc_release(void *handle)
{
struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return;
}
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
exynos_mutex_destroy(gsc_handle->cur_obj_mutex);
free(gsc_handle);
return;
}
void *exynos_gsc_create_exclusive(
int dev_num,
int mode,
int out_mode,
int allow_drm)
{
int i = 0;
int op_id = 0;
char mutex_name[32];
unsigned int total_sleep_time = 0;
bool gsc_flag = false;
int ret = 0;
Exynos_gsc_In();
if ((dev_num < 0) || (dev_num >= NUM_OF_GSC_HW)) {
ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num);
return NULL;
}
if ((mode < 0) || (mode >= NUM_OF_GSC_HW)) {
ALOGE("%s::fail:: mode is not valid(%d) ", __func__, mode);
return NULL;
}
/* currently only gscalers 0 and 3 are DRM capable */
if (allow_drm && (dev_num != 0 && dev_num != 3)) {
ALOGE("%s::fail:: gscaler %d does not support drm\n", __func__,
dev_num);
return NULL;
}
struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)malloc(sizeof(struct GSC_HANDLE));
if (gsc_handle == NULL) {
ALOGE("%s::malloc(struct GSC_HANDLE) fail", __func__);
goto err;
}
memset(gsc_handle, 0, sizeof(struct GSC_HANDLE));
gsc_handle->gsc_fd = -1;
gsc_handle->gsc_mode = mode;
gsc_handle->gsc_id = dev_num;
gsc_handle->allow_drm = allow_drm;
gsc_handle->src.buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
gsc_handle->dst.buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
gsc_handle->op_mutex = NULL;
for (i = 0; i < NUM_OF_GSC_HW; i++)
gsc_handle->obj_mutex[i] = NULL;
gsc_handle->cur_obj_mutex = NULL;
gsc_handle->flag_local_path = false;
gsc_handle->flag_exclusive_open = true;
srand(time(NULL));
op_id = rand() % 1000000; // just make random id
sprintf(mutex_name, "%sOp%d", LOG_TAG, op_id);
gsc_handle->op_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_PRIVATE, mutex_name);
if (gsc_handle->op_mutex == NULL) {
ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name);
goto err;
}
exynos_mutex_lock(gsc_handle->op_mutex);
sprintf(mutex_name, "%sObject%d", LOG_TAG, dev_num);
gsc_handle->cur_obj_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_SHARED, mutex_name);
if (gsc_handle->cur_obj_mutex == NULL) {
ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name);
goto err;
}
do {
if (exynos_mutex_trylock(gsc_handle->cur_obj_mutex) == true) {
if (mode == GSC_M2M_MODE) {
gsc_handle->gsc_fd = m_exynos_gsc_m2m_create(dev_num);
if (gsc_handle->gsc_fd < 0) {
ALOGE("%s::m_exynos_gsc_m2m_create(%i) fail", __func__, dev_num);
goto err;
}
} else if (mode == GSC_OUTPUT_MODE) {
ret = m_exynos_gsc_output_create(gsc_handle, dev_num, out_mode);
if (ret < 0) {
ALOGE("%s::m_exynos_gsc_output_create(%i) fail", __func__, dev_num);
goto err;
}
}
/*else
gsc_handle->gsc_fd = m_exynos_gsc_capture_create(dev_num);*/
gsc_flag = true;
break;
}
usleep(GSC_WAITING_TIME_FOR_TRYLOCK);
total_sleep_time += GSC_WAITING_TIME_FOR_TRYLOCK;
ALOGV("%s::waiting for anthere process doens't use gscaler", __func__);
} while(total_sleep_time < MAX_GSC_WAITING_TIME_FOR_TRYLOCK);
exynos_mutex_unlock(gsc_handle->op_mutex);
if (gsc_flag == true) {
Exynos_gsc_Out();
return (void *)gsc_handle;
}
err:
if (gsc_handle) {
m_exynos_gsc_destroy(gsc_handle);
if (gsc_handle->cur_obj_mutex)
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
for (i = 0; i < NUM_OF_GSC_HW; i++) {
if ((gsc_handle->obj_mutex[i] != NULL) &&
(exynos_mutex_get_created_status(gsc_handle->obj_mutex[i]) == true)) {
if (exynos_mutex_destroy(gsc_handle->obj_mutex[i]) == false)
ALOGE("%s::exynos_mutex_destroy() fail", __func__);
}
}
if (gsc_handle->op_mutex)
exynos_mutex_unlock(gsc_handle->op_mutex);
if (exynos_mutex_destroy(gsc_handle->op_mutex) == false)
ALOGE("%s::exynos_mutex_destroy(op_mutex) fail", __func__);
free(gsc_handle);
}
Exynos_gsc_Out();
return NULL;
}
void exynos_gsc_destroy(
void *handle)
{
int i = 0;
struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return;
}
exynos_mutex_lock(gsc_handle->op_mutex);
if (gsc_handle->flag_exclusive_open == false)
exynos_mutex_lock(gsc_handle->cur_obj_mutex);
if (gsc_handle->gsc_mode == GSC_OUTPUT_MODE)
m_exynos_gsc_out_destroy(gsc_handle);
else
m_exynos_gsc_destroy(gsc_handle);
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
for (i = 0; i < NUM_OF_GSC_HW; i++) {
if ((gsc_handle->obj_mutex[i] != NULL) &&
(exynos_mutex_get_created_status(gsc_handle->obj_mutex[i]) == true)) {
if (exynos_mutex_destroy(gsc_handle->obj_mutex[i]) == false)
ALOGE("%s::exynos_mutex_destroy(obj_mutex) fail", __func__);
}
}
exynos_mutex_unlock(gsc_handle->op_mutex);
if (exynos_mutex_destroy(gsc_handle->op_mutex) == false)
ALOGE("%s::exynos_mutex_destroy(op_mutex) fail", __func__);
if (gsc_handle)
free(gsc_handle);
Exynos_gsc_Out();
}
int exynos_gsc_set_src_format(
void *handle,
unsigned int width,
unsigned int height,
unsigned int crop_left,
unsigned int crop_top,
unsigned int crop_width,
unsigned int crop_height,
unsigned int v4l2_colorformat,
unsigned int cacheable,
unsigned int mode_drm)
{
Exynos_gsc_In();
struct GSC_HANDLE *gsc_handle;
gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
exynos_mutex_lock(gsc_handle->op_mutex);
gsc_handle->src.width = width;
gsc_handle->src.height = height;
gsc_handle->src.crop_left = crop_left;
gsc_handle->src.crop_top = crop_top;
gsc_handle->src.crop_width = crop_width;
gsc_handle->src.crop_height = crop_height;
gsc_handle->src.v4l2_colorformat = v4l2_colorformat;
gsc_handle->src.cacheable = cacheable;
gsc_handle->src.mode_drm = mode_drm;
gsc_handle->src.dirty = true;
exynos_mutex_unlock(gsc_handle->op_mutex);
Exynos_gsc_Out();
return 0;
}
int exynos_gsc_set_dst_format(
void *handle,
unsigned int width,
unsigned int height,
unsigned int crop_left,
unsigned int crop_top,
unsigned int crop_width,
unsigned int crop_height,
unsigned int v4l2_colorformat,
unsigned int cacheable,
unsigned int mode_drm,
unsigned int narrowRgb)
{
Exynos_gsc_In();
struct GSC_HANDLE *gsc_handle;
gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
exynos_mutex_lock(gsc_handle->op_mutex);
gsc_handle->dst.width = width;
gsc_handle->dst.height = height;
gsc_handle->dst.crop_left = crop_left;
gsc_handle->dst.crop_top = crop_top;
gsc_handle->dst.crop_width = crop_width;
gsc_handle->dst.crop_height = crop_height;
gsc_handle->dst.v4l2_colorformat = v4l2_colorformat;
gsc_handle->dst.cacheable = cacheable;
gsc_handle->dst.mode_drm = mode_drm;
gsc_handle->dst.dirty = true;
gsc_handle->dst.csc_range = !narrowRgb;
exynos_mutex_unlock(gsc_handle->op_mutex);
Exynos_gsc_Out();
return 0;
}
int exynos_gsc_set_rotation(
void *handle,
int rotation,
int flip_horizontal,
int flip_vertical)
{
int ret = -1;
struct GSC_HANDLE *gsc_handle;
gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return ret;
}
exynos_mutex_lock(gsc_handle->op_mutex);
int new_rotation = rotation % 360;
if (new_rotation % 90 != 0) {
ALOGE("%s::rotation(%d) cannot be acceptable fail", __func__, rotation);
goto done;
}
if(new_rotation < 0)
new_rotation = -new_rotation;
gsc_handle->dst.rotation = new_rotation;
gsc_handle->dst.flip_horizontal = flip_horizontal;
gsc_handle->dst.flip_vertical = flip_vertical;
ret = 0;
done:
exynos_mutex_unlock(gsc_handle->op_mutex);
return ret;
}
int exynos_gsc_set_src_addr(
void *handle,
void *addr[3],
int acquireFenceFd)
{
struct GSC_HANDLE *gsc_handle;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
exynos_mutex_lock(gsc_handle->op_mutex);
gsc_handle->src.addr[0] = addr[0];
gsc_handle->src.addr[1] = addr[1];
gsc_handle->src.addr[2] = addr[2];
gsc_handle->src.acquireFenceFd = acquireFenceFd;
exynos_mutex_unlock(gsc_handle->op_mutex);
Exynos_gsc_Out();
return 0;
}
int exynos_gsc_set_dst_addr(
void *handle,
void *addr[3],
int acquireFenceFd)
{
struct GSC_HANDLE *gsc_handle;
gsc_handle = (struct GSC_HANDLE *)handle;
int ret = 0;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
exynos_mutex_lock(gsc_handle->op_mutex);
gsc_handle->dst.addr[0] = addr[0];
gsc_handle->dst.addr[1] = addr[1];
gsc_handle->dst.addr[2] = addr[2];
gsc_handle->dst.acquireFenceFd = acquireFenceFd;
exynos_mutex_unlock(gsc_handle->op_mutex);
Exynos_gsc_Out();
return ret;
}
static void rotateValueHAL2GSC(unsigned int transform,
unsigned int *rotate,
unsigned int *hflip,
unsigned int *vflip)
{
int rotate_flag = transform & 0x7;
*rotate = 0;
*hflip = 0;
*vflip = 0;
switch (rotate_flag) {
case HAL_TRANSFORM_ROT_90:
*rotate = 90;
break;
case HAL_TRANSFORM_ROT_180:
*rotate = 180;
break;
case HAL_TRANSFORM_ROT_270:
*rotate = 270;
break;
case HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90:
*rotate = 90;
*vflip = 1; /* set vflip to compensate the rot & flip order. */
break;
case HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90:
*rotate = 90;
*hflip = 1; /* set hflip to compensate the rot & flip order. */
break;
case HAL_TRANSFORM_FLIP_H:
*hflip = 1;
break;
case HAL_TRANSFORM_FLIP_V:
*vflip = 1;
break;
default:
break;
}
}
static bool get_plane_size(int V4L2_PIX,
unsigned int * size,
unsigned int frame_size,
int src_planes)
{
unsigned int frame_ratio = 1;
int src_bpp = get_yuv_bpp(V4L2_PIX);
src_planes = (src_planes == -1) ? 1 : src_planes;
frame_ratio = 8 * (src_planes -1) / (src_bpp - 8);
switch (src_planes) {
case 1:
switch (V4L2_PIX) {
case V4L2_PIX_FMT_BGR32:
case V4L2_PIX_FMT_RGB32:
size[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:
size[0] = frame_size << 1;
break;
case V4L2_PIX_FMT_YUV420:
case V4L2_PIX_FMT_NV12:
case V4L2_PIX_FMT_NV21:
case V4L2_PIX_FMT_NV21M:
size[0] = (frame_size * 3) >> 1;
break;
default:
ALOGE("%s::invalid color type", __func__);
return false;
break;
}
size[1] = 0;
size[2] = 0;
break;
case 2:
size[0] = frame_size;
size[1] = frame_size / frame_ratio;
size[2] = 0;
break;
case 3:
size[0] = frame_size;
size[1] = frame_size / frame_ratio;
size[2] = frame_size / frame_ratio;
break;
default:
ALOGE("%s::invalid color foarmt", __func__);
return false;
break;
}
return true;
}
int exynos_gsc_m2m_config(void *handle,
exynos_gsc_img *src_img,
exynos_gsc_img *dst_img)
{
struct GSC_HANDLE *gsc_handle;
int32_t src_color_space;
int32_t dst_color_space;
int ret;
unsigned int rotate;
unsigned int hflip;
unsigned int vflip;
Exynos_gsc_In();
gsc_handle = (struct GSC_HANDLE *)handle;
if (gsc_handle == NULL) {
ALOGE("%s::gsc_handle == NULL() fail", __func__);
return -1;
}
if ((src_img->drmMode && !gsc_handle->allow_drm) ||
(src_img->drmMode != dst_img->drmMode)) {
ALOGE("%s::invalid drm state request for gsc%d (s=%d d=%d)",
__func__, gsc_handle->gsc_id,
src_img->drmMode, dst_img->drmMode);
return -1;
}
src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format);
dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format);
rotateValueHAL2GSC(dst_img->rot, &rotate, &hflip, &vflip);
exynos_gsc_set_rotation(gsc_handle, rotate, hflip, vflip);
ret = exynos_gsc_set_src_format(gsc_handle, src_img->fw, src_img->fh,
src_img->x, src_img->y, src_img->w, src_img->h,
src_color_space, src_img->cacheable, src_img->drmMode);
if (ret < 0) {
ALOGE("%s: fail: exynos_gsc_set_src_format [fw %d fh %d x %d y %d w %d h %d f %x rot %d]",
__func__, src_img->fw, src_img->fh, src_img->x, src_img->y, src_img->w, src_img->h,
src_color_space, src_img->rot);
return -1;
}
ret = exynos_gsc_set_dst_format(gsc_handle, dst_img->fw, dst_img->fh,
dst_img->x, dst_img->y, dst_img->w, dst_img->h,
dst_color_space, dst_img->cacheable, dst_img->drmMode,
dst_img->narrowRgb);
if (ret < 0) {
ALOGE("%s: fail: exynos_gsc_set_dst_format [fw %d fh %d x %d y %d w %d h %d f %x rot %d]",
__func__, dst_img->fw, dst_img->fh, dst_img->x, dst_img->y, dst_img->w, dst_img->h,
src_color_space, dst_img->rot);
return -1;
}
Exynos_gsc_Out();
return 0;
}
int exynos_gsc_out_config(void *handle,
exynos_gsc_img *src_img,
exynos_gsc_img *dst_img)
{
struct GSC_HANDLE *gsc_handle;
struct v4l2_format fmt;
struct v4l2_crop crop;
struct v4l2_requestbuffers reqbuf;
struct v4l2_subdev_format sd_fmt;
struct v4l2_subdev_crop sd_crop;
int i;
unsigned int rotate;
unsigned int hflip;
unsigned int vflip;
unsigned int plane_size[NUM_OF_GSC_PLANES];
bool rgb;
int csc_range = !dst_img->narrowRgb;
struct v4l2_rect dst_rect;
int32_t src_color_space;
int32_t dst_color_space;
int32_t src_planes;
gsc_handle = (struct GSC_HANDLE *)handle;
if (gsc_handle == NULL) {
ALOGE("%s::gsc_handle == NULL() fail", __func__);
return -1;
}
Exynos_gsc_In();
if (gsc_handle->src.stream_on != false) {
ALOGE("Error: Src is already streamed on !!!!");
return -1;
}
memcpy(&gsc_handle->src_img, src_img, sizeof(exynos_gsc_img));
memcpy(&gsc_handle->dst_img, dst_img, sizeof(exynos_gsc_img));
src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format);
dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format);
src_planes = get_yuv_planes(src_color_space);
src_planes = (src_planes == -1) ? 1 : src_planes;
rgb = get_yuv_planes(dst_color_space) == -1;
rotateValueHAL2GSC(dst_img->rot, &rotate, &hflip, &vflip);
if (m_exynos_gsc_check_src_size(&gsc_handle->src_img.fw, &gsc_handle->src_img.fh,
&gsc_handle->src_img.x, &gsc_handle->src_img.y,
&gsc_handle->src_img.w, &gsc_handle->src_img.h,
src_color_space) == false) {
ALOGE("%s::m_exynos_gsc_check_src_size() fail", __func__);
return -1;
}
if (m_exynos_gsc_check_dst_size(&gsc_handle->dst_img.fw, &gsc_handle->dst_img.fh,
&gsc_handle->dst_img.x, &gsc_handle->dst_img.y,
&gsc_handle->dst_img.w, &gsc_handle->dst_img.h,
dst_color_space,
rotate) == false) {
ALOGE("%s::m_exynos_gsc_check_dst_size() fail", __func__);
return -1;
}
/*set: src v4l2_buffer*/
gsc_handle->src.src_buf_idx = 0;
gsc_handle->src.qbuf_cnt = 0;
/* set format: src pad of GSC sub-dev*/
sd_fmt.pad = GSCALER_SUBDEV_PAD_SOURCE;
sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
if (gsc_handle->out_mode == GSC_OUT_FIMD) {
sd_fmt.format.width = gsc_handle->dst_img.fw;
sd_fmt.format.height = gsc_handle->dst_img.fh;
} else {
sd_fmt.format.width = gsc_handle->dst_img.w;
sd_fmt.format.height = gsc_handle->dst_img.h;
}
sd_fmt.format.code = rgb ? V4L2_MBUS_FMT_XRGB8888_4X8_LE :
V4L2_MBUS_FMT_YUV8_1X24;
if (exynos_subdev_s_fmt(gsc_handle->gsc_sd_entity->fd, &sd_fmt) < 0) {
ALOGE("%s::GSC subdev set format failed", __func__);
return -1;
}
/* set crop: src crop of GSC sub-dev*/
sd_crop.pad = GSCALER_SUBDEV_PAD_SOURCE;
sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE;
if (gsc_handle->out_mode == GSC_OUT_FIMD) {
sd_crop.rect.left = gsc_handle->dst_img.x;
sd_crop.rect.top = gsc_handle->dst_img.y;
sd_crop.rect.width = gsc_handle->dst_img.w;
sd_crop.rect.height = gsc_handle->dst_img.h;
} else {
sd_crop.rect.left = 0;
sd_crop.rect.top = 0;
sd_crop.rect.width = gsc_handle->dst_img.w;
sd_crop.rect.height = gsc_handle->dst_img.h;
}
if (exynos_subdev_s_crop(gsc_handle->gsc_sd_entity->fd, &sd_crop) < 0) {
ALOGE("%s::GSC subdev set crop failed", __func__);
return -1;
}
/* sink pad is connected to GSC out */
/* set format: sink sub-dev */
if (gsc_handle->out_mode == GSC_OUT_FIMD) {
sd_fmt.pad = FIMD_SUBDEV_PAD_SINK;
sd_fmt.format.width = gsc_handle->dst_img.w;
sd_fmt.format.height = gsc_handle->dst_img.h;
} else {
sd_fmt.pad = MIXER_V_SUBDEV_PAD_SINK;
sd_fmt.format.width = gsc_handle->dst_img.w + gsc_handle->dst_img.x*2;
sd_fmt.format.height = gsc_handle->dst_img.h + gsc_handle->dst_img.y*2;
}
sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
sd_fmt.format.code = rgb ? V4L2_MBUS_FMT_XRGB8888_4X8_LE :
V4L2_MBUS_FMT_YUV8_1X24;
if (exynos_subdev_s_fmt(gsc_handle->sink_sd_entity->fd, &sd_fmt) < 0) {
ALOGE("%s::sink:set format failed (PAD=%d)", __func__, sd_fmt.pad);
return -1;
}
/* set crop: sink sub-dev */
if (gsc_handle->out_mode == GSC_OUT_FIMD)
sd_crop.pad = FIMD_SUBDEV_PAD_SINK;
else
sd_crop.pad = MIXER_V_SUBDEV_PAD_SINK;
sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE;
if (gsc_handle->out_mode == GSC_OUT_FIMD) {
sd_crop.rect.left = gsc_handle->dst_img.x;
sd_crop.rect.top = gsc_handle->dst_img.y;
sd_crop.rect.width = gsc_handle->dst_img.w;
sd_crop.rect.height = gsc_handle->dst_img.h;
} else {
sd_crop.rect.left = 0;
sd_crop.rect.top = 0;
sd_crop.rect.width = gsc_handle->dst_img.w;
sd_crop.rect.height = gsc_handle->dst_img.h;
}
if (exynos_subdev_s_crop(gsc_handle->sink_sd_entity->fd, &sd_crop) < 0) {
ALOGE("%s::sink: subdev set crop failed(PAD=%d)", __func__, sd_crop.pad);
return -1;
}
if (gsc_handle->out_mode != GSC_OUT_FIMD) {
sd_fmt.pad = MIXER_V_SUBDEV_PAD_SOURCE;
sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
sd_fmt.format.width = gsc_handle->dst_img.w + gsc_handle->dst_img.x*2;
sd_fmt.format.height = gsc_handle->dst_img.h + gsc_handle->dst_img.y*2;
sd_fmt.format.code = V4L2_MBUS_FMT_XRGB8888_4X8_LE;
if (exynos_subdev_s_fmt(gsc_handle->sink_sd_entity->fd, &sd_fmt) < 0) {
ALOGE("%s::sink:set format failed (PAD=%d)", __func__, sd_fmt.pad);
return -1;
}
sd_fmt.pad = MIXER_V_SUBDEV_PAD_SOURCE;
sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE;
sd_crop.rect.left = gsc_handle->dst_img.x;
sd_crop.rect.top = gsc_handle->dst_img.y;
sd_crop.rect.width = gsc_handle->dst_img.w;
sd_crop.rect.height = gsc_handle->dst_img.h;
if (exynos_subdev_s_crop(gsc_handle->sink_sd_entity->fd, &sd_crop) < 0) {
ALOGE("%s::sink: subdev set crop failed(PAD=%d)", __func__, sd_crop.pad);
return -1;
}
}
/*set GSC ctrls */
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_ROTATE, rotate) < 0) {
ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_ROTATE: %d) failed", __func__, rotate);
return -1;
}
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_HFLIP, hflip) < 0) {
ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_HFLIP: %d) failed", __func__, hflip);
return -1;
}
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_VFLIP, vflip) < 0) {
ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_VFLIP: %d) failed", __func__, vflip);
return -1;
}
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_CACHEABLE, 1) < 0) {
ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_CACHEABLE: 1) failed", __func__);
return -1;
}
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd,
V4L2_CID_CONTENT_PROTECTION, gsc_handle->src_img.drmMode) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CONTENT_PROTECTION) fail", __func__);
return -1;
}
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_CSC_RANGE,
csc_range)) {
ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_RANGE: %d) fail", __func__,
csc_range);
return -1;
}
/* set src format :GSC video dev*/
fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
fmt.fmt.pix_mp.width = gsc_handle->src_img.fw;
fmt.fmt.pix_mp.height = gsc_handle->src_img.fh;
fmt.fmt.pix_mp.pixelformat = src_color_space;
fmt.fmt.pix_mp.field = V4L2_FIELD_NONE;
fmt.fmt.pix_mp.num_planes = src_planes;
if (exynos_v4l2_s_fmt(gsc_handle->gsc_vd_entity->fd, &fmt) < 0) {
ALOGE("%s::videodev set format failed", __func__);
return -1;
}
/* set src crop info :GSC video dev*/
crop.type = fmt.type;
crop.c.left = gsc_handle->src_img.x;
crop.c.top = gsc_handle->src_img.y;
crop.c.width = gsc_handle->src_img.w;
crop.c.height = gsc_handle->src_img.h;
if (exynos_v4l2_s_crop(gsc_handle->gsc_vd_entity->fd, &crop) < 0) {
ALOGE("%s::videodev set crop failed", __func__);
return -1;
}
reqbuf.type = fmt.type;
reqbuf.memory = V4L2_MEMORY_DMABUF;
reqbuf.count = MAX_BUFFERS_GSCALER_OUT;
if (exynos_v4l2_reqbufs(gsc_handle->gsc_vd_entity->fd, &reqbuf) < 0) {
ALOGE("%s::request buffers failed", __func__);
return -1;
}
Exynos_gsc_Out();
return 0;
}
static int exynos_gsc_out_run(void *handle,
exynos_gsc_img *src_img)
{
struct GSC_HANDLE *gsc_handle;
struct v4l2_plane planes[NUM_OF_GSC_PLANES];
struct v4l2_buffer buf;
int32_t src_color_space;
int32_t src_planes;
int i;
unsigned int plane_size[NUM_OF_GSC_PLANES];
gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
/* All buffers have been queued, dequeue one */
if (gsc_handle->src.qbuf_cnt == MAX_BUFFERS_GSCALER_OUT) {
memset(&buf, 0, sizeof(struct v4l2_buffer));
for (i = 0; i < MAX_BUFFERS_GSCALER_OUT; i++)
memset(&planes[i], 0, sizeof(struct v4l2_plane));
buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
buf.memory = V4L2_MEMORY_DMABUF;
buf.length = src_planes;
buf.m.planes = planes;
if (exynos_v4l2_dqbuf(gsc_handle->gsc_vd_entity->fd, &buf) < 0) {
ALOGE("%s::dequeue buffer failed (index=%d)(mSrcBufNum=%d)", __func__,
gsc_handle->src.src_buf_idx, MAX_BUFFERS_GSCALER_OUT);
return -1;
}
gsc_handle->src.qbuf_cnt--;
}
memset(&buf, 0, sizeof(struct v4l2_buffer));
for (i = 0; i < NUM_OF_GSC_PLANES; i++)
memset(&planes[i], 0, sizeof(struct v4l2_plane));
src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(gsc_handle->src_img.format);
src_planes = get_yuv_planes(src_color_space);
src_planes = (src_planes == -1) ? 1 : src_planes;
buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
buf.memory = V4L2_MEMORY_DMABUF;
buf.flags = V4L2_BUF_FLAG_USE_SYNC;
buf.length = src_planes;
buf.index = gsc_handle->src.src_buf_idx;
buf.m.planes = planes;
buf.reserved = src_img->acquireFenceFd;
gsc_handle->src.addr[0] = src_img->yaddr;
gsc_handle->src.addr[1] = src_img->uaddr;
gsc_handle->src.addr[2] = src_img->vaddr;
if (get_plane_size(src_color_space, plane_size,
gsc_handle->src_img.fw * gsc_handle->src_img.fh, src_planes) != true) {
ALOGE("%s:get_plane_size:fail", __func__);
return -1;
}
for (i = 0; i < buf.length; i++) {
buf.m.planes[i].m.fd = (int)gsc_handle->src.addr[i];
buf.m.planes[i].length = plane_size[i];
buf.m.planes[i].bytesused = plane_size[i];
}
/* Queue the buf */
if (exynos_v4l2_qbuf(gsc_handle->gsc_vd_entity->fd, &buf) < 0) {
ALOGE("%s::queue buffer failed (index=%d)(mSrcBufNum=%d)", __func__,
gsc_handle->src.src_buf_idx, MAX_BUFFERS_GSCALER_OUT);
return -1;
}
gsc_handle->src.src_buf_idx++;
gsc_handle->src.src_buf_idx = gsc_handle->src.src_buf_idx % MAX_BUFFERS_GSCALER_OUT;
gsc_handle->src.qbuf_cnt++;
if (gsc_handle->src.stream_on == false) {
if (exynos_v4l2_streamon(gsc_handle->gsc_vd_entity->fd, buf.type) < 0) {
ALOGE("%s::stream on failed", __func__);
return -1;
}
gsc_handle->src.stream_on = true;
}
src_img->releaseFenceFd = buf.reserved;
return 0;
}
int exynos_gsc_out_stop(void *handle)
{
struct GSC_HANDLE *gsc_handle;
struct v4l2_requestbuffers reqbuf;
struct v4l2_buffer buf;
struct v4l2_plane planes[NUM_OF_GSC_PLANES];
int i;
Exynos_gsc_In();
gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
if (gsc_handle->src.stream_on == true) {
if (exynos_v4l2_streamoff(gsc_handle->gsc_vd_entity->fd,
V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
ALOGE("%s::stream off failed", __func__);
return -1;
}
gsc_handle->src.stream_on = false;
}
gsc_handle->src.src_buf_idx = 0;
gsc_handle->src.qbuf_cnt = 0;
reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
reqbuf.memory = V4L2_MEMORY_DMABUF;
reqbuf.count = 0;
if (exynos_v4l2_reqbufs(gsc_handle->gsc_vd_entity->fd, &reqbuf) < 0) {
ALOGE("%s::request buffers failed", __func__);
return -1;
}
Exynos_gsc_Out();
return 0;
}
static int exynos_gsc_m2m_run_core(void *handle)
{
struct GSC_HANDLE *gsc_handle;
bool is_dirty;
bool is_drm;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
is_dirty = gsc_handle->src.dirty || gsc_handle->dst.dirty;
is_drm = gsc_handle->src.mode_drm;
if (is_dirty && (gsc_handle->src.mode_drm != gsc_handle->dst.mode_drm)) {
ALOGE("%s: drm mode mismatch between src and dst, gsc%d (s=%d d=%d)",
__func__, gsc_handle->gsc_id, gsc_handle->src.mode_drm,
gsc_handle->dst.mode_drm);
return -1;
} else if (is_drm && !gsc_handle->allow_drm) {
ALOGE("%s: drm mode is not supported on gsc%d", __func__,
gsc_handle->gsc_id);
return -1;
}
if (m_exynos_gsc_check_src_size(&gsc_handle->src.width, &gsc_handle->src.height,
&gsc_handle->src.crop_left, &gsc_handle->src.crop_top,
&gsc_handle->src.crop_width, &gsc_handle->src.crop_height,
gsc_handle->src.v4l2_colorformat) == false) {
ALOGE("%s::m_exynos_gsc_check_src_size() fail", __func__);
return -1;
}
if (m_exynos_gsc_check_dst_size(&gsc_handle->dst.width, &gsc_handle->dst.height,
&gsc_handle->dst.crop_left, &gsc_handle->dst.crop_top,
&gsc_handle->dst.crop_width, &gsc_handle->dst.crop_height,
gsc_handle->dst.v4l2_colorformat,
gsc_handle->dst.rotation) == false) {
ALOGE("%s::m_exynos_gsc_check_dst_size() fail", __func__);
return -1;
}
/* dequeue buffers from previous work if necessary */
if (gsc_handle->src.stream_on == true) {
if (exynos_gsc_m2m_wait_frame_done(handle) < 0) {
ALOGE("%s::exynos_gsc_m2m_wait_frame_done fail", __func__);
return -1;
}
}
/*
* need to set the content protection flag before doing reqbufs
* in set_format
*/
if (is_dirty && gsc_handle->allow_drm && is_drm) {
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_fd,
V4L2_CID_CONTENT_PROTECTION, is_drm) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl() fail", __func__);
return -1;
}
}
/*
* from this point on, we have to ensure to call stop to clean up whatever
* state we have set.
*/
if (gsc_handle->src.dirty) {
if (m_exynos_gsc_set_format(gsc_handle->gsc_fd, &gsc_handle->src) == false) {
ALOGE("%s::m_exynos_gsc_set_format(src) fail", __func__);
goto done;
}
gsc_handle->src.dirty = false;
}
if (gsc_handle->dst.dirty) {
if (m_exynos_gsc_set_format(gsc_handle->gsc_fd, &gsc_handle->dst) == false) {
ALOGE("%s::m_exynos_gsc_set_format(dst) fail", __func__);
goto done;
}
gsc_handle->dst.dirty = false;
}
/* if we are enabling drm, make sure to enable hw protection.
* Need to do this before queuing buffers so that the mmu is reserved
* and power domain is kept on.
*/
if (is_dirty && gsc_handle->allow_drm && is_drm) {
unsigned int protect_id = 0;
if (gsc_handle->gsc_id == 0) {
protect_id = CP_PROTECT_GSC0;
} else if (gsc_handle->gsc_id == 3) {
protect_id = CP_PROTECT_GSC3;
} else {
ALOGE("%s::invalid gscaler id %d for content protection", __func__,
gsc_handle->gsc_id);
goto done;
}
if (CP_Enable_Path_Protection(protect_id) != 0) {
ALOGE("%s::CP_Enable_Path_Protection failed", __func__);
goto done;
}
gsc_handle->protection_enabled = true;
}
if (m_exynos_gsc_set_addr(gsc_handle->gsc_fd, &gsc_handle->src) == false) {
ALOGE("%s::m_exynos_gsc_set_addr(src) fail", __func__);
goto done;
}
if (m_exynos_gsc_set_addr(gsc_handle->gsc_fd, &gsc_handle->dst) == false) {
ALOGE("%s::m_exynos_gsc_set_addr(dst) fail", __func__);
goto done;
}
if (gsc_handle->src.stream_on == false) {
if (exynos_v4l2_streamon(gsc_handle->gsc_fd, gsc_handle->src.buf_type) < 0) {
ALOGE("%s::exynos_v4l2_streamon(src) fail", __func__);
goto done;
}
gsc_handle->src.stream_on = true;
}
if (gsc_handle->dst.stream_on == false) {
if (exynos_v4l2_streamon(gsc_handle->gsc_fd, gsc_handle->dst.buf_type) < 0) {
ALOGE("%s::exynos_v4l2_streamon(dst) fail", __func__);
goto done;
}
gsc_handle->dst.stream_on = true;
}
Exynos_gsc_Out();
return 0;
done:
exynos_gsc_m2m_stop(handle);
return -1;
}
static int exynos_gsc_m2m_wait_frame_done(void *handle)
{
struct GSC_HANDLE *gsc_handle;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
if ((gsc_handle->src.stream_on == false) || (gsc_handle->dst.stream_on == false)) {
ALOGE("%s:: src_strean_on or dst_stream_on are false", __func__);
return -1;
}
if (gsc_handle->src.buffer_queued) {
if (exynos_v4l2_dqbuf(gsc_handle->gsc_fd, &gsc_handle->src.buffer) < 0) {
ALOGE("%s::exynos_v4l2_dqbuf(src) fail", __func__);
return -1;
}
gsc_handle->src.buffer_queued = false;
}
if (gsc_handle->dst.buffer_queued) {
if (exynos_v4l2_dqbuf(gsc_handle->gsc_fd, &gsc_handle->dst.buffer) < 0) {
ALOGE("%s::exynos_v4l2_dqbuf(dst) fail", __func__);
return -1;
}
gsc_handle->dst.buffer_queued = false;
}
Exynos_gsc_Out();
return 0;
}
static int exynos_gsc_m2m_stop(void *handle)
{
struct GSC_HANDLE *gsc_handle;
struct v4l2_requestbuffers req_buf;
int ret = 0;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (!gsc_handle->src.stream_on && !gsc_handle->dst.stream_on) {
/* wasn't streaming, return success */
return 0;
} else if (gsc_handle->src.stream_on != gsc_handle->dst.stream_on) {
ALOGE("%s: invalid state, queue stream state doesn't match (%d != %d)",
__func__, gsc_handle->src.stream_on, gsc_handle->dst.stream_on);
ret = -1;
}
/*
* we need to plow forward on errors below to make sure that if we had
* turned on content protection on secure side, we turn it off.
*
* also, if we only failed to turn on one of the streams, we'll turn
* the other one off correctly.
*/
if (gsc_handle->src.stream_on == true) {
if (exynos_v4l2_streamoff(gsc_handle->gsc_fd, gsc_handle->src.buf_type) < 0) {
ALOGE("%s::exynos_v4l2_streamoff(src) fail", __func__);
ret = -1;
}
gsc_handle->src.stream_on = false;
}
if (gsc_handle->dst.stream_on == true) {
if (exynos_v4l2_streamoff(gsc_handle->gsc_fd, gsc_handle->dst.buf_type) < 0) {
ALOGE("%s::exynos_v4l2_streamoff(dst) fail", __func__);
ret = -1;
}
gsc_handle->dst.stream_on = false;
}
/* if drm is enabled */
if (gsc_handle->allow_drm && gsc_handle->protection_enabled) {
unsigned int protect_id = 0;
if (gsc_handle->gsc_id == 0)
protect_id = CP_PROTECT_GSC0;
else if (gsc_handle->gsc_id == 3)
protect_id = CP_PROTECT_GSC3;
CP_Disable_Path_Protection(protect_id);
gsc_handle->protection_enabled = false;
}
if (exynos_v4l2_s_ctrl(gsc_handle->gsc_fd,
V4L2_CID_CONTENT_PROTECTION, 0) < 0) {
ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CONTENT_PROTECTION) fail",
__func__);
ret = -1;
}
/* src: clear_buf */
req_buf.count = 0;
req_buf.type = gsc_handle->src.buf_type;
req_buf.memory = V4L2_MEMORY_DMABUF;
if (exynos_v4l2_reqbufs(gsc_handle->gsc_fd, &req_buf) < 0) {
ALOGE("%s::exynos_v4l2_reqbufs():src: fail", __func__);
ret = -1;
}
/* dst: clear_buf */
req_buf.count = 0;
req_buf.type = gsc_handle->dst.buf_type;
req_buf.memory = V4L2_MEMORY_DMABUF;
if (exynos_v4l2_reqbufs(gsc_handle->gsc_fd, &req_buf) < 0) {
ALOGE("%s::exynos_v4l2_reqbufs():dst: fail", __func__);
ret = -1;
}
Exynos_gsc_Out();
return ret;
}
int exynos_gsc_convert(
void *handle)
{
struct GSC_HANDLE *gsc_handle;
int ret = -1;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
exynos_mutex_lock(gsc_handle->op_mutex);
if (gsc_handle->flag_local_path == true) {
ALOGE("%s::this exynos_gsc is connected by another hw internaly. So, don't call exynos_gsc_convert()", __func__);
goto done;
}
if (exynos_gsc_m2m_run_core(handle) < 0) {
ALOGE("%s::exynos_gsc_run_core fail", __func__);
goto done;
}
if (exynos_gsc_m2m_wait_frame_done(handle) < 0) {
ALOGE("%s::exynos_gsc_m2m_wait_frame_done", __func__);
goto done;
}
if (gsc_handle->src.releaseFenceFd >= 0) {
close(gsc_handle->src.releaseFenceFd);
gsc_handle->src.releaseFenceFd = -1;
}
if (gsc_handle->dst.releaseFenceFd >= 0) {
close(gsc_handle->dst.releaseFenceFd);
gsc_handle->dst.releaseFenceFd = -1;
}
if (exynos_gsc_m2m_stop(handle) < 0) {
ALOGE("%s::exynos_gsc_m2m_stop", __func__);
goto done;
}
ret = 0;
done:
if (gsc_handle->flag_exclusive_open == false) {
if (gsc_handle->flag_local_path == false)
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
}
exynos_mutex_unlock(gsc_handle->op_mutex);
Exynos_gsc_Out();
return ret;
}
int exynos_gsc_m2m_run(void *handle,
exynos_gsc_img *src_img,
exynos_gsc_img *dst_img)
{
struct GSC_HANDLE *gsc_handle = handle;
void *addr[3] = {NULL, NULL, NULL};
int ret = 0;
Exynos_gsc_In();
addr[0] = (void *)src_img->yaddr;
addr[1] = (void *)src_img->uaddr;
addr[2] = (void *)src_img->vaddr;
ret = exynos_gsc_set_src_addr(handle, addr, src_img->acquireFenceFd);
if (ret < 0) {
ALOGE("%s::fail: exynos_gsc_set_src_addr[%x %x %x]", __func__,
(unsigned int)addr[0], (unsigned int)addr[1], (unsigned int)addr[2]);
return -1;
}
addr[0] = (void *)dst_img->yaddr;
addr[1] = (void *)dst_img->uaddr;
addr[2] = (void *)dst_img->vaddr;
ret = exynos_gsc_set_dst_addr(handle, addr, dst_img->acquireFenceFd);
if (ret < 0) {
ALOGE("%s::fail: exynos_gsc_set_dst_addr[%x %x %x]", __func__,
(unsigned int)addr[0], (unsigned int)addr[1], (unsigned int)addr[2]);
return -1;
}
ret = exynos_gsc_m2m_run_core(handle);
if (ret < 0) {
ALOGE("%s::fail: exynos_gsc_m2m_run_core", __func__);
return -1;
}
if (src_img->acquireFenceFd >= 0) {
close(src_img->acquireFenceFd);
src_img->acquireFenceFd = -1;
}
if (dst_img->acquireFenceFd >= 0) {
close(dst_img->acquireFenceFd);
dst_img->acquireFenceFd = -1;
}
src_img->releaseFenceFd = gsc_handle->src.releaseFenceFd;
dst_img->releaseFenceFd = gsc_handle->dst.releaseFenceFd;
Exynos_gsc_Out();
return 0;
}
int exynos_gsc_config_exclusive(void *handle,
exynos_gsc_img *src_img,
exynos_gsc_img *dst_img)
{
Exynos_gsc_In();
struct GSC_HANDLE *gsc_handle;
int ret = 0;
gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
switch (gsc_handle->gsc_mode) {
case GSC_M2M_MODE:
ret = exynos_gsc_m2m_config(handle, src_img, dst_img);
break;
case GSC_OUTPUT_MODE:
ret = exynos_gsc_out_config(handle, src_img, dst_img);
break;
case GSC_CAPTURE_MODE:
//to do
break;
default:
break;
}
Exynos_gsc_Out();
return ret;
}
int exynos_gsc_run_exclusive(void *handle,
exynos_gsc_img *src_img,
exynos_gsc_img *dst_img)
{
struct GSC_HANDLE *gsc_handle;
int ret = 0;
Exynos_gsc_In();
gsc_handle = (struct GSC_HANDLE *)handle;
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
switch (gsc_handle->gsc_mode) {
case GSC_M2M_MODE:
ret = exynos_gsc_m2m_run(handle, src_img, dst_img);
break;
case GSC_OUTPUT_MODE:
ret = exynos_gsc_out_run(handle, src_img);
break;
case GSC_CAPTURE_MODE:
//to do
break;
default:
break;
}
Exynos_gsc_Out();
return ret;
}
int exynos_gsc_wait_frame_done_exclusive(void *handle)
{
struct GSC_HANDLE *gsc_handle;
int ret = 0;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
if (gsc_handle->gsc_mode == GSC_M2M_MODE)
ret = exynos_gsc_m2m_wait_frame_done(handle);
Exynos_gsc_Out();
return ret;
}
int exynos_gsc_stop_exclusive(void *handle)
{
struct GSC_HANDLE *gsc_handle;
int ret = 0;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
switch (gsc_handle->gsc_mode) {
case GSC_M2M_MODE:
ret = exynos_gsc_m2m_stop(handle);
break;
case GSC_OUTPUT_MODE:
ret = exynos_gsc_out_stop(handle);
break;
case GSC_CAPTURE_MODE:
//to do
break;
default:
break;
}
Exynos_gsc_Out();
return ret;
}
int exynos_gsc_connect(
void *handle,
void *hw)
{
struct GSC_HANDLE *gsc_handle;
int ret = -1;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
exynos_mutex_lock(gsc_handle->op_mutex);
gsc_handle->flag_local_path = true;
if (exynos_mutex_trylock(gsc_handle->cur_obj_mutex) == false) {
if (m_exynos_gsc_find_and_trylock_and_create(gsc_handle) == false) {
ALOGE("%s::m_exynos_gsc_find_and_trylock_and_create() fail", __func__);
goto done;
}
}
ret = 0;
Exynos_gsc_Out();
done:
exynos_mutex_unlock(gsc_handle->op_mutex);
return ret;
}
int exynos_gsc_disconnect(
void *handle,
void *hw)
{
struct GSC_HANDLE *gsc_handle;
gsc_handle = (struct GSC_HANDLE *)handle;
Exynos_gsc_In();
if (handle == NULL) {
ALOGE("%s::handle == NULL() fail", __func__);
return -1;
}
exynos_mutex_lock(gsc_handle->op_mutex);
gsc_handle->flag_local_path = false;
exynos_mutex_unlock(gsc_handle->cur_obj_mutex);
exynos_mutex_unlock(gsc_handle->op_mutex);
Exynos_gsc_Out();
return 0;
}