/src/ffmpeg/libswscale/ops_chain.h

Source
/**
 * Copyright (C) 2025 Niklas Haas
 *
 * 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
 */

#ifndef SWSCALE_OPS_CHAIN_H
#define SWSCALE_OPS_CHAIN_H

#include "libavutil/cpu.h"
#include "libavutil/mem.h"

#include "ops_internal.h"

/**
 * Helpers for SIMD implementations based on chained kernels, using a
 * continuation passing style to link them together.
 *
 * The basic idea here is to "link" together a series of different operation
 * kernels by constructing a list of kernel addresses into an SwsOpChain. Each
 * kernel will load the address of the next kernel (the "continuation") from
 * this struct, and jump directly into it; using an internal function signature
 * that is an implementation detail of the specific backend.
 */

typedef struct SwsUOpTable SwsUOpTable;

/**
 * Private data for each kernel.
 */
typedef union SwsOpPriv {
    DECLARE_ALIGNED_16(char, data)[16];

    /* Common types */
    void *ptr;
    uint8_t    u8[16];
    int8_t     i8[16];
    uint16_t   u16[8];
    int16_t    i16[8];
    uint32_t   u32[4];
    int32_t    i32[4];
    float      f32[4];
    uint64_t   u64[2];
    int64_t    i64[2];
    uintptr_t uptr[2];
    intptr_t  iptr[2];
} SwsOpPriv;

static_assert(sizeof(SwsOpPriv) == 16, "SwsOpPriv size mismatch");

/**
 * Per-kernel execution context.
 *
 * Note: This struct is hard-coded in assembly, so do not change the layout.
 */
typedef void (*SwsFuncPtr)(void);
typedef struct SwsOpImpl {
    SwsFuncPtr cont; /* [offset =  0] Continuation for this operation. */
    SwsOpPriv  priv; /* [offset = 16] Private data for this operation. */
} SwsOpImpl;

static_assert(sizeof(SwsOpImpl) == 32,         "SwsOpImpl layout mismatch");
static_assert(offsetof(SwsOpImpl, priv) == 16, "SwsOpImpl layout mismatch");

/**
 * Compiled "chain" of operations, which can be dispatched efficiently.
 * Effectively just a list of function pointers, alongside a small amount of
 * private data for each operation.
 */
typedef struct SwsOpChain {
#define SWS_MAX_OPS 16
    SwsOpImpl impl[SWS_MAX_OPS + 1]; /* reserve extra space for the entrypoint */
    void (*free[SWS_MAX_OPS + 1])(SwsOpPriv *);
    int num_impl;
    int cpu_flags;      /* set of all used CPU flags */
    int over_read[4];   /* chain over-reads input by this many bytes */
    int over_write[4];  /* chain over-writes output by this many bytes */
} SwsOpChain;

SwsOpChain *ff_sws_op_chain_alloc(void);
void ff_sws_op_chain_free_cb(void *chain);
static inline void ff_sws_op_chain_free(SwsOpChain *chain)
{
    ff_sws_op_chain_free_cb(chain);
}

/* Returns 0 on success, or a negative error code. */
int ff_sws_op_chain_append(SwsOpChain *chain, SwsFuncPtr func,
                           void (*free)(SwsOpPriv *), const SwsOpPriv *priv);

typedef struct SwsImplParams {
    const SwsUOpTable *table;
    union {
        const SwsUOp *uop;
        const SwsOp *op;
    };
    SwsContext *ctx;
} SwsImplParams;

typedef struct SwsImplResult {
    SwsFuncPtr func; /* overrides `SwsUOpEntry.func` if non-NULL */
    SwsOpPriv priv; /* private data for this implementation instance */
    void (*free)(SwsOpPriv *priv); /* free function for `priv` */
    int over_read[4];  /* implementation over-reads input by this many bytes */
    int over_write[4]; /* implementation over-writes output by this many bytes */
} SwsImplResult;

typedef struct SwsUOpEntry {
    /* Kernel metadata; reduced size subset of SwsUOp (sans data) */
    SwsUOpType uop;
    SwsPixelType type;
    SwsCompMask mask;
    SwsUOpParams par;

    /* Kernel implementation */
    SwsFuncPtr func;
    int (*setup)(const SwsImplParams *params, SwsImplResult *out); /* optional */
    bool (*check)(const SwsImplParams *params); /* optional, return true if supported */
} SwsUOpEntry;

/* Setup helpers for common/trivial operation types */
int ff_sws_setup_scale(const SwsImplParams *params, SwsImplResult *out);
int ff_sws_setup_clamp(const SwsImplParams *params, SwsImplResult *out);
int ff_sws_setup_clear(const SwsImplParams *params, SwsImplResult *out);

/* Setup helpers for SwsUOp data */
int ff_sws_setup_scalar(const SwsImplParams *params, SwsImplResult *out);
int ff_sws_setup_vec4(const SwsImplParams *params, SwsImplResult *out);

static inline void ff_op_priv_free(SwsOpPriv *priv)
{
    av_freep(&priv->ptr);
}

static inline void ff_op_priv_unref(SwsOpPriv *priv)
{
    av_refstruct_unref(&priv->ptr);
}

struct SwsUOpTable {
    unsigned cpu_flags;   /* required CPU flags for this table */
    int block_size;       /* fixed block size of this table */
    const SwsUOpEntry *entries[]; /* terminated by NULL */
};

/**
 * "Compile" a single uop by looking it up in a list of fixed size uop tables,
 * in decreasing order of preference.
 *
 * Returns 0 or a negative error code.
 */
int ff_sws_uop_lookup(SwsContext *ctx, const SwsUOpTable *const tables[],
                      int num_tables, const SwsUOp *uop, const int block_size,
                      SwsOpChain *chain);

#endif

Line	Count	Source
1		/**
2		* Copyright (C) 2025 Niklas Haas
3		*
4		* This file is part of FFmpeg.
5		*
6		* FFmpeg is free software; you can redistribute it and/or
7		* modify it under the terms of the GNU Lesser General Public
8		* License as published by the Free Software Foundation; either
9		* version 2.1 of the License, or (at your option) any later version.
10		*
11		* FFmpeg is distributed in the hope that it will be useful,
12		* but WITHOUT ANY WARRANTY; without even the implied warranty of
13		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14		* Lesser General Public License for more details.
15		*
16		* You should have received a copy of the GNU Lesser General Public
17		* License along with FFmpeg; if not, write to the Free Software
18		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19		*/
20
21		#ifndef SWSCALE_OPS_CHAIN_H
22		#define SWSCALE_OPS_CHAIN_H
23
24		#include "libavutil/cpu.h"
25		#include "libavutil/mem.h"
26
27		#include "ops_internal.h"
28
29		/**
30		* Helpers for SIMD implementations based on chained kernels, using a
31		* continuation passing style to link them together.
32		*
33		* The basic idea here is to "link" together a series of different operation
34		* kernels by constructing a list of kernel addresses into an SwsOpChain. Each
35		* kernel will load the address of the next kernel (the "continuation") from
36		* this struct, and jump directly into it; using an internal function signature
37		* that is an implementation detail of the specific backend.
38		*/
39
40		typedef struct SwsUOpTable SwsUOpTable;
41
42		/**
43		* Private data for each kernel.
44		*/
45		typedef union SwsOpPriv {
46		DECLARE_ALIGNED_16(char, data)[16];
47
48		/* Common types */
49		void *ptr;
50		uint8_t u8[16];
51		int8_t i8[16];
52		uint16_t u16[8];
53		int16_t i16[8];
54		uint32_t u32[4];
55		int32_t i32[4];
56		float f32[4];
57		uint64_t u64[2];
58		int64_t i64[2];
59		uintptr_t uptr[2];
60		intptr_t iptr[2];
61		} SwsOpPriv;
62
63		static_assert(sizeof(SwsOpPriv) == 16, "SwsOpPriv size mismatch");
64
65		/**
66		* Per-kernel execution context.
67		*
68		* Note: This struct is hard-coded in assembly, so do not change the layout.
69		*/
70		typedef void (*SwsFuncPtr)(void);
71		typedef struct SwsOpImpl {
72		SwsFuncPtr cont; /* [offset = 0] Continuation for this operation. */
73		SwsOpPriv priv; /* [offset = 16] Private data for this operation. */
74		} SwsOpImpl;
75
76		static_assert(sizeof(SwsOpImpl) == 32, "SwsOpImpl layout mismatch");
77		static_assert(offsetof(SwsOpImpl, priv) == 16, "SwsOpImpl layout mismatch");
78
79		/**
80		* Compiled "chain" of operations, which can be dispatched efficiently.
81		* Effectively just a list of function pointers, alongside a small amount of
82		* private data for each operation.
83		*/
84		typedef struct SwsOpChain {
85	0	#define SWS_MAX_OPS 16
86		SwsOpImpl impl[SWS_MAX_OPS + 1]; /* reserve extra space for the entrypoint */
87		void (free[SWS_MAX_OPS + 1])(SwsOpPriv );
88		int num_impl;
89		int cpu_flags; /* set of all used CPU flags */
90		int over_read[4]; /* chain over-reads input by this many bytes */
91		int over_write[4]; /* chain over-writes output by this many bytes */
92		} SwsOpChain;
93
94		SwsOpChain *ff_sws_op_chain_alloc(void);
95		void ff_sws_op_chain_free_cb(void *chain);
96		static inline void ff_sws_op_chain_free(SwsOpChain *chain)
97	0	{
98	0	ff_sws_op_chain_free_cb(chain);
99	0	} Unexecuted instantiation: uops_backend.c:ff_sws_op_chain_free Unexecuted instantiation: ops_chain.c:ff_sws_op_chain_free
100
101		/* Returns 0 on success, or a negative error code. */
102		int ff_sws_op_chain_append(SwsOpChain *chain, SwsFuncPtr func,
103		void (free)(SwsOpPriv ), const SwsOpPriv *priv);
104
105		typedef struct SwsImplParams {
106		const SwsUOpTable *table;
107		union {
108		const SwsUOp *uop;
109		const SwsOp *op;
110		};
111		SwsContext *ctx;
112		} SwsImplParams;
113
114		typedef struct SwsImplResult {
115		SwsFuncPtr func; /* overrides `SwsUOpEntry.func` if non-NULL */
116		SwsOpPriv priv; /* private data for this implementation instance */
117		void (free)(SwsOpPriv priv); /* free function for `priv` */
118		int over_read[4]; /* implementation over-reads input by this many bytes */
119		int over_write[4]; /* implementation over-writes output by this many bytes */
120		} SwsImplResult;
121
122		typedef struct SwsUOpEntry {
123		/* Kernel metadata; reduced size subset of SwsUOp (sans data) */
124		SwsUOpType uop;
125		SwsPixelType type;
126		SwsCompMask mask;
127		SwsUOpParams par;
128
129		/* Kernel implementation */
130		SwsFuncPtr func;
131		int (setup)(const SwsImplParams params, SwsImplResult out); / optional */
132		bool (check)(const SwsImplParams params); /* optional, return true if supported */
133		} SwsUOpEntry;
134
135		/* Setup helpers for common/trivial operation types */
136		int ff_sws_setup_scale(const SwsImplParams params, SwsImplResult out);
137		int ff_sws_setup_clamp(const SwsImplParams params, SwsImplResult out);
138		int ff_sws_setup_clear(const SwsImplParams params, SwsImplResult out);
139
140		/* Setup helpers for SwsUOp data */
141		int ff_sws_setup_scalar(const SwsImplParams params, SwsImplResult out);
142		int ff_sws_setup_vec4(const SwsImplParams params, SwsImplResult out);
143
144		static inline void ff_op_priv_free(SwsOpPriv *priv)
145	0	{
146	0	av_freep(&priv->ptr);
147	0	} Unexecuted instantiation: uops_backend.c:ff_op_priv_free Unexecuted instantiation: ops_chain.c:ff_op_priv_free
148
149		static inline void ff_op_priv_unref(SwsOpPriv *priv)
150	0	{
151	0	av_refstruct_unref(&priv->ptr);
152	0	} Unexecuted instantiation: uops_backend.c:ff_op_priv_unref Unexecuted instantiation: ops_chain.c:ff_op_priv_unref
153
154		struct SwsUOpTable {
155		unsigned cpu_flags; /* required CPU flags for this table */
156		int block_size; /* fixed block size of this table */
157		const SwsUOpEntry entries[]; / terminated by NULL */
158		};
159
160		/**
161		* "Compile" a single uop by looking it up in a list of fixed size uop tables,
162		* in decreasing order of preference.
163		*
164		* Returns 0 or a negative error code.
165		*/
166		int ff_sws_uop_lookup(SwsContext ctx, const SwsUOpTable const tables[],
167		int num_tables, const SwsUOp *uop, const int block_size,
168		SwsOpChain *chain);
169
170		#endif

Coverage Report

Created: 2026-07-15 07:31