This is an automated email from the git hooks/post-receive script. Git pushed a commit to branch master in repository ffmpeg.
commit adaf1426470614259c1960a9cfc3c31b071eaefc Author: Niklas Haas <[email protected]> AuthorDate: Sun May 17 13:23:06 2026 +0200 Commit: Niklas Haas <[email protected]> CommitDate: Tue Jun 9 18:27:20 2026 +0200 swscale/uops: generate uop helper macros This follows the same approach as is used currently by ops_entries_aarch64, except I decided to have the generation logic live directly in uops.c to allow re-using internal helpers and move it closer to the other helpers that depend on the exact set of uops and their fields. Unlike libswscale/tests/sws_ops.c, we make an effort to actually test all relevant flag combinations, since these can affect the generated op lists. I will use these macros to auto-generate both the C template-based kernels, as well as the entire x86 backend, in the near future, hence their excessive flexibility. Re-use the libswscale/tests/sws_ops.c that we already compile. We could put it in its own file but this is just as convenient, and it's easily moved anyways. Having it be a FATE test ensures that it is always up-to-date. Signed-off-by: Niklas Haas <[email protected]> --- libswscale/tests/sws_ops.c | 14 + libswscale/uops.c | 299 ++++++++++++- libswscale/uops.h | 13 + libswscale/uops_macros.h | 1009 ++++++++++++++++++++++++++++++++++++++++++++ tests/fate/libswscale.mak | 7 + tests/ref/fate/source | 1 + 6 files changed, 1342 insertions(+), 1 deletion(-) diff --git a/libswscale/tests/sws_ops.c b/libswscale/tests/sws_ops.c index 32fcece1b6..22b90926ca 100644 --- a/libswscale/tests/sws_ops.c +++ b/libswscale/tests/sws_ops.c @@ -18,6 +18,7 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "libavutil/mem.h" #include "libavutil/pixdesc.h" #include "libswscale/ops.h" #include "libswscale/ops_dispatch.h" @@ -109,6 +110,7 @@ int main(int argc, char **argv) enum AVPixelFormat dst_fmt = AV_PIX_FMT_NONE; SwsContext *ctx = NULL; SwsGraph *graph = NULL; + bool macros_gen = false; int ret = 1; #ifdef _WIN32 @@ -127,6 +129,8 @@ int main(int argc, char **argv) " Only test the specified source pixel format\n" " -v <level>\n" " Enable log verbosity at given level\n" + " -macros\n" + " Generate helper macros\n" ); return 0; } @@ -153,6 +157,8 @@ int main(int argc, char **argv) goto bad_option; av_log_set_level(atoi(argv[i + 1])); i++; + } else if (!strcmp(argv[i], "-macros")) { + macros_gen = true; } else { bad_option: fprintf(stderr, "bad option or argument missing (%s) see -help\n", argv[i]); @@ -160,6 +166,14 @@ bad_option: } } + if (macros_gen) { + char *macros = NULL; + ret = ff_sws_uops_macros_gen(¯os); + if (ret >= 0) + puts(macros); + av_free(macros); + return ret; + } /* Allocate dummy graph and context for ff_sws_compile_pass() */ graph = ff_sws_graph_alloc(); if (!graph) diff --git a/libswscale/uops.c b/libswscale/uops.c index f3c0bb7b81..12b92c2bde 100644 --- a/libswscale/uops.c +++ b/libswscale/uops.c @@ -23,6 +23,7 @@ #include "libavutil/avassert.h" #include "libavutil/mem.h" #include "libavutil/refstruct.h" +#include "libavutil/tree.h" #include "ops.h" #include "ops_internal.h" @@ -42,8 +43,9 @@ int ff_sws_uop_cmp(const SwsUOp *a, const SwsUOp *b) static const struct { char full[24]; char abbr[16]; + char macro[16]; } uop_names[SWS_UOP_TYPE_NB] = { -#define UOP_NAME(OP, ABBR) [SWS_UOP_##OP] = { "SWS_UOP_" #OP, ABBR } +#define UOP_NAME(OP, ABBR) [SWS_UOP_##OP] = { "SWS_UOP_" #OP, ABBR, #OP } UOP_NAME(INVALID, "invalid"), UOP_NAME(READ_PLANAR, "read_planar"), UOP_NAME(READ_PLANAR_FH, "read_planar_fh"), @@ -79,6 +81,17 @@ static const struct { #undef UOP_NAME }; +static const struct { + char full[16]; + char prefix[8]; +} pixel_types[SWS_PIXEL_TYPE_NB] = { + [SWS_PIXEL_NONE] = { "SWS_PIXEL_NONE", "" }, + [SWS_PIXEL_U8] = { "SWS_PIXEL_U8", "U8_" }, + [SWS_PIXEL_U16] = { "SWS_PIXEL_U16", "U16_" }, + [SWS_PIXEL_U32] = { "SWS_PIXEL_U32", "U32_" }, + [SWS_PIXEL_F32] = { "SWS_PIXEL_F32", "F32_" }, +}; + static SwsPixel pixel_from_q(SwsPixelType type, AVRational val) { av_assert1(val.den != 0); @@ -188,6 +201,101 @@ void ff_sws_uop_name(const SwsUOp *op, char buf[SWS_UOP_NAME_MAX]) av_assert0(av_bprint_is_complete(&bp)); } +static int generate_entry_struct(void *opaque, void *key) +{ + const SwsUOp *ref = opaque; + const SwsUOp *uop = key; + AVBPrint *bp = ref->data.opaque; + char name[SWS_UOP_NAME_MAX]; + ff_sws_uop_name(uop, name); + av_bprintf(bp, " \\\n MACRO(__VA_ARGS__, %-40s", name); + av_bprintf(bp, ", .type = %-13s, .uop = %-24s, .mask = 0x%x", + pixel_types[uop->type].full, uop_names[uop->uop].full, uop->mask); + + const SwsUOpParams *par = &uop->par; + switch (uop->uop) { + case SWS_UOP_LSHIFT: + case SWS_UOP_RSHIFT: + av_bprintf(bp, ", .par.shift.amount = %u", par->shift.amount); + break; + case SWS_UOP_PERMUTE: + case SWS_UOP_COPY: + av_bprintf(bp, ", .par.swizzle.in = {%d, %d, %d, %d}", + par->swizzle.in[0], par->swizzle.in[1], + par->swizzle.in[2], par->swizzle.in[3]); + break; + case SWS_UOP_PACK: + case SWS_UOP_UNPACK: + av_bprintf(bp, ", .par.pack.pattern = {%d, %d, %d, %d}", + par->pack.pattern[0], par->pack.pattern[1], + par->pack.pattern[2], par->pack.pattern[3]); + break; + case SWS_UOP_CLEAR: + av_bprintf(bp, ", .par.clear.one = 0x%x, .par.clear.zero = 0x%x", + par->clear.one, par->clear.zero); + break; + case SWS_UOP_LINEAR: + av_bprintf(bp, ", .par.lin.one = 0x%x, .par.lin.zero = 0x%x", + par->lin.one, par->lin.zero); + break; + case SWS_UOP_DITHER: + av_bprintf(bp, ", .par.dither = { .y_offset = {%u, %u, %u, %u}, .size_log2 = %u }", + par->dither.y_offset[0], par->dither.y_offset[1], + par->dither.y_offset[2], par->dither.y_offset[3], + par->dither.size_log2); + break; + } + + av_bprintf(bp, ")"); + return 0; +} + +static int generate_entry_args(void *opaque, void *key) +{ + const SwsUOp *ref = opaque; + const SwsUOp *uop = key; + AVBPrint *bp = ref->data.opaque; + char name[SWS_UOP_NAME_MAX]; + ff_sws_uop_name(uop, name); + av_bprintf(bp, " \\\n MACRO(__VA_ARGS__, %-40s, %-13s, %-24s, 0x%x", + name, pixel_types[uop->type].full, uop_names[uop->uop].full, uop->mask); + + const SwsUOpParams *par = &uop->par; + switch (uop->uop) { + case SWS_UOP_LSHIFT: + case SWS_UOP_RSHIFT: + av_bprintf(bp, ", %u", par->shift.amount); + break; + case SWS_UOP_PERMUTE: + case SWS_UOP_COPY: + av_bprintf(bp, ", %d, %d, %d, %d", + par->swizzle.in[0], par->swizzle.in[1], + par->swizzle.in[2], par->swizzle.in[3]); + break; + case SWS_UOP_PACK: + case SWS_UOP_UNPACK: + av_bprintf(bp, ", %d, %d, %d, %d", + par->pack.pattern[0], par->pack.pattern[1], + par->pack.pattern[2], par->pack.pattern[3]); + break; + case SWS_UOP_CLEAR: + av_bprintf(bp, ", 0x%05x, 0x%05x", par->clear.one, par->clear.zero); + break; + case SWS_UOP_LINEAR: + av_bprintf(bp, ", 0x%05x, 0x%05x", par->lin.one, par->lin.zero); + break; + case SWS_UOP_DITHER: + av_bprintf(bp, ", %u, %u, %u, %u, %u", + par->dither.y_offset[0], par->dither.y_offset[1], + par->dither.y_offset[2], par->dither.y_offset[3], + par->dither.size_log2); + break; + } + + av_bprintf(bp, ")"); + return 0; +} + static void uop_uninit(SwsUOp *uop) { switch (uop->uop) { @@ -541,3 +649,192 @@ int ff_sws_ops_translate(const SwsOpList *ops, SwsUOpList *uops) } return 0; } + +static int register_uop(struct AVTreeNode **root, const SwsUOp *uop) +{ + SwsUOp *key = av_memdup(uop, sizeof(*uop)); + if (!key) + return AVERROR(ENOMEM); + memset(&key->data, 0, sizeof(key->data)); + + struct AVTreeNode *node = av_tree_node_alloc(); + if (!node) { + av_free(key); + return AVERROR(ENOMEM); + } + + av_tree_insert(root, key, ff_sws_uop_cmp_v, &node); + if (node) { + av_free(node); + av_free(key); + } + return 0; +} + +static int register_uops(SwsContext *ctx, SwsOpList *ops, SwsCompiledOp *out) +{ + SwsUOpList *uops = ff_sws_uop_list_alloc(); + if (!uops) + return AVERROR(ENOMEM); + + int ret = ff_sws_ops_translate(ops, uops); + if (ret < 0) + goto fail; + + struct AVTreeNode **root = ctx->opaque; + for (int i = 0; i < uops->num_ops; i++) { + ret = register_uop(root, &uops->ops[i]); + if (ret < 0) + goto fail; + } + +fail: + *out = (SwsCompiledOp) {0}; /* dummy value, will be immediately freed */ + ff_sws_uop_list_free(&uops); + return ret; +} + +/* Dummy backend that just registers all seen uops */ +static const SwsOpBackend backend_uops = { + .name = "uops_gen", + .compile = register_uops, +}; + +static int register_all_uops(SwsContext *ctx, void *graph, SwsOpList *ops) +{ + /* ff_sws_compile_pass() takes over ownership of `ops` */ + SwsOpList *copy = ff_sws_op_list_duplicate(ops); + if (!copy) + return AVERROR(ENOMEM); + + return ff_sws_compile_pass(graph, &backend_uops, ©, 0, NULL, NULL); +} + +static const SwsFlags flags[] = { + 0, + + /* SWS_ACCURATE_RND may insert extra 1x1 dither ops (for accurate rounding) */ + SWS_ACCURATE_RND, +}; + +/* Limit the range of av_tree_enumerate() to only matching uop and type */ +static int enum_type(void *opaque, void *elem) +{ + const SwsUOp *a = opaque, *b = elem; + if (a->type != b->type) + return (int) b->type - a->type; + if (a->uop != b->uop) + return (int) b->uop - a->uop; + return 0; +} + +static int free_uop_key(void *opaque, void *key) +{ + av_free(key); + return 0; +} + +int ff_sws_uops_macros_gen(char **out_str) +{ + int ret; + struct AVTreeNode *root = NULL; + + AVBPrint bprint, *const bp = &bprint; + av_bprint_init(bp, 0, AV_BPRINT_SIZE_UNLIMITED); + + /* Allocate dummy graph and context for ff_sws_compile_pass() */ + SwsGraph *graph = ff_sws_graph_alloc(); + if (!graph) + return AVERROR(ENOMEM); + + SwsContext *ctx = graph->ctx = sws_alloc_context(); + if (!ctx) { + ret = AVERROR(ENOMEM); + goto fail; + } + + /* Use this to plumb the tree state through all the layers of abstraction */ + ctx->opaque = &root; + ctx->scaler = SWS_SCALE_BILINEAR; /* cheaper to generate filter kernels */ + + /* Register all unique uops over every relevant combination of flags */ + for (int i = 0; i < FF_ARRAY_ELEMS(flags); i++) { + ctx->flags = flags[i]; + ret = ff_sws_enum_op_lists(ctx, graph, AV_PIX_FMT_NONE, AV_PIX_FMT_NONE, + register_all_uops); + if (ret < 0) + goto fail; + } + + /** + * Additionally make sure planar reads/writes are always available for all + * formats, because checkasm depends on them to be able to verify the + * input/output of any other operations. + */ + for (enum SwsPixelType type = SWS_PIXEL_NONE+1; type < SWS_PIXEL_TYPE_NB; type++) { + if (!ff_sws_pixel_type_is_int(type)) + continue; + for (int elems = 1; elems <= 4; elems++) { + for (int rw = 0; rw < 2; rw++) { + SwsUOp uop = { + .type = type, + .uop = rw ? SWS_UOP_WRITE_PLANAR : SWS_UOP_READ_PLANAR, + .mask = SWS_COMP_ELEMS(elems), + }; + + ret = register_uop(&root, &uop); + if (ret < 0) + goto fail; + } + } + } + + #define BPRINT_STR(str) av_bprint_append_data(bp, str, strlen(str)) + BPRINT_STR( +"/**\n" +" * This file is automatically generated. Do not edit manually.\n" +" * To regenerate, run: make fate-sws-uops-macros GEN=1\n" +" */\n" +"\n" +"#ifndef SWSCALE_UOPS_MACROS_H\n" +"#define SWSCALE_UOPS_MACROS_H\n" +"\n" +"/**\n" +" * Boilerplate helper macros, for template-based backends. These will be\n" +" * instantiated like this, with parameters in struct order:\n" +" * MACRO(__VA_ARGS__, NAME, UOP, TYPE, MASK, [PARAMS,])\n" +" * The _STRUCT variants pass all arguments in C struct syntax, while the\n" +" * plain variants give them as separate C values (e.g. for use in calls)\n" +" */\n" +"#define SWS_GLUE3(x, y, z) x ## _ ## y ## _ ## z\n" +"#define SWS_FOR(TYPE, UOP, MACRO, ...) \\\n" +" SWS_GLUE3(SWS_FOR, TYPE, UOP)(MACRO, __VA_ARGS__)\n" +"#define SWS_FOR_STRUCT(TYPE, UOP, MACRO, ...) \\\n" +" SWS_GLUE3(SWS_FOR_STRUCT, TYPE, UOP)(MACRO, __VA_ARGS__)\n" +"\n"); + + SwsUOp key = { .data.opaque = bp }; + for (key.type = SWS_PIXEL_NONE + 1; key.type < SWS_PIXEL_TYPE_NB; key.type++) { + for (key.uop = SWS_UOP_INVALID + 1; key.uop < SWS_UOP_TYPE_NB; key.uop++) { + const char *macro = uop_names[key.uop].macro; + const char *prefix = pixel_types[key.type].prefix; + av_bprintf(bp, "#define SWS_FOR_%s%s(MACRO, ...)", prefix, macro); + av_tree_enumerate(root, &key, enum_type, generate_entry_args); + av_bprintf(bp, "\n"); + av_bprintf(bp, "#define SWS_FOR_STRUCT_%s%s(MACRO, ...)", prefix, macro); + av_tree_enumerate(root, &key, enum_type, generate_entry_struct); + av_bprintf(bp, "\n"); + } + } + + BPRINT_STR("\n#endif /* SWSCALE_UOPS_MACROS_H */"); + ret = av_bprint_finalize(bp, out_str); + +fail: + av_bprint_finalize(bp, NULL); + av_tree_enumerate(root, NULL, NULL, free_uop_key); + av_tree_destroy(root); + ff_sws_graph_free(&graph); + sws_free_context(&ctx); + return ret; +} diff --git a/libswscale/uops.h b/libswscale/uops.h index 9e989125d4..3e59119bbf 100644 --- a/libswscale/uops.h +++ b/libswscale/uops.h @@ -182,6 +182,7 @@ typedef struct SwsUOp { SwsPixel scalar; SwsPixel vec4[4]; SwsPixel mat4[4][5]; /* row major */ + void *opaque; /* reserved for internal use */ } data; } SwsUOp; @@ -220,4 +221,16 @@ int ff_sws_uop_list_append(SwsUOpList *uops, SwsUOp *uop); */ int ff_sws_ops_translate(const SwsOpList *ops, SwsUOpList *uops); +/** + * Generate a set of boilerplate C preprocessor macros for describing and + * programmatically iterating over all possible SwsUOps. + * + * This function can be quite slow as it iterates over every possible + * combination of pixel formats and flags. + * + * Returns 0 or a negative error code. On success, an allocated string is + * returned via `out_str`, and must be av_free()'d by the caller. + */ +int ff_sws_uops_macros_gen(char **out_str); + #endif diff --git a/libswscale/uops_macros.h b/libswscale/uops_macros.h new file mode 100644 index 0000000000..a2fccd08fa --- /dev/null +++ b/libswscale/uops_macros.h @@ -0,0 +1,1009 @@ +/** + * This file is automatically generated. Do not edit manually. + * To regenerate, run: make fate-sws-uops-macros GEN=1 + */ + +#ifndef SWSCALE_UOPS_MACROS_H +#define SWSCALE_UOPS_MACROS_H + +/** + * Boilerplate helper macros, for template-based backends. These will be + * instantiated like this, with parameters in struct order: + * MACRO(__VA_ARGS__, NAME, UOP, TYPE, MASK, [PARAMS,]) + * The _STRUCT variants pass all arguments in C struct syntax, while the + * plain variants give them as separate C values (e.g. for use in calls) + */ +#define SWS_GLUE3(x, y, z) x ## _ ## y ## _ ## z +#define SWS_FOR(TYPE, UOP, MACRO, ...) \ + SWS_GLUE3(SWS_FOR, TYPE, UOP)(MACRO, __VA_ARGS__) +#define SWS_FOR_STRUCT(TYPE, UOP, MACRO, ...) \ + SWS_GLUE3(SWS_FOR_STRUCT, TYPE, UOP)(MACRO, __VA_ARGS__) + +#define SWS_FOR_U8_READ_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_planar_x , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR , 0x1) \ + MACRO(__VA_ARGS__, u8_read_planar_xy , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR , 0x3) \ + MACRO(__VA_ARGS__, u8_read_planar_xyz , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR , 0x7) \ + MACRO(__VA_ARGS__, u8_read_planar_xyzw , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR , 0xf) +#define SWS_FOR_STRUCT_U8_READ_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_planar_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_read_planar_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_read_planar_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_read_planar_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR , .mask = 0xf) +#define SWS_FOR_U8_READ_PLANAR_FH(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_x , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FH , 0x1) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_xy , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FH , 0x3) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_xyz , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FH , 0x7) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_xyzw , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FH , 0xf) +#define SWS_FOR_STRUCT_U8_READ_PLANAR_FH(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_read_planar_fh_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0xf) +#define SWS_FOR_U8_READ_PLANAR_FV(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_x , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FV , 0x1) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_xy , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FV , 0x3) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_xyz , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FV , 0x7) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_xyzw , SWS_PIXEL_U8 , SWS_UOP_READ_PLANAR_FV , 0xf) +#define SWS_FOR_STRUCT_U8_READ_PLANAR_FV(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_read_planar_fv_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0xf) +#define SWS_FOR_U8_READ_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_packed_xy , SWS_PIXEL_U8 , SWS_UOP_READ_PACKED , 0x3) \ + MACRO(__VA_ARGS__, u8_read_packed_xyz , SWS_PIXEL_U8 , SWS_UOP_READ_PACKED , 0x7) \ + MACRO(__VA_ARGS__, u8_read_packed_xyzw , SWS_PIXEL_U8 , SWS_UOP_READ_PACKED , 0xf) +#define SWS_FOR_STRUCT_U8_READ_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_packed_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PACKED , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_read_packed_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PACKED , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_read_packed_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_PACKED , .mask = 0xf) +#define SWS_FOR_U8_READ_NIBBLE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_nibble_x , SWS_PIXEL_U8 , SWS_UOP_READ_NIBBLE , 0x1) +#define SWS_FOR_STRUCT_U8_READ_NIBBLE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_nibble_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_NIBBLE , .mask = 0x1) +#define SWS_FOR_U8_READ_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_bit_x , SWS_PIXEL_U8 , SWS_UOP_READ_BIT , 0x1) +#define SWS_FOR_STRUCT_U8_READ_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_read_bit_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_READ_BIT , .mask = 0x1) +#define SWS_FOR_U8_WRITE_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_planar_x , SWS_PIXEL_U8 , SWS_UOP_WRITE_PLANAR , 0x1) \ + MACRO(__VA_ARGS__, u8_write_planar_xy , SWS_PIXEL_U8 , SWS_UOP_WRITE_PLANAR , 0x3) \ + MACRO(__VA_ARGS__, u8_write_planar_xyz , SWS_PIXEL_U8 , SWS_UOP_WRITE_PLANAR , 0x7) \ + MACRO(__VA_ARGS__, u8_write_planar_xyzw , SWS_PIXEL_U8 , SWS_UOP_WRITE_PLANAR , 0xf) +#define SWS_FOR_STRUCT_U8_WRITE_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_planar_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_write_planar_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_write_planar_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_write_planar_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_PLANAR , .mask = 0xf) +#define SWS_FOR_U8_WRITE_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_packed_xy , SWS_PIXEL_U8 , SWS_UOP_WRITE_PACKED , 0x3) \ + MACRO(__VA_ARGS__, u8_write_packed_xyz , SWS_PIXEL_U8 , SWS_UOP_WRITE_PACKED , 0x7) \ + MACRO(__VA_ARGS__, u8_write_packed_xyzw , SWS_PIXEL_U8 , SWS_UOP_WRITE_PACKED , 0xf) +#define SWS_FOR_STRUCT_U8_WRITE_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_packed_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_PACKED , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_write_packed_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_PACKED , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_write_packed_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_PACKED , .mask = 0xf) +#define SWS_FOR_U8_WRITE_NIBBLE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_nibble_x , SWS_PIXEL_U8 , SWS_UOP_WRITE_NIBBLE , 0x1) +#define SWS_FOR_STRUCT_U8_WRITE_NIBBLE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_nibble_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_NIBBLE , .mask = 0x1) +#define SWS_FOR_U8_WRITE_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_bit_x , SWS_PIXEL_U8 , SWS_UOP_WRITE_BIT , 0x1) +#define SWS_FOR_STRUCT_U8_WRITE_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_write_bit_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_WRITE_BIT , .mask = 0x1) +#define SWS_FOR_U8_PERMUTE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_permute_x_y , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x1, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u8_permute_x_z , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x1, 2, 1, 0, 3) \ + MACRO(__VA_ARGS__, u8_permute_x_w , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x1, 3, 1, 2, 0) \ + MACRO(__VA_ARGS__, u8_permute_y_w , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x2, 0, 3, 2, 1) \ + MACRO(__VA_ARGS__, u8_permute_y_x , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x2, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u8_permute_xy_yx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x3, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u8_permute_xy_yw , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x3, 1, 3, 2, 0) \ + MACRO(__VA_ARGS__, u8_permute_xy_zw , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x3, 2, 3, 0, 1) \ + MACRO(__VA_ARGS__, u8_permute_xy_wx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x3, 3, 0, 2, 1) \ + MACRO(__VA_ARGS__, u8_permute_z_x , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x4, 1, 2, 0, 3) \ + MACRO(__VA_ARGS__, u8_permute_xz_zx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x5, 2, 1, 0, 3) \ + MACRO(__VA_ARGS__, u8_permute_yz_zy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x6, 0, 2, 1, 3) \ + MACRO(__VA_ARGS__, u8_permute_xyz_yzx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x7, 1, 2, 0, 3) \ + MACRO(__VA_ARGS__, u8_permute_xyz_yzw , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x7, 1, 2, 3, 0) \ + MACRO(__VA_ARGS__, u8_permute_xyz_zxy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x7, 2, 0, 1, 3) \ + MACRO(__VA_ARGS__, u8_permute_xyz_zwy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x7, 2, 3, 1, 0) \ + MACRO(__VA_ARGS__, u8_permute_xyz_wzy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x7, 3, 2, 1, 0) \ + MACRO(__VA_ARGS__, u8_permute_w_x , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0x8, 3, 1, 2, 0) \ + MACRO(__VA_ARGS__, u8_permute_yw_wy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xa, 0, 3, 2, 1) \ + MACRO(__VA_ARGS__, u8_permute_zw_xz , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xc, 3, 1, 0, 2) \ + MACRO(__VA_ARGS__, u8_permute_xzw_zwx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xd, 2, 1, 3, 0) \ + MACRO(__VA_ARGS__, u8_permute_xzw_wxz , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xd, 3, 1, 0, 2) \ + MACRO(__VA_ARGS__, u8_permute_yzw_zwy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xe, 0, 2, 3, 1) \ + MACRO(__VA_ARGS__, u8_permute_yzw_xyz , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xe, 3, 0, 1, 2) \ + MACRO(__VA_ARGS__, u8_permute_yzw_zxy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xe, 3, 2, 0, 1) \ + MACRO(__VA_ARGS__, u8_permute_yzw_zyx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xe, 3, 2, 1, 0) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_yzwx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xf, 1, 2, 3, 0) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_wxyz , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xf, 3, 0, 1, 2) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_wzxy , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xf, 3, 2, 0, 1) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_wzyx , SWS_PIXEL_U8 , SWS_UOP_PERMUTE , 0xf, 3, 2, 1, 0) +#define SWS_FOR_STRUCT_U8_PERMUTE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_permute_x_y , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u8_permute_x_z , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {2, 1, 0, 3}) \ + MACRO(__VA_ARGS__, u8_permute_x_w , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {3, 1, 2, 0}) \ + MACRO(__VA_ARGS__, u8_permute_y_w , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x2, .par.swizzle.in = {0, 3, 2, 1}) \ + MACRO(__VA_ARGS__, u8_permute_y_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x2, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u8_permute_xy_yx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x3, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u8_permute_xy_yw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x3, .par.swizzle.in = {1, 3, 2, 0}) \ + MACRO(__VA_ARGS__, u8_permute_xy_zw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x3, .par.swizzle.in = {2, 3, 0, 1}) \ + MACRO(__VA_ARGS__, u8_permute_xy_wx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x3, .par.swizzle.in = {3, 0, 2, 1}) \ + MACRO(__VA_ARGS__, u8_permute_z_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x4, .par.swizzle.in = {1, 2, 0, 3}) \ + MACRO(__VA_ARGS__, u8_permute_xz_zx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x5, .par.swizzle.in = {2, 1, 0, 3}) \ + MACRO(__VA_ARGS__, u8_permute_yz_zy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x6, .par.swizzle.in = {0, 2, 1, 3}) \ + MACRO(__VA_ARGS__, u8_permute_xyz_yzx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {1, 2, 0, 3}) \ + MACRO(__VA_ARGS__, u8_permute_xyz_yzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {1, 2, 3, 0}) \ + MACRO(__VA_ARGS__, u8_permute_xyz_zxy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {2, 0, 1, 3}) \ + MACRO(__VA_ARGS__, u8_permute_xyz_zwy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {2, 3, 1, 0}) \ + MACRO(__VA_ARGS__, u8_permute_xyz_wzy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {3, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u8_permute_w_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0x8, .par.swizzle.in = {3, 1, 2, 0}) \ + MACRO(__VA_ARGS__, u8_permute_yw_wy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xa, .par.swizzle.in = {0, 3, 2, 1}) \ + MACRO(__VA_ARGS__, u8_permute_zw_xz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xc, .par.swizzle.in = {3, 1, 0, 2}) \ + MACRO(__VA_ARGS__, u8_permute_xzw_zwx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xd, .par.swizzle.in = {2, 1, 3, 0}) \ + MACRO(__VA_ARGS__, u8_permute_xzw_wxz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xd, .par.swizzle.in = {3, 1, 0, 2}) \ + MACRO(__VA_ARGS__, u8_permute_yzw_zwy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {0, 2, 3, 1}) \ + MACRO(__VA_ARGS__, u8_permute_yzw_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 0, 1, 2}) \ + MACRO(__VA_ARGS__, u8_permute_yzw_zxy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 2, 0, 1}) \ + MACRO(__VA_ARGS__, u8_permute_yzw_zyx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_yzwx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {1, 2, 3, 0}) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_wxyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 0, 1, 2}) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_wzxy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 2, 0, 1}) \ + MACRO(__VA_ARGS__, u8_permute_xyzw_wzyx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 2, 1, 0}) +#define SWS_FOR_U8_COPY(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_copy_yz_xx , SWS_PIXEL_U8 , SWS_UOP_COPY , 0x6, 0, 0, 0, 3) \ + MACRO(__VA_ARGS__, u8_copy_yzw_xxx , SWS_PIXEL_U8 , SWS_UOP_COPY , 0xe, 0, 0, 0, 0) \ + MACRO(__VA_ARGS__, u8_copy_yzw_xxy , SWS_PIXEL_U8 , SWS_UOP_COPY , 0xe, 0, 0, 0, 1) \ + MACRO(__VA_ARGS__, u8_copy_xyzw_yxxx , SWS_PIXEL_U8 , SWS_UOP_COPY , 0xf, 1, 0, 0, 0) +#define SWS_FOR_STRUCT_U8_COPY(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_copy_yz_xx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_COPY , .mask = 0x6, .par.swizzle.in = {0, 0, 0, 3}) \ + MACRO(__VA_ARGS__, u8_copy_yzw_xxx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_COPY , .mask = 0xe, .par.swizzle.in = {0, 0, 0, 0}) \ + MACRO(__VA_ARGS__, u8_copy_yzw_xxy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_COPY , .mask = 0xe, .par.swizzle.in = {0, 0, 0, 1}) \ + MACRO(__VA_ARGS__, u8_copy_xyzw_yxxx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_COPY , .mask = 0xf, .par.swizzle.in = {1, 0, 0, 0}) +#define SWS_FOR_U8_SWAP_BYTES(MACRO, ...) +#define SWS_FOR_STRUCT_U8_SWAP_BYTES(MACRO, ...) +#define SWS_FOR_U8_EXPAND_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_expand_bit_x , SWS_PIXEL_U8 , SWS_UOP_EXPAND_BIT , 0x1) +#define SWS_FOR_STRUCT_U8_EXPAND_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_expand_bit_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_EXPAND_BIT , .mask = 0x1) +#define SWS_FOR_U8_EXPAND_PAIR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_expand_pair_x , SWS_PIXEL_U8 , SWS_UOP_EXPAND_PAIR , 0x1) \ + MACRO(__VA_ARGS__, u8_expand_pair_xy , SWS_PIXEL_U8 , SWS_UOP_EXPAND_PAIR , 0x3) \ + MACRO(__VA_ARGS__, u8_expand_pair_xyz , SWS_PIXEL_U8 , SWS_UOP_EXPAND_PAIR , 0x7) \ + MACRO(__VA_ARGS__, u8_expand_pair_yzw , SWS_PIXEL_U8 , SWS_UOP_EXPAND_PAIR , 0xe) \ + MACRO(__VA_ARGS__, u8_expand_pair_xyzw , SWS_PIXEL_U8 , SWS_UOP_EXPAND_PAIR , 0xf) +#define SWS_FOR_STRUCT_U8_EXPAND_PAIR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_expand_pair_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_EXPAND_PAIR , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_expand_pair_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_EXPAND_PAIR , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_expand_pair_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_EXPAND_PAIR , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_expand_pair_yzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_EXPAND_PAIR , .mask = 0xe) \ + MACRO(__VA_ARGS__, u8_expand_pair_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_EXPAND_PAIR , .mask = 0xf) +#define SWS_FOR_U8_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_STRUCT_U8_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_U8_TO_U8(MACRO, ...) +#define SWS_FOR_STRUCT_U8_TO_U8(MACRO, ...) +#define SWS_FOR_U8_TO_U16(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_to_u16_x , SWS_PIXEL_U8 , SWS_UOP_TO_U16 , 0x1) \ + MACRO(__VA_ARGS__, u8_to_u16_xyz , SWS_PIXEL_U8 , SWS_UOP_TO_U16 , 0x7) \ + MACRO(__VA_ARGS__, u8_to_u16_yzw , SWS_PIXEL_U8 , SWS_UOP_TO_U16 , 0xe) +#define SWS_FOR_STRUCT_U8_TO_U16(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_to_u16_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_U16 , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_to_u16_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_U16 , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_to_u16_yzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_U16 , .mask = 0xe) +#define SWS_FOR_U8_TO_U32(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_to_u32_x , SWS_PIXEL_U8 , SWS_UOP_TO_U32 , 0x1) \ + MACRO(__VA_ARGS__, u8_to_u32_xyz , SWS_PIXEL_U8 , SWS_UOP_TO_U32 , 0x7) +#define SWS_FOR_STRUCT_U8_TO_U32(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_to_u32_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_U32 , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_to_u32_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_U32 , .mask = 0x7) +#define SWS_FOR_U8_TO_F32(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_to_f32_x , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0x1) \ + MACRO(__VA_ARGS__, u8_to_f32_y , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0x2) \ + MACRO(__VA_ARGS__, u8_to_f32_xy , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0x3) \ + MACRO(__VA_ARGS__, u8_to_f32_z , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0x4) \ + MACRO(__VA_ARGS__, u8_to_f32_xyz , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0x7) \ + MACRO(__VA_ARGS__, u8_to_f32_yw , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0xa) \ + MACRO(__VA_ARGS__, u8_to_f32_zw , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0xc) \ + MACRO(__VA_ARGS__, u8_to_f32_yzw , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0xe) \ + MACRO(__VA_ARGS__, u8_to_f32_xyzw , SWS_PIXEL_U8 , SWS_UOP_TO_F32 , 0xf) +#define SWS_FOR_STRUCT_U8_TO_F32(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_to_f32_x , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0x1) \ + MACRO(__VA_ARGS__, u8_to_f32_y , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0x2) \ + MACRO(__VA_ARGS__, u8_to_f32_xy , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0x3) \ + MACRO(__VA_ARGS__, u8_to_f32_z , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0x4) \ + MACRO(__VA_ARGS__, u8_to_f32_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0x7) \ + MACRO(__VA_ARGS__, u8_to_f32_yw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0xa) \ + MACRO(__VA_ARGS__, u8_to_f32_zw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0xc) \ + MACRO(__VA_ARGS__, u8_to_f32_yzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0xe) \ + MACRO(__VA_ARGS__, u8_to_f32_xyzw , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32 , .mask = 0xf) +#define SWS_FOR_U8_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_scale_xyz , SWS_PIXEL_U8 , SWS_UOP_SCALE , 0x7) +#define SWS_FOR_STRUCT_U8_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_scale_xyz , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_SCALE , .mask = 0x7) +#define SWS_FOR_U8_ADD(MACRO, ...) +#define SWS_FOR_STRUCT_U8_ADD(MACRO, ...) +#define SWS_FOR_U8_MIN(MACRO, ...) +#define SWS_FOR_STRUCT_U8_MIN(MACRO, ...) +#define SWS_FOR_U8_MAX(MACRO, ...) +#define SWS_FOR_STRUCT_U8_MAX(MACRO, ...) +#define SWS_FOR_U8_UNPACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_unpack_xyz_121 , SWS_PIXEL_U8 , SWS_UOP_UNPACK , 0x7, 1, 2, 1, 0) \ + MACRO(__VA_ARGS__, u8_unpack_xyz_233 , SWS_PIXEL_U8 , SWS_UOP_UNPACK , 0x7, 2, 3, 3, 0) \ + MACRO(__VA_ARGS__, u8_unpack_xyz_332 , SWS_PIXEL_U8 , SWS_UOP_UNPACK , 0x7, 3, 3, 2, 0) +#define SWS_FOR_STRUCT_U8_UNPACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_unpack_xyz_121 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_UNPACK , .mask = 0x7, .par.pack.pattern = {1, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u8_unpack_xyz_233 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_UNPACK , .mask = 0x7, .par.pack.pattern = {2, 3, 3, 0}) \ + MACRO(__VA_ARGS__, u8_unpack_xyz_332 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_UNPACK , .mask = 0x7, .par.pack.pattern = {3, 3, 2, 0}) +#define SWS_FOR_U8_PACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_pack_xyz_121 , SWS_PIXEL_U8 , SWS_UOP_PACK , 0x7, 1, 2, 1, 0) \ + MACRO(__VA_ARGS__, u8_pack_xyz_233 , SWS_PIXEL_U8 , SWS_UOP_PACK , 0x7, 2, 3, 3, 0) \ + MACRO(__VA_ARGS__, u8_pack_xyz_332 , SWS_PIXEL_U8 , SWS_UOP_PACK , 0x7, 3, 3, 2, 0) +#define SWS_FOR_STRUCT_U8_PACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_pack_xyz_121 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PACK , .mask = 0x7, .par.pack.pattern = {1, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u8_pack_xyz_233 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PACK , .mask = 0x7, .par.pack.pattern = {2, 3, 3, 0}) \ + MACRO(__VA_ARGS__, u8_pack_xyz_332 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_PACK , .mask = 0x7, .par.pack.pattern = {3, 3, 2, 0}) +#define SWS_FOR_U8_LSHIFT(MACRO, ...) +#define SWS_FOR_STRUCT_U8_LSHIFT(MACRO, ...) +#define SWS_FOR_U8_RSHIFT(MACRO, ...) +#define SWS_FOR_STRUCT_U8_RSHIFT(MACRO, ...) +#define SWS_FOR_U8_CLEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_clear_x_0 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x1, 0x00000, 0x00001) \ + MACRO(__VA_ARGS__, u8_clear_x_1 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x1, 0x00001, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_y_1 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x2, 0x00002, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_xy_xx , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x3, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_xz_xx , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x5, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_yz_xx , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x6, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_w_0 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x8, 0x00000, 0x00008) \ + MACRO(__VA_ARGS__, u8_clear_w_1 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0x8, 0x00008, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_xyw_xx0 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0xb, 0x00000, 0x00008) \ + MACRO(__VA_ARGS__, u8_clear_xyw_xx1 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0xb, 0x00008, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_zw_xx , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0xc, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_xzw_1xx , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0xd, 0x00001, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_xzw_xx1 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0xd, 0x00008, 0x00000) \ + MACRO(__VA_ARGS__, u8_clear_yzw_xx1 , SWS_PIXEL_U8 , SWS_UOP_CLEAR , 0xe, 0x00008, 0x00000) +#define SWS_FOR_STRUCT_U8_CLEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u8_clear_x_0 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x1, .par.clear.one = 0x0, .par.clear.zero = 0x1) \ + MACRO(__VA_ARGS__, u8_clear_x_1 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x1, .par.clear.one = 0x1, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_y_1 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x2, .par.clear.one = 0x2, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_xy_xx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x3, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_xz_xx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x5, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_yz_xx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x6, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_w_0 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x8, .par.clear.one = 0x0, .par.clear.zero = 0x8) \ + MACRO(__VA_ARGS__, u8_clear_w_1 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0x8, .par.clear.one = 0x8, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_xyw_xx0 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0xb, .par.clear.one = 0x0, .par.clear.zero = 0x8) \ + MACRO(__VA_ARGS__, u8_clear_xyw_xx1 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0xb, .par.clear.one = 0x8, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_zw_xx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0xc, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_xzw_1xx , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0xd, .par.clear.one = 0x1, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_xzw_xx1 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0xd, .par.clear.one = 0x8, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u8_clear_yzw_xx1 , .type = SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR , .mask = 0xe, .par.clear.one = 0x8, .par.clear.zero = 0x0) +#define SWS_FOR_U8_LINEAR(MACRO, ...) +#define SWS_FOR_STRUCT_U8_LINEAR(MACRO, ...) +#define SWS_FOR_U8_DITHER(MACRO, ...) +#define SWS_FOR_STRUCT_U8_DITHER(MACRO, ...) +#define SWS_FOR_U16_READ_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_planar_x , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR , 0x1) \ + MACRO(__VA_ARGS__, u16_read_planar_xy , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR , 0x3) \ + MACRO(__VA_ARGS__, u16_read_planar_xyz , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR , 0x7) \ + MACRO(__VA_ARGS__, u16_read_planar_xyzw , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR , 0xf) +#define SWS_FOR_STRUCT_U16_READ_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_planar_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_read_planar_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_read_planar_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_read_planar_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR , .mask = 0xf) +#define SWS_FOR_U16_READ_PLANAR_FH(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_x , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FH , 0x1) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_xy , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FH , 0x3) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_xyz , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FH , 0x7) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_xyzw , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FH , 0xf) +#define SWS_FOR_STRUCT_U16_READ_PLANAR_FH(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_read_planar_fh_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0xf) +#define SWS_FOR_U16_READ_PLANAR_FV(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_x , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FV , 0x1) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_xy , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FV , 0x3) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_xyz , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FV , 0x7) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_xyzw , SWS_PIXEL_U16, SWS_UOP_READ_PLANAR_FV , 0xf) +#define SWS_FOR_STRUCT_U16_READ_PLANAR_FV(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_read_planar_fv_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0xf) +#define SWS_FOR_U16_READ_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_packed_xy , SWS_PIXEL_U16, SWS_UOP_READ_PACKED , 0x3) \ + MACRO(__VA_ARGS__, u16_read_packed_xyz , SWS_PIXEL_U16, SWS_UOP_READ_PACKED , 0x7) \ + MACRO(__VA_ARGS__, u16_read_packed_xyzw , SWS_PIXEL_U16, SWS_UOP_READ_PACKED , 0xf) +#define SWS_FOR_STRUCT_U16_READ_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_read_packed_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PACKED , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_read_packed_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PACKED , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_read_packed_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_READ_PACKED , .mask = 0xf) +#define SWS_FOR_U16_READ_NIBBLE(MACRO, ...) +#define SWS_FOR_STRUCT_U16_READ_NIBBLE(MACRO, ...) +#define SWS_FOR_U16_READ_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_U16_READ_BIT(MACRO, ...) +#define SWS_FOR_U16_WRITE_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_write_planar_x , SWS_PIXEL_U16, SWS_UOP_WRITE_PLANAR , 0x1) \ + MACRO(__VA_ARGS__, u16_write_planar_xy , SWS_PIXEL_U16, SWS_UOP_WRITE_PLANAR , 0x3) \ + MACRO(__VA_ARGS__, u16_write_planar_xyz , SWS_PIXEL_U16, SWS_UOP_WRITE_PLANAR , 0x7) \ + MACRO(__VA_ARGS__, u16_write_planar_xyzw , SWS_PIXEL_U16, SWS_UOP_WRITE_PLANAR , 0xf) +#define SWS_FOR_STRUCT_U16_WRITE_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_write_planar_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_write_planar_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_write_planar_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_write_planar_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0xf) +#define SWS_FOR_U16_WRITE_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_write_packed_xy , SWS_PIXEL_U16, SWS_UOP_WRITE_PACKED , 0x3) \ + MACRO(__VA_ARGS__, u16_write_packed_xyz , SWS_PIXEL_U16, SWS_UOP_WRITE_PACKED , 0x7) \ + MACRO(__VA_ARGS__, u16_write_packed_xyzw , SWS_PIXEL_U16, SWS_UOP_WRITE_PACKED , 0xf) +#define SWS_FOR_STRUCT_U16_WRITE_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_write_packed_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_WRITE_PACKED , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_write_packed_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_WRITE_PACKED , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_write_packed_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_WRITE_PACKED , .mask = 0xf) +#define SWS_FOR_U16_WRITE_NIBBLE(MACRO, ...) +#define SWS_FOR_STRUCT_U16_WRITE_NIBBLE(MACRO, ...) +#define SWS_FOR_U16_WRITE_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_U16_WRITE_BIT(MACRO, ...) +#define SWS_FOR_U16_PERMUTE(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_permute_x_y , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x1, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u16_permute_x_z , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x1, 2, 1, 0, 3) \ + MACRO(__VA_ARGS__, u16_permute_x_w , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x1, 3, 1, 2, 0) \ + MACRO(__VA_ARGS__, u16_permute_y_w , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x2, 0, 3, 2, 1) \ + MACRO(__VA_ARGS__, u16_permute_y_x , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x2, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u16_permute_xy_yx , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x3, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u16_permute_xy_wx , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x3, 3, 0, 2, 1) \ + MACRO(__VA_ARGS__, u16_permute_xz_zx , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x5, 2, 1, 0, 3) \ + MACRO(__VA_ARGS__, u16_permute_xz_zw , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x5, 2, 1, 3, 0) \ + MACRO(__VA_ARGS__, u16_permute_xyz_yzx , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x7, 1, 2, 0, 3) \ + MACRO(__VA_ARGS__, u16_permute_xyz_yzw , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x7, 1, 2, 3, 0) \ + MACRO(__VA_ARGS__, u16_permute_xyz_zxy , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x7, 2, 0, 1, 3) \ + MACRO(__VA_ARGS__, u16_permute_xyz_zwy , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x7, 2, 3, 1, 0) \ + MACRO(__VA_ARGS__, u16_permute_xyz_wzy , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x7, 3, 2, 1, 0) \ + MACRO(__VA_ARGS__, u16_permute_w_x , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0x8, 3, 1, 2, 0) \ + MACRO(__VA_ARGS__, u16_permute_zw_xz , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0xc, 3, 1, 0, 2) \ + MACRO(__VA_ARGS__, u16_permute_yzw_zwy , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0xe, 0, 2, 3, 1) \ + MACRO(__VA_ARGS__, u16_permute_yzw_xyz , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0xe, 3, 0, 1, 2) \ + MACRO(__VA_ARGS__, u16_permute_yzw_zyx , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0xe, 3, 2, 1, 0) \ + MACRO(__VA_ARGS__, u16_permute_xyzw_yzwx , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0xf, 1, 2, 3, 0) \ + MACRO(__VA_ARGS__, u16_permute_xyzw_wxyz , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0xf, 3, 0, 1, 2) \ + MACRO(__VA_ARGS__, u16_permute_xyzw_wzyx , SWS_PIXEL_U16, SWS_UOP_PERMUTE , 0xf, 3, 2, 1, 0) +#define SWS_FOR_STRUCT_U16_PERMUTE(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_permute_x_y , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u16_permute_x_z , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {2, 1, 0, 3}) \ + MACRO(__VA_ARGS__, u16_permute_x_w , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {3, 1, 2, 0}) \ + MACRO(__VA_ARGS__, u16_permute_y_w , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x2, .par.swizzle.in = {0, 3, 2, 1}) \ + MACRO(__VA_ARGS__, u16_permute_y_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x2, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u16_permute_xy_yx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x3, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u16_permute_xy_wx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x3, .par.swizzle.in = {3, 0, 2, 1}) \ + MACRO(__VA_ARGS__, u16_permute_xz_zx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x5, .par.swizzle.in = {2, 1, 0, 3}) \ + MACRO(__VA_ARGS__, u16_permute_xz_zw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x5, .par.swizzle.in = {2, 1, 3, 0}) \ + MACRO(__VA_ARGS__, u16_permute_xyz_yzx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {1, 2, 0, 3}) \ + MACRO(__VA_ARGS__, u16_permute_xyz_yzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {1, 2, 3, 0}) \ + MACRO(__VA_ARGS__, u16_permute_xyz_zxy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {2, 0, 1, 3}) \ + MACRO(__VA_ARGS__, u16_permute_xyz_zwy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {2, 3, 1, 0}) \ + MACRO(__VA_ARGS__, u16_permute_xyz_wzy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {3, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u16_permute_w_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0x8, .par.swizzle.in = {3, 1, 2, 0}) \ + MACRO(__VA_ARGS__, u16_permute_zw_xz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0xc, .par.swizzle.in = {3, 1, 0, 2}) \ + MACRO(__VA_ARGS__, u16_permute_yzw_zwy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {0, 2, 3, 1}) \ + MACRO(__VA_ARGS__, u16_permute_yzw_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 0, 1, 2}) \ + MACRO(__VA_ARGS__, u16_permute_yzw_zyx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u16_permute_xyzw_yzwx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {1, 2, 3, 0}) \ + MACRO(__VA_ARGS__, u16_permute_xyzw_wxyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 0, 1, 2}) \ + MACRO(__VA_ARGS__, u16_permute_xyzw_wzyx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 2, 1, 0}) +#define SWS_FOR_U16_COPY(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_copy_yz_xx , SWS_PIXEL_U16, SWS_UOP_COPY , 0x6, 0, 0, 0, 3) \ + MACRO(__VA_ARGS__, u16_copy_yzw_xxy , SWS_PIXEL_U16, SWS_UOP_COPY , 0xe, 0, 0, 0, 1) +#define SWS_FOR_STRUCT_U16_COPY(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_copy_yz_xx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_COPY , .mask = 0x6, .par.swizzle.in = {0, 0, 0, 3}) \ + MACRO(__VA_ARGS__, u16_copy_yzw_xxy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_COPY , .mask = 0xe, .par.swizzle.in = {0, 0, 0, 1}) +#define SWS_FOR_U16_SWAP_BYTES(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_swap_bytes_x , SWS_PIXEL_U16, SWS_UOP_SWAP_BYTES , 0x1) \ + MACRO(__VA_ARGS__, u16_swap_bytes_y , SWS_PIXEL_U16, SWS_UOP_SWAP_BYTES , 0x2) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xy , SWS_PIXEL_U16, SWS_UOP_SWAP_BYTES , 0x3) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xyz , SWS_PIXEL_U16, SWS_UOP_SWAP_BYTES , 0x7) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xw , SWS_PIXEL_U16, SWS_UOP_SWAP_BYTES , 0x9) \ + MACRO(__VA_ARGS__, u16_swap_bytes_yzw , SWS_PIXEL_U16, SWS_UOP_SWAP_BYTES , 0xe) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xyzw , SWS_PIXEL_U16, SWS_UOP_SWAP_BYTES , 0xf) +#define SWS_FOR_STRUCT_U16_SWAP_BYTES(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_swap_bytes_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_swap_bytes_y , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x2) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x9) \ + MACRO(__VA_ARGS__, u16_swap_bytes_yzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SWAP_BYTES , .mask = 0xe) \ + MACRO(__VA_ARGS__, u16_swap_bytes_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SWAP_BYTES , .mask = 0xf) +#define SWS_FOR_U16_EXPAND_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_expand_bit_x , SWS_PIXEL_U16, SWS_UOP_EXPAND_BIT , 0x1) +#define SWS_FOR_STRUCT_U16_EXPAND_BIT(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_expand_bit_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_EXPAND_BIT , .mask = 0x1) +#define SWS_FOR_U16_EXPAND_PAIR(MACRO, ...) +#define SWS_FOR_STRUCT_U16_EXPAND_PAIR(MACRO, ...) +#define SWS_FOR_U16_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_STRUCT_U16_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_U16_TO_U8(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_to_u8_xyz , SWS_PIXEL_U16, SWS_UOP_TO_U8 , 0x7) +#define SWS_FOR_STRUCT_U16_TO_U8(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_to_u8_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_U8 , .mask = 0x7) +#define SWS_FOR_U16_TO_U16(MACRO, ...) +#define SWS_FOR_STRUCT_U16_TO_U16(MACRO, ...) +#define SWS_FOR_U16_TO_U32(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_to_u32_x , SWS_PIXEL_U16, SWS_UOP_TO_U32 , 0x1) \ + MACRO(__VA_ARGS__, u16_to_u32_xyz , SWS_PIXEL_U16, SWS_UOP_TO_U32 , 0x7) +#define SWS_FOR_STRUCT_U16_TO_U32(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_to_u32_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_U32 , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_to_u32_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_U32 , .mask = 0x7) +#define SWS_FOR_U16_TO_F32(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_to_f32_x , SWS_PIXEL_U16, SWS_UOP_TO_F32 , 0x1) \ + MACRO(__VA_ARGS__, u16_to_f32_y , SWS_PIXEL_U16, SWS_UOP_TO_F32 , 0x2) \ + MACRO(__VA_ARGS__, u16_to_f32_xy , SWS_PIXEL_U16, SWS_UOP_TO_F32 , 0x3) \ + MACRO(__VA_ARGS__, u16_to_f32_xyz , SWS_PIXEL_U16, SWS_UOP_TO_F32 , 0x7) \ + MACRO(__VA_ARGS__, u16_to_f32_yzw , SWS_PIXEL_U16, SWS_UOP_TO_F32 , 0xe) \ + MACRO(__VA_ARGS__, u16_to_f32_xyzw , SWS_PIXEL_U16, SWS_UOP_TO_F32 , 0xf) +#define SWS_FOR_STRUCT_U16_TO_F32(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_to_f32_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32 , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_to_f32_y , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32 , .mask = 0x2) \ + MACRO(__VA_ARGS__, u16_to_f32_xy , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32 , .mask = 0x3) \ + MACRO(__VA_ARGS__, u16_to_f32_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32 , .mask = 0x7) \ + MACRO(__VA_ARGS__, u16_to_f32_yzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32 , .mask = 0xe) \ + MACRO(__VA_ARGS__, u16_to_f32_xyzw , .type = SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32 , .mask = 0xf) +#define SWS_FOR_U16_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_scale_x , SWS_PIXEL_U16, SWS_UOP_SCALE , 0x1) \ + MACRO(__VA_ARGS__, u16_scale_xyz , SWS_PIXEL_U16, SWS_UOP_SCALE , 0x7) +#define SWS_FOR_STRUCT_U16_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_scale_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SCALE , .mask = 0x1) \ + MACRO(__VA_ARGS__, u16_scale_xyz , .type = SWS_PIXEL_U16, .uop = SWS_UOP_SCALE , .mask = 0x7) +#define SWS_FOR_U16_ADD(MACRO, ...) +#define SWS_FOR_STRUCT_U16_ADD(MACRO, ...) +#define SWS_FOR_U16_MIN(MACRO, ...) +#define SWS_FOR_STRUCT_U16_MIN(MACRO, ...) +#define SWS_FOR_U16_MAX(MACRO, ...) +#define SWS_FOR_STRUCT_U16_MAX(MACRO, ...) +#define SWS_FOR_U16_UNPACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_unpack_xyz_444 , SWS_PIXEL_U16, SWS_UOP_UNPACK , 0x7, 4, 4, 4, 0) \ + MACRO(__VA_ARGS__, u16_unpack_xyz_555 , SWS_PIXEL_U16, SWS_UOP_UNPACK , 0x7, 5, 5, 5, 0) \ + MACRO(__VA_ARGS__, u16_unpack_xyz_565 , SWS_PIXEL_U16, SWS_UOP_UNPACK , 0x7, 5, 6, 5, 0) +#define SWS_FOR_STRUCT_U16_UNPACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_unpack_xyz_444 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_UNPACK , .mask = 0x7, .par.pack.pattern = {4, 4, 4, 0}) \ + MACRO(__VA_ARGS__, u16_unpack_xyz_555 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_UNPACK , .mask = 0x7, .par.pack.pattern = {5, 5, 5, 0}) \ + MACRO(__VA_ARGS__, u16_unpack_xyz_565 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_UNPACK , .mask = 0x7, .par.pack.pattern = {5, 6, 5, 0}) +#define SWS_FOR_U16_PACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_pack_xyz_444 , SWS_PIXEL_U16, SWS_UOP_PACK , 0x7, 4, 4, 4, 0) \ + MACRO(__VA_ARGS__, u16_pack_xyz_555 , SWS_PIXEL_U16, SWS_UOP_PACK , 0x7, 5, 5, 5, 0) \ + MACRO(__VA_ARGS__, u16_pack_xyz_565 , SWS_PIXEL_U16, SWS_UOP_PACK , 0x7, 5, 6, 5, 0) +#define SWS_FOR_STRUCT_U16_PACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_pack_xyz_444 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PACK , .mask = 0x7, .par.pack.pattern = {4, 4, 4, 0}) \ + MACRO(__VA_ARGS__, u16_pack_xyz_555 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PACK , .mask = 0x7, .par.pack.pattern = {5, 5, 5, 0}) \ + MACRO(__VA_ARGS__, u16_pack_xyz_565 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_PACK , .mask = 0x7, .par.pack.pattern = {5, 6, 5, 0}) +#define SWS_FOR_U16_LSHIFT(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_lshift_x_4 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x1, 4) \ + MACRO(__VA_ARGS__, u16_lshift_x_6 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x1, 6) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_1 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 1) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_2 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 2) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_3 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 3) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_4 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 4) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_5 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 5) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_6 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 6) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_7 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 7) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_8 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0x7, 8) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_1 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0xe, 1) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_2 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0xe, 2) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_4 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0xe, 4) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_6 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0xe, 6) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_8 , SWS_PIXEL_U16, SWS_UOP_LSHIFT , 0xe, 8) +#define SWS_FOR_STRUCT_U16_LSHIFT(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_lshift_x_4 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x1, .par.shift.amount = 4) \ + MACRO(__VA_ARGS__, u16_lshift_x_6 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x1, .par.shift.amount = 6) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_1 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 1) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_2 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 2) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_3 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 3) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_4 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 4) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_5 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 5) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_6 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 6) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_7 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 7) \ + MACRO(__VA_ARGS__, u16_lshift_xyz_8 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 8) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_1 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0xe, .par.shift.amount = 1) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_2 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0xe, .par.shift.amount = 2) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_4 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0xe, .par.shift.amount = 4) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_6 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0xe, .par.shift.amount = 6) \ + MACRO(__VA_ARGS__, u16_lshift_yzw_8 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_LSHIFT , .mask = 0xe, .par.shift.amount = 8) +#define SWS_FOR_U16_RSHIFT(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_rshift_x_4 , SWS_PIXEL_U16, SWS_UOP_RSHIFT , 0x1, 4) \ + MACRO(__VA_ARGS__, u16_rshift_x_6 , SWS_PIXEL_U16, SWS_UOP_RSHIFT , 0x1, 6) \ + MACRO(__VA_ARGS__, u16_rshift_y_4 , SWS_PIXEL_U16, SWS_UOP_RSHIFT , 0x2, 4) \ + MACRO(__VA_ARGS__, u16_rshift_xyz_4 , SWS_PIXEL_U16, SWS_UOP_RSHIFT , 0x7, 4) \ + MACRO(__VA_ARGS__, u16_rshift_xyz_6 , SWS_PIXEL_U16, SWS_UOP_RSHIFT , 0x7, 6) +#define SWS_FOR_STRUCT_U16_RSHIFT(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_rshift_x_4 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_RSHIFT , .mask = 0x1, .par.shift.amount = 4) \ + MACRO(__VA_ARGS__, u16_rshift_x_6 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_RSHIFT , .mask = 0x1, .par.shift.amount = 6) \ + MACRO(__VA_ARGS__, u16_rshift_y_4 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_RSHIFT , .mask = 0x2, .par.shift.amount = 4) \ + MACRO(__VA_ARGS__, u16_rshift_xyz_4 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_RSHIFT , .mask = 0x7, .par.shift.amount = 4) \ + MACRO(__VA_ARGS__, u16_rshift_xyz_6 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_RSHIFT , .mask = 0x7, .par.shift.amount = 6) +#define SWS_FOR_U16_CLEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_clear_x_1 , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0x1, 0x00001, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_y_1 , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0x2, 0x00002, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_yz_xx , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0x6, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_w_x , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0x8, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_w_0 , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0x8, 0x00000, 0x00008) \ + MACRO(__VA_ARGS__, u16_clear_w_1 , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0x8, 0x00008, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_zw_xx , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0xc, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_xzw_xx0 , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0xd, 0x00000, 0x00008) \ + MACRO(__VA_ARGS__, u16_clear_xzw_1xx , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0xd, 0x00001, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_yzw_xxx , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0xe, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u16_clear_yzw_xx1 , SWS_PIXEL_U16, SWS_UOP_CLEAR , 0xe, 0x00008, 0x00000) +#define SWS_FOR_STRUCT_U16_CLEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u16_clear_x_1 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0x1, .par.clear.one = 0x1, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_y_1 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0x2, .par.clear.one = 0x2, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_yz_xx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0x6, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_w_x , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0x8, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_w_0 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0x8, .par.clear.one = 0x0, .par.clear.zero = 0x8) \ + MACRO(__VA_ARGS__, u16_clear_w_1 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0x8, .par.clear.one = 0x8, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_zw_xx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0xc, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_xzw_xx0 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0xd, .par.clear.one = 0x0, .par.clear.zero = 0x8) \ + MACRO(__VA_ARGS__, u16_clear_xzw_1xx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0xd, .par.clear.one = 0x1, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_yzw_xxx , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0xe, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u16_clear_yzw_xx1 , .type = SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR , .mask = 0xe, .par.clear.one = 0x8, .par.clear.zero = 0x0) +#define SWS_FOR_U16_LINEAR(MACRO, ...) +#define SWS_FOR_STRUCT_U16_LINEAR(MACRO, ...) +#define SWS_FOR_U16_DITHER(MACRO, ...) +#define SWS_FOR_STRUCT_U16_DITHER(MACRO, ...) +#define SWS_FOR_U32_READ_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_read_planar_x , SWS_PIXEL_U32, SWS_UOP_READ_PLANAR , 0x1) \ + MACRO(__VA_ARGS__, u32_read_planar_xy , SWS_PIXEL_U32, SWS_UOP_READ_PLANAR , 0x3) \ + MACRO(__VA_ARGS__, u32_read_planar_xyz , SWS_PIXEL_U32, SWS_UOP_READ_PLANAR , 0x7) \ + MACRO(__VA_ARGS__, u32_read_planar_xyzw , SWS_PIXEL_U32, SWS_UOP_READ_PLANAR , 0xf) +#define SWS_FOR_STRUCT_U32_READ_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_read_planar_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_READ_PLANAR , .mask = 0x1) \ + MACRO(__VA_ARGS__, u32_read_planar_xy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_READ_PLANAR , .mask = 0x3) \ + MACRO(__VA_ARGS__, u32_read_planar_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_READ_PLANAR , .mask = 0x7) \ + MACRO(__VA_ARGS__, u32_read_planar_xyzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_READ_PLANAR , .mask = 0xf) +#define SWS_FOR_U32_READ_PLANAR_FH(MACRO, ...) +#define SWS_FOR_STRUCT_U32_READ_PLANAR_FH(MACRO, ...) +#define SWS_FOR_U32_READ_PLANAR_FV(MACRO, ...) +#define SWS_FOR_STRUCT_U32_READ_PLANAR_FV(MACRO, ...) +#define SWS_FOR_U32_READ_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_read_packed_xy , SWS_PIXEL_U32, SWS_UOP_READ_PACKED , 0x3) \ + MACRO(__VA_ARGS__, u32_read_packed_xyz , SWS_PIXEL_U32, SWS_UOP_READ_PACKED , 0x7) \ + MACRO(__VA_ARGS__, u32_read_packed_xyzw , SWS_PIXEL_U32, SWS_UOP_READ_PACKED , 0xf) +#define SWS_FOR_STRUCT_U32_READ_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_read_packed_xy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_READ_PACKED , .mask = 0x3) \ + MACRO(__VA_ARGS__, u32_read_packed_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_READ_PACKED , .mask = 0x7) \ + MACRO(__VA_ARGS__, u32_read_packed_xyzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_READ_PACKED , .mask = 0xf) +#define SWS_FOR_U32_READ_NIBBLE(MACRO, ...) +#define SWS_FOR_STRUCT_U32_READ_NIBBLE(MACRO, ...) +#define SWS_FOR_U32_READ_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_U32_READ_BIT(MACRO, ...) +#define SWS_FOR_U32_WRITE_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_write_planar_x , SWS_PIXEL_U32, SWS_UOP_WRITE_PLANAR , 0x1) \ + MACRO(__VA_ARGS__, u32_write_planar_xy , SWS_PIXEL_U32, SWS_UOP_WRITE_PLANAR , 0x3) \ + MACRO(__VA_ARGS__, u32_write_planar_xyz , SWS_PIXEL_U32, SWS_UOP_WRITE_PLANAR , 0x7) \ + MACRO(__VA_ARGS__, u32_write_planar_xyzw , SWS_PIXEL_U32, SWS_UOP_WRITE_PLANAR , 0xf) +#define SWS_FOR_STRUCT_U32_WRITE_PLANAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_write_planar_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x1) \ + MACRO(__VA_ARGS__, u32_write_planar_xy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x3) \ + MACRO(__VA_ARGS__, u32_write_planar_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0x7) \ + MACRO(__VA_ARGS__, u32_write_planar_xyzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_WRITE_PLANAR , .mask = 0xf) +#define SWS_FOR_U32_WRITE_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_write_packed_xy , SWS_PIXEL_U32, SWS_UOP_WRITE_PACKED , 0x3) \ + MACRO(__VA_ARGS__, u32_write_packed_xyz , SWS_PIXEL_U32, SWS_UOP_WRITE_PACKED , 0x7) \ + MACRO(__VA_ARGS__, u32_write_packed_xyzw , SWS_PIXEL_U32, SWS_UOP_WRITE_PACKED , 0xf) +#define SWS_FOR_STRUCT_U32_WRITE_PACKED(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_write_packed_xy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_WRITE_PACKED , .mask = 0x3) \ + MACRO(__VA_ARGS__, u32_write_packed_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_WRITE_PACKED , .mask = 0x7) \ + MACRO(__VA_ARGS__, u32_write_packed_xyzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_WRITE_PACKED , .mask = 0xf) +#define SWS_FOR_U32_WRITE_NIBBLE(MACRO, ...) +#define SWS_FOR_STRUCT_U32_WRITE_NIBBLE(MACRO, ...) +#define SWS_FOR_U32_WRITE_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_U32_WRITE_BIT(MACRO, ...) +#define SWS_FOR_U32_PERMUTE(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_permute_x_y , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x1, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u32_permute_x_z , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x1, 2, 1, 0, 3) \ + MACRO(__VA_ARGS__, u32_permute_x_w , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x1, 3, 1, 2, 0) \ + MACRO(__VA_ARGS__, u32_permute_y_w , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x2, 0, 3, 2, 1) \ + MACRO(__VA_ARGS__, u32_permute_y_x , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x2, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u32_permute_xy_yx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x3, 1, 0, 2, 3) \ + MACRO(__VA_ARGS__, u32_permute_z_x , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x4, 1, 2, 0, 3) \ + MACRO(__VA_ARGS__, u32_permute_xz_zx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x5, 2, 1, 0, 3) \ + MACRO(__VA_ARGS__, u32_permute_xz_zw , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x5, 2, 1, 3, 0) \ + MACRO(__VA_ARGS__, u32_permute_xz_wx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x5, 3, 1, 0, 2) \ + MACRO(__VA_ARGS__, u32_permute_yz_zy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x6, 0, 2, 1, 3) \ + MACRO(__VA_ARGS__, u32_permute_xyz_yzx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x7, 1, 2, 0, 3) \ + MACRO(__VA_ARGS__, u32_permute_xyz_yzw , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x7, 1, 2, 3, 0) \ + MACRO(__VA_ARGS__, u32_permute_xyz_zxy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x7, 2, 0, 1, 3) \ + MACRO(__VA_ARGS__, u32_permute_xyz_zwy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x7, 2, 3, 1, 0) \ + MACRO(__VA_ARGS__, u32_permute_xyz_wzy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x7, 3, 2, 1, 0) \ + MACRO(__VA_ARGS__, u32_permute_w_y , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x8, 0, 2, 3, 1) \ + MACRO(__VA_ARGS__, u32_permute_w_x , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x8, 3, 1, 2, 0) \ + MACRO(__VA_ARGS__, u32_permute_xw_yx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0x9, 1, 2, 3, 0) \ + MACRO(__VA_ARGS__, u32_permute_yw_wy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xa, 0, 3, 2, 1) \ + MACRO(__VA_ARGS__, u32_permute_yw_xy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xa, 3, 0, 2, 1) \ + MACRO(__VA_ARGS__, u32_permute_zw_xz , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xc, 3, 1, 0, 2) \ + MACRO(__VA_ARGS__, u32_permute_yzw_xyz , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xe, 3, 0, 1, 2) \ + MACRO(__VA_ARGS__, u32_permute_yzw_zxy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xe, 3, 2, 0, 1) \ + MACRO(__VA_ARGS__, u32_permute_yzw_zyx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xe, 3, 2, 1, 0) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_yzwx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xf, 1, 2, 3, 0) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_wxyz , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xf, 3, 0, 1, 2) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_wzxy , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xf, 3, 2, 0, 1) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_wzyx , SWS_PIXEL_U32, SWS_UOP_PERMUTE , 0xf, 3, 2, 1, 0) +#define SWS_FOR_STRUCT_U32_PERMUTE(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_permute_x_y , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u32_permute_x_z , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {2, 1, 0, 3}) \ + MACRO(__VA_ARGS__, u32_permute_x_w , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x1, .par.swizzle.in = {3, 1, 2, 0}) \ + MACRO(__VA_ARGS__, u32_permute_y_w , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x2, .par.swizzle.in = {0, 3, 2, 1}) \ + MACRO(__VA_ARGS__, u32_permute_y_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x2, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u32_permute_xy_yx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x3, .par.swizzle.in = {1, 0, 2, 3}) \ + MACRO(__VA_ARGS__, u32_permute_z_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x4, .par.swizzle.in = {1, 2, 0, 3}) \ + MACRO(__VA_ARGS__, u32_permute_xz_zx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x5, .par.swizzle.in = {2, 1, 0, 3}) \ + MACRO(__VA_ARGS__, u32_permute_xz_zw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x5, .par.swizzle.in = {2, 1, 3, 0}) \ + MACRO(__VA_ARGS__, u32_permute_xz_wx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x5, .par.swizzle.in = {3, 1, 0, 2}) \ + MACRO(__VA_ARGS__, u32_permute_yz_zy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x6, .par.swizzle.in = {0, 2, 1, 3}) \ + MACRO(__VA_ARGS__, u32_permute_xyz_yzx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {1, 2, 0, 3}) \ + MACRO(__VA_ARGS__, u32_permute_xyz_yzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {1, 2, 3, 0}) \ + MACRO(__VA_ARGS__, u32_permute_xyz_zxy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {2, 0, 1, 3}) \ + MACRO(__VA_ARGS__, u32_permute_xyz_zwy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {2, 3, 1, 0}) \ + MACRO(__VA_ARGS__, u32_permute_xyz_wzy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x7, .par.swizzle.in = {3, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u32_permute_w_y , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x8, .par.swizzle.in = {0, 2, 3, 1}) \ + MACRO(__VA_ARGS__, u32_permute_w_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x8, .par.swizzle.in = {3, 1, 2, 0}) \ + MACRO(__VA_ARGS__, u32_permute_xw_yx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0x9, .par.swizzle.in = {1, 2, 3, 0}) \ + MACRO(__VA_ARGS__, u32_permute_yw_wy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xa, .par.swizzle.in = {0, 3, 2, 1}) \ + MACRO(__VA_ARGS__, u32_permute_yw_xy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xa, .par.swizzle.in = {3, 0, 2, 1}) \ + MACRO(__VA_ARGS__, u32_permute_zw_xz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xc, .par.swizzle.in = {3, 1, 0, 2}) \ + MACRO(__VA_ARGS__, u32_permute_yzw_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 0, 1, 2}) \ + MACRO(__VA_ARGS__, u32_permute_yzw_zxy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 2, 0, 1}) \ + MACRO(__VA_ARGS__, u32_permute_yzw_zyx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xe, .par.swizzle.in = {3, 2, 1, 0}) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_yzwx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {1, 2, 3, 0}) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_wxyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 0, 1, 2}) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_wzxy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 2, 0, 1}) \ + MACRO(__VA_ARGS__, u32_permute_xyzw_wzyx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PERMUTE , .mask = 0xf, .par.swizzle.in = {3, 2, 1, 0}) +#define SWS_FOR_U32_COPY(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_copy_yz_xx , SWS_PIXEL_U32, SWS_UOP_COPY , 0x6, 0, 0, 0, 3) \ + MACRO(__VA_ARGS__, u32_copy_yzw_xxx , SWS_PIXEL_U32, SWS_UOP_COPY , 0xe, 0, 0, 0, 0) \ + MACRO(__VA_ARGS__, u32_copy_yzw_xxy , SWS_PIXEL_U32, SWS_UOP_COPY , 0xe, 0, 0, 0, 1) +#define SWS_FOR_STRUCT_U32_COPY(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_copy_yz_xx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_COPY , .mask = 0x6, .par.swizzle.in = {0, 0, 0, 3}) \ + MACRO(__VA_ARGS__, u32_copy_yzw_xxx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_COPY , .mask = 0xe, .par.swizzle.in = {0, 0, 0, 0}) \ + MACRO(__VA_ARGS__, u32_copy_yzw_xxy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_COPY , .mask = 0xe, .par.swizzle.in = {0, 0, 0, 1}) +#define SWS_FOR_U32_SWAP_BYTES(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_swap_bytes_x , SWS_PIXEL_U32, SWS_UOP_SWAP_BYTES , 0x1) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xy , SWS_PIXEL_U32, SWS_UOP_SWAP_BYTES , 0x3) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xyz , SWS_PIXEL_U32, SWS_UOP_SWAP_BYTES , 0x7) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xw , SWS_PIXEL_U32, SWS_UOP_SWAP_BYTES , 0x9) \ + MACRO(__VA_ARGS__, u32_swap_bytes_yzw , SWS_PIXEL_U32, SWS_UOP_SWAP_BYTES , 0xe) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xyzw , SWS_PIXEL_U32, SWS_UOP_SWAP_BYTES , 0xf) +#define SWS_FOR_STRUCT_U32_SWAP_BYTES(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_swap_bytes_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x1) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xy , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x3) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x7) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SWAP_BYTES , .mask = 0x9) \ + MACRO(__VA_ARGS__, u32_swap_bytes_yzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SWAP_BYTES , .mask = 0xe) \ + MACRO(__VA_ARGS__, u32_swap_bytes_xyzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SWAP_BYTES , .mask = 0xf) +#define SWS_FOR_U32_EXPAND_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_U32_EXPAND_BIT(MACRO, ...) +#define SWS_FOR_U32_EXPAND_PAIR(MACRO, ...) +#define SWS_FOR_STRUCT_U32_EXPAND_PAIR(MACRO, ...) +#define SWS_FOR_U32_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_STRUCT_U32_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_U32_TO_U8(MACRO, ...) +#define SWS_FOR_STRUCT_U32_TO_U8(MACRO, ...) +#define SWS_FOR_U32_TO_U16(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_to_u16_y , SWS_PIXEL_U32, SWS_UOP_TO_U16 , 0x2) \ + MACRO(__VA_ARGS__, u32_to_u16_z , SWS_PIXEL_U32, SWS_UOP_TO_U16 , 0x4) \ + MACRO(__VA_ARGS__, u32_to_u16_xyz , SWS_PIXEL_U32, SWS_UOP_TO_U16 , 0x7) \ + MACRO(__VA_ARGS__, u32_to_u16_yzw , SWS_PIXEL_U32, SWS_UOP_TO_U16 , 0xe) +#define SWS_FOR_STRUCT_U32_TO_U16(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_to_u16_y , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_U16 , .mask = 0x2) \ + MACRO(__VA_ARGS__, u32_to_u16_z , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_U16 , .mask = 0x4) \ + MACRO(__VA_ARGS__, u32_to_u16_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_U16 , .mask = 0x7) \ + MACRO(__VA_ARGS__, u32_to_u16_yzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_U16 , .mask = 0xe) +#define SWS_FOR_U32_TO_U32(MACRO, ...) +#define SWS_FOR_STRUCT_U32_TO_U32(MACRO, ...) +#define SWS_FOR_U32_TO_F32(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_to_f32_y , SWS_PIXEL_U32, SWS_UOP_TO_F32 , 0x2) \ + MACRO(__VA_ARGS__, u32_to_f32_z , SWS_PIXEL_U32, SWS_UOP_TO_F32 , 0x4) \ + MACRO(__VA_ARGS__, u32_to_f32_xyz , SWS_PIXEL_U32, SWS_UOP_TO_F32 , 0x7) \ + MACRO(__VA_ARGS__, u32_to_f32_yzw , SWS_PIXEL_U32, SWS_UOP_TO_F32 , 0xe) +#define SWS_FOR_STRUCT_U32_TO_F32(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_to_f32_y , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32 , .mask = 0x2) \ + MACRO(__VA_ARGS__, u32_to_f32_z , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32 , .mask = 0x4) \ + MACRO(__VA_ARGS__, u32_to_f32_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32 , .mask = 0x7) \ + MACRO(__VA_ARGS__, u32_to_f32_yzw , .type = SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32 , .mask = 0xe) +#define SWS_FOR_U32_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_scale_x , SWS_PIXEL_U32, SWS_UOP_SCALE , 0x1) \ + MACRO(__VA_ARGS__, u32_scale_xyz , SWS_PIXEL_U32, SWS_UOP_SCALE , 0x7) +#define SWS_FOR_STRUCT_U32_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_scale_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SCALE , .mask = 0x1) \ + MACRO(__VA_ARGS__, u32_scale_xyz , .type = SWS_PIXEL_U32, .uop = SWS_UOP_SCALE , .mask = 0x7) +#define SWS_FOR_U32_ADD(MACRO, ...) +#define SWS_FOR_STRUCT_U32_ADD(MACRO, ...) +#define SWS_FOR_U32_MIN(MACRO, ...) +#define SWS_FOR_STRUCT_U32_MIN(MACRO, ...) +#define SWS_FOR_U32_MAX(MACRO, ...) +#define SWS_FOR_STRUCT_U32_MAX(MACRO, ...) +#define SWS_FOR_U32_UNPACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_unpack_xyzw_2aaa , SWS_PIXEL_U32, SWS_UOP_UNPACK , 0xf, 2, 10, 10, 10) \ + MACRO(__VA_ARGS__, u32_unpack_xyzw_aaa2 , SWS_PIXEL_U32, SWS_UOP_UNPACK , 0xf, 10, 10, 10, 2) +#define SWS_FOR_STRUCT_U32_UNPACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_unpack_xyzw_2aaa , .type = SWS_PIXEL_U32, .uop = SWS_UOP_UNPACK , .mask = 0xf, .par.pack.pattern = {2, 10, 10, 10}) \ + MACRO(__VA_ARGS__, u32_unpack_xyzw_aaa2 , .type = SWS_PIXEL_U32, .uop = SWS_UOP_UNPACK , .mask = 0xf, .par.pack.pattern = {10, 10, 10, 2}) +#define SWS_FOR_U32_PACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_pack_xyzw_2aaa , SWS_PIXEL_U32, SWS_UOP_PACK , 0xf, 2, 10, 10, 10) \ + MACRO(__VA_ARGS__, u32_pack_xyzw_aaa2 , SWS_PIXEL_U32, SWS_UOP_PACK , 0xf, 10, 10, 10, 2) +#define SWS_FOR_STRUCT_U32_PACK(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_pack_xyzw_2aaa , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PACK , .mask = 0xf, .par.pack.pattern = {2, 10, 10, 10}) \ + MACRO(__VA_ARGS__, u32_pack_xyzw_aaa2 , .type = SWS_PIXEL_U32, .uop = SWS_UOP_PACK , .mask = 0xf, .par.pack.pattern = {10, 10, 10, 2}) +#define SWS_FOR_U32_LSHIFT(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_lshift_xyz_2 , SWS_PIXEL_U32, SWS_UOP_LSHIFT , 0x7, 2) +#define SWS_FOR_STRUCT_U32_LSHIFT(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_lshift_xyz_2 , .type = SWS_PIXEL_U32, .uop = SWS_UOP_LSHIFT , .mask = 0x7, .par.shift.amount = 2) +#define SWS_FOR_U32_RSHIFT(MACRO, ...) +#define SWS_FOR_STRUCT_U32_RSHIFT(MACRO, ...) +#define SWS_FOR_U32_CLEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_clear_x_x , SWS_PIXEL_U32, SWS_UOP_CLEAR , 0x1, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u32_clear_y_x , SWS_PIXEL_U32, SWS_UOP_CLEAR , 0x2, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u32_clear_xz_xx , SWS_PIXEL_U32, SWS_UOP_CLEAR , 0x5, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u32_clear_w_x , SWS_PIXEL_U32, SWS_UOP_CLEAR , 0x8, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u32_clear_yw_xx , SWS_PIXEL_U32, SWS_UOP_CLEAR , 0xa, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u32_clear_xyw_xxx , SWS_PIXEL_U32, SWS_UOP_CLEAR , 0xb, 0x00000, 0x00000) \ + MACRO(__VA_ARGS__, u32_clear_xzw_xxx , SWS_PIXEL_U32, SWS_UOP_CLEAR , 0xd, 0x00000, 0x00000) +#define SWS_FOR_STRUCT_U32_CLEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, u32_clear_x_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR , .mask = 0x1, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u32_clear_y_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR , .mask = 0x2, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u32_clear_xz_xx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR , .mask = 0x5, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u32_clear_w_x , .type = SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR , .mask = 0x8, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u32_clear_yw_xx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR , .mask = 0xa, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u32_clear_xyw_xxx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR , .mask = 0xb, .par.clear.one = 0x0, .par.clear.zero = 0x0) \ + MACRO(__VA_ARGS__, u32_clear_xzw_xxx , .type = SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR , .mask = 0xd, .par.clear.one = 0x0, .par.clear.zero = 0x0) +#define SWS_FOR_U32_LINEAR(MACRO, ...) +#define SWS_FOR_STRUCT_U32_LINEAR(MACRO, ...) +#define SWS_FOR_U32_DITHER(MACRO, ...) +#define SWS_FOR_STRUCT_U32_DITHER(MACRO, ...) +#define SWS_FOR_F32_READ_PLANAR(MACRO, ...) +#define SWS_FOR_STRUCT_F32_READ_PLANAR(MACRO, ...) +#define SWS_FOR_F32_READ_PLANAR_FH(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_x , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FH , 0x1) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_xy , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FH , 0x3) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_xyz , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FH , 0x7) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_xyzw , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FH , 0xf) +#define SWS_FOR_STRUCT_F32_READ_PLANAR_FH(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_read_planar_fh_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FH , .mask = 0xf) +#define SWS_FOR_F32_READ_PLANAR_FV(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_x , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FV , 0x1) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_xy , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FV , 0x3) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_xyz , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FV , 0x7) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_xyzw , SWS_PIXEL_F32, SWS_UOP_READ_PLANAR_FV , 0xf) +#define SWS_FOR_STRUCT_F32_READ_PLANAR_FV(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_read_planar_fv_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_READ_PLANAR_FV , .mask = 0xf) +#define SWS_FOR_F32_READ_PACKED(MACRO, ...) +#define SWS_FOR_STRUCT_F32_READ_PACKED(MACRO, ...) +#define SWS_FOR_F32_READ_NIBBLE(MACRO, ...) +#define SWS_FOR_STRUCT_F32_READ_NIBBLE(MACRO, ...) +#define SWS_FOR_F32_READ_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_F32_READ_BIT(MACRO, ...) +#define SWS_FOR_F32_WRITE_PLANAR(MACRO, ...) +#define SWS_FOR_STRUCT_F32_WRITE_PLANAR(MACRO, ...) +#define SWS_FOR_F32_WRITE_PACKED(MACRO, ...) +#define SWS_FOR_STRUCT_F32_WRITE_PACKED(MACRO, ...) +#define SWS_FOR_F32_WRITE_NIBBLE(MACRO, ...) +#define SWS_FOR_STRUCT_F32_WRITE_NIBBLE(MACRO, ...) +#define SWS_FOR_F32_WRITE_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_F32_WRITE_BIT(MACRO, ...) +#define SWS_FOR_F32_PERMUTE(MACRO, ...) +#define SWS_FOR_STRUCT_F32_PERMUTE(MACRO, ...) +#define SWS_FOR_F32_COPY(MACRO, ...) +#define SWS_FOR_STRUCT_F32_COPY(MACRO, ...) +#define SWS_FOR_F32_SWAP_BYTES(MACRO, ...) +#define SWS_FOR_STRUCT_F32_SWAP_BYTES(MACRO, ...) +#define SWS_FOR_F32_EXPAND_BIT(MACRO, ...) +#define SWS_FOR_STRUCT_F32_EXPAND_BIT(MACRO, ...) +#define SWS_FOR_F32_EXPAND_PAIR(MACRO, ...) +#define SWS_FOR_STRUCT_F32_EXPAND_PAIR(MACRO, ...) +#define SWS_FOR_F32_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_STRUCT_F32_EXPAND_QUAD(MACRO, ...) +#define SWS_FOR_F32_TO_U8(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_to_u8_x , SWS_PIXEL_F32, SWS_UOP_TO_U8 , 0x1) \ + MACRO(__VA_ARGS__, f32_to_u8_xy , SWS_PIXEL_F32, SWS_UOP_TO_U8 , 0x3) \ + MACRO(__VA_ARGS__, f32_to_u8_xyz , SWS_PIXEL_F32, SWS_UOP_TO_U8 , 0x7) \ + MACRO(__VA_ARGS__, f32_to_u8_xw , SWS_PIXEL_F32, SWS_UOP_TO_U8 , 0x9) \ + MACRO(__VA_ARGS__, f32_to_u8_yzw , SWS_PIXEL_F32, SWS_UOP_TO_U8 , 0xe) \ + MACRO(__VA_ARGS__, f32_to_u8_xyzw , SWS_PIXEL_F32, SWS_UOP_TO_U8 , 0xf) +#define SWS_FOR_STRUCT_F32_TO_U8(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_to_u8_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U8 , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_to_u8_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U8 , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_to_u8_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U8 , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_to_u8_xw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U8 , .mask = 0x9) \ + MACRO(__VA_ARGS__, f32_to_u8_yzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U8 , .mask = 0xe) \ + MACRO(__VA_ARGS__, f32_to_u8_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U8 , .mask = 0xf) +#define SWS_FOR_F32_TO_U16(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_to_u16_x , SWS_PIXEL_F32, SWS_UOP_TO_U16 , 0x1) \ + MACRO(__VA_ARGS__, f32_to_u16_xy , SWS_PIXEL_F32, SWS_UOP_TO_U16 , 0x3) \ + MACRO(__VA_ARGS__, f32_to_u16_xyz , SWS_PIXEL_F32, SWS_UOP_TO_U16 , 0x7) \ + MACRO(__VA_ARGS__, f32_to_u16_xw , SWS_PIXEL_F32, SWS_UOP_TO_U16 , 0x9) \ + MACRO(__VA_ARGS__, f32_to_u16_yzw , SWS_PIXEL_F32, SWS_UOP_TO_U16 , 0xe) \ + MACRO(__VA_ARGS__, f32_to_u16_xyzw , SWS_PIXEL_F32, SWS_UOP_TO_U16 , 0xf) +#define SWS_FOR_STRUCT_F32_TO_U16(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_to_u16_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U16 , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_to_u16_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U16 , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_to_u16_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U16 , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_to_u16_xw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U16 , .mask = 0x9) \ + MACRO(__VA_ARGS__, f32_to_u16_yzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U16 , .mask = 0xe) \ + MACRO(__VA_ARGS__, f32_to_u16_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U16 , .mask = 0xf) +#define SWS_FOR_F32_TO_U32(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_to_u32_x , SWS_PIXEL_F32, SWS_UOP_TO_U32 , 0x1) \ + MACRO(__VA_ARGS__, f32_to_u32_xyz , SWS_PIXEL_F32, SWS_UOP_TO_U32 , 0x7) \ + MACRO(__VA_ARGS__, f32_to_u32_xw , SWS_PIXEL_F32, SWS_UOP_TO_U32 , 0x9) \ + MACRO(__VA_ARGS__, f32_to_u32_yzw , SWS_PIXEL_F32, SWS_UOP_TO_U32 , 0xe) \ + MACRO(__VA_ARGS__, f32_to_u32_xyzw , SWS_PIXEL_F32, SWS_UOP_TO_U32 , 0xf) +#define SWS_FOR_STRUCT_F32_TO_U32(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_to_u32_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U32 , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_to_u32_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U32 , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_to_u32_xw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U32 , .mask = 0x9) \ + MACRO(__VA_ARGS__, f32_to_u32_yzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U32 , .mask = 0xe) \ + MACRO(__VA_ARGS__, f32_to_u32_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_TO_U32 , .mask = 0xf) +#define SWS_FOR_F32_TO_F32(MACRO, ...) +#define SWS_FOR_STRUCT_F32_TO_F32(MACRO, ...) +#define SWS_FOR_F32_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_scale_x , SWS_PIXEL_F32, SWS_UOP_SCALE , 0x1) \ + MACRO(__VA_ARGS__, f32_scale_xy , SWS_PIXEL_F32, SWS_UOP_SCALE , 0x3) \ + MACRO(__VA_ARGS__, f32_scale_xyz , SWS_PIXEL_F32, SWS_UOP_SCALE , 0x7) \ + MACRO(__VA_ARGS__, f32_scale_yzw , SWS_PIXEL_F32, SWS_UOP_SCALE , 0xe) \ + MACRO(__VA_ARGS__, f32_scale_xyzw , SWS_PIXEL_F32, SWS_UOP_SCALE , 0xf) +#define SWS_FOR_STRUCT_F32_SCALE(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_scale_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_SCALE , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_scale_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_SCALE , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_scale_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_SCALE , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_scale_yzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_SCALE , .mask = 0xe) \ + MACRO(__VA_ARGS__, f32_scale_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_SCALE , .mask = 0xf) +#define SWS_FOR_F32_ADD(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_add_x , SWS_PIXEL_F32, SWS_UOP_ADD , 0x1) \ + MACRO(__VA_ARGS__, f32_add_xy , SWS_PIXEL_F32, SWS_UOP_ADD , 0x3) \ + MACRO(__VA_ARGS__, f32_add_xz , SWS_PIXEL_F32, SWS_UOP_ADD , 0x5) \ + MACRO(__VA_ARGS__, f32_add_xyz , SWS_PIXEL_F32, SWS_UOP_ADD , 0x7) \ + MACRO(__VA_ARGS__, f32_add_w , SWS_PIXEL_F32, SWS_UOP_ADD , 0x8) \ + MACRO(__VA_ARGS__, f32_add_xw , SWS_PIXEL_F32, SWS_UOP_ADD , 0x9) \ + MACRO(__VA_ARGS__, f32_add_yzw , SWS_PIXEL_F32, SWS_UOP_ADD , 0xe) \ + MACRO(__VA_ARGS__, f32_add_xyzw , SWS_PIXEL_F32, SWS_UOP_ADD , 0xf) +#define SWS_FOR_STRUCT_F32_ADD(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_add_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_add_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_add_xz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0x5) \ + MACRO(__VA_ARGS__, f32_add_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_add_w , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0x8) \ + MACRO(__VA_ARGS__, f32_add_xw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0x9) \ + MACRO(__VA_ARGS__, f32_add_yzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0xe) \ + MACRO(__VA_ARGS__, f32_add_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_ADD , .mask = 0xf) +#define SWS_FOR_F32_MIN(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_min_x , SWS_PIXEL_F32, SWS_UOP_MIN , 0x1) \ + MACRO(__VA_ARGS__, f32_min_xy , SWS_PIXEL_F32, SWS_UOP_MIN , 0x3) \ + MACRO(__VA_ARGS__, f32_min_xyz , SWS_PIXEL_F32, SWS_UOP_MIN , 0x7) \ + MACRO(__VA_ARGS__, f32_min_xw , SWS_PIXEL_F32, SWS_UOP_MIN , 0x9) \ + MACRO(__VA_ARGS__, f32_min_yzw , SWS_PIXEL_F32, SWS_UOP_MIN , 0xe) \ + MACRO(__VA_ARGS__, f32_min_xyzw , SWS_PIXEL_F32, SWS_UOP_MIN , 0xf) +#define SWS_FOR_STRUCT_F32_MIN(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_min_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MIN , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_min_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MIN , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_min_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MIN , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_min_xw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MIN , .mask = 0x9) \ + MACRO(__VA_ARGS__, f32_min_yzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MIN , .mask = 0xe) \ + MACRO(__VA_ARGS__, f32_min_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MIN , .mask = 0xf) +#define SWS_FOR_F32_MAX(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_max_x , SWS_PIXEL_F32, SWS_UOP_MAX , 0x1) \ + MACRO(__VA_ARGS__, f32_max_xy , SWS_PIXEL_F32, SWS_UOP_MAX , 0x3) \ + MACRO(__VA_ARGS__, f32_max_xyz , SWS_PIXEL_F32, SWS_UOP_MAX , 0x7) \ + MACRO(__VA_ARGS__, f32_max_xw , SWS_PIXEL_F32, SWS_UOP_MAX , 0x9) \ + MACRO(__VA_ARGS__, f32_max_xyzw , SWS_PIXEL_F32, SWS_UOP_MAX , 0xf) +#define SWS_FOR_STRUCT_F32_MAX(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_max_x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MAX , .mask = 0x1) \ + MACRO(__VA_ARGS__, f32_max_xy , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MAX , .mask = 0x3) \ + MACRO(__VA_ARGS__, f32_max_xyz , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MAX , .mask = 0x7) \ + MACRO(__VA_ARGS__, f32_max_xw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MAX , .mask = 0x9) \ + MACRO(__VA_ARGS__, f32_max_xyzw , .type = SWS_PIXEL_F32, .uop = SWS_UOP_MAX , .mask = 0xf) +#define SWS_FOR_F32_UNPACK(MACRO, ...) +#define SWS_FOR_STRUCT_F32_UNPACK(MACRO, ...) +#define SWS_FOR_F32_PACK(MACRO, ...) +#define SWS_FOR_STRUCT_F32_PACK(MACRO, ...) +#define SWS_FOR_F32_LSHIFT(MACRO, ...) +#define SWS_FOR_STRUCT_F32_LSHIFT(MACRO, ...) +#define SWS_FOR_F32_RSHIFT(MACRO, ...) +#define SWS_FOR_STRUCT_F32_RSHIFT(MACRO, ...) +#define SWS_FOR_F32_CLEAR(MACRO, ...) +#define SWS_FOR_STRUCT_F32_CLEAR(MACRO, ...) +#define SWS_FOR_F32_LINEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_linear_x_x000x , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x1, 0x41040, 0xbefae) \ + MACRO(__VA_ARGS__, f32_linear_x_xxx00 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x1, 0x41040, 0xbefb8) \ + MACRO(__VA_ARGS__, f32_linear_x_xxx01 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x1, 0x41050, 0xbefa8) \ + MACRO(__VA_ARGS__, f32_linear_x_x0001 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x1, 0x41050, 0xbefae) \ + MACRO(__VA_ARGS__, f32_linear_y_0x000 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x2, 0x41001, 0xbefbe) \ + MACRO(__VA_ARGS__, f32_linear_xyz_xxx0x_xxx0x_xxx0x , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x40000, 0xba108) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0x0x_xxx0x_xx00x , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x40000, 0xbb10a) \ + MACRO(__VA_ARGS__, f32_linear_xyz_xxx00_xxx0x_xxx0x , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x40000, 0xba118) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x000x_0x00x_00x0x , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x40000, 0xbadae) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0000_0x000_00x00 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x40000, 0xbefbe) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0001_0x00x_00x01 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x44010, 0xbadae) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0001_0x001_00x01 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x44210, 0xbadae) \ + MACRO(__VA_ARGS__, f32_linear_xyz_10x0x_1xx0x_1x00x , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x7, 0x40421, 0xbb10a) \ + MACRO(__VA_ARGS__, f32_linear_w_000x0 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x8, 0x01041, 0xbefbe) \ + MACRO(__VA_ARGS__, f32_linear_xw_x000x_000x0 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x9, 0x01040, 0xbefae) \ + MACRO(__VA_ARGS__, f32_linear_xw_xxx00_000x0 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0x9, 0x01040, 0xbefb8) \ + MACRO(__VA_ARGS__, f32_linear_xyzw_xxx0x_xxx0x_xxx0x_000x0 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0xf, 0x00000, 0xba108) \ + MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0xf, 0x00000, 0xbb10a) \ + MACRO(__VA_ARGS__, f32_linear_xyzw_x0000_0x000_00x00_000x0 , SWS_PIXEL_F32, SWS_UOP_LINEAR , 0xf, 0x00000, 0xbefbe) +#define SWS_FOR_STRUCT_F32_LINEAR(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_linear_x_x000x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x1, .par.lin.one = 0x41040, .par.lin.zero = 0xbefae) \ + MACRO(__VA_ARGS__, f32_linear_x_xxx00 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x1, .par.lin.one = 0x41040, .par.lin.zero = 0xbefb8) \ + MACRO(__VA_ARGS__, f32_linear_x_xxx01 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x1, .par.lin.one = 0x41050, .par.lin.zero = 0xbefa8) \ + MACRO(__VA_ARGS__, f32_linear_x_x0001 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x1, .par.lin.one = 0x41050, .par.lin.zero = 0xbefae) \ + MACRO(__VA_ARGS__, f32_linear_y_0x000 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x2, .par.lin.one = 0x41001, .par.lin.zero = 0xbefbe) \ + MACRO(__VA_ARGS__, f32_linear_xyz_xxx0x_xxx0x_xxx0x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x40000, .par.lin.zero = 0xba108) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0x0x_xxx0x_xx00x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x40000, .par.lin.zero = 0xbb10a) \ + MACRO(__VA_ARGS__, f32_linear_xyz_xxx00_xxx0x_xxx0x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x40000, .par.lin.zero = 0xba118) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x000x_0x00x_00x0x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x40000, .par.lin.zero = 0xbadae) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0000_0x000_00x00 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x40000, .par.lin.zero = 0xbefbe) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0001_0x00x_00x01 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x44010, .par.lin.zero = 0xbadae) \ + MACRO(__VA_ARGS__, f32_linear_xyz_x0001_0x001_00x01 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x44210, .par.lin.zero = 0xbadae) \ + MACRO(__VA_ARGS__, f32_linear_xyz_10x0x_1xx0x_1x00x , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x7, .par.lin.one = 0x40421, .par.lin.zero = 0xbb10a) \ + MACRO(__VA_ARGS__, f32_linear_w_000x0 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x8, .par.lin.one = 0x1041, .par.lin.zero = 0xbefbe) \ + MACRO(__VA_ARGS__, f32_linear_xw_x000x_000x0 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x9, .par.lin.one = 0x1040, .par.lin.zero = 0xbefae) \ + MACRO(__VA_ARGS__, f32_linear_xw_xxx00_000x0 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0x9, .par.lin.one = 0x1040, .par.lin.zero = 0xbefb8) \ + MACRO(__VA_ARGS__, f32_linear_xyzw_xxx0x_xxx0x_xxx0x_000x0 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0xf, .par.lin.one = 0x0, .par.lin.zero = 0xba108) \ + MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0xf, .par.lin.one = 0x0, .par.lin.zero = 0xbb10a) \ + MACRO(__VA_ARGS__, f32_linear_xyzw_x0000_0x000_00x00_000x0 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR , .mask = 0xf, .par.lin.one = 0x0, .par.lin.zero = 0xbefbe) +#define SWS_FOR_F32_DITHER(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_dither_x_0_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x1, 0, 0, 0, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_y_3_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x2, 0, 3, 0, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xy_0_3_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x3, 0, 3, 0, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_z_2_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x4, 0, 0, 2, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xz_0_2_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x5, 0, 0, 2, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyz_0_0_0_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x7, 0, 0, 0, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyz_0_3_2_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x7, 0, 3, 2, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyz_2_0_3_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x7, 2, 0, 3, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyz_2_3_0_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x7, 2, 3, 0, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyz_3_0_2_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x7, 3, 0, 2, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyz_3_2_0_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x7, 3, 2, 0, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_w_5_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x8, 0, 0, 0, 5, 4) \ + MACRO(__VA_ARGS__, f32_dither_xw_0_3_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x9, 0, 0, 0, 3, 4) \ + MACRO(__VA_ARGS__, f32_dither_xw_0_5_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0x9, 0, 0, 0, 5, 4) \ + MACRO(__VA_ARGS__, f32_dither_yzw_0_3_2_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xe, 0, 0, 3, 2, 4) \ + MACRO(__VA_ARGS__, f32_dither_yzw_2_0_3_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xe, 0, 2, 0, 3, 4) \ + MACRO(__VA_ARGS__, f32_dither_yzw_2_3_0_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xe, 0, 2, 3, 0, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_0_0_0_3_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xf, 0, 0, 0, 3, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_0_3_2_5_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xf, 0, 3, 2, 5, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_2_3_0_5_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xf, 2, 3, 0, 5, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_3_0_2_5_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xf, 3, 0, 2, 5, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_3_2_0_5_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xf, 3, 2, 0, 5, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_5_0_3_2_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xf, 5, 0, 3, 2, 4) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_5_2_3_0_16x16 , SWS_PIXEL_F32, SWS_UOP_DITHER , 0xf, 5, 2, 3, 0, 4) +#define SWS_FOR_STRUCT_F32_DITHER(MACRO, ...) \ + MACRO(__VA_ARGS__, f32_dither_x_0_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x1, .par.dither = { .y_offset = {0, 0, 0, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_y_3_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x2, .par.dither = { .y_offset = {0, 3, 0, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xy_0_3_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x3, .par.dither = { .y_offset = {0, 3, 0, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_z_2_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x4, .par.dither = { .y_offset = {0, 0, 2, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xz_0_2_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x5, .par.dither = { .y_offset = {0, 0, 2, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyz_0_0_0_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x7, .par.dither = { .y_offset = {0, 0, 0, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyz_0_3_2_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x7, .par.dither = { .y_offset = {0, 3, 2, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyz_2_0_3_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x7, .par.dither = { .y_offset = {2, 0, 3, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyz_2_3_0_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x7, .par.dither = { .y_offset = {2, 3, 0, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyz_3_0_2_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x7, .par.dither = { .y_offset = {3, 0, 2, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyz_3_2_0_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x7, .par.dither = { .y_offset = {3, 2, 0, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_w_5_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x8, .par.dither = { .y_offset = {0, 0, 0, 5}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xw_0_3_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x9, .par.dither = { .y_offset = {0, 0, 0, 3}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xw_0_5_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0x9, .par.dither = { .y_offset = {0, 0, 0, 5}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_yzw_0_3_2_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xe, .par.dither = { .y_offset = {0, 0, 3, 2}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_yzw_2_0_3_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xe, .par.dither = { .y_offset = {0, 2, 0, 3}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_yzw_2_3_0_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xe, .par.dither = { .y_offset = {0, 2, 3, 0}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_0_0_0_3_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xf, .par.dither = { .y_offset = {0, 0, 0, 3}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_0_3_2_5_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xf, .par.dither = { .y_offset = {0, 3, 2, 5}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_2_3_0_5_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xf, .par.dither = { .y_offset = {2, 3, 0, 5}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_3_0_2_5_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xf, .par.dither = { .y_offset = {3, 0, 2, 5}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_3_2_0_5_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xf, .par.dither = { .y_offset = {3, 2, 0, 5}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_5_0_3_2_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xf, .par.dither = { .y_offset = {5, 0, 3, 2}, .size_log2 = 4 }) \ + MACRO(__VA_ARGS__, f32_dither_xyzw_5_2_3_0_16x16 , .type = SWS_PIXEL_F32, .uop = SWS_UOP_DITHER , .mask = 0xf, .par.dither = { .y_offset = {5, 2, 3, 0}, .size_log2 = 4 }) + +#endif /* SWSCALE_UOPS_MACROS_H */ diff --git a/tests/fate/libswscale.mak b/tests/fate/libswscale.mak index ff6bd2edba..f39cd50ab9 100644 --- a/tests/fate/libswscale.mak +++ b/tests/fate/libswscale.mak @@ -47,6 +47,13 @@ ifneq ($(HAVE_BIGENDIAN),yes) FATE_LIBSWSCALE-$(CONFIG_UNSTABLE) += fate-sws-ops-list fate-sws-ops-list: libswscale/tests/sws_ops$(EXESUF) fate-sws-ops-list: CMD = run libswscale/tests/sws_ops$(EXESUF) | do_md5sum | cut -d" " -f1 + +# Disable on bigendian because it would result in a different iteration order +# (and thus output) due to sorting by memcmp() on the parameters struct. +FATE_LIBSWSCALE-$(CONFIG_UNSTABLE) += fate-sws-uops-macros +fate-sws-uops-macros: libswscale/tests/sws_ops$(EXESUF) +fate-sws-uops-macros: REF = $(SRC_PATH)/libswscale/uops_macros.h +fate-sws-uops-macros: CMD = run libswscale/tests/sws_ops$(EXESUF) -macros endif FATE_LIBSWSCALE += $(FATE_LIBSWSCALE-yes) diff --git a/tests/ref/fate/source b/tests/ref/fate/source index cbbd347ef2..e40e8f0b86 100644 --- a/tests/ref/fate/source +++ b/tests/ref/fate/source @@ -19,6 +19,7 @@ libswresample/log2_tab.c libswscale/aarch64/ops_entries.c libswscale/log2_tab.c libswscale/riscv/cpu_common.c +libswscale/uops_macros.h tools/uncoded_frame.c tools/yuvcmp.c Headers without standard inclusion guards: _______________________________________________ ffmpeg-cvslog mailing list -- [email protected] To unsubscribe send an email to [email protected]
