new/external/rockit/mpi/example/common/test_comm_imgproc.cpp
2025-05-10 21:58:58 +08:00

792 lines
25 KiB
C++

/*
* Copyright 2020 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 <stdlib.h>
#include "test_comm_imgproc.h"
#include "test_comm_utils.h"
#define RK_CLIP3(l, h, a) ((a) < (l) ? (l) : ((a) > (h) ? (h) : (a)))
static void get_rgb_color(RK_U32 *R, RK_U32 *G, RK_U32 *B, RK_S32 x, RK_S32 y, RK_S32 frm_cnt) {
// moving color bar
RK_U8 Y = (0 + x + y + frm_cnt * 3);
RK_U8 U = (128 + (y / 2) + frm_cnt * 2);
RK_U8 V = (64 + (x / 2) + frm_cnt * 5);
RK_S32 _R = Y + ((360 * (V - 128)) >> 8);
RK_S32 _G = Y - (((88 * (U - 128) + 184 * (V - 128))) >> 8);
RK_S32 _B = Y + ((455 * (U - 128)) >> 8);
R[0] = RK_CLIP3(0, 255, _R);
G[0] = RK_CLIP3(0, 255, _G);
B[0] = RK_CLIP3(0, 255, _B);
}
static void fill_MPP_FMT_RGB565(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_RGB565 = tmedia: rgb565be
// 16 bit pixel MSB --------> LSB
// (rrrr,rggg,gggb,bbbb)
// big endian | byte 0 | byte 1 |
// little endian | byte 1 | byte 0 |
RK_U16 val = (((R >> 3) & 0x1f) << 11) |
(((G >> 2) & 0x3f) << 5) |
(((B >> 3) & 0x1f) << 0);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_BGR565(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_BGR565 = tmedia: bgr565be
// 16 bit pixel MSB --------> LSB
// (bbbb,bggg,gggr,rrrr)
// big endian | byte 0 | byte 1 |
// little endian | byte 1 | byte 0 |
RK_U16 val = (((R >> 3) & 0x1f) << 0) |
(((G >> 2) & 0x3f) << 5) |
(((B >> 3) & 0x1f) << 11);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_RGB555(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_RGB555 = tmedia: rgb555be
// 16 bit pixel MSB --------> LSB
// (0rrr,rrgg,gggb,bbbb)
// big endian | byte 0 | byte 1 |
// little endian | byte 1 | byte 0 |
RK_U16 val = (((R >> 3) & 0x1f) << 10) |
(((G >> 3) & 0x1f) << 5) |
(((B >> 3) & 0x1f) << 0);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_BGR555(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_BGR555 = tmedia: bgr555be
// 16 bit pixel MSB --------> LSB
// (0bbb,bbgg,gggr,rrrr)
// big endian | byte 0 | byte 1 |
// little endian | byte 1 | byte 0 |
RK_U16 val = (((R >> 3) & 0x1f) << 0) |
(((G >> 3) & 0x1f) << 5) |
(((B >> 3) & 0x1f) << 10);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_RGB444(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_RGB444 = tmedia: rgb444be
// 16 bit pixel MSB --------> LSB
// (0000,rrrr,gggg,bbbb)
// big endian | byte 0 | byte 1 |
// little endian | byte 1 | byte 0 |
RK_U16 val = (((R >> 4) & 0xf) << 8) |
(((G >> 4) & 0xf) << 4) |
(((B >> 4) & 0xf) << 0);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_BGR444(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_BGR444 = tmedia: bgr444be
// 16 bit pixel MSB --------> LSB
// (0000,bbbb,gggg,rrrr)
// big endian | byte 0 | byte 1 |
// little endian | byte 1 | byte 0 |
RK_U16 val = (((R >> 4) & 0xf) << 0) |
(((G >> 4) & 0xf) << 4) |
(((B >> 4) & 0xf) << 8);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_RGB888(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_RGB888
// 24 bit pixel MSB --------> LSB
// (rrrr,rrrr,gggg,gggg,bbbb,bbbb)
// big endian | byte 0 | byte 1 | byte 2 |
// little endian | byte 2 | byte 1 | byte 0 |
if (be) {
p[0] = R;
p[1] = G;
p[2] = B;
} else {
p[0] = B;
p[1] = G;
p[2] = R;
}
}
static void fill_MPP_FMT_BGR888(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_BGR888
// 24 bit pixel MSB --------> LSB
// (bbbb,bbbb,gggg,gggg,rrrr,rrrr)
// big endian | byte 0 | byte 1 | byte 2 |
// little endian | byte 2 | byte 1 | byte 0 |
if (be) {
p[0] = B;
p[1] = G;
p[2] = R;
} else {
p[0] = R;
p[1] = G;
p[2] = B;
}
}
static void fill_MPP_FMT_RGB101010(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_RGB101010
// 32 bit pixel MSB --------> LSB
// (00rr,rrrr,rrrr,gggg,gggg,ggbb,bbbb,bbbb)
// big endian | byte 0 | byte 1 | byte 2 | byte 3 |
// little endian | byte 3 | byte 2 | byte 1 | byte 0 |
RK_U32 val = (((R * 4) & 0x3ff) << 20) |
(((G * 4) & 0x3ff) << 10) |
(((B * 4) & 0x3ff) << 0);
if (be) {
p[0] = (val >> 24) & 0xff;
p[1] = (val >> 16) & 0xff;
p[2] = (val >> 8) & 0xff;
p[3] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
p[2] = (val >> 16) & 0xff;
p[3] = (val >> 24) & 0xff;
}
}
static void fill_MPP_FMT_BGR101010(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_BGR101010
// 32 bit pixel MSB --------> LSB
// (00bb,bbbb,bbbb,gggg,gggg,ggrr,rrrr,rrrr)
// big endian | byte 0 | byte 1 | byte 2 | byte 3 |
// little endian | byte 3 | byte 2 | byte 1 | byte 0 |
RK_U32 val = (((R * 4) & 0x3ff) << 0) |
(((G * 4) & 0x3ff) << 10) |
(((B * 4) & 0x3ff) << 20);
if (be) {
p[0] = (val >> 24) & 0xff;
p[1] = (val >> 16) & 0xff;
p[2] = (val >> 8) & 0xff;
p[3] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
p[2] = (val >> 16) & 0xff;
p[3] = (val >> 24) & 0xff;
}
}
static void fill_MPP_FMT_ARGB8888(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_ARGB8888
// 32 bit pixel MSB --------> LSB
// (XXXX,XXXX,rrrr,rrrr,gggg,gggg,bbbb,bbbb)
// big endian | byte 0 | byte 1 | byte 2 | byte 3 |
// little endian | byte 3 | byte 2 | byte 1 | byte 0 |
if (be) {
p[0] = 0xff;
p[1] = R;
p[2] = G;
p[3] = B;
} else {
p[0] = B;
p[1] = G;
p[2] = R;
p[3] = 0xff;
}
}
static void fill_MPP_FMT_ABGR8888(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_ABGR8888
// 32 bit pixel MSB --------> LSB
// (XXXX,XXXX,bbbb,bbbb,gggg,gggg,rrrr,rrrr)
// big endian | byte 0 | byte 1 | byte 2 | byte 3 |
// little endian | byte 3 | byte 2 | byte 1 | byte 0 |
if (be) {
p[0] = 0xff;
p[1] = B;
p[2] = G;
p[3] = R;
} else {
p[0] = R;
p[1] = G;
p[2] = B;
p[3] = 0xff;
}
}
static void fill_MPP_FMT_BGRA8888(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_BGRA8888
// 32 bit pixel MSB --------> LSB
// (bbbb,bbbb,gggg,gggg,rrrr,rrrr,XXXX,XXXX)
// big endian | byte 0 | byte 1 | byte 2 | byte 3 |
// little endian | byte 3 | byte 2 | byte 1 | byte 0 |
if (be) {
p[0] = B;
p[1] = G;
p[2] = R;
p[3] = 0xff;
} else {
p[0] = 0xff;
p[1] = R;
p[2] = G;
p[3] = B;
}
}
static void fill_MPP_FMT_RGBA8888(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
// MPP_FMT_RGBA8888
// 32 bit pixel MSB --------> LSB
// (rrrr,rrrr,gggg,gggg,bbbb,bbbb,XXXX,XXXX)
// big endian | byte 0 | byte 1 | byte 2 | byte 3 |
// little endian | byte 3 | byte 2 | byte 1 | byte 0 |
if (be) {
p[0] = R;
p[1] = G;
p[2] = B;
p[3] = 0xff;
} else {
p[0] = 0xff;
p[1] = B;
p[2] = G;
p[3] = R;
}
}
static void fill_MPP_FMT_ARGB1555(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
RK_U8 r1, g1, b1, a1;
RK_U16 *u16p = reinterpret_cast<RK_U16 *>(p);
a1 = 1;
r1 = g1 = b1 = 0;
r1 = R >> 3;
g1 = G >> 3;
b1 = B >> 3;
if (be) {
*u16p = a1 | (r1 << 1) | (g1 << 6) | (b1 << 11);
} else {
*u16p = (a1 << 15) + (r1 << 10) | (g1 << 5) | b1;
}
}
static void fill_MPP_FMT_ABGR1555(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
RK_U8 r1, g1, b1, a1;
RK_U16 *u16p = reinterpret_cast<RK_U16 *>(p);
a1 = 1;
r1 = g1 = b1 = 0;
r1 = R >> 3;
g1 = G >> 3;
b1 = B >> 3;
if (be) {
*u16p = a1 | (b1 << 1) | (g1 << 6) | (r1 << 11);
} else {
*u16p = (a1 << 15) + (b1 << 10) | (g1 << 5) | r1;
}
}
static void fill_MPP_FMT_ARGB4444(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
RK_U16 val = (0xf << 12) |
(((R >> 4) & 0xf) << 8) |
(((G >> 4) & 0xf) << 4) |
(((B >> 4) & 0xf) << 0);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_ABGR4444(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
RK_U16 val = (((R >> 4) & 0xf) << 0) |
(((G >> 4) & 0xf) << 4) |
(((B >> 4) & 0xf) << 8) |
(0xf << 12);
if (be) {
p[0] = (val >> 8) & 0xff;
p[1] = (val >> 0) & 0xff;
} else {
p[0] = (val >> 0) & 0xff;
p[1] = (val >> 8) & 0xff;
}
}
static void fill_MPP_FMT_BGRA4444(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
RK_U8 r1, g1, b1, a1;
RK_U16 *u16p = reinterpret_cast<RK_U16 *>(p);
a1 = 0xf;
r1 = g1 = b1 = 0;
r1 = R >> 4;
g1 = G >> 4;
b1 = B >> 4;
if (be) {
*u16p = b1 | (g1 << 4) | (r1 << 8) | (a1 << 12);
} else {
*u16p = (b1 << 12) + (g1 << 8) | (r1 << 4) | a1;
}
}
static void fill_MPP_FMT_RGBA5551(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
RK_U8 r1, g1, b1, a1;
RK_U16 *u16p = reinterpret_cast<RK_U16 *>(p);
a1 = 1;
r1 = g1 = b1 = 0;
r1 = R >> 3;
g1 = G >> 3;
b1 = B >> 3;
if (be) {
*u16p = r1 | (g1 << 5) | (b1 << 10)| (a1 << 15);
} else {
*u16p = (r1 << 11) | (g1 << 6) | (b1 << 1) | a1;
}
}
static void fill_MPP_FMT_BGRA5551(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be) {
RK_U8 r1, g1, b1, a1;
RK_U16 *u16p = reinterpret_cast<RK_U16 *>(p);
a1 = 1;
r1 = g1 = b1 = 0;
r1 = R >> 3;
g1 = G >> 3;
b1 = B >> 3;
if (be) {
*u16p = b1 | (g1 << 5) | (r1 << 10) | (a1 << 15);
} else {
*u16p = (b1 << 11) + (g1 << 6) | (r1 << 1) | a1;
}
}
typedef void (*FillRgbFunc)(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be);
FillRgbFunc fill_rgb_funcs[] = {
fill_MPP_FMT_RGB565,
fill_MPP_FMT_BGR565,
fill_MPP_FMT_RGB555,
fill_MPP_FMT_BGR555,
fill_MPP_FMT_RGB444,
fill_MPP_FMT_BGR444,
fill_MPP_FMT_RGB888,
fill_MPP_FMT_BGR888,
fill_MPP_FMT_RGB101010,
fill_MPP_FMT_BGR101010,
fill_MPP_FMT_ARGB1555,
fill_MPP_FMT_ABGR1555,
fill_MPP_FMT_ARGB4444,
fill_MPP_FMT_ABGR4444,
RK_NULL,
RK_NULL,
fill_MPP_FMT_ARGB8888,
fill_MPP_FMT_ABGR8888,
fill_MPP_FMT_BGRA8888,
fill_MPP_FMT_RGBA8888,
fill_MPP_FMT_RGBA5551,
fill_MPP_FMT_BGRA5551,
fill_MPP_FMT_BGRA4444
};
static RK_S32 util_check_stride_by_pixel(RK_S32 workaround, RK_S32 width,
RK_S32 hor_stride, RK_S32 pixel_size) {
if (!workaround && hor_stride < width * pixel_size) {
RK_LOGW("warning: stride by bytes %d is smarller than width %d mutiple by pixel size %d",
hor_stride, width, pixel_size);
RK_LOGW("multiple stride %d by pixel size %d and set new byte stride to %d",
hor_stride, pixel_size, hor_stride * pixel_size);
workaround = 1;
}
return workaround;
}
static RK_S32 util_check_8_pixel_aligned(RK_S32 workaround, RK_S32 hor_stride,
RK_S32 pixel_aign, RK_S32 pixel_size,
const char *fmt_name) {
if (!workaround && hor_stride != RK_ALIGN(hor_stride, pixel_aign * pixel_size)) {
RK_LOGW("warning: vepu only support 8 aligned horizontal stride in pixel for %s with pixel size %d",
fmt_name, pixel_size);
RK_LOGW("set byte stride to %d to match the requirement",
RK_ALIGN(hor_stride, pixel_aign * pixel_size));
workaround = 1;
}
return workaround;
}
RK_S32 TEST_COMM_FillImage(RK_U8 *buf, RK_U32 width, RK_U32 height,
RK_U32 hor_stride, RK_U32 ver_stride, PIXEL_FORMAT_E fmt,
RK_U32 frame_count) {
RK_S32 ret = RK_SUCCESS;
RK_U8 *buf_y = buf;
RK_U8 *buf_c = buf + hor_stride * ver_stride;
RK_U32 x, y, i;
static RK_S32 is_pixel_stride = 0;
static RK_S32 not_8_pixel = 0;
switch (fmt) {
case RK_FMT_YUV420SP : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width; x++) {
p[x] = x + y + frame_count * 3;
}
}
p = buf + hor_stride * ver_stride;
for (y = 0; y < height / 2; y++, p += hor_stride) {
for (x = 0; x < width / 2; x++) {
p[x * 2 + 0] = 128 + y + frame_count * 2;
p[x * 2 + 1] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV422SP : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width; x++) {
p[x] = x + y + frame_count * 3;
}
}
p = buf + hor_stride * ver_stride;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width / 2; x++) {
p[x * 2 + 0] = 128 + y / 2 + frame_count * 2;
p[x * 2 + 1] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV420P : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width; x++) {
p[x] = x + y + frame_count * 3;
}
}
p = buf_c;
for (y = 0; y < height / 2; y++, p += hor_stride / 2) {
for (x = 0; x < width / 2; x++) {
p[x] = 128 + y + frame_count * 2;
}
}
p = buf_c + hor_stride * ver_stride / 4;
for (y = 0; y < height / 2; y++, p += hor_stride / 2) {
for (x = 0; x < width / 2; x++) {
p[x] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV420SP_VU : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width; x++) {
p[x] = x + y + frame_count * 3;
}
}
p = buf_c;
for (y = 0; y < height / 2; y++, p += hor_stride) {
for (x = 0; x < width / 2; x++) {
p[x * 2 + 1] = 128 + y + frame_count * 2;
p[x * 2 + 0] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV422P : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width; x++) {
p[x] = x + y + frame_count * 3;
}
}
p = buf_c;
for (y = 0; y < height; y++, p += hor_stride / 2) {
for (x = 0; x < width / 2; x++) {
p[x] = 128 + y / 2 + frame_count * 2;
}
}
p = buf_c + hor_stride * ver_stride / 2;
for (y = 0; y < height; y++, p += hor_stride / 2) {
for (x = 0; x < width / 2; x++) {
p[x] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV422SP_VU : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width; x++) {
p[x] = x + y + frame_count * 3;
}
}
p = buf_c;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width / 2; x++) {
p[x * 2 + 1] = 128 + y / 2 + frame_count * 2;
p[x * 2 + 0] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV422_YUYV : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride * 2) {
for (x = 0; x < width / 2; x++) {
p[x * 4 + 0] = x * 2 + 0 + y + frame_count * 3;
p[x * 4 + 2] = x * 2 + 1 + y + frame_count * 3;
p[x * 4 + 1] = 128 + y / 2 + frame_count * 2;
p[x * 4 + 3] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV422_YVYU : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride * 2) {
for (x = 0; x < width / 2; x++) {
p[x * 4 + 0] = x * 2 + 0 + y + frame_count * 3;
p[x * 4 + 2] = x * 2 + 1 + y + frame_count * 3;
p[x * 4 + 3] = 128 + y / 2 + frame_count * 2;
p[x * 4 + 1] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV422_UYVY : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride * 2) {
for (x = 0; x < width / 2; x++) {
p[x * 4 + 1] = x * 2 + 0 + y + frame_count * 3;
p[x * 4 + 3] = x * 2 + 1 + y + frame_count * 3;
p[x * 4 + 0] = 128 + y / 2 + frame_count * 2;
p[x * 4 + 2] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV422_VYUY : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride * 2) {
for (x = 0; x < width / 2; x++) {
p[x * 4 + 1] = x * 2 + 0 + y + frame_count * 3;
p[x * 4 + 3] = x * 2 + 1 + y + frame_count * 3;
p[x * 4 + 2] = 128 + y / 2 + frame_count * 2;
p[x * 4 + 0] = 64 + x + frame_count * 5;
}
}
} break;
case RK_FMT_YUV400SP : {
RK_U8 *p = buf_y;
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0; x < width; x++) {
p[x] = x + y + frame_count * 3;
}
}
} break;
case RK_FMT_RGB565 :
case RK_FMT_BGR565 :
case RK_FMT_RGB555 :
case RK_FMT_BGR555 :
case RK_FMT_RGB444 :
case RK_FMT_BGR444 :
case RK_FMT_ARGB1555 :
case RK_FMT_ABGR1555 :
case RK_FMT_RGBA5551 :
case RK_FMT_BGRA5551 :
case RK_FMT_ARGB4444 :
case RK_FMT_ABGR4444 :
case RK_FMT_BGRA4444 : {
RK_U8 *p = buf_y;
RK_U32 pix_w = 2;
FillRgbFunc fill = fill_rgb_funcs[fmt - RK_VIDEO_FMT_RGB];
if (util_check_stride_by_pixel(is_pixel_stride, width, hor_stride, pix_w)) {
hor_stride *= pix_w;
is_pixel_stride = 1;
}
if (util_check_8_pixel_aligned(not_8_pixel, hor_stride,
8, pix_w, "16bit RGB")) {
hor_stride = RK_ALIGN(hor_stride, 16);
not_8_pixel = 1;
}
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0, i = 0; x < width; x++, i += pix_w) {
RK_U32 R, G, B;
get_rgb_color(&R, &G, &B, x, y, frame_count);
fill(p + i, R, G, B, 1);
}
}
} break;
case RK_FMT_RGB101010 :
case RK_FMT_BGR101010 :
case RK_FMT_ARGB8888 :
case RK_FMT_ABGR8888 :
case RK_FMT_BGRA8888 :
case RK_FMT_RGBA8888 : {
RK_U8 *p = buf_y;
RK_U32 pix_w = 4;
FillRgbFunc fill = fill_rgb_funcs[fmt - RK_VIDEO_FMT_RGB];
if (util_check_stride_by_pixel(is_pixel_stride, width, hor_stride, pix_w)) {
hor_stride *= pix_w;
is_pixel_stride = 1;
}
if (util_check_8_pixel_aligned(not_8_pixel, hor_stride,
8, pix_w, "32bit RGB")) {
hor_stride = RK_ALIGN(hor_stride, 32);
not_8_pixel = 1;
}
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0, i = 0; x < width; x++, i += pix_w) {
RK_U32 R, G, B;
get_rgb_color(&R, &G, &B, x, y, frame_count);
fill(p + i, R, G, B, 1);
}
}
} break;
case RK_FMT_BGR888 :
case RK_FMT_RGB888 : {
RK_U8 *p = buf_y;
RK_U32 pix_w = 3;
FillRgbFunc fill = fill_rgb_funcs[fmt - RK_VIDEO_FMT_RGB];
if (util_check_stride_by_pixel(is_pixel_stride, width, hor_stride, pix_w)) {
hor_stride *= pix_w;
is_pixel_stride = 1;
}
if (util_check_8_pixel_aligned(not_8_pixel, hor_stride,
8, pix_w, "24bit RGB")) {
hor_stride = RK_ALIGN(hor_stride, 24);
not_8_pixel = 1;
}
for (y = 0; y < height; y++, p += hor_stride) {
for (x = 0, i = 0; x < width; x++, i += pix_w) {
RK_U32 R, G, B;
get_rgb_color(&R, &G, &B, x, y, frame_count);
fill(p + i, R, G, B, 1);
}
}
} break;
default : {
RK_LOGE("filling function do not support type %d\n", fmt);
ret = -1;
} break;
}
return ret;
}
RK_BOOL TEST_COMM_CompareImageFuzzy(
RK_U8 *pu8Src, RK_U8 *pu8Dst, RK_U32 u32Stride,
RK_U32 u32Width, RK_U32 u32Height, RK_DOUBLE dThreshold) {
RK_U8 *pu8TmpSrc = pu8Src;
RK_U8 *pu8TmpDst = pu8Dst;
RK_U32 u32LineDiffCnt = 0;
RK_U32 u32MaxLineDiffCnt = 0;
RK_U32 u32TotalDiffCnt = 0;
RK_DOUBLE dAvgDiffRate = 0.0f;
RK_U32 u32EffectStride = (u32Stride / u32Width) * u32Width;
for (RK_U32 i = 0; i < u32Height; i++) {
for (RK_U32 j = 0; j < u32EffectStride; j++) {
if (abs(pu8TmpSrc[i * u32Stride +j] - pu8TmpDst[i * u32Stride +j]) > 0x20) {
u32LineDiffCnt++;
}
}
if (u32LineDiffCnt > u32MaxLineDiffCnt) {
u32MaxLineDiffCnt = u32LineDiffCnt;
}
u32TotalDiffCnt += u32LineDiffCnt;
u32LineDiffCnt = 0;
}
dAvgDiffRate = (RK_DOUBLE)u32TotalDiffCnt / u32EffectStride / u32Height;
RK_LOGI("max line diff(%d), stride(%d), diff rate act(%f) VS exp(%f)",
u32MaxLineDiffCnt, u32EffectStride,
(RK_DOUBLE)u32MaxLineDiffCnt / u32EffectStride, dThreshold * 2);
RK_LOGI("total pixel diff(%d), pixel number(%d), diff rate act(%f) VS exp(%f)",
u32TotalDiffCnt, u32EffectStride * u32Height, dAvgDiffRate, dThreshold / 2);
if (dThreshold * 2 < (RK_DOUBLE)u32MaxLineDiffCnt / u32EffectStride
&& dThreshold / 2 < dAvgDiffRate) {
return RK_TRUE;
} else {
return RK_FALSE;
}
}