This is an automated email from the git hooks/post-receive script. Git pushed a commit to branch master in repository ffmpeg.
commit f4edbf0b38bb88f3ad950754063266f979bc4ebb Author: Ramiro Polla <[email protected]> AuthorDate: Thu Jun 18 01:18:22 2026 +0200 Commit: Ramiro Polla <[email protected]> CommitDate: Sun Jul 19 15:07:02 2026 +0200 swscale/aarch64/ops: remove overly-complicated field-specific functions ... and replace them by simple switches. Since the last commit, op_fields is no longer used by aarch64/ops_asmgen, so it can be simplified into its only user. Sponsored-by: Sovereign Tech Fund Signed-off-by: Ramiro Polla <[email protected]> --- libswscale/aarch64/ops_impl.c | 385 ------------------------------------- libswscale/tests/sws_ops_aarch64.c | 225 +++++++++++++++++++--- 2 files changed, 200 insertions(+), 410 deletions(-) diff --git a/libswscale/aarch64/ops_impl.c b/libswscale/aarch64/ops_impl.c deleted file mode 100644 index f30cc18baf..0000000000 --- a/libswscale/aarch64/ops_impl.c +++ /dev/null @@ -1,385 +0,0 @@ -/* - * Copyright (C) 2026 Ramiro Polla - * - * This file is part of FFmpeg. - * - * FFmpeg is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * FFmpeg is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with FFmpeg; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - */ - -/** - * This file is used both by sws_ops_aarch64 to generate ops_entries.c and - * by the standalone build-time tool that generates the static assembly - * functions (aarch64/ops_asmgen). Therefore, it must not depend on internal - * FFmpeg libraries. - */ - -#include <inttypes.h> -#include <stdarg.h> -#include <stdbool.h> -#include <stdio.h> - -#include "libavutil/attributes.h" - -/** - * NOTE: ops_asmgen contains header redefinitions to provide av_assert0 - * while not depending on internal FFmpeg libraries. - */ -#include "libavutil/avassert.h" - -#include "ops_impl.h" - -/*********************************************************************/ -static const char pixel_types[AARCH64_PIXEL_TYPE_NB][32] = { - [AARCH64_PIXEL_U8 ] = "AARCH64_PIXEL_U8", - [AARCH64_PIXEL_U16] = "AARCH64_PIXEL_U16", - [AARCH64_PIXEL_U32] = "AARCH64_PIXEL_U32", - [AARCH64_PIXEL_F32] = "AARCH64_PIXEL_F32", -}; - -static const char *aarch64_pixel_type(SwsAArch64PixelType fmt) -{ - if (fmt >= AARCH64_PIXEL_TYPE_NB) { - av_assert0(!"Invalid pixel type!"); - return NULL; - } - return pixel_types[fmt]; -} - -static const char pixel_type_names[AARCH64_PIXEL_TYPE_NB][4] = { - [AARCH64_PIXEL_U8 ] = "u8", - [AARCH64_PIXEL_U16] = "u16", - [AARCH64_PIXEL_U32] = "u32", - [AARCH64_PIXEL_F32] = "f32", -}; - -static const char *aarch64_pixel_type_name(SwsAArch64PixelType fmt) -{ - if (fmt >= AARCH64_PIXEL_TYPE_NB) { - av_assert0(!"Invalid pixel type!"); - return NULL; - } - return pixel_type_names[fmt]; -} - -/*********************************************************************/ -static const char op_types[AARCH64_SWS_OP_TYPE_NB][32] = { - [AARCH64_SWS_OP_NONE ] = "AARCH64_SWS_OP_NONE", - [AARCH64_SWS_OP_READ_BIT ] = "AARCH64_SWS_OP_READ_BIT", - [AARCH64_SWS_OP_READ_NIBBLE ] = "AARCH64_SWS_OP_READ_NIBBLE", - [AARCH64_SWS_OP_READ_PACKED ] = "AARCH64_SWS_OP_READ_PACKED", - [AARCH64_SWS_OP_READ_PLANAR ] = "AARCH64_SWS_OP_READ_PLANAR", - [AARCH64_SWS_OP_WRITE_BIT ] = "AARCH64_SWS_OP_WRITE_BIT", - [AARCH64_SWS_OP_WRITE_NIBBLE ] = "AARCH64_SWS_OP_WRITE_NIBBLE", - [AARCH64_SWS_OP_WRITE_PACKED ] = "AARCH64_SWS_OP_WRITE_PACKED", - [AARCH64_SWS_OP_WRITE_PLANAR ] = "AARCH64_SWS_OP_WRITE_PLANAR", - [AARCH64_SWS_OP_SWAP_BYTES ] = "AARCH64_SWS_OP_SWAP_BYTES", - [AARCH64_SWS_OP_PERMUTE ] = "AARCH64_SWS_OP_PERMUTE", - [AARCH64_SWS_OP_COPY ] = "AARCH64_SWS_OP_COPY", - [AARCH64_SWS_OP_UNPACK ] = "AARCH64_SWS_OP_UNPACK", - [AARCH64_SWS_OP_PACK ] = "AARCH64_SWS_OP_PACK", - [AARCH64_SWS_OP_LSHIFT ] = "AARCH64_SWS_OP_LSHIFT", - [AARCH64_SWS_OP_RSHIFT ] = "AARCH64_SWS_OP_RSHIFT", - [AARCH64_SWS_OP_CLEAR ] = "AARCH64_SWS_OP_CLEAR", - [AARCH64_SWS_OP_TO_U8 ] = "AARCH64_SWS_OP_TO_U8", - [AARCH64_SWS_OP_TO_U16 ] = "AARCH64_SWS_OP_TO_U16", - [AARCH64_SWS_OP_TO_U32 ] = "AARCH64_SWS_OP_TO_U32", - [AARCH64_SWS_OP_TO_F32 ] = "AARCH64_SWS_OP_TO_F32", - [AARCH64_SWS_OP_EXPAND_PAIR ] = "AARCH64_SWS_OP_EXPAND_PAIR", - [AARCH64_SWS_OP_EXPAND_QUAD ] = "AARCH64_SWS_OP_EXPAND_QUAD", - [AARCH64_SWS_OP_MIN ] = "AARCH64_SWS_OP_MIN", - [AARCH64_SWS_OP_MAX ] = "AARCH64_SWS_OP_MAX", - [AARCH64_SWS_OP_SCALE ] = "AARCH64_SWS_OP_SCALE", - [AARCH64_SWS_OP_LINEAR ] = "AARCH64_SWS_OP_LINEAR", - [AARCH64_SWS_OP_LINEAR_FMA ] = "AARCH64_SWS_OP_LINEAR_FMA", - [AARCH64_SWS_OP_DITHER ] = "AARCH64_SWS_OP_DITHER", -}; - -static const char *aarch64_op_type(SwsAArch64OpType op) -{ - if (op == AARCH64_SWS_OP_NONE || op >= AARCH64_SWS_OP_TYPE_NB) { - av_assert0(!"Invalid op type!"); - return NULL; - } - return op_types[op]; -} - -static const char op_type_names[AARCH64_SWS_OP_TYPE_NB][16] = { - [AARCH64_SWS_OP_NONE ] = "none", - [AARCH64_SWS_OP_READ_BIT ] = "read_bit", - [AARCH64_SWS_OP_READ_NIBBLE ] = "read_nibble", - [AARCH64_SWS_OP_READ_PACKED ] = "read_packed", - [AARCH64_SWS_OP_READ_PLANAR ] = "read_planar", - [AARCH64_SWS_OP_WRITE_BIT ] = "write_bit", - [AARCH64_SWS_OP_WRITE_NIBBLE ] = "write_nibble", - [AARCH64_SWS_OP_WRITE_PACKED ] = "write_packed", - [AARCH64_SWS_OP_WRITE_PLANAR ] = "write_planar", - [AARCH64_SWS_OP_SWAP_BYTES ] = "swap_bytes", - [AARCH64_SWS_OP_PERMUTE ] = "permute", - [AARCH64_SWS_OP_COPY ] = "copy", - [AARCH64_SWS_OP_UNPACK ] = "unpack", - [AARCH64_SWS_OP_PACK ] = "pack", - [AARCH64_SWS_OP_LSHIFT ] = "lshift", - [AARCH64_SWS_OP_RSHIFT ] = "rshift", - [AARCH64_SWS_OP_CLEAR ] = "clear", - [AARCH64_SWS_OP_TO_U8 ] = "to_u8", - [AARCH64_SWS_OP_TO_U16 ] = "to_u16", - [AARCH64_SWS_OP_TO_U32 ] = "to_u32", - [AARCH64_SWS_OP_TO_F32 ] = "to_f32", - [AARCH64_SWS_OP_EXPAND_PAIR ] = "expand_pair", - [AARCH64_SWS_OP_EXPAND_QUAD ] = "expand_quad", - [AARCH64_SWS_OP_MIN ] = "min", - [AARCH64_SWS_OP_MAX ] = "max", - [AARCH64_SWS_OP_SCALE ] = "scale", - [AARCH64_SWS_OP_LINEAR ] = "linear", - [AARCH64_SWS_OP_LINEAR_FMA ] = "linear_fma", - [AARCH64_SWS_OP_DITHER ] = "dither", -}; - -static const char *aarch64_op_type_name(SwsAArch64OpType op) -{ - if (op == AARCH64_SWS_OP_NONE || op >= AARCH64_SWS_OP_TYPE_NB) { - av_assert0(!"Invalid op type!"); - return NULL; - } - return op_type_names[op]; -} - -/*********************************************************************/ -/* - * Helper string concatenation function that does not depend on the - * FFmpeg libraries, so it may be used standalone. - */ -av_printf_format(3, 4) -static void buf_appendf(char **pbuf, size_t *prem, const char *fmt, ...) -{ - char *buf = *pbuf; - size_t rem = *prem; - if (!rem) - return; - - va_list ap; - va_start(ap, fmt); - int n = vsnprintf(buf, rem, fmt, ap); - va_end(ap); - - if (n > 0) { - if (n < rem) { - buf += n; - rem -= n; - } else { - buf += rem - 1; - rem = 0; - } - *pbuf = buf; - *prem = rem; - } -} - -/*********************************************************************/ -/** - * The following structure is used to describe one field from - * SwsAArch64OpImplParams. This will be used to serialize the parameter - * structure, generate function names, and compare two sets of - * parameters. - */ - -typedef struct ParamField { - const char *name; - size_t offset; - size_t size; - void (*print_str)(char **pbuf, size_t *prem, void *p); - void (*print_val)(char **pbuf, size_t *prem, void *p); - int (*cmp_val)(void *pa, void *pb); -} ParamField; - -#define PARAM_FIELD(name) #name, offsetof(SwsAArch64OpImplParams, name), sizeof(((SwsAArch64OpImplParams *) 0)->name) - -static void print_op_name(char **pbuf, size_t *prem, void *p) -{ - SwsAArch64OpType op = *(SwsAArch64OpType *) p; - buf_appendf(pbuf, prem, "_%s", aarch64_op_type_name(op)); -} - -static void print_op_val(char **pbuf, size_t *prem, void *p) -{ - SwsAArch64OpType op = *(SwsAArch64OpType *) p; - buf_appendf(pbuf, prem, "%s", aarch64_op_type(op)); -} - -static int cmp_op(void *pa, void *pb) -{ - int64_t ia = (int64_t) *((SwsAArch64OpType *) pa); - int64_t ib = (int64_t) *((SwsAArch64OpType *) pb); - int64_t diff = ia - ib; - if (diff) - return diff < 0 ? -1 : 1; - return 0; -} - -static void print_pixel_name(char **pbuf, size_t *prem, void *p) -{ - SwsAArch64PixelType type = *(SwsAArch64PixelType *) p; - buf_appendf(pbuf, prem, "_%s", aarch64_pixel_type_name(type)); -} - -static void print_pixel_val(char **pbuf, size_t *prem, void *p) -{ - SwsAArch64PixelType type = *(SwsAArch64PixelType *) p; - buf_appendf(pbuf, prem, "%s", aarch64_pixel_type(type)); -} - -static int cmp_pixel(void *pa, void *pb) -{ - int64_t ia = (int64_t) *((SwsAArch64PixelType *) pa); - int64_t ib = (int64_t) *((SwsAArch64PixelType *) pb); - int64_t diff = ia - ib; - if (diff) - return diff < 0 ? -1 : 1; - return 0; -} - -static void print_u8_name(char **pbuf, size_t *prem, void *p) -{ - uint8_t val = *(uint8_t *) p; - buf_appendf(pbuf, prem, "_%u", val); -} - -static void print_u8_val(char **pbuf, size_t *prem, void *p) -{ - uint8_t val = *(uint8_t *) p; - buf_appendf(pbuf, prem, "%u", val); -} - -static int cmp_u8(void *pa, void *pb) -{ - int64_t ia = (int64_t) *((uint8_t *) pa); - int64_t ib = (int64_t) *((uint8_t *) pb); - int64_t diff = ia - ib; - if (diff) - return diff < 0 ? -1 : 1; - return 0; -} - -static void print_u16_name(char **pbuf, size_t *prem, void *p) -{ - uint16_t val = *(uint16_t *) p; - buf_appendf(pbuf, prem, "_%04x", val); -} - -static void print_u16_val(char **pbuf, size_t *prem, void *p) -{ - uint16_t val = *(uint16_t *) p; - buf_appendf(pbuf, prem, "0x%04x", val); -} - -static int cmp_u16(void *pa, void *pb) -{ - int64_t ia = (int64_t) *((uint16_t *) pa); - int64_t ib = (int64_t) *((uint16_t *) pb); - int64_t diff = ia - ib; - if (diff) - return diff < 0 ? -1 : 1; - return 0; -} - -static void print_u48_name(char **pbuf, size_t *prem, void *p) -{ - uint64_t val = *(uint64_t *) p; - buf_appendf(pbuf, prem, "_%012" PRIx64, val); -} - -static void print_u48_val(char **pbuf, size_t *prem, void *p) -{ - uint64_t val = *(uint64_t *) p; - buf_appendf(pbuf, prem, "0x%012" PRIx64 "ULL", val); -} - -static int cmp_u48(void *pa, void *pb) -{ - int64_t ia = (int64_t) *((uint64_t *) pa); - int64_t ib = (int64_t) *((uint64_t *) pb); - int64_t diff = ia - ib; - if (diff) - return diff < 0 ? -1 : 1; - return 0; -} - -static void print_u40_name(char **pbuf, size_t *prem, void *p) -{ - uint64_t val = *(uint64_t *) p; - buf_appendf(pbuf, prem, "_%010" PRIx64, val); -} - -static void print_u40_val(char **pbuf, size_t *prem, void *p) -{ - uint64_t val = *(uint64_t *) p; - buf_appendf(pbuf, prem, "0x%010" PRIx64 "ULL", val); -} - -static int cmp_u40(void *pa, void *pb) -{ - int64_t ia = (int64_t) *((uint64_t *) pa); - int64_t ib = (int64_t) *((uint64_t *) pb); - int64_t diff = ia - ib; - if (diff) - return diff < 0 ? -1 : 1; - return 0; -} - -/*********************************************************************/ -static const ParamField field_op = { PARAM_FIELD(op), print_op_name, print_op_val, cmp_op }; -static const ParamField field_mask = { PARAM_FIELD(mask), print_u16_name, print_u16_val, cmp_u16 }; -static const ParamField field_type = { PARAM_FIELD(type), print_pixel_name, print_pixel_val, cmp_pixel }; -static const ParamField field_block_size = { PARAM_FIELD(block_size), print_u8_name, print_u8_val, cmp_u8 }; -static const ParamField field_shift = { PARAM_FIELD(shift), print_u8_name, print_u8_val, cmp_u8 }; -static const ParamField field_clear = { PARAM_FIELD(clear), print_u16_name, print_u16_val, cmp_u16 }; -static const ParamField field_move = { PARAM_FIELD(move), print_u48_name, print_u48_val, cmp_u48 }; -static const ParamField field_pack = { PARAM_FIELD(pack), print_u16_name, print_u16_val, cmp_u16 }; -static const ParamField field_linear_mask = { PARAM_FIELD(linear.mask), print_u40_name, print_u40_val, cmp_u40 }; -static const ParamField field_dither_y_offset = { PARAM_FIELD(dither.y_offset), print_u16_name, print_u16_val, cmp_u16 }; -static const ParamField field_dither_size_log2 = { PARAM_FIELD(dither.size_log2), print_u8_name, print_u8_val, cmp_u8 }; - -/* Fields needed to uniquely identify each SwsAArch64OpType. */ -#define MAX_LEVELS 8 -static const ParamField *op_fields[AARCH64_SWS_OP_TYPE_NB][MAX_LEVELS] = { - [AARCH64_SWS_OP_READ_BIT ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_READ_NIBBLE ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_READ_PACKED ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_READ_PLANAR ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_WRITE_BIT ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_WRITE_NIBBLE ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_WRITE_PACKED ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_WRITE_PLANAR ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_SWAP_BYTES ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_PERMUTE ] = { &field_op, &field_move, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_COPY ] = { &field_op, &field_move, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_UNPACK ] = { &field_op, &field_pack, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_PACK ] = { &field_op, &field_pack, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_LSHIFT ] = { &field_op, &field_shift, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_RSHIFT ] = { &field_op, &field_shift, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_CLEAR ] = { &field_op, &field_clear, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_TO_U8 ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_TO_U16 ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_TO_U32 ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_TO_F32 ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_EXPAND_PAIR ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_EXPAND_QUAD ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_MIN ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_MAX ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_SCALE ] = { &field_op, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_LINEAR ] = { &field_op, &field_linear_mask, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_LINEAR_FMA ] = { &field_op, &field_linear_mask, &field_block_size, &field_type, &field_mask }, - [AARCH64_SWS_OP_DITHER ] = { &field_op, &field_dither_y_offset, &field_dither_size_log2, &field_block_size, &field_type, &field_mask }, -}; diff --git a/libswscale/tests/sws_ops_aarch64.c b/libswscale/tests/sws_ops_aarch64.c index a48e95a8a3..dd7f4f0a85 100644 --- a/libswscale/tests/sws_ops_aarch64.c +++ b/libswscale/tests/sws_ops_aarch64.c @@ -20,6 +20,7 @@ #include <stdio.h> +#include "libavutil/avassert.h" #include "libavutil/mem.h" #include "libavutil/tree.h" #include "libswscale/graph.h" @@ -28,7 +29,6 @@ #include "libswscale/op_list_gen_template.c" #include "libswscale/ops_dispatch.h" -#include "libswscale/aarch64/ops_impl.c" #include "libswscale/aarch64/ops_impl_conv.c" #ifdef _WIN32 @@ -36,20 +36,86 @@ #include <fcntl.h> #endif +/*********************************************************************/ +/* + * Helper string concatenation function that does not depend on the + * FFmpeg libraries, so it may be used standalone. + */ +av_printf_format(3, 4) +static void buf_appendf(char **pbuf, size_t *prem, const char *fmt, ...) +{ + char *buf = *pbuf; + size_t rem = *prem; + if (!rem) + return; + + va_list ap; + va_start(ap, fmt); + int n = vsnprintf(buf, rem, fmt, ap); + va_end(ap); + + if (n > 0) { + if (n < rem) { + buf += n; + rem -= n; + } else { + buf += rem - 1; + rem = 0; + } + *pbuf = buf; + *prem = rem; + } +} + /*********************************************************************/ static int aarch64_op_impl_cmp(const void *a, const void *b) { const SwsAArch64OpImplParams *pa = (const SwsAArch64OpImplParams *) a; const SwsAArch64OpImplParams *pb = (const SwsAArch64OpImplParams *) b; - const ParamField **fields = op_fields[pa->op]; - for (int i = 0; fields[i]; i++) { - const ParamField *field = fields[i]; - int diff = field->cmp_val((void *) (((uintptr_t) pa) + field->offset), - (void *) (((uintptr_t) pb) + field->offset)); - if (diff) - return diff; + if (pa->op != pb->op) + return (int) pa->op - pb->op; + + switch (pa->op) { + case AARCH64_SWS_OP_PERMUTE: + case AARCH64_SWS_OP_COPY: + if (pa->move != pb->move) + return (int64_t) (pa->move - pb->move) < 0 ? -1 : 1; + break; + case AARCH64_SWS_OP_UNPACK: + case AARCH64_SWS_OP_PACK: + if (pa->pack != pb->pack) + return (int) pa->pack - pb->pack; + break; + case AARCH64_SWS_OP_LSHIFT: + case AARCH64_SWS_OP_RSHIFT: + if (pa->shift != pb->shift) + return (int) pa->shift - pb->shift; + break; + case AARCH64_SWS_OP_CLEAR: + if (pa->clear != pb->clear) + return (int) pa->clear - pb->clear; + break; + case AARCH64_SWS_OP_LINEAR: + case AARCH64_SWS_OP_LINEAR_FMA: + if (pa->linear.mask != pb->linear.mask) + return (int64_t) (pa->linear.mask - pb->linear.mask) < 0 ? -1 : 1; + break; + case AARCH64_SWS_OP_DITHER: + if (pa->dither.y_offset != pb->dither.y_offset) + return (int) pa->dither.y_offset - pb->dither.y_offset; + if (pa->dither.size_log2 != pb->dither.size_log2) + return (int) pa->dither.size_log2 - pb->dither.size_log2; + break; } + + if (pa->block_size != pb->block_size) + return (int) pa->block_size - pb->block_size; + if (pa->type != pb->type) + return (int) pa->type - pb->type; + if (pa->mask != pb->mask) + return (int) pa->mask - pb->mask; + return 0; } @@ -147,33 +213,142 @@ static int register_op(SwsContext *ctx, void *opaque, SwsOpList *ops) } /*********************************************************************/ +static const char op_type_names[AARCH64_SWS_OP_TYPE_NB][16] = { + [AARCH64_SWS_OP_READ_BIT ] = "read_bit", + [AARCH64_SWS_OP_READ_NIBBLE ] = "read_nibble", + [AARCH64_SWS_OP_READ_PACKED ] = "read_packed", + [AARCH64_SWS_OP_READ_PLANAR ] = "read_planar", + [AARCH64_SWS_OP_WRITE_BIT ] = "write_bit", + [AARCH64_SWS_OP_WRITE_NIBBLE ] = "write_nibble", + [AARCH64_SWS_OP_WRITE_PACKED ] = "write_packed", + [AARCH64_SWS_OP_WRITE_PLANAR ] = "write_planar", + [AARCH64_SWS_OP_SWAP_BYTES ] = "swap_bytes", + [AARCH64_SWS_OP_PERMUTE ] = "permute", + [AARCH64_SWS_OP_COPY ] = "copy", + [AARCH64_SWS_OP_UNPACK ] = "unpack", + [AARCH64_SWS_OP_PACK ] = "pack", + [AARCH64_SWS_OP_LSHIFT ] = "lshift", + [AARCH64_SWS_OP_RSHIFT ] = "rshift", + [AARCH64_SWS_OP_CLEAR ] = "clear", + [AARCH64_SWS_OP_TO_U8 ] = "to_u8", + [AARCH64_SWS_OP_TO_U16 ] = "to_u16", + [AARCH64_SWS_OP_TO_U32 ] = "to_u32", + [AARCH64_SWS_OP_TO_F32 ] = "to_f32", + [AARCH64_SWS_OP_EXPAND_PAIR ] = "expand_pair", + [AARCH64_SWS_OP_EXPAND_QUAD ] = "expand_quad", + [AARCH64_SWS_OP_MIN ] = "min", + [AARCH64_SWS_OP_MAX ] = "max", + [AARCH64_SWS_OP_SCALE ] = "scale", + [AARCH64_SWS_OP_LINEAR ] = "linear", + [AARCH64_SWS_OP_LINEAR_FMA ] = "linear_fma", + [AARCH64_SWS_OP_DITHER ] = "dither", +}; + +static const char pixel_type_names[AARCH64_PIXEL_TYPE_NB][4] = { + [AARCH64_PIXEL_U8 ] = "u8", + [AARCH64_PIXEL_U16] = "u16", + [AARCH64_PIXEL_U32] = "u32", + [AARCH64_PIXEL_F32] = "f32", +}; + static void impl_func_name(char **buf, size_t *size, const SwsAArch64OpImplParams *params) { - buf_appendf(buf, size, "ff_sws"); - const ParamField **fields = op_fields[params->op]; - for (int i = 0; fields[i]; i++) { - const ParamField *field = fields[i]; - void *p = (void *) (((uintptr_t) params) + field->offset); - field->print_str(buf, size, p); + buf_appendf(buf, size, "ff_sws_%s", op_type_names[params->op]); + switch (params->op) { + case AARCH64_SWS_OP_PERMUTE: + case AARCH64_SWS_OP_COPY: + buf_appendf(buf, size, "_%012" PRIx64, params->move); + break; + case AARCH64_SWS_OP_UNPACK: + case AARCH64_SWS_OP_PACK: + buf_appendf(buf, size, "_%04x", params->pack); + break; + case AARCH64_SWS_OP_LSHIFT: + case AARCH64_SWS_OP_RSHIFT: + buf_appendf(buf, size, "_%u", params->shift); + break; + case AARCH64_SWS_OP_CLEAR: + buf_appendf(buf, size, "_%04x", params->clear); + break; + case AARCH64_SWS_OP_LINEAR: + case AARCH64_SWS_OP_LINEAR_FMA: + buf_appendf(buf, size, "_%010" PRIx64, params->linear.mask); + break; + case AARCH64_SWS_OP_DITHER: + buf_appendf(buf, size, "_%04x_%u", params->dither.y_offset, params->dither.size_log2); + break; } - buf_appendf(buf, size, "_neon"); + buf_appendf(buf, size, "_%u_%s_%04x_neon", params->block_size, pixel_type_names[params->type], params->mask); } +static const char op_types[AARCH64_SWS_OP_TYPE_NB][32] = { + [AARCH64_SWS_OP_READ_BIT ] = "AARCH64_SWS_OP_READ_BIT", + [AARCH64_SWS_OP_READ_NIBBLE ] = "AARCH64_SWS_OP_READ_NIBBLE", + [AARCH64_SWS_OP_READ_PACKED ] = "AARCH64_SWS_OP_READ_PACKED", + [AARCH64_SWS_OP_READ_PLANAR ] = "AARCH64_SWS_OP_READ_PLANAR", + [AARCH64_SWS_OP_WRITE_BIT ] = "AARCH64_SWS_OP_WRITE_BIT", + [AARCH64_SWS_OP_WRITE_NIBBLE ] = "AARCH64_SWS_OP_WRITE_NIBBLE", + [AARCH64_SWS_OP_WRITE_PACKED ] = "AARCH64_SWS_OP_WRITE_PACKED", + [AARCH64_SWS_OP_WRITE_PLANAR ] = "AARCH64_SWS_OP_WRITE_PLANAR", + [AARCH64_SWS_OP_SWAP_BYTES ] = "AARCH64_SWS_OP_SWAP_BYTES", + [AARCH64_SWS_OP_PERMUTE ] = "AARCH64_SWS_OP_PERMUTE", + [AARCH64_SWS_OP_COPY ] = "AARCH64_SWS_OP_COPY", + [AARCH64_SWS_OP_UNPACK ] = "AARCH64_SWS_OP_UNPACK", + [AARCH64_SWS_OP_PACK ] = "AARCH64_SWS_OP_PACK", + [AARCH64_SWS_OP_LSHIFT ] = "AARCH64_SWS_OP_LSHIFT", + [AARCH64_SWS_OP_RSHIFT ] = "AARCH64_SWS_OP_RSHIFT", + [AARCH64_SWS_OP_CLEAR ] = "AARCH64_SWS_OP_CLEAR", + [AARCH64_SWS_OP_TO_U8 ] = "AARCH64_SWS_OP_TO_U8", + [AARCH64_SWS_OP_TO_U16 ] = "AARCH64_SWS_OP_TO_U16", + [AARCH64_SWS_OP_TO_U32 ] = "AARCH64_SWS_OP_TO_U32", + [AARCH64_SWS_OP_TO_F32 ] = "AARCH64_SWS_OP_TO_F32", + [AARCH64_SWS_OP_EXPAND_PAIR ] = "AARCH64_SWS_OP_EXPAND_PAIR", + [AARCH64_SWS_OP_EXPAND_QUAD ] = "AARCH64_SWS_OP_EXPAND_QUAD", + [AARCH64_SWS_OP_MIN ] = "AARCH64_SWS_OP_MIN", + [AARCH64_SWS_OP_MAX ] = "AARCH64_SWS_OP_MAX", + [AARCH64_SWS_OP_SCALE ] = "AARCH64_SWS_OP_SCALE", + [AARCH64_SWS_OP_LINEAR ] = "AARCH64_SWS_OP_LINEAR", + [AARCH64_SWS_OP_LINEAR_FMA ] = "AARCH64_SWS_OP_LINEAR_FMA", + [AARCH64_SWS_OP_DITHER ] = "AARCH64_SWS_OP_DITHER", +}; + +static const char pixel_types[AARCH64_PIXEL_TYPE_NB][32] = { + [AARCH64_PIXEL_U8 ] = "AARCH64_PIXEL_U8", + [AARCH64_PIXEL_U16] = "AARCH64_PIXEL_U16", + [AARCH64_PIXEL_U32] = "AARCH64_PIXEL_U32", + [AARCH64_PIXEL_F32] = "AARCH64_PIXEL_F32", +}; + static void serialize_op(char *buf, size_t size, const SwsAArch64OpImplParams *params) { buf_appendf(&buf, &size, "ENTRY("); impl_func_name(&buf, &size, params); - buf_appendf(&buf, &size, ", {"); - const ParamField **fields = op_fields[params->op]; - for (int i = 0; fields[i]; i++) { - const ParamField *field = fields[i]; - void *p = (void *) (((uintptr_t) params) + field->offset); - if (i) - buf_appendf(&buf, &size, ","); - buf_appendf(&buf, &size, " .%s = ", field->name); - field->print_val(&buf, &size, p); + buf_appendf(&buf, &size, ", { .op = %s", op_types[params->op]); + switch (params->op) { + case AARCH64_SWS_OP_PERMUTE: + case AARCH64_SWS_OP_COPY: + buf_appendf(&buf, &size, ", .move = 0x%012" PRIx64 "ULL", params->move); + break; + case AARCH64_SWS_OP_UNPACK: + case AARCH64_SWS_OP_PACK: + buf_appendf(&buf, &size, ", .pack = 0x%04x", params->pack); + break; + case AARCH64_SWS_OP_LSHIFT: + case AARCH64_SWS_OP_RSHIFT: + buf_appendf(&buf, &size, ", .shift = %u", params->shift); + break; + case AARCH64_SWS_OP_CLEAR: + buf_appendf(&buf, &size, ", .clear = 0x%04x", params->clear); + break; + case AARCH64_SWS_OP_LINEAR: + case AARCH64_SWS_OP_LINEAR_FMA: + buf_appendf(&buf, &size, ", .linear.mask = 0x%010" PRIx64 "ULL", params->linear.mask); + break; + case AARCH64_SWS_OP_DITHER: + buf_appendf(&buf, &size, ", .dither.y_offset = 0x%04x, .dither.size_log2 = %u", params->dither.y_offset, params->dither.size_log2); + break; } - buf_appendf(&buf, &size, " })"); + buf_appendf(&buf, &size, ", .block_size = %u, .type = %s, .mask = 0x%04x })", params->block_size, pixel_types[params->type], params->mask); av_assert0(size && "string buffer exhausted"); } _______________________________________________ ffmpeg-cvslog mailing list -- [email protected] To unsubscribe send an email to [email protected]
