792 lines
25 KiB
C++
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;
|
|
}
|
|
}
|