/*
|
* image_processor.cpp - 2D Image Process Hardware Implementation
|
*
|
* Copyright (c) 2021 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 "image_processor.h"
|
|
#include <xcam_log.h>
|
|
#include <map>
|
#include <memory>
|
#include <string>
|
|
#ifdef HAS_LIBRGA
|
#ifdef HAS_LIBDL
|
#include <dlfcn.h>
|
#endif
|
#include "rga/im2d.h"
|
#include "rga/rga.h"
|
#endif
|
|
namespace RkCam {
|
|
#ifdef HAS_LIBRGA
|
#define RGA_LIBRARY_NAME "librga.so"
|
|
using fp_imresize_t = int (*)(const rga_buffer_t src, rga_buffer_t dst, double fx, double fy,
|
int interpolation, int sync);
|
using fp_imcrop_t = int (*)(const rga_buffer_t src, rga_buffer_t dst, im_rect rect, int sync);
|
using fp_imcvtcolor_t = int (*)(rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode,
|
int sync);
|
using fp_imrotate_t = int (*)(const rga_buffer_t src, rga_buffer_t dst, int rotation, int sync);
|
using fp_imflip_t = int (*)(const rga_buffer_t src, rga_buffer_t dst, int mode, int sync);
|
using fp_imcopy_t = int (*)(const rga_buffer_t src, rga_buffer_t dst, int sync);
|
using fp_wrapbuffer_virtualaddr_t = rga_buffer_t (*)(void* vir_addr, int width, int height,
|
int wstride, int hstride, int format);
|
using fp_wrapbuffer_physicaladdr_t = rga_buffer_t (*)(void* phy_addr, int width, int height,
|
int wstride, int hstride, int format);
|
using fp_wrapbuffer_fd_t = rga_buffer_t (*)(int fd, int width, int height, int wstride, int hstride,
|
int format);
|
|
struct rga_ops_s {
|
fp_imresize_t imresize_t;
|
fp_imcrop_t imcrop_t;
|
fp_imcvtcolor_t imcvtcolor_t;
|
fp_imrotate_t imrotate_t;
|
fp_imflip_t imflip_t;
|
fp_imcopy_t imcopy_t;
|
fp_wrapbuffer_virtualaddr_t wrapbuffer_virtualaddr_t;
|
fp_wrapbuffer_physicaladdr_t wrapbuffer_physicaladdr_t;
|
fp_wrapbuffer_fd_t wrapbuffer_fd_t;
|
};
|
|
class RGAOperator : public ImageOperator {
|
public:
|
RGAOperator() : ImageOperator("rga"){};
|
|
virtual ~RGAOperator() {
|
#ifdef HAS_LIBDL
|
if (handle_) {
|
dlclose(handle_);
|
}
|
#endif
|
};
|
|
RGAOperator(const RGAOperator&) = delete;
|
RGAOperator& operator=(const RGAOperator&) = delete;
|
|
int WrapFormat(rk_aiq_format_t fmt) {
|
std::map<rk_aiq_format_t, int> rga_format_map = {
|
{RK_PIX_FMT_Y4, RK_FORMAT_Y4},
|
{RK_PIX_FMT_GREY, RK_FORMAT_YCbCr_400},
|
{RK_PIX_FMT_NV12, RK_FORMAT_YCbCr_420_SP},
|
{RK_PIX_FMT_NV21, RK_FORMAT_YCrCb_420_SP},
|
{RK_PIX_FMT_NV16, RK_FORMAT_YCbCr_422_SP},
|
{RK_PIX_FMT_NV61, RK_FORMAT_YCrCb_422_SP},
|
{RK_PIX_FMT_YVYU, RK_FORMAT_YVYU_422},
|
{RK_PIX_FMT_YVU420, RK_FORMAT_YVYU_420},
|
{RK_PIX_FMT_YUYV, RK_FORMAT_YUYV_422},
|
{RK_PIX_FMT_UYVY, RK_FORMAT_UYVY_422},
|
};
|
auto it = rga_format_map.find(fmt);
|
if (it != rga_format_map.end()) {
|
return it->second;
|
}
|
return -1;
|
}
|
|
XCamReturn resolve_symbles(void) {
|
#ifdef HAS_LIBDL
|
char* error;
|
handle_ = dlopen(RGA_LIBRARY_NAME, RTLD_LAZY);
|
if (!handle_) {
|
LOGE("Failed to dlopen librga.so : %s", dlerror());
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
dlerror();
|
rga_ops_.wrapbuffer_virtualaddr_t =
|
(fp_wrapbuffer_virtualaddr_t)dlsym(handle_, "wrapbuffer_virtualaddr_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble wrapbuffer_virtualaddr_t: %s", error);
|
}
|
|
rga_ops_.wrapbuffer_physicaladdr_t =
|
(fp_wrapbuffer_physicaladdr_t)dlsym(handle_, "wrapbuffer_physicaladdr_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble wrapbuffer_physicaladdr_t: %s", error);
|
}
|
|
rga_ops_.wrapbuffer_fd_t = (fp_wrapbuffer_fd_t)dlsym(handle_, "wrapbuffer_fd_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble wrapbuffer_fd_t : %s", error);
|
}
|
|
rga_ops_.imresize_t = (fp_imresize_t)dlsym(handle_, "imresize_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble imreize_t : %s", error);
|
}
|
|
rga_ops_.imcrop_t = (fp_imcrop_t)dlsym(handle_, "imcrop_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble imcrop_t: %s", error);
|
}
|
|
rga_ops_.imcvtcolor_t = (fp_imcvtcolor_t)dlsym(handle_, "imcvtcolor_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble imcvtcolor_t : %s", error);
|
}
|
|
rga_ops_.imrotate_t = (fp_imrotate_t)dlsym(handle_, "imrotate_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble imrotete_t : %s", error);
|
}
|
|
rga_ops_.imflip_t = (fp_imflip_t)dlsym(handle_, "imflip_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble imflip_t : %s", error);
|
}
|
|
rga_ops_.imcopy_t = (fp_imcopy_t)dlsym(handle_, "imcopy_t");
|
error = dlerror();
|
if (error != NULL) {
|
LOGE("Failed to resolve symble imcopy_t : %s", error);
|
}
|
#endif // HAS_LIBDL
|
|
return XCAM_RETURN_NO_ERROR;
|
};
|
|
virtual XCamReturn resize(const img_buffer_t& src, img_buffer_t& dst, double factor_x,
|
double factor_y, int interpolation, int sync) final {
|
if (rga_ops_.imresize_t) {
|
rga_buffer_t rga_src = rga_ops_.wrapbuffer_fd_t(
|
src.fd, src.width, src.height, src.wstride, src.hstride, WrapFormat(src.format));
|
rga_buffer_t rga_dst = rga_ops_.wrapbuffer_fd_t(
|
dst.fd, dst.width, dst.height, dst.wstride, dst.hstride, WrapFormat(dst.format));
|
|
if (0 > rga_ops_.imresize_t(rga_src, rga_dst, factor_x, factor_y, interpolation, sync)) {
|
return XCAM_RETURN_ERROR_FAILED;
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
};
|
|
virtual XCamReturn crop(const img_buffer_t& src, img_buffer_t& dst, img_rect_t rect,
|
int sync) final {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
};
|
|
virtual XCamReturn cvtcolor(img_buffer_t& src, img_buffer_t& dst, int sfmt, int dfmt, int mode,
|
int sync) final {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
};
|
|
virtual XCamReturn rotate(const img_buffer_t& src, img_buffer_t& dst, int rotation,
|
int sync) final {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
};
|
|
virtual XCamReturn flip(const img_buffer_t& src, img_buffer_t& dst, int mode, int sync) final {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
};
|
|
virtual XCamReturn copy(const img_buffer_t& src, img_buffer_t& dst, int sync) final {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
};
|
|
private:
|
void* handle_;
|
struct rga_ops_s rga_ops_;
|
};
|
#endif // HAS_LIBRGA
|
|
ImageOperator::ImageOperator(const std::string name) : name_(name) {}
|
|
XCamReturn ImageOperator::resize(const img_buffer_t& src, img_buffer_t& dst, double fx, double fy,
|
int interpolation, int sync) {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
|
XCamReturn ImageOperator::crop(const img_buffer_t& src, img_buffer_t& dst, img_rect_t rect,
|
int sync) {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
|
XCamReturn ImageOperator::cvtcolor(img_buffer_t& src, img_buffer_t& dst, int sfmt, int dfmt,
|
int mode, int sync) {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
|
XCamReturn ImageOperator::rotate(const img_buffer_t& src, img_buffer_t& dst, int rotation,
|
int sync) {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
|
XCamReturn ImageOperator::flip(const img_buffer_t& src, img_buffer_t& dst, int mode, int sync) {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
|
XCamReturn ImageOperator::copy(const img_buffer_t& src, img_buffer_t& dst, int sync) {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
|
void ImageProcessor::set_operator(const std::string& name) {
|
if (operator_ != nullptr && !name.compare(operator_->get_name())) {
|
return;
|
}
|
#ifdef HAS_LIBRGA
|
#ifdef HAS_LIBDL
|
if (!name.compare("rga")) {
|
auto ops = std::unique_ptr<RGAOperator>{new RGAOperator};
|
ops->resolve_symbles();
|
operator_ = std::move(ops);
|
}
|
#else
|
#warning "Using RGA without dynamic loading is NOT implemented yet!!!"
|
#endif
|
#endif
|
}
|
|
XCamReturn ImageProcessor::resize(const img_buffer_t& src, img_buffer_t& dst, double factor_x,
|
double factor_y) {
|
if (operator_) {
|
return operator_->resize(src, dst, factor_x, factor_y);
|
} else {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
}
|
|
XCamReturn ImageProcessor::crop(const img_buffer_t& src, img_buffer_t& dst,
|
const img_rect_t& rect) {
|
LOGE("%s : Not implemented", __func__);
|
return XCAM_RETURN_ERROR_UNKNOWN;
|
}
|
|
} // namespace RkCam
|
