#include <limits.h>
#include <libavutil/pixfmt.h>
#include "common/common.h"
#include "common/global.h"
#include "img_utils.h"
#include "sub/draw_bmp.h"
#include "sub/osd.h"
#include "test_utils.h"
#include "video/fmt-conversion.h"
#include "video/mp_image.h"
#include "video/img_format.h"
#include "video/repack.h"
#include "video/sws_utils.h"
#include "video/zimg.h"
// Excuse the utter stupidity.
#define UNFUCK(v) ((v) > 0 ? (v) : pixfmt2imgfmt(-(v)))
static_assert(IMGFMT_START > 0, "");
#define IMGFMT_GBRP (-AV_PIX_FMT_GBRP)
#define IMGFMT_GBRAP (-AV_PIX_FMT_GBRAP)
struct entry {
int w, h;
int fmt_a;
const void *const a[4];
int fmt_b;
const void *const b[4];
int flags;
};
#define P8(...) (const uint8_t[]){__VA_ARGS__}
#define P16(...) (const uint16_t[]){__VA_ARGS__}
#define P32(...) (const uint32_t[]){__VA_ARGS__}
#define SW16(v) ((((v) & 0xFF) << 8) | ((v) >> 8))
#define SW32(v) ((SW16((v) & 0xFFFFu) << 16) | (SW16(((v) | 0u) >> 16)))
#define ZIMG_IMAGE_DIMENSION_MAX ((size_t)(1) << (CHAR_BIT * sizeof(size_t) / 2 - 2))
// Warning: only entries that match existing conversions are tested.
static const struct entry repack_tests[] = {
// Note: the '0' tests rely on 0 being written, although by definition the
// contents of this padding is undefined. The repacker always writes
// it this way, though.
{1, 1, IMGFMT_RGB0, {P8(1, 2, 3, 0)},
IMGFMT_GBRP, {P8(2), P8(3), P8(1)}},
{1, 1, IMGFMT_BGR0, {P8(1, 2, 3, 0)},
IMGFMT_GBRP, {P8(2), P8(1), P8(3)}},
{1, 1, IMGFMT_0RGB, {P8(0, 1, 2, 3)},
IMGFMT_GBRP, {P8(2), P8(3), P8(1)}},
{1, 1, IMGFMT_0BGR, {P8(0, 1, 2, 3)},
IMGFMT_GBRP, {P8(2), P8(1), P8(3)}},
{1, 1, IMGFMT_RGBA, {P8(1, 2, 3, 4)},
IMGFMT_GBRAP, {P8(2), P8(3), P8(1), P8(4)}},
{1, 1, IMGFMT_BGRA, {P8(1, 2, 3, 4)},
IMGFMT_GBRAP, {P8(2), P8(1), P8(3), P8(4)}},
{1, 1, IMGFMT_ARGB, {P8(4, 1, 2, 3)},
IMGFMT_GBRAP, {P8(2), P8(3), P8(1), P8(4)}},
{1, 1, IMGFMT_ABGR, {P8(4, 1, 2, 3)},
IMGFMT_GBRAP, {P8(2), P8(1), P8(3), P8(4)}},
{1, 1, IMGFMT_BGR24, {P8(1, 2, 3)},
IMGFMT_GBRP, {P8(2), P8(1), P8(3)}},
{1, 1, IMGFMT_RGB24, {P8(1, 2, 3)},
IMGFMT_GBRP, {P8(2), P8(3), P8(1)}},
{1, 1, IMGFMT_RGBA64, {P16(0x1a1b, 0x2a2b, 0x3a3b, 0x4a4b)},
-AV_PIX_FMT_GBRAP16, {P16(0x2a2b), P16(0x3a3b),
P16(0x1a1b), P16(0x4a4b)}},
{1, 1, -AV_PIX_FMT_BGRA64LE, {P16(0x1a1b, 0x2a2b, 0x3a3b, 0x4a4b)},
-AV_PIX_FMT_GBRAP16, {P16(0x2a2b), P16(0x1a1b),
P16(0x3a3b), P16(0x4a4b)}},
{1, 1, -AV_PIX_FMT_RGBA64BE, {P16(0x1b1a, 0x2b2a, 0x3b3a, 0x4b4a)},
-AV_PIX_FMT_GBRAP16, {P16(0x2a2b), P16(0x3a3b),
P16(0x1a1b), P16(0x4a4b)}},
{1, 1, -AV_PIX_FMT_BGRA64BE, {P16(0x1b1a, 0x2b2a, 0x3b3a, 0x4b4a)},
-AV_PIX_FMT_GBRAP16, {P16(0x2a2b), P16(0x1a1b),
P16(0x3a3b), P16(0x4a4b)}},
{1, 1, -AV_PIX_FMT_RGB48BE, {P16(0x1a1b, 0x2a2b, 0x3a3b)},
-AV_PIX_FMT_GBRP16, {P16(0x2b2a), P16(0x3b3a), P16(0x1b1a)}},
{1, 1, -AV_PIX_FMT_RGB48LE, {P16(0x1a1b, 0x2a2b, 0x3a3b)},
-AV_PIX_FMT_GBRP16, {P16(0x2a2b), P16(0x3a3b), P16(0x1a1b)}},
{1, 1, -AV_PIX_FMT_BGR48BE, {P16(0x1a1b, 0x2a2b, 0x3a3b)},
-AV_PIX_FMT_GBRP16, {P16(0x2b2a), P16(0x1b1a), P16(0x3b3a)}},
{1, 1, -AV_PIX_FMT_BGR48LE, {P16(0x1a1b, 0x2a2b, 0x3a3b)},
-AV_PIX_FMT_GBRP16, {P16(0x2a2b), P16(0x1a1b), P16(0x3a3b)}},
{1, 1, -AV_PIX_FMT_XYZ12LE, {P16(0x1a1b, 0x2a2b, 0x3a3b)},
-AV_PIX_FMT_GBRP16, {P16(0x2a2b), P16(0x3a3b), P16(0x1a1b)}},
{1, 1, -AV_PIX_FMT_XYZ12BE, {P16(0x1b1a, 0x2b2a, 0x3b3a)},
-AV_PIX_FMT_GBRP16, {P16(0x2a2b), P16(0x3a3b), P16(0x1a1b)}},
{3, 1, -AV_PIX_FMT_BGR8, {P8(7, (7 << 3), (3 << 6))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB8, {P8(3, (7 << 2), (7 << 5))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_BGR4_BYTE, {P8(1, (3 << 1), (1 << 3))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB4_BYTE, {P8(1, (3 << 1), (1 << 3))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB565LE, {P16((31), (63 << 5), (31 << 11))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB565BE, {P16(SW16(31), SW16(63 << 5), SW16(31 << 11))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_BGR565LE, {P16((31), (63 << 5), (31 << 11))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_BGR565BE, {P16(SW16(31), SW16(63 << 5), SW16(31 << 11))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB555LE, {P16((31), (31 << 5), (31 << 10))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB555BE, {P16(SW16(31), SW16(31 << 5), SW16(31 << 10))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_BGR555LE, {P16((31), (31 << 5), (31 << 10))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_BGR555BE, {P16(SW16(31), SW16(31 << 5), SW16(31 << 10))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB444LE, {P16((15), (15 << 4), (15 << 8))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_RGB444BE, {P16(SW16(15), SW16(15 << 4), SW16(15 << 8))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0xFF,0,0), P8(0,0,0xFF)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_BGR444LE, {P16((15), (15 << 4), (15 << 8))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{3, 1, -AV_PIX_FMT_BGR444BE, {P16(SW16(15), SW16(15 << 4), SW16(15 << 8))},
IMGFMT_GBRP, {P8(0,0xFF,0), P8(0,0,0xFF), P8(0xFF,0,0)},
.flags = REPACK_CREATE_EXPAND_8BIT},
{1, 1, IMGFMT_RGB30, {P32((3 << 20) | (2 << 10) | 1)},
-AV_PIX_FMT_GBRP10, {P16(2), P16(1), P16(3)}},
{1, 1, -AV_PIX_FMT_X2RGB10BE, {P32(SW32((3 << 20) | (2 << 10) | 1))},
-AV_PIX_FMT_GBRP10, {P16(2), P16(1), P16(3)}},
{8, 1, -AV_PIX_FMT_MONOWHITE, {P8(0xAA)},
IMGFMT_Y1, {P8(0, 1, 0, 1, 0, 1, 0, 1)}},
{8, 1, -AV_PIX_FMT_MONOBLACK, {P8(0xAA)},
IMGFMT_Y1, {P8(1, 0, 1, 0, 1, 0, 1, 0)}},
{2, 2, IMGFMT_NV12, {P8(1, 2, 3, 4), P8(5, 6)},
IMGFMT_420P, {P8(1, 2, 3, 4), P8(5), P8(6)}},
{2, 2, -AV_PIX_FMT_NV21, {P8(1, 2, 3, 4), P8(5, 6)},
IMGFMT_420P, {P8(1, 2, 3, 4), P8(6), P8(5)}},
{1, 1, -AV_PIX_FMT_AYUV64LE, {P16(1, 2, 3, 4)},
-AV_PIX_FMT_YUVA444P16, {P16(2), P16(3), P16(4), P16(1)}},
{1, 1, -AV_PIX_FMT_AYUV64BE, {P16(0x0100, 0x0200, 0x0300, 0x0400)},
-AV_PIX_FMT_YUVA444P16, {P16(2), P16(3), P16(4), P16(1)}},
{4, 1, -AV_PIX_FMT_YUYV422, {P8(1, 2, 3, 4, 5, 6, 7, 8)},
-AV_PIX_FMT_YUV422P, {P8(1, 3, 5, 7), P8(2, 6), P8(4, 8)}},
{2, 1, -AV_PIX_FMT_YVYU422, {P8(1, 2, 3, 4)},
-AV_PIX_FMT_YUV422P, {P8(1, 3), P8(4), P8(2)}},
{2, 1, -AV_PIX_FMT_UYVY422, {P8(1, 2, 3, 4)},
-AV_PIX_FMT_YUV422P, {P8(2, 4), P8(1), P8(3)}},
{2, 1, -AV_PIX_FMT_Y210LE, {P16(0x1a1b, 0x2a2b, 0x3a3b, 0x4a4b)},
-AV_PIX_FMT_YUV422P16, {P16(0x1a1b, 0x3a3b), P16(0x2a2b), P16(0x4a4b)}},
{2, 1, -AV_PIX_FMT_Y210BE, {P16(0x1b1a, 0x2b2a, 0x3b3a, 0x4b4a)},
-AV_PIX_FMT_YUV422P16, {P16(0x1a1b, 0x3a3b), P16(0x2a2b), P16(0x4a4b)}},
{1, 1, -AV_PIX_FMT_YA8, {P8(1, 2)},
IMGFMT_YAP8, {P8(1), P8(2)}},
{1, 1, -AV_PIX_FMT_YA16, {P16(0x1a1b, 0x2a2b)},
IMGFMT_YAP16, {P16(0x1a1b), P16(0x2a2b)}},
{2, 1, -AV_PIX_FMT_YUV422P16BE, {P16(0x1a1b, 0x2a2b), P16(0x3a3b),
P16(0x4a4b)},
-AV_PIX_FMT_YUV422P16, {P16(0x1b1a, 0x2b2a), P16(0x3b3a),
P16(0x4b4a)}},
{8, 1, -AV_PIX_FMT_UYYVYY411, {P8(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)},
-AV_PIX_FMT_YUV411P, {P8(2, 3, 5, 6, 8, 9, 11, 12),
P8(1, 7), P8(4, 10)}},
};
static bool is_true_planar(int imgfmt)
{
struct mp_regular_imgfmt desc;
if (!mp_get_regular_imgfmt(&desc, imgfmt))
return false;
for (int n = 0; n < desc.num_planes; n++) {
if (desc.planes[n].num_components != 1)
return false;
}
return true;
}
static int try_repack(FILE *f, int imgfmt, int flags, int not_if_fmt)
{
char *head = mp_tprintf(80, "%-15s =>", mp_imgfmt_to_name(imgfmt));
struct mp_repack *un = mp_repack_create_planar(imgfmt, false, flags);
struct mp_repack *pa = mp_repack_create_planar(imgfmt, true, flags);
// If both exists, they must be always symmetric.
if (un && pa) {
assert(mp_repack_get_format_src(pa) == mp_repack_get_format_dst(un));
assert(mp_repack_get_format_src(un) == mp_repack_get_format_dst(pa));
assert(mp_repack_get_align_x(pa) == mp_repack_get_align_x(un));
assert(mp_repack_get_align_y(pa) == mp_repack_get_align_y(un));
}
int a = 0;
int b = 0;
if (un) {
a = mp_repack_get_format_src(un);
b = mp_repack_get_format_dst(un);
} else if (pa) {
a = mp_repack_get_format_dst(pa);
b = mp_repack_get_format_src(pa);
}
// Skip the identity ones because they're uninteresting, and add too much
// noise. But still make sure they behave as expected.
if (a == imgfmt && b == imgfmt) {
assert(is_true_planar(imgfmt));
// (note that we require alpha-enabled zimg)
assert(mp_zimg_supports_in_format(imgfmt));
assert(un && pa);
talloc_free(pa);
talloc_free(un);
return b;
}
struct mp_repack *rp = pa ? pa : un;
if (!rp) {
if (!flags)
fprintf(f, "%s no\n", head);
return 0;
}
assert(a == imgfmt);
if (b && b == not_if_fmt) {
talloc_free(pa);
talloc_free(un);
return 0;
}
fprintf(f, "%s %4s %4s %-15s |", head, pa ? "[pa]" : "", un ? "[un]" : "",
mp_imgfmt_to_name(b));
fprintf(f, " a=%d:%d", mp_repack_get_align_x(rp), mp_repack_get_align_y(rp));
if (flags & REPACK_CREATE_PLANAR_F32)
fprintf(f, " [planar-f32]");
if (flags & REPACK_CREATE_ROUND_DOWN)
fprintf(f, " [round-down]");
if (flags & REPACK_CREATE_EXPAND_8BIT)
fprintf(f, " [expand-8bit]");
// LCM of alignment of all packers.
int ax = mp_repack_get_align_x(rp);
int ay = mp_repack_get_align_y(rp);
if (pa && un) {
ax = MPMAX(mp_repack_get_align_x(pa), mp_repack_get_align_x(un));
ay = MPMAX(mp_repack_get_align_y(pa), mp_repack_get_align_y(un));
}
for (int n = 0; n < MP_ARRAY_SIZE(repack_tests); n++) {
const struct entry *e = &repack_tests[n];
int fmt_a = UNFUCK(e->fmt_a);
int fmt_b = UNFUCK(e->fmt_b);
if (!(fmt_a == a && fmt_b == b && e->flags == flags))
continue;
// We convert a "random" macro pixel to catch potential addressing bugs
// that might be ignored with (0, 0) origins.
struct mp_image *ia = mp_image_alloc(fmt_a, e->w * 5 * ax, e->h * 5 * ay);
struct mp_image *ib = mp_image_alloc(fmt_b, e->w * 7 * ax, e->h * 6 * ay);
int sx = 4 * ax, sy = 3 * ay, dx = 3 * ax, dy = 2 * ay;
assert(ia && ib);
mp_image_params_guess_csp(&ia->params);
mp_image_params_guess_csp(&ib->params);
for (int pack = 0; pack < 2; pack++) {
struct mp_repack *repacker = pack ? pa : un;
if (!repacker)
continue;
mp_image_clear(ia, 0, 0, ia->w, ia->h);
mp_image_clear(ib, 0, 0, ib->w, ib->h);
const void *const *dstd = pack ? e->a : e->b;
const void *const *srcd = pack ? e->b : e->a;
struct mp_image *dsti = pack ? ia : ib;
struct mp_image *srci = pack ? ib : ia;
bool r = repack_config_buffers(repacker, 0, dsti, 0, srci, NULL);
assert(r);
for (int p = 0; p < srci->num_planes; p++) {
uint8_t *ptr = mp_image_pixel_ptr(srci, p, sx, sy);
for (int y = 0; y < e->h >> srci->fmt.ys[p]; y++) {
int wb = mp_image_plane_bytes(srci, p, 0, e->w);
const void *cptr = (uint8_t *)srcd[p] + wb * y;
memcpy(ptr + srci->stride[p] * y, cptr, wb);
}
}
repack_line(repacker, dx, dy, sx, sy, e->w);
for (int p = 0; p < dsti->num_planes; p++) {
uint8_t *ptr = mp_image_pixel_ptr(dsti, p, dx, dy);
for (int y = 0; y < e->h >> dsti->fmt.ys[p]; y++) {
int wb = mp_image_plane_bytes(dsti, p, 0, e->w);
const void *cptr = (uint8_t *)dstd[p] + wb * y;
assert_memcmp(ptr + dsti->stride[p] * y, cptr, wb);
}
}
fprintf(f, " [t%s]", pack ? "p" : "u");
}
talloc_free(ia);
talloc_free(ib);
}
fprintf(f, "\n");
talloc_free(pa);
talloc_free(un);
return b;
}
static void check_float_repack(int imgfmt, enum mp_csp csp,
enum mp_csp_levels levels)
{
imgfmt = UNFUCK(imgfmt);
struct mp_regular_imgfmt desc = {0};
mp_get_regular_imgfmt(&desc, imgfmt);
int bpp = desc.component_size;
int comp_bits = desc.component_size * 8 + MPMIN(desc.component_pad, 0);
assert(bpp == 1 || bpp == 2);
int w = 1 << (bpp * 8);
if (w > ZIMG_IMAGE_DIMENSION_MAX) {
printf("Image dimension (%d) exceeded maximum allowed by zimg (%zu)."
" Skipping test...\n", w, ZIMG_IMAGE_DIMENSION_MAX);
return;
}
struct mp_image *src = mp_image_alloc(imgfmt, w, 1);
assert(src);
src->params.color.space = csp;
src->params.color.levels = levels;
mp_image_params_guess_csp(&src->params);
// mpv may not allow all combinations
assert(src->params.color.space == csp);
assert(src->params.color.levels == levels);
for (int p = 0; p < src->num_planes; p++) {
int val = 0;
for (int x = 0; x < w >> src->fmt.xs[p]; x++) {
val = MPMIN(val, (1 << comp_bits) - 1);
void *pixel = mp_image_pixel_ptr(src, p, x, 0);
if (bpp == 1) {
*(uint8_t *)pixel = val;
} else {
*(uint16_t *)pixel = val;
}
val++;
}
}
struct mp_repack *to_f =
mp_repack_create_planar(src->imgfmt, false, REPACK_CREATE_PLANAR_F32);
struct mp_repack *from_f =
mp_repack_create_planar(src->imgfmt, true, REPACK_CREATE_PLANAR_F32);
assert(to_f && from_f);
struct mp_image *z_f = mp_image_alloc(mp_repack_get_format_dst(to_f), w, 1);
struct mp_image *r_f = mp_image_alloc(z_f->imgfmt, w, 1);
struct mp_image *z_i = mp_image_alloc(src->imgfmt, w, 1);
struct mp_image *r_i = mp_image_alloc(src->imgfmt, w, 1);
assert(z_f && r_f && z_i && r_i);
z_f->params.color = r_f->params.color = z_i->params.color =
r_i->params.color = src->params.color;
// The idea is to use zimg to cross-check conversion.
struct mp_sws_context *s = mp_sws_alloc(NULL);
s->force_scaler = MP_SWS_ZIMG;
struct zimg_opts opts = zimg_opts_defaults;
opts.dither = ZIMG_DITHER_NONE;
s->zimg_opts = &opts;
int ret = mp_sws_scale(s, z_f, src);
assert_true(ret >= 0);
ret = mp_sws_scale(s, z_i, z_f);
assert_true(ret >= 0);
talloc_free(s);
repack_config_buffers(to_f, 0, r_f, 0, src, NULL);
repack_line(to_f, 0, 0, 0, 0, w);
repack_config_buffers(from_f, 0, r_i, 0, r_f, NULL);
repack_line(from_f, 0, 0, 0, 0, w);
for (int p = 0; p < src->num_planes; p++) {
for (int x = 0; x < w >> src->fmt.xs[p]; x++) {
uint32_t src_val, z_i_val, r_i_val;
if (bpp == 1) {
src_val = *(uint8_t *)mp_image_pixel_ptr(src, p, x, 0);
z_i_val = *(uint8_t *)mp_image_pixel_ptr(z_i, p, x, 0);
r_i_val = *(uint8_t *)mp_image_pixel_ptr(r_i, p, x, 0);
} else {
src_val = *(uint16_t *)mp_image_pixel_ptr(src, p, x, 0);
z_i_val = *(uint16_t *)mp_image_pixel_ptr(z_i, p, x, 0);
r_i_val = *(uint16_t *)mp_image_pixel_ptr(r_i, p, x, 0);
}
float z_f_val = *(float *)mp_image_pixel_ptr(z_f, p, x, 0);
float r_f_val = *(float *)mp_image_pixel_ptr(r_f, p, x, 0);
assert_int_equal(src_val, z_i_val);
assert_int_equal(src_val, r_i_val);
double tolerance = 1.0 / (1 << (bpp * 8)) / 4;
assert_float_equal(r_f_val, z_f_val, tolerance);
}
}
talloc_free(src);
talloc_free(z_i);
talloc_free(z_f);
talloc_free(r_i);
talloc_free(r_f);
talloc_free(to_f);
talloc_free(from_f);
}
static bool try_draw_bmp(FILE *f, int imgfmt)
{
bool ok = false;
struct mp_image *dst = mp_image_alloc(imgfmt, 64, 64);
if (!dst)
goto done;
struct sub_bitmap sb = {
.bitmap = &(uint8_t[]){123},
.stride = 1,
.x = 1,
.y = 1,
.w = 1, .dw = 1,
.h = 1, .dh = 1,
.libass = { .color = 0xDEDEDEDE },
};
struct sub_bitmaps sbs = {
.format = SUBBITMAP_LIBASS,
.parts = &sb,
.num_parts = 1,
.change_id = 1,
};
struct sub_bitmap_list sbs_list = {
.change_id = 1,
.w = dst->w,
.h = dst->h,
.items = (struct sub_bitmaps *[]){&sbs},
.num_items = 1,
};
struct mp_draw_sub_cache *c = mp_draw_sub_alloc_test(dst);
if (mp_draw_sub_bitmaps(c, dst, &sbs_list)) {
char *info = mp_draw_sub_get_dbg_info(c);
fprintf(f, "%s\n", info);
talloc_free(info);
ok = true;
}
talloc_free(c);
talloc_free(dst);
done:
if (!ok)
fprintf(f, "no\n");
return ok;
}
int main(int argc, char *argv[])
{
const char *refdir = argv[1];
const char *outdir = argv[2];
FILE *f = test_open_out(outdir, "repack.txt");
init_imgfmts_list();
for (int n = 0; n < num_imgfmts; n++) {
int imgfmt = imgfmts[n];
int other = try_repack(f, imgfmt, 0, 0);
try_repack(f, imgfmt, REPACK_CREATE_ROUND_DOWN, other);
try_repack(f, imgfmt, REPACK_CREATE_EXPAND_8BIT, other);
try_repack(f, imgfmt, REPACK_CREATE_PLANAR_F32, other);
}
fclose(f);
assert_text_files_equal(refdir, outdir, "repack.txt",
"This can fail if FFmpeg/libswscale adds or removes pixfmts.");
check_float_repack(-AV_PIX_FMT_GBRAP, MP_CSP_RGB, MP_CSP_LEVELS_PC);
check_float_repack(-AV_PIX_FMT_GBRAP10, MP_CSP_RGB, MP_CSP_LEVELS_PC);
check_float_repack(-AV_PIX_FMT_GBRAP16, MP_CSP_RGB, MP_CSP_LEVELS_PC);
check_float_repack(-AV_PIX_FMT_YUVA444P, MP_CSP_BT_709, MP_CSP_LEVELS_PC);
check_float_repack(-AV_PIX_FMT_YUVA444P, MP_CSP_BT_709, MP_CSP_LEVELS_TV);
check_float_repack(-AV_PIX_FMT_YUVA444P10, MP_CSP_BT_709, MP_CSP_LEVELS_PC);
check_float_repack(-AV_PIX_FMT_YUVA444P10, MP_CSP_BT_709, MP_CSP_LEVELS_TV);
check_float_repack(-AV_PIX_FMT_YUVA444P16, MP_CSP_BT_709, MP_CSP_LEVELS_PC);
check_float_repack(-AV_PIX_FMT_YUVA444P16, MP_CSP_BT_709, MP_CSP_LEVELS_TV);
// Determine the list of possible draw_bmp input formats. Do this here
// because it mostly depends on repack and imgformat stuff.
f = test_open_out(outdir, "draw_bmp.txt");
for (int n = 0; n < num_imgfmts; n++) {
int imgfmt = imgfmts[n];
fprintf(f, "%-12s= ", mp_imgfmt_to_name(imgfmt));
try_draw_bmp(f, imgfmt);
}
fclose(f);
assert_text_files_equal(refdir, outdir, "draw_bmp.txt",
"This can fail if FFmpeg/libswscale adds or removes pixfmts.");
return 0;
}