/* * Copyright (C) 2013 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 libgscaler.cpp * \brief source file for Gscaler HAL * \author Sungchun Kang (sungchun.kang@samsung.com) * \date 2013/06/01 * * Revision History: * - 2013.06.01 : Sungchun Kang (sungchun.kang@samsung.com) \n * Create */ #include #include "libgscaler_obj.h" #include "libgscaler_media.h" void *exynos_gsc_create(void) { CGscaler *gsc = new CGscaler(GSC_M2M_MODE); if (!gsc) { ALOGE("%s:: failed to allocate Gscaler handle", __func__); return NULL; } if (gsc->m_gsc_find_and_create(gsc) == false) { ALOGE("%s::m_exynos_gsc_find_and_create() fail", __func__); delete gsc; return NULL; } return reinterpret_cast(gsc); } void *exynos_gsc_create_exclusive( int dev_num, int mode, int out_mode, int allow_drm) { Exynos_gsc_In(); if ((dev_num < 0) || (dev_num >= HW_SCAL_MAX)) { ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num); return NULL; } if ((dev_num >= NUM_OF_GSC_HW) && (dev_num < HW_SCAL_MAX)) { CGscaler *gsc = new CGscaler(mode, out_mode, dev_num, allow_drm); if (!gsc) { ALOGE("%s:: failed to allocate Gscaler handle", __func__); return NULL; } gsc->scaler = exynos_sc_create_exclusive(dev_num - HW_SCAL0, allow_drm); if (!gsc->scaler) { delete(gsc); ALOGE("%s::exynos_sc_create fail", __func__); return NULL; } Exynos_gsc_Out(); return reinterpret_cast(gsc); } if ((mode < 0) || (mode >= NUM_OF_GSC_HW)) { ALOGE("%s::fail:: mode is not valid(%d) ", __func__, mode); return NULL; } CGscaler *gsc = new CGscaler(mode, out_mode, dev_num, allow_drm); if (!gsc) { ALOGE("%s:: failed to allocate Gscaler handle", __func__); return NULL; } if (mode == GSC_M2M_MODE) { gsc->gsc_fd = gsc->m_gsc_m2m_create(dev_num); if (gsc->gsc_fd < 0) { ALOGE("%s::m_gsc_m2m_create(%i) fail", __func__, dev_num); goto err; } } else { ALOGE("%s::Unsupported Mode(%i) fail", __func__, dev_num); goto err; } Exynos_gsc_Out(); return reinterpret_cast(gsc); err: switch (mode) { case GSC_M2M_MODE: gsc->m_gsc_m2m_destroy(gsc); break; } delete(gsc); Exynos_gsc_Out(); return NULL; } void exynos_gsc_destroy(void *handle) { Exynos_gsc_In(); CGscaler* gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return; } if (gsc->mode == GSC_M2M_MODE) gsc->m_gsc_m2m_destroy(gsc); delete(gsc); Exynos_gsc_Out(); } int exynos_gsc_set_csc_property( void *handle, unsigned int eq_auto, unsigned int range_full, unsigned int v4l2_colorspace) { Exynos_gsc_In(); CGscaler *gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } if (gsc->gsc_id >= HW_SCAL0) { int ret; ret = exynos_sc_csc_exclusive(gsc->scaler, range_full, v4l2_colorspace); Exynos_gsc_Out(); return ret; } gsc->eq_auto = eq_auto; gsc->range_full = range_full; gsc->v4l2_colorspace = v4l2_colorspace; Exynos_gsc_Out(); return 0; } 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(); CGscaler *gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } gsc->src_info.width = width; gsc->src_info.height = height; gsc->src_info.crop_left = crop_left; gsc->src_info.crop_top = crop_top; gsc->src_info.crop_width = crop_width; gsc->src_info.crop_height = crop_height; gsc->src_info.v4l2_colorformat = v4l2_colorformat; gsc->src_info.cacheable = cacheable; gsc->src_info.mode_drm = mode_drm; gsc->src_info.dirty = true; 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) { Exynos_gsc_In(); CGscaler *gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } gsc->dst_info.width = width; gsc->dst_info.height = height; gsc->dst_info.crop_left = crop_left; gsc->dst_info.crop_top = crop_top; gsc->dst_info.crop_width = crop_width; gsc->dst_info.crop_height = crop_height; gsc->dst_info.v4l2_colorformat = v4l2_colorformat; gsc->dst_info.dirty = true; gsc->dst_info.cacheable = cacheable; gsc->dst_info.mode_drm = mode_drm; Exynos_gsc_Out(); return 0; } int exynos_gsc_set_rotation( void *handle, int rotation, int flip_horizontal, int flip_vertical) { CGscaler *gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } int new_rotation = rotation % 360; if (new_rotation % 90 != 0) { ALOGE("%s::rotation(%d) cannot be acceptable fail", __func__, rotation); return -1; } if(new_rotation < 0) new_rotation = -new_rotation; gsc->dst_info.rotation = new_rotation; gsc->dst_info.flip_horizontal = flip_horizontal; gsc->dst_info.flip_vertical = flip_vertical; return 0; } int exynos_gsc_set_src_addr( void *handle, void *addr[3], int mem_type, int acquireFenceFd) { Exynos_gsc_In(); CGscaler* gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } gsc->src_info.buf.addr[0] = addr[0]; gsc->src_info.buf.addr[1] = addr[1]; gsc->src_info.buf.addr[2] = addr[2]; gsc->src_info.acquireFenceFd = acquireFenceFd; gsc->src_info.buf.mem_type = (enum v4l2_memory)mem_type; Exynos_gsc_Out(); return 0; } int exynos_gsc_set_dst_addr( void *handle, void *addr[3], int mem_type, int acquireFenceFd) { Exynos_gsc_In(); CGscaler* gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } gsc->dst_info.buf.addr[0] = addr[0]; gsc->dst_info.buf.addr[1] = addr[1]; gsc->dst_info.buf.addr[2] = addr[2]; gsc->dst_info.acquireFenceFd = acquireFenceFd; gsc->dst_info.buf.mem_type = (enum v4l2_memory)mem_type; Exynos_gsc_Out(); return 0; } int exynos_gsc_convert(void *handle) { Exynos_gsc_In(); int ret = -1; CGscaler* gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return ret; } if (gsc->m_gsc_m2m_run_core(handle) < 0) { ALOGE("%s::exynos_gsc_run_core fail", __func__); goto done; } if (gsc->m_gsc_m2m_wait_frame_done(handle) < 0) { ALOGE("%s::exynos_gsc_m2m_wait_frame_done", __func__); goto done; } if (gsc->src_info.releaseFenceFd >= 0) { close(gsc->src_info.releaseFenceFd); gsc->src_info.releaseFenceFd = -1; } if (gsc->dst_info.releaseFenceFd >= 0) { close(gsc->dst_info.releaseFenceFd); gsc->dst_info.releaseFenceFd = -1; } if (gsc->m_gsc_m2m_stop(handle) < 0) { ALOGE("%s::m_gsc_m2m_stop", __func__); goto done; } ret = 0; done: Exynos_gsc_Out(); return ret; } int exynos_gsc_subdev_s_crop(void *handle, exynos_mpp_img __UNUSED__ *src_img, exynos_mpp_img *dst_img) { struct v4l2_subdev_crop sd_crop; CGscaler *gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } sd_crop.pad = GSCALER_SUBDEV_PAD_SOURCE; sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE; sd_crop.rect.left = dst_img->x; sd_crop.rect.top = dst_img->y; sd_crop.rect.width = dst_img->w; sd_crop.rect.height = dst_img->h; return exynos_subdev_s_crop(gsc->mdev.gsc_sd_entity->fd, &sd_crop); } int exynos_gsc_config_exclusive(void *handle, exynos_mpp_img *src_img, exynos_mpp_img *dst_img) { Exynos_gsc_In(); int ret = 0; CGscaler* gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } if (gsc->gsc_id >= HW_SCAL0) { ret = exynos_sc_config_exclusive(gsc->scaler, (exynos_sc_img *)src_img, (exynos_sc_img *)dst_img); Exynos_gsc_Out(); return ret; } switch (gsc->mode) { case GSC_M2M_MODE: ret = gsc->m_gsc_m2m_config(handle, src_img, dst_img); break; case GSC_OUTPUT_MODE: ret = gsc->m_gsc_out_config(handle, src_img, dst_img); break; case GSC_CAPTURE_MODE: ret = gsc->m_gsc_cap_config(handle, src_img, dst_img); break; default: break; } Exynos_gsc_Out(); return ret; } int exynos_gsc_run_exclusive(void *handle, exynos_mpp_img *src_img, exynos_mpp_img *dst_img) { Exynos_gsc_In(); int ret = 0; CGscaler* gsc = GetGscaler(handle); if (handle == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } if (gsc->gsc_id >= HW_SCAL0) { ret = exynos_sc_run_exclusive(gsc->scaler, (exynos_sc_img *)src_img, (exynos_sc_img *)dst_img); Exynos_gsc_Out(); return ret; } switch (gsc->mode) { case GSC_M2M_MODE: ret = gsc->m_gsc_m2m_run(handle, src_img, dst_img); break; case GSC_OUTPUT_MODE: ret = gsc->m_gsc_out_run(handle, src_img); break; case GSC_CAPTURE_MODE: ret = gsc->m_gsc_cap_run(handle, dst_img); break; default: break; } Exynos_gsc_Out(); return ret; } void *exynos_gsc_create_blend_exclusive(int dev_num, int mode, int out_mode, int allow_drm) { Exynos_gsc_In(); if ((dev_num < 0) || (dev_num >= HW_SCAL_MAX)) { ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num); return NULL; } if ((dev_num >= NUM_OF_GSC_HW) && (dev_num < HW_SCAL_MAX)) { CGscaler *gsc = new CGscaler(mode, out_mode, dev_num, allow_drm); if (!gsc) { ALOGE("%s:: failed to allocate Gscaler handle", __func__); return NULL; } gsc->scaler = exynos_sc_create_blend_exclusive(dev_num - HW_SCAL0, allow_drm); if (!gsc->scaler) { Exynos_gsc_Out(); delete(gsc); ALOGE("%s::exynos_sc_create_blend_exclusive failed", __func__); return NULL; } Exynos_gsc_Out(); return reinterpret_cast(gsc); } Exynos_gsc_Out(); return NULL; } int exynos_gsc_config_blend_exclusive(void *handle, exynos_mpp_img *src_img, exynos_mpp_img *dst_img, struct SrcBlendInfo *srcblendinfo) { Exynos_gsc_In(); int ret = 0; CGscaler* gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } if (gsc->gsc_id >= HW_SCAL0) { ret = exynos_sc_config_blend_exclusive(gsc->scaler, (exynos_sc_img *)src_img, (exynos_sc_img *)dst_img, srcblendinfo); Exynos_gsc_Out(); return ret; } Exynos_gsc_Out(); return ret; } int exynos_gsc_wait_frame_done_exclusive(void *handle) { Exynos_gsc_In(); int ret = 0; CGscaler* gsc = GetGscaler(handle); if (handle == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } if (gsc->gsc_id >= HW_SCAL0) { ret = exynos_sc_wait_frame_done_exclusive(gsc->scaler); Exynos_gsc_Out(); return ret; } if (gsc->mode == GSC_M2M_MODE) ret = gsc->m_gsc_m2m_wait_frame_done(handle); Exynos_gsc_Out(); return ret; } int exynos_gsc_stop_exclusive(void *handle) { Exynos_gsc_In(); int ret = 0; CGscaler* gsc = GetGscaler(handle); if (handle == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } if (gsc->gsc_id >= HW_SCAL0) { ret = exynos_sc_stop_exclusive(gsc->scaler); Exynos_gsc_Out(); return ret; } switch (gsc->mode) { case GSC_M2M_MODE: ret = gsc->m_gsc_m2m_stop(handle); break; default: break; } Exynos_gsc_Out(); return ret; } int exynos_gsc_free_and_close(void *handle) { Exynos_gsc_In(); struct v4l2_requestbuffers reqbuf; int ret = 0; CGscaler* gsc = GetGscaler(handle); if (gsc == NULL) { ALOGE("%s::handle == NULL() fail", __func__); return -1; } if (gsc->gsc_id >= HW_SCAL0) { ret = exynos_sc_free_and_close(gsc->scaler); Exynos_gsc_Out(); return ret; } memset(&reqbuf, 0, sizeof(struct v4l2_requestbuffers)); if (gsc->mode == GSC_OUTPUT_MODE) reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; else reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; reqbuf.memory = V4L2_MEMORY_DMABUF; reqbuf.count = 0; if (ioctl(gsc->mdev.gsc_vd_entity->fd, VIDIOC_REQBUFS, &reqbuf) < 0) { ALOGE("%s::request buffers failed", __func__); return -1; } exynos_gsc_destroy(gsc); Exynos_gsc_Out(); return 0; }