// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
#include "image.h"
|
|
#include <assert.h>
|
#include <string.h>
|
|
#include "key_string.h"
|
#include "media_type.h"
|
#include "utils.h"
|
|
void GetPixFmtNumDen(const PixelFormat& fmt, int& num, int& den)
|
{
|
num = 0;
|
den = 1;
|
switch (fmt) {
|
case PIX_FMT_RGB332:
|
num = 1;
|
break;
|
case PIX_FMT_YUV420P:
|
case PIX_FMT_NV12:
|
case PIX_FMT_NV21:
|
case PIX_FMT_FBC0:
|
num = 3;
|
den = 2;
|
break;
|
case PIX_FMT_YUV422P:
|
case PIX_FMT_NV16:
|
case PIX_FMT_NV61:
|
case PIX_FMT_YUYV422:
|
case PIX_FMT_UYVY422:
|
case PIX_FMT_RGB565:
|
case PIX_FMT_BGR565:
|
case PIX_FMT_FBC2:
|
num = 2;
|
break;
|
case PIX_FMT_RGB888:
|
case PIX_FMT_BGR888:
|
num = 3;
|
break;
|
case PIX_FMT_ARGB8888:
|
case PIX_FMT_ABGR8888:
|
num = 4;
|
break;
|
default:
|
LOG("unsupport get num/den for pixel fmt: %d\n", fmt);
|
}
|
}
|
|
int CalPixFmtSize(const PixelFormat& fmt, const int width, const int height, int align)
|
{
|
int num = 0;
|
int den = 0;
|
int extra_hdr_size = 0;
|
int pix_fmt_size = 0;
|
GetPixFmtNumDen(fmt, num, den);
|
// fbc image: fbc hdr + fbc body.
|
// fbc w,h must be 16 align, and body offset must be 4k align
|
if (fmt == PIX_FMT_FBC0 || fmt == PIX_FMT_FBC2) {
|
align = 16;
|
extra_hdr_size = UPALIGNTO(width, align) * UPALIGNTO(height, align) / 16;
|
extra_hdr_size = UPALIGNTO(extra_hdr_size, 4096);
|
}
|
// mpp always require buffer align by align value
|
if (align > 0)
|
pix_fmt_size = UPALIGNTO(width, align) * UPALIGNTO(height, align) * num / den;
|
else {
|
pix_fmt_size = width * height * num / den;
|
}
|
|
return (extra_hdr_size + pix_fmt_size);
|
}
|
|
static const struct PixFmtStringEntry {
|
PixelFormat fmt;
|
const char* type_str;
|
} pix_fmt_string_map[] = {
|
{PIX_FMT_YUV420P, IMAGE_YUV420P}, {PIX_FMT_NV12, IMAGE_NV12}, {PIX_FMT_NV21, IMAGE_NV21},
|
{PIX_FMT_YUV422P, IMAGE_YUV422P}, {PIX_FMT_NV16, IMAGE_NV16}, {PIX_FMT_NV61, IMAGE_NV61},
|
{PIX_FMT_YUYV422, IMAGE_YUYV422}, {PIX_FMT_UYVY422, IMAGE_UYVY422}, {PIX_FMT_RGB332, IMAGE_RGB332},
|
{PIX_FMT_RGB565, IMAGE_RGB565}, {PIX_FMT_BGR565, IMAGE_BGR565}, {PIX_FMT_RGB888, IMAGE_RGB888},
|
{PIX_FMT_BGR888, IMAGE_BGR888}, {PIX_FMT_ARGB8888, IMAGE_ARGB8888}, {PIX_FMT_ABGR8888, IMAGE_ABGR8888},
|
{PIX_FMT_FBC0, IMAGE_FBC0}, {PIX_FMT_FBC0, IMAGE_FBC2}};
|
|
PixelFormat StringToPixFmt(const char* type)
|
{
|
if (!type) {
|
return PIX_FMT_NONE;
|
}
|
FIND_ENTRY_TARGET_BY_STRCMP(type, pix_fmt_string_map, type_str, fmt)
|
return PIX_FMT_NONE;
|
}
|
|
const char* PixFmtToString(PixelFormat fmt)
|
{
|
FIND_ENTRY_TARGET(fmt, pix_fmt_string_map, fmt, type_str)
|
return nullptr;
|
}
|
|
namespace easymedia
|
{
|
bool ParseImageInfoFromMap(std::map<std::string, std::string>& params, ImageInfo& info, bool input)
|
{
|
std::string value;
|
const char* type = input ? KEY_INPUTDATATYPE : KEY_OUTPUTDATATYPE;
|
CHECK_EMPTY(value, params, type)
|
info.pix_fmt = StringToPixFmt(value.c_str());
|
if (info.pix_fmt == PIX_FMT_NONE) {
|
LOG("unsupport pix fmt %s\n", value.c_str());
|
return false;
|
}
|
CHECK_EMPTY(value, params, KEY_BUFFER_WIDTH)
|
info.width = std::stoi(value);
|
CHECK_EMPTY(value, params, KEY_BUFFER_HEIGHT)
|
info.height = std::stoi(value);
|
CHECK_EMPTY(value, params, KEY_BUFFER_VIR_WIDTH)
|
info.vir_width = std::stoi(value);
|
CHECK_EMPTY(value, params, KEY_BUFFER_VIR_HEIGHT)
|
info.vir_height = std::stoi(value);
|
return true;
|
}
|
|
std::string to_param_string(const ImageInfo& info, bool input)
|
{
|
std::string s;
|
const char* fmt = PixFmtToString(info.pix_fmt);
|
if (!fmt) {
|
return s;
|
}
|
if (input) {
|
PARAM_STRING_APPEND(s, KEY_INPUTDATATYPE, fmt);
|
} else {
|
PARAM_STRING_APPEND(s, KEY_OUTPUTDATATYPE, fmt);
|
}
|
PARAM_STRING_APPEND_TO(s, KEY_BUFFER_WIDTH, info.width);
|
PARAM_STRING_APPEND_TO(s, KEY_BUFFER_HEIGHT, info.height);
|
PARAM_STRING_APPEND_TO(s, KEY_BUFFER_VIR_WIDTH, info.vir_width);
|
PARAM_STRING_APPEND_TO(s, KEY_BUFFER_VIR_HEIGHT, info.vir_height);
|
return s;
|
}
|
|
std::string TwoImageRectToString(const std::vector<ImageRect>& src_dst)
|
{
|
char r[128] = {0};
|
assert(src_dst[0].x < 10000 && src_dst[0].y < 10000);
|
assert(src_dst[0].w < 10000 && src_dst[0].h < 10000);
|
assert(src_dst[1].x < 10000 && src_dst[1].y < 10000);
|
assert(src_dst[1].w < 10000 && src_dst[1].h < 10000);
|
snprintf(r, sizeof(r), "(%d,%d,%d,%d)%s(%d,%d,%d,%d)", src_dst[0].x, src_dst[0].y, src_dst[0].w, src_dst[0].h,
|
KEY_RIGHT_DIRECTION, src_dst[1].x, src_dst[1].y, src_dst[1].w, src_dst[1].h);
|
return r;
|
}
|
|
std::vector<ImageRect> StringToTwoImageRect(const std::string& str_rect)
|
{
|
std::vector<ImageRect> ret;
|
const char* s = nullptr;
|
if (str_rect.empty() || !(s = strstr(str_rect.c_str(), KEY_RIGHT_DIRECTION))) {
|
return std::move(ret);
|
}
|
const char* args[2] = {str_rect.c_str(), s + sizeof(KEY_RIGHT_DIRECTION) - 1};
|
for (int i = 0; i < 2; i++) {
|
ImageRect rect = {0, 0, 0, 0};
|
int r = sscanf(args[i], "(%d,%d,%d,%d)", &rect.x, &rect.y, &rect.w, &rect.h);
|
if (r != 4) {
|
LOG("Fail to sscanf(ret=%d) : %m\n", r);
|
ret.clear();
|
return std::move(ret);
|
}
|
ret.push_back(std::move(rect));
|
}
|
|
return std::move(ret);
|
}
|
|
std::string ImageRectToString(const ImageRect& src_dst)
|
{
|
char r[64] = {0};
|
assert(src_dst.x >= 0 && src_dst.y >= 0);
|
assert(src_dst.x < 10000 && src_dst.y < 10000);
|
assert(src_dst.w < 10000 && src_dst.h < 10000);
|
snprintf(r, sizeof(r), "(%d,%d,%d,%d)", src_dst.x, src_dst.y, src_dst.w, src_dst.h);
|
return r;
|
}
|
|
std::vector<ImageRect> StringToImageRect(const std::string& str_rect)
|
{
|
std::vector<ImageRect> ret;
|
const char* start = nullptr;
|
const char* delimiter = nullptr;
|
|
if (str_rect.empty()) {
|
return std::move(ret);
|
}
|
|
start = str_rect.c_str();
|
while (start) {
|
delimiter = start;
|
// (x,y,w,h) format check.
|
for (int i = 0; i < 4; i++) {
|
if (i == 3) {
|
delimiter = strstr(delimiter, ")");
|
} else {
|
delimiter = strstr(delimiter, ",");
|
}
|
if (!delimiter) {
|
return std::move(ret);
|
}
|
delimiter += 1;
|
}
|
|
ImageRect rect = {0, 0, 0, 0};
|
int r = sscanf(start, "(%d,%d,%d,%d)", &rect.x, &rect.y, &rect.w, &rect.h);
|
if (r != 4) {
|
LOG("Fail to sscanf(ret=%d) : %m\n", r);
|
return std::move(ret);
|
}
|
|
ret.push_back(std::move(rect));
|
start = strstr(delimiter, "(");
|
}
|
|
return std::move(ret);
|
}
|
|
} // namespace easymedia
|
