diff options
Diffstat (limited to 'test/repack.c')
| -rw-r--r-- | test/repack.c | 532 |
1 files changed, 532 insertions, 0 deletions
diff --git a/test/repack.c b/test/repack.c new file mode 100644 index 0000000..a37559b --- /dev/null +++ b/test/repack.c @@ -0,0 +1,532 @@ +#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; +} |