928 lines
20 KiB
C
928 lines
20 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) Rockchip Electronics Co., Ltd.
|
|
*
|
|
* Author: Cerf Yu <cerf.yu@rock-chips.com>
|
|
*/
|
|
|
|
#include "rga.h"
|
|
#include "rga_common.h"
|
|
|
|
bool rga_is_rgb_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_RGBA_8888:
|
|
case RGA_FORMAT_RGBX_8888:
|
|
case RGA_FORMAT_RGB_888:
|
|
case RGA_FORMAT_BGRA_8888:
|
|
case RGA_FORMAT_BGRX_8888:
|
|
case RGA_FORMAT_BGR_888:
|
|
case RGA_FORMAT_RGB_565:
|
|
case RGA_FORMAT_RGBA_5551:
|
|
case RGA_FORMAT_RGBA_4444:
|
|
case RGA_FORMAT_BGR_565:
|
|
case RGA_FORMAT_BGRA_5551:
|
|
case RGA_FORMAT_BGRA_4444:
|
|
case RGA_FORMAT_ARGB_8888:
|
|
case RGA_FORMAT_XRGB_8888:
|
|
case RGA_FORMAT_ARGB_5551:
|
|
case RGA_FORMAT_ARGB_4444:
|
|
case RGA_FORMAT_ABGR_8888:
|
|
case RGA_FORMAT_XBGR_8888:
|
|
case RGA_FORMAT_ABGR_5551:
|
|
case RGA_FORMAT_ABGR_4444:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_Y4:
|
|
case RGA_FORMAT_Y8:
|
|
case RGA_FORMAT_YCbCr_400:
|
|
|
|
case RGA_FORMAT_YCbCr_422_SP:
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
case RGA_FORMAT_YCbCr_420_SP:
|
|
case RGA_FORMAT_YCbCr_420_P:
|
|
case RGA_FORMAT_YCrCb_422_SP:
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
case RGA_FORMAT_YCrCb_420_SP:
|
|
case RGA_FORMAT_YCrCb_420_P:
|
|
|
|
case RGA_FORMAT_YVYU_422:
|
|
case RGA_FORMAT_YVYU_420:
|
|
case RGA_FORMAT_VYUY_422:
|
|
case RGA_FORMAT_VYUY_420:
|
|
case RGA_FORMAT_YUYV_422:
|
|
case RGA_FORMAT_YUYV_420:
|
|
case RGA_FORMAT_UYVY_422:
|
|
case RGA_FORMAT_UYVY_420:
|
|
|
|
case RGA_FORMAT_YCbCr_420_SP_10B:
|
|
case RGA_FORMAT_YCrCb_420_SP_10B:
|
|
case RGA_FORMAT_YCbCr_422_SP_10B:
|
|
case RGA_FORMAT_YCrCb_422_SP_10B:
|
|
|
|
case RGA_FORMAT_YCbCr_444_SP:
|
|
case RGA_FORMAT_YCrCb_444_SP:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_alpha_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_RGBA_8888:
|
|
case RGA_FORMAT_BGRA_8888:
|
|
case RGA_FORMAT_RGBA_5551:
|
|
case RGA_FORMAT_RGBA_4444:
|
|
case RGA_FORMAT_BGRA_5551:
|
|
case RGA_FORMAT_BGRA_4444:
|
|
case RGA_FORMAT_ARGB_8888:
|
|
case RGA_FORMAT_ARGB_5551:
|
|
case RGA_FORMAT_ARGB_4444:
|
|
case RGA_FORMAT_ABGR_8888:
|
|
case RGA_FORMAT_ABGR_5551:
|
|
case RGA_FORMAT_ABGR_4444:
|
|
|
|
case RGA_FORMAT_A8:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv420_packed_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YVYU_420:
|
|
case RGA_FORMAT_VYUY_420:
|
|
case RGA_FORMAT_YUYV_420:
|
|
case RGA_FORMAT_UYVY_420:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv420_planar_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YCbCr_420_P:
|
|
case RGA_FORMAT_YCrCb_420_P:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv420_semi_planar_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YCbCr_420_SP:
|
|
case RGA_FORMAT_YCrCb_420_SP:
|
|
case RGA_FORMAT_YCbCr_420_SP_10B:
|
|
case RGA_FORMAT_YCrCb_420_SP_10B:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv422_packed_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YVYU_422:
|
|
case RGA_FORMAT_VYUY_422:
|
|
case RGA_FORMAT_YUYV_422:
|
|
case RGA_FORMAT_UYVY_422:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv422_planar_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv422_semi_planar_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YCbCr_422_SP:
|
|
case RGA_FORMAT_YCrCb_422_SP:
|
|
case RGA_FORMAT_YCbCr_422_SP_10B:
|
|
case RGA_FORMAT_YCrCb_422_SP_10B:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv8bit_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_Y4:
|
|
case RGA_FORMAT_Y8:
|
|
case RGA_FORMAT_YCbCr_400:
|
|
|
|
case RGA_FORMAT_YCbCr_422_SP:
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
case RGA_FORMAT_YCbCr_420_SP:
|
|
case RGA_FORMAT_YCbCr_420_P:
|
|
case RGA_FORMAT_YCrCb_422_SP:
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
case RGA_FORMAT_YCrCb_420_SP:
|
|
case RGA_FORMAT_YCrCb_420_P:
|
|
|
|
case RGA_FORMAT_YVYU_422:
|
|
case RGA_FORMAT_YVYU_420:
|
|
case RGA_FORMAT_VYUY_422:
|
|
case RGA_FORMAT_VYUY_420:
|
|
case RGA_FORMAT_YUYV_422:
|
|
case RGA_FORMAT_YUYV_420:
|
|
case RGA_FORMAT_UYVY_422:
|
|
case RGA_FORMAT_UYVY_420:
|
|
|
|
case RGA_FORMAT_YCbCr_444_SP:
|
|
case RGA_FORMAT_YCrCb_444_SP:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv10bit_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YCbCr_420_SP_10B:
|
|
case RGA_FORMAT_YCrCb_420_SP_10B:
|
|
case RGA_FORMAT_YCbCr_422_SP_10B:
|
|
case RGA_FORMAT_YCrCb_422_SP_10B:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_yuv422p_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool rga_is_only_y_format(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_YCbCr_400:
|
|
case RGA_FORMAT_Y4:
|
|
case RGA_FORMAT_Y8:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const char *rga_get_format_name(uint32_t format)
|
|
{
|
|
switch (format) {
|
|
case RGA_FORMAT_RGBA_8888:
|
|
return "RGBA8888";
|
|
case RGA_FORMAT_RGBX_8888:
|
|
return "RGBX8888";
|
|
case RGA_FORMAT_RGB_888:
|
|
return "RGB888";
|
|
case RGA_FORMAT_BGRA_8888:
|
|
return "BGRA8888";
|
|
case RGA_FORMAT_BGRX_8888:
|
|
return "BGRX8888";
|
|
case RGA_FORMAT_BGR_888:
|
|
return "BGR888";
|
|
case RGA_FORMAT_RGB_565:
|
|
return "RGB565";
|
|
case RGA_FORMAT_RGBA_5551:
|
|
return "RGBA5551";
|
|
case RGA_FORMAT_RGBA_4444:
|
|
return "RGBA4444";
|
|
case RGA_FORMAT_BGR_565:
|
|
return "BGR565";
|
|
case RGA_FORMAT_BGRA_5551:
|
|
return "BGRA5551";
|
|
case RGA_FORMAT_BGRA_4444:
|
|
return "BGRA4444";
|
|
|
|
case RGA_FORMAT_YCbCr_422_SP:
|
|
return "YCbCr422SP";
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
return "YCbCr422P";
|
|
case RGA_FORMAT_YCbCr_420_SP:
|
|
return "YCbCr420SP";
|
|
case RGA_FORMAT_YCbCr_420_P:
|
|
return "YCbCr420P";
|
|
case RGA_FORMAT_YCrCb_422_SP:
|
|
return "YCrCb422SP";
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
return "YCrCb422P";
|
|
case RGA_FORMAT_YCrCb_420_SP:
|
|
return "YCrCb420SP";
|
|
case RGA_FORMAT_YCrCb_420_P:
|
|
return "YCrCb420P";
|
|
|
|
case RGA_FORMAT_YVYU_422:
|
|
return "YVYU422";
|
|
case RGA_FORMAT_YVYU_420:
|
|
return "YVYU420";
|
|
case RGA_FORMAT_VYUY_422:
|
|
return "VYUY422";
|
|
case RGA_FORMAT_VYUY_420:
|
|
return "VYUY420";
|
|
case RGA_FORMAT_YUYV_422:
|
|
return "YUYV422";
|
|
case RGA_FORMAT_YUYV_420:
|
|
return "YUYV420";
|
|
case RGA_FORMAT_UYVY_422:
|
|
return "UYVY422";
|
|
case RGA_FORMAT_UYVY_420:
|
|
return "UYVY420";
|
|
|
|
case RGA_FORMAT_YCbCr_420_SP_10B:
|
|
return "YCrCb420SP10B";
|
|
case RGA_FORMAT_YCrCb_420_SP_10B:
|
|
return "YCbCr420SP10B";
|
|
case RGA_FORMAT_YCbCr_422_SP_10B:
|
|
return "YCbCr422SP10B";
|
|
case RGA_FORMAT_YCrCb_422_SP_10B:
|
|
return "YCrCb422SP10B";
|
|
case RGA_FORMAT_BPP1:
|
|
return "BPP1";
|
|
case RGA_FORMAT_BPP2:
|
|
return "BPP2";
|
|
case RGA_FORMAT_BPP4:
|
|
return "BPP4";
|
|
case RGA_FORMAT_BPP8:
|
|
return "BPP8";
|
|
case RGA_FORMAT_YCbCr_400:
|
|
return "YCbCr400";
|
|
case RGA_FORMAT_Y4:
|
|
return "Y4";
|
|
|
|
case RGA_FORMAT_ARGB_8888:
|
|
return "ARGB8888";
|
|
case RGA_FORMAT_XRGB_8888:
|
|
return "XRGB8888";
|
|
case RGA_FORMAT_ARGB_5551:
|
|
return "ARGB5551";
|
|
case RGA_FORMAT_ARGB_4444:
|
|
return "ARGB4444";
|
|
case RGA_FORMAT_ABGR_8888:
|
|
return "ABGR8888";
|
|
case RGA_FORMAT_XBGR_8888:
|
|
return "XBGR8888";
|
|
case RGA_FORMAT_ABGR_5551:
|
|
return "ABGR5551";
|
|
case RGA_FORMAT_ABGR_4444:
|
|
return "ABGR4444";
|
|
|
|
case RGA_FORMAT_RGBA_2BPP:
|
|
return "RGBA2BPP";
|
|
|
|
case RGA_FORMAT_A8:
|
|
return "alpha-8";
|
|
case RGA_FORMAT_YCbCr_444_SP:
|
|
return "YCbCr444SP";
|
|
case RGA_FORMAT_YCrCb_444_SP:
|
|
return "YCrCb444SP";
|
|
|
|
case RGA_FORMAT_Y8:
|
|
return "Y8";
|
|
|
|
default:
|
|
return "UNF";
|
|
}
|
|
}
|
|
|
|
int rga_get_format_bits(uint32_t format)
|
|
{
|
|
int bits = 0;
|
|
|
|
switch (format) {
|
|
case RGA_FORMAT_RGBA_8888:
|
|
case RGA_FORMAT_RGBX_8888:
|
|
case RGA_FORMAT_BGRA_8888:
|
|
case RGA_FORMAT_BGRX_8888:
|
|
case RGA_FORMAT_ARGB_8888:
|
|
case RGA_FORMAT_XRGB_8888:
|
|
case RGA_FORMAT_ABGR_8888:
|
|
case RGA_FORMAT_XBGR_8888:
|
|
bits = 32;
|
|
break;
|
|
case RGA_FORMAT_RGB_888:
|
|
case RGA_FORMAT_BGR_888:
|
|
case RGA_FORMAT_YCbCr_444_SP:
|
|
case RGA_FORMAT_YCrCb_444_SP:
|
|
bits = 24;
|
|
break;
|
|
case RGA_FORMAT_RGB_565:
|
|
case RGA_FORMAT_RGBA_5551:
|
|
case RGA_FORMAT_RGBA_4444:
|
|
case RGA_FORMAT_BGR_565:
|
|
case RGA_FORMAT_BGRA_5551:
|
|
case RGA_FORMAT_BGRA_4444:
|
|
case RGA_FORMAT_ARGB_5551:
|
|
case RGA_FORMAT_ARGB_4444:
|
|
case RGA_FORMAT_ABGR_5551:
|
|
case RGA_FORMAT_ABGR_4444:
|
|
case RGA_FORMAT_YCbCr_422_SP:
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
case RGA_FORMAT_YCrCb_422_SP:
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
case RGA_FORMAT_YUYV_422:
|
|
case RGA_FORMAT_YVYU_422:
|
|
case RGA_FORMAT_UYVY_422:
|
|
case RGA_FORMAT_VYUY_422:
|
|
/* YUV 420 packed according to the arrangement of YUV422 packed. */
|
|
case RGA_FORMAT_YUYV_420:
|
|
case RGA_FORMAT_YVYU_420:
|
|
case RGA_FORMAT_UYVY_420:
|
|
case RGA_FORMAT_VYUY_420:
|
|
bits = 16;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_420_SP:
|
|
case RGA_FORMAT_YCbCr_420_P:
|
|
case RGA_FORMAT_YCrCb_420_SP:
|
|
case RGA_FORMAT_YCrCb_420_P:
|
|
bits = 12;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_420_SP_10B:
|
|
case RGA_FORMAT_YCrCb_420_SP_10B:
|
|
case RGA_FORMAT_YCbCr_422_SP_10B:
|
|
case RGA_FORMAT_YCrCb_422_SP_10B:
|
|
bits = 15;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_400:
|
|
case RGA_FORMAT_BPP8:
|
|
case RGA_FORMAT_A8:
|
|
case RGA_FORMAT_Y8:
|
|
bits = 8;
|
|
break;
|
|
case RGA_FORMAT_Y4:
|
|
case RGA_FORMAT_BPP4:
|
|
bits = 4;
|
|
break;
|
|
case RGA_FORMAT_BPP2:
|
|
bits = 2;
|
|
break;
|
|
case RGA_FORMAT_BPP1:
|
|
bits = 1;
|
|
break;
|
|
default:
|
|
rga_err("unknown format [0x%x]\n", format);
|
|
return -1;
|
|
}
|
|
|
|
return bits;
|
|
}
|
|
|
|
int rga_get_pixel_stride_from_format(uint32_t format)
|
|
{
|
|
int pixel_stride = 0;
|
|
|
|
switch (format) {
|
|
case RGA_FORMAT_RGBA_8888:
|
|
case RGA_FORMAT_RGBX_8888:
|
|
case RGA_FORMAT_BGRA_8888:
|
|
case RGA_FORMAT_BGRX_8888:
|
|
case RGA_FORMAT_ARGB_8888:
|
|
case RGA_FORMAT_XRGB_8888:
|
|
case RGA_FORMAT_ABGR_8888:
|
|
case RGA_FORMAT_XBGR_8888:
|
|
pixel_stride = 32;
|
|
break;
|
|
case RGA_FORMAT_RGB_888:
|
|
case RGA_FORMAT_BGR_888:
|
|
case RGA_FORMAT_YCbCr_444_SP:
|
|
case RGA_FORMAT_YCrCb_444_SP:
|
|
pixel_stride = 24;
|
|
break;
|
|
case RGA_FORMAT_RGB_565:
|
|
case RGA_FORMAT_RGBA_5551:
|
|
case RGA_FORMAT_RGBA_4444:
|
|
case RGA_FORMAT_BGR_565:
|
|
case RGA_FORMAT_BGRA_5551:
|
|
case RGA_FORMAT_BGRA_4444:
|
|
case RGA_FORMAT_ARGB_5551:
|
|
case RGA_FORMAT_ARGB_4444:
|
|
case RGA_FORMAT_ABGR_5551:
|
|
case RGA_FORMAT_ABGR_4444:
|
|
case RGA_FORMAT_YVYU_422:
|
|
case RGA_FORMAT_YVYU_420:
|
|
case RGA_FORMAT_VYUY_422:
|
|
case RGA_FORMAT_VYUY_420:
|
|
case RGA_FORMAT_YUYV_422:
|
|
case RGA_FORMAT_YUYV_420:
|
|
case RGA_FORMAT_UYVY_422:
|
|
case RGA_FORMAT_UYVY_420:
|
|
pixel_stride = 16;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_420_SP_10B:
|
|
case RGA_FORMAT_YCrCb_420_SP_10B:
|
|
case RGA_FORMAT_YCbCr_422_SP_10B:
|
|
case RGA_FORMAT_YCrCb_422_SP_10B:
|
|
pixel_stride = 10;
|
|
break;
|
|
case RGA_FORMAT_BPP1:
|
|
case RGA_FORMAT_BPP2:
|
|
case RGA_FORMAT_BPP4:
|
|
case RGA_FORMAT_BPP8:
|
|
case RGA_FORMAT_YCbCr_400:
|
|
case RGA_FORMAT_A8:
|
|
case RGA_FORMAT_YCbCr_420_SP:
|
|
case RGA_FORMAT_YCbCr_420_P:
|
|
case RGA_FORMAT_YCrCb_420_SP:
|
|
case RGA_FORMAT_YCrCb_420_P:
|
|
case RGA_FORMAT_YCbCr_422_SP:
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
case RGA_FORMAT_YCrCb_422_SP:
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
case RGA_FORMAT_Y8:
|
|
pixel_stride = 8;
|
|
break;
|
|
case RGA_FORMAT_Y4:
|
|
pixel_stride = 4;
|
|
break;
|
|
default:
|
|
rga_err("unknown format [0x%x]\n", format);
|
|
return -1;
|
|
}
|
|
|
|
return pixel_stride;
|
|
}
|
|
|
|
const char *rga_get_render_mode_str(uint8_t mode)
|
|
{
|
|
switch (mode) {
|
|
case 0x0:
|
|
return "bitblt";
|
|
case 0x1:
|
|
return "RGA_COLOR_PALETTE";
|
|
case 0x2:
|
|
return "RGA_COLOR_FILL";
|
|
case 0x3:
|
|
return "update_palette_table";
|
|
case 0x4:
|
|
return "update_patten_buff";
|
|
default:
|
|
return "UNF";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_store_mode_str(uint32_t mode)
|
|
{
|
|
switch (mode) {
|
|
case RGA_RASTER_MODE:
|
|
return "raster";
|
|
case RGA_FBC_MODE:
|
|
return "afbc16x16";
|
|
case RGA_TILE_MODE:
|
|
return "tile8x8";
|
|
case RGA_TILE4x4_MODE:
|
|
return "tile4x4";
|
|
case RGA_RKFBC_MODE:
|
|
return "rkfbc64x4";
|
|
case RGA_AFBC32x8_MODE:
|
|
return "afbc32x8";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_interp_str(uint8_t interp)
|
|
{
|
|
switch (interp) {
|
|
case RGA_INTERP_DEFAULT:
|
|
return "default";
|
|
case RGA_INTERP_LINEAR:
|
|
return "bi-linear";
|
|
case RGA_INTERP_BICUBIC:
|
|
return "bi-cubic";
|
|
case RGA_INTERP_AVERAGE:
|
|
return "average_filter";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_rotate_mode_str(uint8_t mode)
|
|
{
|
|
switch (mode) {
|
|
case 0x0:
|
|
return "0";
|
|
case 0x1:
|
|
return "90 degree";
|
|
case 0x2:
|
|
return "180 degree";
|
|
case 0x3:
|
|
return "270 degree";
|
|
case 0x10:
|
|
return "xmirror";
|
|
case 0x20:
|
|
return "ymirror";
|
|
case 0x30:
|
|
return "xymirror";
|
|
default:
|
|
return "UNF";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_blend_mode_str(enum rga_alpha_blend_mode mode)
|
|
{
|
|
switch (mode) {
|
|
case RGA_ALPHA_NONE:
|
|
return "no blend";
|
|
|
|
case RGA_ALPHA_BLEND_SRC:
|
|
return "src";
|
|
|
|
case RGA_ALPHA_BLEND_DST:
|
|
return "dst";
|
|
|
|
case RGA_ALPHA_BLEND_SRC_OVER:
|
|
return "src-over";
|
|
|
|
case RGA_ALPHA_BLEND_DST_OVER:
|
|
return "dst-over";
|
|
|
|
case RGA_ALPHA_BLEND_SRC_IN:
|
|
return "src-in";
|
|
|
|
case RGA_ALPHA_BLEND_DST_IN:
|
|
return "dst-in";
|
|
|
|
case RGA_ALPHA_BLEND_SRC_OUT:
|
|
return "src-out";
|
|
|
|
case RGA_ALPHA_BLEND_DST_OUT:
|
|
return "dst-out";
|
|
|
|
case RGA_ALPHA_BLEND_SRC_ATOP:
|
|
return "src-atop";
|
|
|
|
case RGA_ALPHA_BLEND_DST_ATOP:
|
|
return "dst-atop";
|
|
|
|
case RGA_ALPHA_BLEND_XOR:
|
|
return "xor";
|
|
|
|
case RGA_ALPHA_BLEND_CLEAR:
|
|
return "clear";
|
|
|
|
default:
|
|
return "check reg for more imformation";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_memory_type_str(uint8_t type)
|
|
{
|
|
switch (type) {
|
|
case RGA_DMA_BUFFER:
|
|
return "dma_fd";
|
|
case RGA_VIRTUAL_ADDRESS:
|
|
return "virt_addr";
|
|
case RGA_PHYSICAL_ADDRESS:
|
|
return "phys_addr";
|
|
case RGA_DMA_BUFFER_PTR:
|
|
return "dma_buf_ptr";
|
|
default:
|
|
return "UNF";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_mmu_type_str(enum rga_mmu mmu_type)
|
|
{
|
|
switch (mmu_type) {
|
|
case RGA_MMU:
|
|
return "RGA_MMU";
|
|
case RGA_IOMMU:
|
|
return "RK_IOMMU";
|
|
default:
|
|
return "NONE_MMU";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_dma_data_direction_str(enum dma_data_direction dir)
|
|
{
|
|
switch (dir) {
|
|
case DMA_BIDIRECTIONAL:
|
|
return "bidirectional";
|
|
case DMA_TO_DEVICE:
|
|
return "to_device";
|
|
case DMA_FROM_DEVICE:
|
|
return "from_device";
|
|
case DMA_NONE:
|
|
return "none";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
const char *rga_get_core_name(enum RGA_SCHEDULER_CORE core)
|
|
{
|
|
switch (core) {
|
|
case RGA3_SCHEDULER_CORE0:
|
|
return "RGA3_core0";
|
|
case RGA3_SCHEDULER_CORE1:
|
|
return "RGA3_core1";
|
|
case RGA2_SCHEDULER_CORE0:
|
|
return "RGA2_core0";
|
|
case RGA2_SCHEDULER_CORE1:
|
|
return "RGA2_core1";
|
|
default:
|
|
return "unknown_core";
|
|
}
|
|
}
|
|
|
|
void rga_convert_addr(struct rga_img_info_t *img, bool before_vir_get_channel)
|
|
{
|
|
/*
|
|
* If it is not using dma fd, the virtual/phyical address is assigned
|
|
* to the address of the corresponding channel.
|
|
*/
|
|
|
|
//img->yrgb_addr = img->uv_addr;
|
|
|
|
/*
|
|
* if before_vir_get_channel is true, then convert addr by default
|
|
* when has iova (before_vir_get_channel is false),
|
|
* need to consider whether fbc case
|
|
*/
|
|
if (img->rd_mode != RGA_FBC_MODE || before_vir_get_channel) {
|
|
img->uv_addr = img->yrgb_addr + (img->vir_w * img->vir_h);
|
|
|
|
//warning: rga3 may need /2 for all
|
|
if (rga_is_yuv422p_format(img->format))
|
|
img->v_addr =
|
|
img->uv_addr + (img->vir_w * img->vir_h) / 2;
|
|
else
|
|
img->v_addr =
|
|
img->uv_addr + (img->vir_w * img->vir_h) / 4;
|
|
} else {
|
|
img->uv_addr = img->yrgb_addr;
|
|
img->v_addr = 0;
|
|
}
|
|
}
|
|
|
|
void rga_swap_pd_mode(struct rga_req *req_rga)
|
|
{
|
|
if (((req_rga->alpha_rop_flag) & 1)) {
|
|
if ((req_rga->alpha_rop_flag >> 3) & 1) {
|
|
if (req_rga->PD_mode == 1)
|
|
req_rga->PD_mode = 2;
|
|
else if (req_rga->PD_mode == 2)
|
|
req_rga->PD_mode = 1;
|
|
else if (req_rga->PD_mode == 3)
|
|
req_rga->PD_mode = 4;
|
|
else if (req_rga->PD_mode == 4)
|
|
req_rga->PD_mode = 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
int rga_image_size_cal(int w, int h, int format,
|
|
int *yrgb_size, int *uv_size, int *v_size)
|
|
{
|
|
int yrgb = 0;
|
|
int uv = 0;
|
|
int v = 0;
|
|
|
|
switch (format) {
|
|
case RGA_FORMAT_RGBA_8888:
|
|
case RGA_FORMAT_RGBX_8888:
|
|
case RGA_FORMAT_BGRA_8888:
|
|
case RGA_FORMAT_BGRX_8888:
|
|
case RGA_FORMAT_ARGB_8888:
|
|
case RGA_FORMAT_XRGB_8888:
|
|
case RGA_FORMAT_ABGR_8888:
|
|
case RGA_FORMAT_XBGR_8888:
|
|
yrgb = w * h * 4;
|
|
break;
|
|
case RGA_FORMAT_RGB_888:
|
|
case RGA_FORMAT_BGR_888:
|
|
yrgb = w * h * 3;
|
|
break;
|
|
case RGA_FORMAT_RGB_565:
|
|
case RGA_FORMAT_RGBA_5551:
|
|
case RGA_FORMAT_RGBA_4444:
|
|
case RGA_FORMAT_BGR_565:
|
|
case RGA_FORMAT_BGRA_5551:
|
|
case RGA_FORMAT_BGRA_4444:
|
|
case RGA_FORMAT_ARGB_5551:
|
|
case RGA_FORMAT_ARGB_4444:
|
|
case RGA_FORMAT_ABGR_5551:
|
|
case RGA_FORMAT_ABGR_4444:
|
|
case RGA_FORMAT_YVYU_422:
|
|
case RGA_FORMAT_VYUY_422:
|
|
case RGA_FORMAT_YUYV_422:
|
|
case RGA_FORMAT_UYVY_422:
|
|
/* YUV 420 packed according to the arrangement of YUV422 packed. */
|
|
case RGA_FORMAT_YVYU_420:
|
|
case RGA_FORMAT_VYUY_420:
|
|
case RGA_FORMAT_YUYV_420:
|
|
case RGA_FORMAT_UYVY_420:
|
|
yrgb = w * h * 2;
|
|
break;
|
|
/* YUV FORMAT */
|
|
case RGA_FORMAT_YCbCr_444_SP:
|
|
case RGA_FORMAT_YCrCb_444_SP:
|
|
yrgb = w * h;
|
|
uv = w * h;
|
|
v = w * h;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_422_SP:
|
|
case RGA_FORMAT_YCrCb_422_SP:
|
|
/* 10bit format stride is externally configured. */
|
|
case RGA_FORMAT_YCbCr_422_SP_10B:
|
|
case RGA_FORMAT_YCrCb_422_SP_10B:
|
|
yrgb = w * h;
|
|
uv = w * h;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_422_P:
|
|
case RGA_FORMAT_YCrCb_422_P:
|
|
yrgb = w * h;
|
|
uv = (w * h) >> 1;
|
|
v = uv;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_420_SP:
|
|
case RGA_FORMAT_YCrCb_420_SP:
|
|
/* 10bit format stride is externally configured. */
|
|
case RGA_FORMAT_YCbCr_420_SP_10B:
|
|
case RGA_FORMAT_YCrCb_420_SP_10B:
|
|
yrgb = w * h;
|
|
uv = (w * h) >> 1;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_420_P:
|
|
case RGA_FORMAT_YCrCb_420_P:
|
|
yrgb = w * h;
|
|
uv = (w * h) >> 2;
|
|
v = uv;
|
|
break;
|
|
case RGA_FORMAT_YCbCr_400:
|
|
case RGA_FORMAT_A8:
|
|
case RGA_FORMAT_Y8:
|
|
yrgb = w * h;
|
|
break;
|
|
case RGA_FORMAT_Y4:
|
|
yrgb = (w * h) >> 1;
|
|
break;
|
|
default:
|
|
rga_err("Unsuport format [0x%x]\n", format);
|
|
return -EFAULT;
|
|
}
|
|
|
|
if (yrgb_size != NULL)
|
|
*yrgb_size = yrgb;
|
|
if (uv_size != NULL)
|
|
*uv_size = uv;
|
|
if (v_size != NULL)
|
|
*v_size = v;
|
|
|
|
return (yrgb + uv + v);
|
|
}
|
|
|
|
void rga_dump_memory_parm(struct rga_memory_parm *parm)
|
|
{
|
|
rga_log("memory param: w = %d, h = %d, f = %s(0x%x), size = %d\n",
|
|
parm->width, parm->height, rga_get_format_name(parm->format),
|
|
parm->format, parm->size);
|
|
}
|
|
|
|
void rga_dump_external_buffer(struct rga_external_buffer *buffer)
|
|
{
|
|
rga_log("external: memory = 0x%lx, type = %s\n",
|
|
(unsigned long)buffer->memory, rga_get_memory_type_str(buffer->type));
|
|
rga_dump_memory_parm(&buffer->memory_parm);
|
|
}
|
|
|
|
static void rga_dump_image_info(struct rga_request *request, const char *name,
|
|
struct rga_img_info_t *img, uint8_t handle_flag, int need_mmu)
|
|
{
|
|
if (handle_flag) {
|
|
if (img->uv_addr && img->v_addr)
|
|
rga_req_log(request, "%s: handle[y,uv,v] = [%ld(%#lx), %ld(%#lx), %ld(%#lx)], mode = %s\n",
|
|
name,
|
|
(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
|
|
(unsigned long)img->uv_addr, (unsigned long)img->uv_addr,
|
|
(unsigned long)img->v_addr, (unsigned long)img->v_addr,
|
|
rga_get_store_mode_str(img->rd_mode));
|
|
else if (img->uv_addr)
|
|
rga_req_log(request, "%s: handle[y,uv] = [%ld(%#lx), %ld(%#lx)], mode = %s\n",
|
|
name,
|
|
(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
|
|
(unsigned long)img->uv_addr, (unsigned long)img->uv_addr,
|
|
rga_get_store_mode_str(img->rd_mode));
|
|
else
|
|
rga_req_log(request, "%s: handle = %ld(%#lx), mode = %s\n",
|
|
name,
|
|
(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
|
|
rga_get_store_mode_str(img->rd_mode));
|
|
} else {
|
|
if (img->yrgb_addr)
|
|
rga_req_log(request, "%s: fd = %ld(%#lx), mode = %s\n",
|
|
name,
|
|
(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
|
|
rga_get_store_mode_str(img->rd_mode));
|
|
else if (img->uv_addr)
|
|
rga_req_log(request, "%s: %s = %#lx, mode = %s\n",
|
|
name,
|
|
need_mmu ? "virt_addr" : "phys_addr", (unsigned long)img->uv_addr,
|
|
rga_get_store_mode_str(img->rd_mode));
|
|
}
|
|
|
|
rga_req_log(request, "%s: rect[x,y,w,h] = [%d, %d, %d, %d], stride[w,h] = [%d, %d], format = %s(%#x)\n",
|
|
name,
|
|
img->x_offset, img->y_offset, img->act_w, img->act_h, img->vir_w, img->vir_h,
|
|
rga_get_format_name(img->format), img->format);
|
|
}
|
|
|
|
void rga_dump_req(struct rga_request *request, struct rga_req *req)
|
|
{
|
|
rga_req_log(request, "render_mode = %d, bitblit_mode = %d, rotate_mode = %d\n",
|
|
req->render_mode, req->bsfilter_flag,
|
|
req->rotate_mode);
|
|
|
|
rga_dump_image_info(request, "src", &req->src, req->handle_flag,
|
|
(req->mmu_info.mmu_flag >> 8) & 1);
|
|
if (req->pat.yrgb_addr != 0 || req->pat.uv_addr != 0 || req->pat.v_addr != 0)
|
|
rga_dump_image_info(request, "pat", &req->pat, req->handle_flag,
|
|
(req->mmu_info.mmu_flag >> 9) & 1);
|
|
rga_dump_image_info(request, "dst", &req->dst, req->handle_flag,
|
|
(req->mmu_info.mmu_flag >> 10) & 1);
|
|
|
|
rga_req_log(request, "mmu: mmu_flag = %#x en = %#x\n",
|
|
req->mmu_info.mmu_flag, req->mmu_info.mmu_en);
|
|
rga_req_log(request, "alpha: rop_mode = %#x\n", req->alpha_rop_mode);
|
|
rga_req_log(request, "csc = %#x\n", req->yuv2rgb_mode);
|
|
rga_req_log(request, "imterplotion: horiz = %s(%#x), verti = %s(%#x)\n",
|
|
rga_get_interp_str(req->interp.horiz), req->interp.horiz,
|
|
rga_get_interp_str(req->interp.verti), req->interp.verti);
|
|
rga_req_log(request, "core_mask = %#x, priority = %d, in_fence = %d(%#x)\n",
|
|
req->core, req->priority, req->in_fence_fd, req->in_fence_fd);
|
|
}
|