/*
|
* Copyright 2015 Rockchip 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.
|
*/
|
|
#include <sys/types.h>
|
#include <sys/stat.h>
|
#include <sys/ioctl.h>
|
#include <fcntl.h>
|
#include <errno.h>
|
#include <string.h>
|
#include <stdint.h>
|
|
#include "mpp_mem.h"
|
#include "mpp_debug.h"
|
#include "mpp_common.h"
|
|
#include "rga.h"
|
#include "rga_api.h"
|
|
static RK_U32 rga_debug = 0;
|
|
#define RGB_DBG_FUNCTION (0x00000001)
|
#define RGB_DBG_COPY (0x00000002)
|
#define RGB_DBG_DUP_FIELD (0x00000004)
|
|
#define rga_dbg(flag, fmt, ...) _mpp_dbg(rga_debug, flag, fmt, ## __VA_ARGS__)
|
#define rga_dbg_func(fmt, ...) _mpp_dbg_f(rga_debug, RGB_DBG_FUNCTION, fmt, ## __VA_ARGS__)
|
#define rga_dbg_copy(fmt, ...) _mpp_dbg(rga_debug, RGB_DBG_COPY, fmt, ## __VA_ARGS__)
|
#define rga_dbg_dup(fmt, ...) _mpp_dbg(rga_debug, RGB_DBG_COPY, fmt, ## __VA_ARGS__)
|
|
#define DEFAULT_RGA_DEV "/dev/rga"
|
|
typedef struct RgaCtxImpl_t {
|
RK_S32 rga_fd;
|
|
// context holds only one request structure and serial process all input
|
RgaReq request;
|
} RgaCtxImpl;
|
|
static int is_yuv_format(int fmt)
|
{
|
if (fmt >= RGA_FMT_YCbCr_422_SP && fmt <= RGA_FMT_YCrCb_420_P) {
|
return 1;
|
}
|
|
return 0;
|
}
|
|
static int is_rgb_format(int fmt)
|
{
|
if (fmt >= RGA_FMT_RGBA_8888 && fmt <= RGA_FMT_BGR_888) {
|
return 1;
|
}
|
|
return 0;
|
}
|
|
static RgaFormat rga_fmt_map(MppFrameFormat fmt)
|
{
|
RgaFormat ret;
|
|
switch (fmt) {
|
case MPP_FMT_YUV420P:
|
ret = RGA_FMT_YCbCr_420_P;
|
break;
|
case MPP_FMT_YUV420SP:
|
ret = RGA_FMT_YCbCr_420_SP;
|
break;
|
case MPP_FMT_YUV422P:
|
ret = RGA_FMT_YCbCr_422_P;
|
break;
|
case MPP_FMT_YUV422SP:
|
ret = RGA_FMT_YCrCb_422_SP;
|
break;
|
case MPP_FMT_RGB565:
|
ret = RGA_FMT_RGB_565;
|
break;
|
case MPP_FMT_RGB888:
|
ret = RGA_FMT_RGB_888;
|
break;
|
case MPP_FMT_ARGB8888:
|
ret = RGA_FMT_RGBA_8888;
|
break;
|
default:
|
ret = RGA_FMT_BUTT;
|
mpp_err("unsupport mpp fmt %d found\n", fmt);
|
break;
|
}
|
|
return ret;
|
}
|
|
MPP_RET rga_init(RgaCtx *ctx)
|
{
|
MPP_RET ret = MPP_OK;
|
RgaCtxImpl *impl = NULL;
|
|
rga_dbg_func("in\n");
|
|
*ctx = NULL;
|
|
impl = mpp_malloc(RgaCtxImpl, 1);
|
if (!impl) {
|
mpp_err_f("malloc context failed\n");
|
ret = MPP_ERR_NULL_PTR;
|
goto END;
|
}
|
|
impl->rga_fd = open(DEFAULT_RGA_DEV, O_RDWR | O_CLOEXEC, 0);
|
if (impl->rga_fd < 0) {
|
mpp_err_f("open device failed\n");
|
mpp_free(impl);
|
impl = NULL;
|
ret = MPP_ERR_OPEN_FILE;
|
goto END;
|
}
|
|
END:
|
*ctx = impl;
|
rga_dbg_func("out\n");
|
return ret;
|
}
|
|
MPP_RET rga_deinit(RgaCtx ctx)
|
{
|
MPP_RET ret = MPP_OK;
|
RgaCtxImpl *impl = NULL;
|
|
rga_dbg_func("in\n");
|
|
impl = (RgaCtxImpl *)ctx;
|
if (!impl) {
|
mpp_err_f("invalid input");
|
ret = MPP_ERR_NULL_PTR;
|
goto END;
|
}
|
|
if (impl->rga_fd >= 0) {
|
close(impl->rga_fd);
|
impl->rga_fd = -1;
|
}
|
|
mpp_free(impl);
|
END:
|
rga_dbg_func("out\n");
|
return ret;
|
}
|
|
static MPP_RET rga_ioctl(RgaCtxImpl *impl)
|
{
|
int io_ret = ioctl(impl->rga_fd, RGA_BLIT_SYNC, &impl->request);
|
if (io_ret) {
|
mpp_err("rga ioctl failed errno:%d %s", errno, strerror(errno));
|
return MPP_NOK;
|
}
|
|
return MPP_OK;
|
}
|
|
static MPP_RET config_rga_image(RgaImg *img, MppFrame frame)
|
{
|
RgaFormat fmt = rga_fmt_map(mpp_frame_get_fmt(frame));
|
MppBuffer buf = mpp_frame_get_buffer(frame);
|
RK_U32 width = mpp_frame_get_width(frame);
|
RK_U32 height = mpp_frame_get_height(frame);
|
RK_U32 h_str = mpp_frame_get_hor_stride(frame);
|
RK_U32 v_str = mpp_frame_get_ver_stride(frame);
|
RK_S32 fd = mpp_buffer_get_fd(buf);
|
|
if (fmt >= RGA_FMT_BUTT) {
|
mpp_err("invalid input format for rga process %d\n", fmt);
|
return MPP_NOK;
|
}
|
|
memset(img, 0, sizeof(RgaImg));
|
img->yrgb_addr = fd;
|
img->format = (RK_U32)fmt;
|
img->act_w = width;
|
img->act_h = height;
|
img->vir_w = h_str;
|
img->vir_h = v_str;
|
|
return MPP_OK;
|
}
|
|
static MPP_RET config_rga_yuv2rgb_mode(RgaCtx ctx)
|
{
|
RgaCtxImpl *impl = (RgaCtxImpl *)ctx;
|
RgaReq *request = &impl->request;
|
|
/*
|
* yuv2rgb_mode only set when translate yuv to rgb, or rga to yuv.
|
* If format of input and output are both yuv or rga, set yuv2rgb_mode to 0.
|
*/
|
int src_format = request->src.format;
|
int dst_format = request->dst.format;
|
|
request->yuv2rgb_mode = 0;
|
if (is_yuv_format(src_format) && is_rgb_format(dst_format)) {
|
/* Special config for yuv to rgb */
|
request->yuv2rgb_mode |= 0x1 << 0;
|
} else if (is_rgb_format(src_format) && is_yuv_format(dst_format)) {
|
/* Special config for rgb to yuv */
|
request->yuv2rgb_mode = (2 << 4);
|
}
|
|
return MPP_OK;
|
}
|
|
MPP_RET rga_control(RgaCtx ctx, RgaCmd cmd, void *param)
|
{
|
if (NULL == ctx) {
|
mpp_err_f("invalid NULL input\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
|
rga_dbg_func("in\n");
|
|
MPP_RET ret = MPP_OK;
|
RgaCtxImpl *impl = (RgaCtxImpl *)ctx;
|
RgaReq *request = &impl->request;
|
|
switch (cmd) {
|
case RGA_CMD_INIT : {
|
memset(request, 0, sizeof(*request));
|
request->mmu_info.mmu_en = 1;
|
request->mmu_info.mmu_flag = 1;
|
request->mmu_info.mmu_flag = ((2 & 0x3) << 4) | 1;
|
request->mmu_info.mmu_flag |= (1 << 31) | (1 << 10) | (1 << 8);
|
} break;
|
case RGA_CMD_SET_SRC : {
|
if (NULL == param) {
|
mpp_err("invalid NULL param for setup source\n");
|
ret = MPP_NOK;
|
break;
|
}
|
|
MppFrame *src = (MppFrame *)param;
|
ret = config_rga_image(&request->src, src);
|
} break;
|
case RGA_CMD_SET_DST : {
|
if (NULL == param) {
|
mpp_err("invalid NULL param for setup destination\n");
|
ret = MPP_NOK;
|
break;
|
}
|
|
MppFrame *dst = (MppFrame *)param;
|
ret = config_rga_image(&request->dst, dst);
|
// When config dst setup default clip
|
RK_U32 width = mpp_frame_get_width(dst);
|
RK_U32 height = mpp_frame_get_height(dst);
|
request->clip.xmin = 0;
|
request->clip.xmax = width - 1;
|
request->clip.ymin = 0;
|
request->clip.ymax = height - 1;
|
} break;
|
case RGA_CMD_RUN_SYNC : {
|
config_rga_yuv2rgb_mode(ctx);
|
ret = rga_ioctl(impl);
|
} break;
|
default : {
|
mpp_err("invalid command %d\n", cmd);
|
ret = MPP_NOK;
|
} break;
|
}
|
|
rga_dbg_func("out\n");
|
return ret;
|
}
|
|
// sample for copy function
|
MPP_RET rga_copy(RgaCtx ctx, MppFrame src, MppFrame dst)
|
{
|
MPP_RET ret = MPP_OK;
|
RgaCtxImpl *impl = (RgaCtxImpl *)ctx;
|
MppBuffer src_buf = mpp_frame_get_buffer(src);
|
MppBuffer dst_buf = mpp_frame_get_buffer(dst);
|
RK_U32 src_w = mpp_frame_get_width(src);
|
RK_U32 src_h = mpp_frame_get_height(src);
|
RK_U32 dst_w = mpp_frame_get_width(dst);
|
RK_U32 dst_h = mpp_frame_get_height(dst);
|
RK_S32 src_fd = mpp_buffer_get_fd(src_buf);
|
RK_S32 dst_fd = mpp_buffer_get_fd(dst_buf);
|
RgaReq *request = &impl->request;
|
|
RgaFormat src_fmt = rga_fmt_map(mpp_frame_get_fmt(src));
|
RgaFormat dst_fmt = rga_fmt_map(mpp_frame_get_fmt(dst));
|
|
rga_dbg_func("in\n");
|
|
if (src_fmt >= RGA_FMT_BUTT || dst_fmt >= RGA_FMT_BUTT) {
|
mpp_err("invalid input format for rga process src %d dst %d\n",
|
src_fmt, dst_fmt);
|
ret = MPP_NOK;
|
goto END;
|
}
|
|
mpp_assert(src_w > 0 && src_h > 0);
|
|
if (dst_w == 0 || dst_h == 0) {
|
dst_w = src_w;
|
dst_h = src_h;
|
}
|
|
rga_dbg_copy("[fd:w:h:fmt] src - %d:%d:%d:%d dst - %d:%d:%d:%d\n",
|
src_fd, src_w, src_h, src_fmt,
|
dst_fd, dst_w, dst_h, dst_fmt);
|
|
memset(request, 0, sizeof(*request));
|
request->src.yrgb_addr = src_fd;
|
request->src.format = (RK_U32)src_fmt;
|
request->src.vir_w = mpp_frame_get_hor_stride(src);
|
request->src.vir_h = mpp_frame_get_ver_stride(src);
|
request->src.act_w = src_w;
|
request->src.act_h = src_h;
|
|
request->dst.yrgb_addr = dst_fd;
|
request->dst.vir_w = dst_w;
|
request->dst.vir_h = dst_h;
|
request->dst.format = (RK_U32)dst_fmt;
|
request->clip.xmin = 0;
|
request->clip.xmax = dst_w - 1;
|
request->clip.ymin = 0;
|
request->clip.ymax = dst_h - 1;
|
request->dst.act_w = dst_w;
|
request->dst.act_h = dst_h;
|
|
config_rga_yuv2rgb_mode(ctx);
|
|
request->mmu_info.mmu_en = 1;
|
request->mmu_info.mmu_flag = 1;
|
request->mmu_info.mmu_flag = ((2 & 0x3) << 4) | 1;
|
request->mmu_info.mmu_flag |= (1 << 31) | (1 << 10) | (1 << 8);
|
|
ret = rga_ioctl(impl);
|
END:
|
rga_dbg_func("out\n");
|
return ret;
|
}
|
|
// sample for duplicate field to frame function
|
MPP_RET rga_dup_field(RgaCtx ctx, MppFrame frame)
|
{
|
MPP_RET ret = MPP_OK;
|
RgaCtxImpl *impl = (RgaCtxImpl *)ctx;
|
MppBuffer buf = mpp_frame_get_buffer(frame);
|
RK_U32 width = mpp_frame_get_width(frame);
|
RK_U32 height = mpp_frame_get_height(frame);
|
RK_U32 h_str = mpp_frame_get_hor_stride(frame);
|
RK_U32 v_str = mpp_frame_get_ver_stride(frame);
|
RK_S32 fd = mpp_buffer_get_fd(buf);
|
void *ptr = mpp_buffer_get_ptr(buf);
|
RgaFormat fmt = rga_fmt_map(mpp_frame_get_fmt(frame));
|
RgaReq *request = &impl->request;
|
|
rga_dbg_func("in\n");
|
|
mpp_assert(fmt == RGA_FMT_YCbCr_420_SP);
|
mpp_assert(width > 0 && height > 0);
|
if (fmt != RGA_FMT_YCbCr_420_SP || width == 0 || height == 0) {
|
ret = MPP_NOK;
|
goto END;
|
}
|
|
rga_dbg_dup("[fd:w:h:h_str:v_str:fmt] %d:%d:%d:%d:%d:%d\n",
|
fd, width, height, h_str, v_str, fmt);
|
|
memset(request, 0, sizeof(*request));
|
request->src.yrgb_addr = fd;
|
request->src.format = (RK_U32)fmt;
|
request->src.vir_w = h_str * 2;
|
request->src.vir_h = v_str / 2;
|
request->src.act_w = width;
|
request->src.act_h = height / 2;
|
|
request->dst.yrgb_addr = 0;
|
request->dst.uv_addr = (RK_U32)((uintptr_t)ptr) + h_str; // special process here
|
request->dst.vir_w = h_str * 2;
|
request->dst.vir_h = v_str / 2;
|
request->dst.format = (RK_U32)fmt;
|
request->dst.act_w = width;
|
request->dst.act_h = height / 2;
|
|
request->clip.xmin = 0;
|
request->clip.xmax = h_str * 2 - 1;
|
request->clip.ymin = 0;
|
request->clip.ymax = v_str / 2 - 1;
|
|
request->mmu_info.mmu_en = 1;
|
request->mmu_info.mmu_flag = ((2 & 0x3) << 4) | 1;
|
request->mmu_info.mmu_flag |= (1 << 31) | (1 << 10) | (1 << 8);
|
|
ret = rga_ioctl(impl);
|
END:
|
rga_dbg_func("out\n");
|
return ret;
|
}
|
