rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/hardware/google/graphics/common/libscaler/libscaler.cpp

766 lines
19 KiB
C++
Raw Blame History

/*
* 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 libscaler.cpp
* \brief source file for Scaler HAL
* \author Sunyoung Kang (sy0816.kang@samsung.com)
* \date 2013/02/01
*
* <b>Revision History: </b>
* - 2013.02.01 : Sunyoung Kang (sy0816.kang@samsung.com) \n
* Create
* - 2013.04.10 : Cho KyongHo (pullip.cho@samsung.com) \n
* Refactoring
*
*/
#include <sys/types.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <system/graphics.h>
#include "exynos_scaler.h"
#include "libscaler-common.h"
#include "libscalerblend-v4l2.h"
#include "libscaler-v4l2.h"
#include "libscaler-m2m1shot.h"
int hal_pixfmt_to_v4l2(int hal_pixel_format)
{
int v4l2_pixel_format = -1;
switch (hal_pixel_format) {
case HAL_PIXEL_FORMAT_RGBA_8888:
case HAL_PIXEL_FORMAT_RGBX_8888:
v4l2_pixel_format = V4L2_PIX_FMT_RGB32;
break;
case HAL_PIXEL_FORMAT_RGB_888:
v4l2_pixel_format = V4L2_PIX_FMT_RGB24;
break;
case HAL_PIXEL_FORMAT_RGB_565:
v4l2_pixel_format = V4L2_PIX_FMT_RGB565;
break;
case HAL_PIXEL_FORMAT_BGRA_8888:
v4l2_pixel_format = V4L2_PIX_FMT_BGR32;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YV12_M:
v4l2_pixel_format = V4L2_PIX_FMT_YVU420M;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_P_M:
v4l2_pixel_format = V4L2_PIX_FMT_YUV420M;
break;
case HAL_PIXEL_FORMAT_YV12:
v4l2_pixel_format = V4L2_PIX_FMT_YVU420;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_P:
v4l2_pixel_format = V4L2_PIX_FMT_YUV420;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_PN:
v4l2_pixel_format = V4L2_PIX_FMT_YUV420N;
break;
case HAL_PIXEL_FORMAT_YCbCr_422_SP:
v4l2_pixel_format = V4L2_PIX_FMT_NV16;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP:
v4l2_pixel_format = V4L2_PIX_FMT_NV12;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN:
v4l2_pixel_format = V4L2_PIX_FMT_NV12N;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M:
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_PRIV:
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_S10B:
v4l2_pixel_format = V4L2_PIX_FMT_NV12M;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN_S10B:
v4l2_pixel_format = V4L2_PIX_FMT_NV12N_10B;
break;
case HAL_PIXEL_FORMAT_YCbCr_422_I:
v4l2_pixel_format = V4L2_PIX_FMT_YUYV;
break;
case HAL_PIXEL_FORMAT_EXYNOS_CbYCrY_422_I:
v4l2_pixel_format = V4L2_PIX_FMT_UYVY;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_422_SP:
v4l2_pixel_format = V4L2_PIX_FMT_NV61;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M:
case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL:
v4l2_pixel_format = V4L2_PIX_FMT_NV21M;
break;
case HAL_PIXEL_FORMAT_YCrCb_420_SP:
v4l2_pixel_format = V4L2_PIX_FMT_NV21;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_TILED:
#ifdef USES_FIMC
v4l2_pixel_format = V4L2_PIX_FMT_NV12MT;
#else
v4l2_pixel_format = V4L2_PIX_FMT_NV12MT_16X16;
#endif
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN_TILED:
v4l2_pixel_format = V4L2_PIX_FMT_NV12NT;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_422_I:
v4l2_pixel_format = V4L2_PIX_FMT_YVYU;
break;
case HAL_PIXEL_FORMAT_EXYNOS_CrYCbY_422_I:
v4l2_pixel_format = V4L2_PIX_FMT_VYUY;
break;
case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_P010_M:
v4l2_pixel_format = V4L2_PIX_FMT_NV12M_P010;
break;
default:
ALOGE("%s::unmatched HAL_PIXEL_FORMAT color_space(0x%x)\n",
__func__, hal_pixel_format);
break;
}
return v4l2_pixel_format;
}
static bool find_pixel(unsigned int sc_pxfmt, unsigned int __out *v4l2_pxfmt)
{
const static unsigned int sc_fmt_tbl[][2] = {
{EXYNOS_SC_FMT_RGB32, V4L2_PIX_FMT_RGB32},
{EXYNOS_SC_FMT_BGR32, V4L2_PIX_FMT_BGR32},
{EXYNOS_SC_FMT_RGB565, V4L2_PIX_FMT_RGB565},
{EXYNOS_SC_FMT_RGB555X, V4L2_PIX_FMT_RGB555X},
{EXYNOS_SC_FMT_RGB444, V4L2_PIX_FMT_RGB444},
};
for (size_t i = 0; i < ARRSIZE(sc_fmt_tbl); i++) {
if (sc_pxfmt == sc_fmt_tbl[i][0]) {
*v4l2_pxfmt = sc_fmt_tbl[i][1];
return true;
}
}
SC_LOGE("Unknown format value %d", sc_pxfmt);
return false;
}
bool exynos_sc_copy_pixels(exynos_sc_pxinfo *pxinfo, int dev_num)
{
unsigned int srcfmt;
unsigned int dstfmt;
CScalerM2M1SHOT sc(dev_num);
if (!sc.Valid())
return false;
if (!find_pixel(pxinfo->src.pxfmt, &srcfmt))
return false;
if (!find_pixel(pxinfo->dst.pxfmt, &dstfmt))
return false;
if (!sc.SetSrcFormat(pxinfo->src.width, pxinfo->src.height, srcfmt))
return false;
if (!sc.SetDstFormat(pxinfo->dst.width, pxinfo->dst.height, dstfmt))
return false;
if (!sc.SetSrcCrop(pxinfo->src.crop_left, pxinfo->src.crop_top,
pxinfo->src.crop_width, pxinfo->src.crop_height))
return false;
if (!sc.SetDstCrop(pxinfo->dst.crop_left, pxinfo->dst.crop_top,
pxinfo->dst.crop_width, pxinfo->dst.crop_height))
return false;
if (!sc.SetRotate(pxinfo->rotate, pxinfo->hflip, pxinfo->vflip))
return false;
// the first argument ot CScalerM2M1SHOT.SetXXXAddr() must be void *[3]
// it is safe to pass void *[1] which is not an array actually
// because CScalerM2M1SHOT.SetAddr() just accesses the array elements
// that are used for the specified format and this function just specifies
// RGB formats with one planar.
void *addr[SC_NUM_OF_PLANES];
for (size_t i = 1; i < SC_NUM_OF_PLANES; i++)
addr[i] = NULL;
addr[0] = pxinfo->src.addr;
if (!sc.SetSrcAddr(addr, V4L2_MEMORY_USERPTR))
return false;
addr[0] = pxinfo->dst.addr;
if (!sc.SetDstAddr(addr, V4L2_MEMORY_USERPTR))
return false;
return sc.Run();
}
#ifdef SCALER_USE_M2M1SHOT
typedef CScalerM2M1SHOT CScalerNonStream;
#else
typedef CScalerV4L2 CScalerNonStream;
#endif
static CScalerNonStream *GetNonStreamScaler(void *handle)
{
if (handle == NULL) {
SC_LOGE("NULL Scaler handle");
return NULL;
}
CScalerNonStream *sc = reinterpret_cast<CScalerNonStream *>(handle);
if (!sc->Valid()) {
SC_LOGE("Invalid Scaler handle %p", handle);
return NULL;
}
return sc;
}
void *exynos_sc_create(int dev_num)
{
CScalerNonStream *sc = new CScalerNonStream(dev_num);
if (!sc) {
SC_LOGE("Failed to allocate a Scaler handle for instance %d", dev_num);
return NULL;
}
if (!sc->Valid()) {
SC_LOGE("Failed to create a Scaler handle for instance %d", dev_num);
delete sc;
return NULL;
}
return reinterpret_cast<void *>(sc);
}
int exynos_sc_destroy(void *handle)
{
int ret = 0;
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
if (!sc->Stop()) {
SC_LOGE("Failed to stop Scaler (handle %p)", handle);
ret = -1;
}
delete sc;
return ret;
}
int exynos_sc_set_csc_property(
void *handle,
unsigned int csc_range,
unsigned int v4l2_colorspace,
unsigned int filter)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
sc->SetCSCWide(csc_range);
sc->SetCSCEq(v4l2_colorspace);
sc->SetFilter(filter);
return 0;
}
int exynos_sc_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,
unsigned int premultiplied)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
sc->SetSrcPremultiplied(premultiplied != 0);
sc->SetSrcCacheable(cacheable != 0);
sc->SetDRM(mode_drm != 0);
if (!sc->SetSrcFormat(width, height, v4l2_colorformat))
return -1;
return sc->SetSrcCrop(crop_left, crop_top, crop_width, crop_height) ? 0 : -1;
}
int exynos_sc_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 premultiplied)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
sc->SetDstPremultiplied(premultiplied != 0);
sc->SetDstCacheable(cacheable != 0);
sc->SetDRM(mode_drm != 0);
if (!sc->SetDstFormat(width, height, v4l2_colorformat))
return -1;
if (!sc->SetDstCrop(crop_left, crop_top, crop_width, crop_height))
return -1;
return 0;
}
int exynos_sc_set_rotation(
void *handle,
int rot,
int flip_h,
int flip_v)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
return sc->SetRotate(rot, flip_h, flip_v) ? 0 : -1;
}
void exynos_sc_set_framerate(
void *handle,
int framerate)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return;
sc->SetFrameRate(framerate);
}
int exynos_sc_set_src_addr(
void *handle,
void *addr[SC_NUM_OF_PLANES],
int mem_type,
int __UNUSED__ acquireFenceFd)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
// acquireFenceFd is ignored by blocking mode
return sc->SetSrcAddr(addr, mem_type) ? 0 : -1;
}
int exynos_sc_set_dst_addr(
void *handle,
void *addr[SC_NUM_OF_PLANES],
int mem_type,
int __UNUSED__ acquireFenceFd)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
// acquireFenceFd is ignored by blocking mode
return sc->SetDstAddr(addr, mem_type) ? 0 : -1;
}
int exynos_sc_convert(void *handle)
{
CScalerNonStream *sc = GetNonStreamScaler(handle);
if (!sc)
return -1;
return sc->Run() ? 0 : -1;
}
static CScalerBlendV4L2 *GetScalerBlend(void *handle)
{
if (handle == NULL) {
SC_LOGE("NULL Scaler handle");
return NULL;
}
CScalerBlendV4L2 *sc = reinterpret_cast<CScalerBlendV4L2 *>(handle);
if (!sc->Valid()) {
SC_LOGE("Invalid Scaler handle %p", handle);
return NULL;
}
return sc;
}
static CScalerV4L2 *GetScaler(void *handle)
{
if (handle == NULL) {
SC_LOGE("NULL Scaler handle");
return NULL;
}
CScalerV4L2 *sc = reinterpret_cast<CScalerV4L2 *>(handle);
if (!sc->Valid()) {
SC_LOGE("Invalid Scaler handle %p", handle);
return NULL;
}
return sc;
}
void *exynos_sc_create_exclusive(
int dev_num,
int allow_drm
)
{
CScalerV4L2 *sc;
sc = new CScalerV4L2(dev_num, allow_drm);
if (!sc) {
SC_LOGE("Failed to allocate a Scaler handle for instance %d", dev_num);
return NULL;
}
if (!sc->Valid()) {
SC_LOGE("Failed to create a Scaler handle for instance %d", dev_num);
delete sc;
return NULL;
}
SC_LOGD("Scaler %d is successfully created", dev_num);
return reinterpret_cast<void *>(sc);
}
int exynos_sc_free_and_close(void *handle)
{
CScalerV4L2 *sc = GetScaler(handle);
if (!sc)
return -1;
int ret = 0;
if (!sc->Stop()) {
SC_LOGE("Failed to stop Scaler (handle %p)", handle);
ret = -1;
}
delete sc;
return ret;
}
int exynos_sc_stop_exclusive(void *handle)
{
CScalerV4L2 *sc = GetScaler(handle);
if (!sc)
return -1;
if (!sc->Stop()) {
SC_LOGE("Failed to stop Scaler (handle %p)", handle);
return -1;
}
return 0;
}
int exynos_sc_csc_exclusive(void *handle,
unsigned int range_full,
unsigned int v4l2_colorspace)
{
CScalerV4L2 *sc = GetScaler(handle);
if (!sc)
return -1;
sc->SetCSCWide(range_full);
sc->SetCSCEq(v4l2_colorspace);
return 0;
}
int exynos_sc_config_exclusive(
void *handle,
exynos_sc_img *src_img,
exynos_sc_img *dst_img)
{
CScalerV4L2 *sc = GetScaler(handle);
if (!sc)
return -1;
if (src_img->drmMode && !sc->IsDRMAllowed()) {
SC_LOGE("Invalid DRM state request for Scaler%d (s=%d d=%d)",
sc->GetScalerID(), src_img->drmMode, dst_img->drmMode);
return -1;
}
unsigned int rot = 0;
unsigned int flip_h = 0;
unsigned int flip_v = 0;
if (dst_img->rot == HAL_TRANSFORM_ROT_270) {
rot = 270;
} else {
if (dst_img->rot & HAL_TRANSFORM_FLIP_H)
flip_h = 1;
if (dst_img->rot & HAL_TRANSFORM_FLIP_V)
flip_v = 1;
if (dst_img->rot & HAL_TRANSFORM_ROT_90)
rot = 90;
}
if (!sc->SetRotate(rot, flip_h, flip_v)) {
SC_LOGE("Failed to set rotation degree %d, hflip %d, vflip %d",
rot, flip_h, flip_v);
return -1;
}
int32_t src_color_space = hal_pixfmt_to_v4l2(src_img->format);
int32_t dst_color_space = hal_pixfmt_to_v4l2(dst_img->format);
if (!sc->SetSrcFormat(src_img->fw, src_img->fh, src_color_space))
return -1;
if (!sc->SetSrcCrop(src_img->x, src_img->y, src_img->w, src_img->h))
return -1;
if (!sc->SetDstFormat(dst_img->fw, dst_img->fh, dst_color_space))
return -1;
if (!sc->SetDstCrop(dst_img->x, dst_img->y, dst_img->w, dst_img->h))
return -1;
sc->SetCSCWide(!dst_img->narrowRgb);
sc->SetSrcCacheable(src_img->cacheable != 0);
sc->SetDstCacheable(dst_img->cacheable != 0);
sc->SetSrcPremultiplied(src_img->pre_multi);
sc->SetDstPremultiplied(dst_img->pre_multi);
sc->SetDRM(src_img->drmMode != 0 || dst_img->drmMode != 0);
return 0;
}
int exynos_sc_run_exclusive(
void *handle,
exynos_sc_img *src_img,
exynos_sc_img *dst_img)
{
CScalerV4L2 *sc = GetScaler(handle);
if (!sc)
return -1;
void *addr[SC_NUM_OF_PLANES];
addr[0] = (void *)src_img->yaddr;
addr[1] = (void *)src_img->uaddr;
addr[2] = (void *)src_img->vaddr;
sc->SetSrcAddr(addr, src_img->mem_type, src_img->acquireFenceFd);
addr[0] = (void *)dst_img->yaddr;
addr[1] = (void *)dst_img->uaddr;
addr[2] = (void *)dst_img->vaddr;
sc->SetDstAddr(addr, dst_img->mem_type, dst_img->acquireFenceFd);
if (!sc->DevSetCtrl())
return -1;
if (!sc->DevSetFormat())
return -1;
if (!sc->ReqBufs())
return -1;
int fdSrcReleaseFence, fdDstReleaseFence;
if (!sc->QBuf(&fdSrcReleaseFence, &fdDstReleaseFence))
return -1;
if (!sc->StreamOn()) {
close(fdSrcReleaseFence);
close(fdDstReleaseFence);
return -1;
}
src_img->releaseFenceFd = fdSrcReleaseFence;
dst_img->releaseFenceFd = fdDstReleaseFence;
return 0;
}
void *exynos_sc_create_blend_exclusive(
int dev_num,
int allow_drm
)
{
CScalerBlendV4L2 *sc;
sc = new CScalerBlendV4L2(dev_num, allow_drm);
if (!sc) {
SC_LOGE("Failed to allocate a Scaler blend handle for instance %d", dev_num);
return NULL;
}
if (!sc->Valid()) {
SC_LOGE("Failed to create a Scaler blend handle for instance %d", dev_num);
delete sc;
return NULL;
}
SC_LOGD("Scaler blend %d is successfully created", dev_num);
return reinterpret_cast<void *>(sc);
}
int exynos_sc_config_blend_exclusive(
void *handle,
exynos_sc_img *src_img,
exynos_sc_img *dst_img,
struct SrcBlendInfo *srcblendinfo)
{
CScalerBlendV4L2 *sc = GetScalerBlend(handle);
if (!sc)
return -1;
if (src_img->drmMode && !sc->IsDRMAllowed()) {
SC_LOGE("Invalid DRM state request for Scaler%d (s=%d d=%d)",
sc->GetScalerID(), src_img->drmMode, dst_img->drmMode);
return -1;
}
unsigned int rot = 0;
unsigned int flip_h = 0;
unsigned int flip_v = 0;
if (dst_img->rot == HAL_TRANSFORM_ROT_270) {
rot = 270;
} else {
if (dst_img->rot & HAL_TRANSFORM_FLIP_H)
flip_h = 1;
if (dst_img->rot & HAL_TRANSFORM_FLIP_V)
flip_v = 1;
if (dst_img->rot & HAL_TRANSFORM_ROT_90)
rot = 90;
}
if (!sc->SetRotate(rot, flip_h, flip_v)) {
SC_LOGE("Failed to set rotation degree %d, hflip %d, vflip %d",
rot, flip_h, flip_v);
return -1;
}
int32_t src_color_space = hal_pixfmt_to_v4l2(src_img->format);
int32_t dst_color_space = hal_pixfmt_to_v4l2(dst_img->format);
int32_t src_blend_color_space = hal_pixfmt_to_v4l2(srcblendinfo->srcblendfmt);
sc->GetCustomAlphaBlendFmt(src_color_space, src_blend_color_space);
if (src_color_space < 0) {
SC_LOGE("src blending format not supported");
return -1;
}
sc->SetSrcBlendOp(srcblendinfo->blop);
sc->SetSrcGlobalAlpha(srcblendinfo->globalalpha.val,
srcblendinfo->globalalpha.enable);
sc->SetSrcBlendVPos(srcblendinfo->srcblendvpos);
sc->SetSrcBlendHPos(srcblendinfo->srcblendhpos);
sc->SetSrcBlendPremulti(srcblendinfo->srcblendpremulti);
sc->SetSrcBlendFmt(src_blend_color_space);
sc->SetSrcBlendStride(srcblendinfo->srcblendstride);
sc->SetSrcBlendWidth(srcblendinfo->srcblendwidth);
sc->SetSrcBlendHeight(srcblendinfo->srcblendheight);
sc->SetSrcBlendCSCSpace(srcblendinfo->cscspec.enable,
srcblendinfo->cscspec.space,
srcblendinfo->cscspec.wide);
if (!sc->SetSrcFormat(src_img->fw, src_img->fh, src_color_space))
return -1;
if (!sc->SetSrcCrop(src_img->x, src_img->y, src_img->w, src_img->h))
return -1;
if (!sc->SetDstFormat(dst_img->fw, dst_img->fh, dst_color_space))
return -1;
if (!sc->SetDstCrop(dst_img->x, dst_img->y, dst_img->w, dst_img->h))
return -1;
sc->SetSrcCacheable(src_img->cacheable != 0);
sc->SetDstCacheable(dst_img->cacheable != 0);
sc->SetDRM(src_img->drmMode != 0 || dst_img->drmMode != 0);
return 0;
}
int exynos_sc_wait_frame_done_exclusive(
void *handle)
{
CScalerV4L2 *sc = GetScaler(handle);
if (!sc)
return -1;
return sc->DQBuf() ? 0 : -1;
}
Reference in New Issue View Git Blame Copy Permalink