/src/ffmpeg/libswscale/ops_tmpl_float.c

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
 */

#include "libavutil/avassert.h"

#include "ops_backend.h"

#ifndef BIT_DEPTH
#  define BIT_DEPTH 32
#endif

#if BIT_DEPTH == 32
#  define PIXEL_TYPE SWS_PIXEL_F32
#  define PIXEL_MAX  FLT_MAX
#  define PIXEL_MIN  FLT_MIN
#  define pixel_t    float
#  define block_t    f32block_t
#  define px         f32
#else
#  error Invalid BIT_DEPTH
#endif

#define IS_FLOAT 1
#define FMT_CHAR f
#include "ops_tmpl_common.c"

DECL_SETUP(setup_dither)
{
    const int size = 1 << op->dither.size_log2;
    if (size == 1) {
        /* We special case this value */
        av_assert1(!av_cmp_q(op->dither.matrix[0], av_make_q(1, 2)));
        out->ptr = NULL;
        return 0;
    }

    const int width = FFMAX(size, SWS_BLOCK_SIZE);
    pixel_t *matrix = out->ptr = av_malloc(sizeof(pixel_t) * size * width);
    if (!matrix)
        return AVERROR(ENOMEM);

    static_assert(sizeof(out->ptr) <= sizeof(uint8_t[8]), ">8 byte pointers not supported");
    int8_t *offset = &out->i8[8];
    for (int i = 0; i < 4; i++)
        offset[i] = op->dither.y_offset[i];

    for (int y = 0; y < size; y++) {
        for (int x = 0; x < size; x++)
            matrix[y * width + x] = av_q2pixel(op->dither.matrix[y * size + x]);
        for (int x = size; x < width; x++) /* pad to block size */
            matrix[y * width + x] = matrix[y * width + (x % size)];
    }

    return 0;
}

DECL_FUNC(dither, const int size_log2)
{
    const pixel_t *restrict matrix = impl->priv.ptr;
    const int8_t *restrict offset = &impl->priv.i8[8];
    const int mask = (1 << size_log2) - 1;
    const int y_line = iter->y;
    const int size = 1 << size_log2;
    const int width = FFMAX(size, SWS_BLOCK_SIZE);
    const int base = iter->x & ~(SWS_BLOCK_SIZE - 1) & (size - 1);

#define DITHER_COMP(VAR, IDX)                                                            \
    if (offset[IDX] >= 0) {                                                              \
        const int row = (y_line + offset[IDX]) & mask;                                   \
        SWS_LOOP                                                                         \
        for (int i = 0; i < SWS_BLOCK_SIZE; i++)                                         \
            VAR[i] += size_log2 ? matrix[row * width + base + i] : (pixel_t) 0.5;        \
    }

    DITHER_COMP(x, 0)
    DITHER_COMP(y, 1)
    DITHER_COMP(z, 2)
    DITHER_COMP(w, 3)

    CONTINUE(block_t, x, y, z, w);
}

#define WRAP_DITHER(N)                                                          \
DECL_IMPL(dither##N)                                                            \
{                                                                               \
    CALL(dither, N);                                                            \
}                                                                               \
                                                                                \
DECL_ENTRY(dither##N,                                                           \
    .op = SWS_OP_DITHER,                                                        \
    .dither_size = N,                                                           \
    .setup = fn(setup_dither),                                                  \
    .free = av_free,                                                            \
);

WRAP_DITHER(0)
WRAP_DITHER(1)
WRAP_DITHER(2)
WRAP_DITHER(3)
WRAP_DITHER(4)
WRAP_DITHER(5)
WRAP_DITHER(6)
WRAP_DITHER(7)
WRAP_DITHER(8)

typedef struct {
    /* Stored in split form for convenience */
    pixel_t m[4][4];
    pixel_t k[4];
} fn(LinCoeffs);

DECL_SETUP(setup_linear)
{
    fn(LinCoeffs) c;

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++)
            c.m[i][j] = av_q2pixel(op->lin.m[i][j]);
        c.k[i] = av_q2pixel(op->lin.m[i][4]);
    }

    return SETUP_MEMDUP(c);
}

/**
 * Fully general case for a 5x5 linear affine transformation. Should never be
 * called without constant `mask`. This function will compile down to the
 * appropriately optimized version for the required subset of operations when
 * called with a constant mask.
 */
DECL_FUNC(linear_mask, const uint32_t mask)
{
    const fn(LinCoeffs) c = *(const fn(LinCoeffs) *) impl->priv.ptr;

    SWS_LOOP
    for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
        const pixel_t xx = x[i];
        const pixel_t yy = y[i];
        const pixel_t zz = z[i];
        const pixel_t ww = w[i];

        x[i]  = (mask & SWS_MASK_OFF(0)) ? c.k[0] : 0;
        x[i] += (mask & SWS_MASK(0, 0))  ? c.m[0][0] * xx : xx;
        x[i] += (mask & SWS_MASK(0, 1))  ? c.m[0][1] * yy : 0;
        x[i] += (mask & SWS_MASK(0, 2))  ? c.m[0][2] * zz : 0;
        x[i] += (mask & SWS_MASK(0, 3))  ? c.m[0][3] * ww : 0;

        y[i]  = (mask & SWS_MASK_OFF(1)) ? c.k[1] : 0;
        y[i] += (mask & SWS_MASK(1, 0))  ? c.m[1][0] * xx : 0;
        y[i] += (mask & SWS_MASK(1, 1))  ? c.m[1][1] * yy : yy;
        y[i] += (mask & SWS_MASK(1, 2))  ? c.m[1][2] * zz : 0;
        y[i] += (mask & SWS_MASK(1, 3))  ? c.m[1][3] * ww : 0;

        z[i]  = (mask & SWS_MASK_OFF(2)) ? c.k[2] : 0;
        z[i] += (mask & SWS_MASK(2, 0))  ? c.m[2][0] * xx : 0;
        z[i] += (mask & SWS_MASK(2, 1))  ? c.m[2][1] * yy : 0;
        z[i] += (mask & SWS_MASK(2, 2))  ? c.m[2][2] * zz : zz;
        z[i] += (mask & SWS_MASK(2, 3))  ? c.m[2][3] * ww : 0;

        w[i]  = (mask & SWS_MASK_OFF(3)) ? c.k[3] : 0;
        w[i] += (mask & SWS_MASK(3, 0))  ? c.m[3][0] * xx : 0;
        w[i] += (mask & SWS_MASK(3, 1))  ? c.m[3][1] * yy : 0;
        w[i] += (mask & SWS_MASK(3, 2))  ? c.m[3][2] * zz : 0;
        w[i] += (mask & SWS_MASK(3, 3))  ? c.m[3][3] * ww : ww;
    }

    CONTINUE(block_t, x, y, z, w);
}

#define WRAP_LINEAR(NAME, MASK)                                                 \
DECL_IMPL(linear_##NAME)                                                        \
{                                                                               \
    CALL(linear_mask, MASK);                                                    \
}                                                                               \
                                                                                \
DECL_ENTRY(linear_##NAME,                                                       \
    .op    = SWS_OP_LINEAR,                                                     \
    .setup = fn(setup_linear),                                                  \
    .free  = av_free,                                                           \
    .linear_mask = (MASK),                                                      \
);

WRAP_LINEAR(luma,      SWS_MASK_LUMA)
WRAP_LINEAR(alpha,     SWS_MASK_ALPHA)
WRAP_LINEAR(lumalpha,  SWS_MASK_LUMA | SWS_MASK_ALPHA)
WRAP_LINEAR(dot3,      0x7)
WRAP_LINEAR(row0,      SWS_MASK_ROW(0))
WRAP_LINEAR(row0a,     SWS_MASK_ROW(0) | SWS_MASK_ALPHA)
WRAP_LINEAR(diag3,     SWS_MASK_DIAG3)
WRAP_LINEAR(diag4,     SWS_MASK_DIAG4)
WRAP_LINEAR(diagoff3,  SWS_MASK_DIAG3 | SWS_MASK_OFF3)
WRAP_LINEAR(matrix3,   SWS_MASK_MAT3)
WRAP_LINEAR(affine3,   SWS_MASK_MAT3 | SWS_MASK_OFF3)
WRAP_LINEAR(affine3a,  SWS_MASK_MAT3 | SWS_MASK_OFF3 | SWS_MASK_ALPHA)
WRAP_LINEAR(matrix4,   SWS_MASK_MAT4)
WRAP_LINEAR(affine4,   SWS_MASK_MAT4 | SWS_MASK_OFF4)

static const SwsOpTable fn(op_table_float) = {
    .block_size = SWS_BLOCK_SIZE,
    .entries = {
        REF_COMMON_PATTERNS(convert_uint8),
        REF_COMMON_PATTERNS(convert_uint16),
        REF_COMMON_PATTERNS(convert_uint32),

        &fn(op_clear_1110),
        REF_COMMON_PATTERNS(min),
        REF_COMMON_PATTERNS(max),
        REF_COMMON_PATTERNS(scale),

        &fn(op_dither0),
        &fn(op_dither1),
        &fn(op_dither2),
        &fn(op_dither3),
        &fn(op_dither4),
        &fn(op_dither5),
        &fn(op_dither6),
        &fn(op_dither7),
        &fn(op_dither8),

        &fn(op_clear_1110),
        &fn(op_clear_0111),
        &fn(op_clear_0011),

        &fn(op_linear_luma),
        &fn(op_linear_alpha),
        &fn(op_linear_lumalpha),
        &fn(op_linear_dot3),
        &fn(op_linear_row0),
        &fn(op_linear_row0a),
        &fn(op_linear_diag3),
        &fn(op_linear_diag4),
        &fn(op_linear_diagoff3),
        &fn(op_linear_matrix3),
        &fn(op_linear_affine3),
        &fn(op_linear_affine3a),
        &fn(op_linear_matrix4),
        &fn(op_linear_affine4),

        NULL
    },
};

#undef PIXEL_TYPE
#undef PIXEL_MAX
#undef PIXEL_MIN
#undef pixel_t
#undef block_t
#undef px

#undef FMT_CHAR
#undef IS_FLOAT

Coverage Report

Created: 2026-03-12 07:14

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		#include "libavutil/avassert.h"
22
23		#include "ops_backend.h"
24
25		#ifndef BIT_DEPTH
26		# define BIT_DEPTH 32
27		#endif
28
29		#if BIT_DEPTH == 32
30		# define PIXEL_TYPE SWS_PIXEL_F32
31		# define PIXEL_MAX FLT_MAX
32		# define PIXEL_MIN FLT_MIN
33	0	# define pixel_t float
34		# define block_t f32block_t
35	0	# define px f32
36		#else
37		# error Invalid BIT_DEPTH
38		#endif
39
40		#define IS_FLOAT 1
41		#define FMT_CHAR f
42		#include "ops_tmpl_common.c"
43
44		DECL_SETUP(setup_dither)
45	0	{
46	0	const int size = 1 << op->dither.size_log2;
47	0	if (size == 1) {
48		/* We special case this value */
49	0	av_assert1(!av_cmp_q(op->dither.matrix[0], av_make_q(1, 2)));
50	0	out->ptr = NULL;
51	0	return 0;
52	0	}
53
54	0	const int width = FFMAX(size, SWS_BLOCK_SIZE);
55	0	pixel_t matrix = out->ptr = av_malloc(sizeof(pixel_t) size * width);
56	0	if (!matrix)
57	0	return AVERROR(ENOMEM);
58
59	0	static_assert(sizeof(out->ptr) <= sizeof(uint8_t[8]), ">8 byte pointers not supported");
60	0	int8_t *offset = &out->i8[8];
61	0	for (int i = 0; i < 4; i++)
62	0	offset[i] = op->dither.y_offset[i];
63
64	0	for (int y = 0; y < size; y++) {
65	0	for (int x = 0; x < size; x++)
66	0	matrix[y * width + x] = av_q2pixel(op->dither.matrix[y * size + x]);
67	0	for (int x = size; x < width; x++) /* pad to block size */
68	0	matrix[y * width + x] = matrix[y * width + (x % size)];
69	0	}
70
71	0	return 0;
72	0	}
73
74		DECL_FUNC(dither, const int size_log2)
75	0	{
76	0	const pixel_t *restrict matrix = impl->priv.ptr;
77	0	const int8_t *restrict offset = &impl->priv.i8[8];
78	0	const int mask = (1 << size_log2) - 1;
79	0	const int y_line = iter->y;
80	0	const int size = 1 << size_log2;
81	0	const int width = FFMAX(size, SWS_BLOCK_SIZE);
82	0	const int base = iter->x & ~(SWS_BLOCK_SIZE - 1) & (size - 1);
83
84	0	#define DITHER_COMP(VAR, IDX) \
85	0	if (offset[IDX] >= 0) { \
86	0	const int row = (y_line + offset[IDX]) & mask; \
87	0	SWS_LOOP \
88	0	for (int i = 0; i < SWS_BLOCK_SIZE; i++) \
89	0	VAR[i] += size_log2 ? matrix[row * width + base + i] : (pixel_t) 0.5; \
90	0	}
91
92	0	DITHER_COMP(x, 0)
93	0	DITHER_COMP(y, 1)
94	0	DITHER_COMP(z, 2)
95	0	DITHER_COMP(w, 3)
96
97	0	CONTINUE(block_t, x, y, z, w);
98	0	}
99
100		#define WRAP_DITHER(N) \
101	0	DECL_IMPL(dither##N) \
102	0	{ \
103	0	CALL(dither, N); \
104	0	} \ Unexecuted instantiation: ops_backend.c:dither0_f32 Unexecuted instantiation: ops_backend.c:dither1_f32 Unexecuted instantiation: ops_backend.c:dither2_f32 Unexecuted instantiation: ops_backend.c:dither3_f32 Unexecuted instantiation: ops_backend.c:dither4_f32 Unexecuted instantiation: ops_backend.c:dither5_f32 Unexecuted instantiation: ops_backend.c:dither6_f32 Unexecuted instantiation: ops_backend.c:dither7_f32 Unexecuted instantiation: ops_backend.c:dither8_f32
105		\
106		DECL_ENTRY(dither##N, \
107		.op = SWS_OP_DITHER, \
108		.dither_size = N, \
109		.setup = fn(setup_dither), \
110		.free = av_free, \
111		);
112
113		WRAP_DITHER(0)
114		WRAP_DITHER(1)
115		WRAP_DITHER(2)
116		WRAP_DITHER(3)
117		WRAP_DITHER(4)
118		WRAP_DITHER(5)
119		WRAP_DITHER(6)
120		WRAP_DITHER(7)
121		WRAP_DITHER(8)
122
123		typedef struct {
124		/* Stored in split form for convenience */
125		pixel_t m[4][4];
126		pixel_t k[4];
127		} fn(LinCoeffs);
128
129		DECL_SETUP(setup_linear)
130	0	{
131	0	fn(LinCoeffs) c;
132
133	0	for (int i = 0; i < 4; i++) {
134	0	for (int j = 0; j < 4; j++)
135	0	c.m[i][j] = av_q2pixel(op->lin.m[i][j]);
136	0	c.k[i] = av_q2pixel(op->lin.m[i][4]);
137	0	}
138
139	0	return SETUP_MEMDUP(c);
140	0	}
141
142		/**
143		* Fully general case for a 5x5 linear affine transformation. Should never be
144		* called without constant `mask`. This function will compile down to the
145		* appropriately optimized version for the required subset of operations when
146		* called with a constant mask.
147		*/
148		DECL_FUNC(linear_mask, const uint32_t mask)
149	0	{
150	0	const fn(LinCoeffs) c = (const fn(LinCoeffs) ) impl->priv.ptr;
151
152	0	SWS_LOOP
153	0	for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
154	0	const pixel_t xx = x[i];
155	0	const pixel_t yy = y[i];
156	0	const pixel_t zz = z[i];
157	0	const pixel_t ww = w[i];
158
159	0	x[i] = (mask & SWS_MASK_OFF(0)) ? c.k[0] : 0;
160	0	x[i] += (mask & SWS_MASK(0, 0)) ? c.m[0][0] * xx : xx;
161	0	x[i] += (mask & SWS_MASK(0, 1)) ? c.m[0][1] * yy : 0;
162	0	x[i] += (mask & SWS_MASK(0, 2)) ? c.m[0][2] * zz : 0;
163	0	x[i] += (mask & SWS_MASK(0, 3)) ? c.m[0][3] * ww : 0;
164
165	0	y[i] = (mask & SWS_MASK_OFF(1)) ? c.k[1] : 0;
166	0	y[i] += (mask & SWS_MASK(1, 0)) ? c.m[1][0] * xx : 0;
167	0	y[i] += (mask & SWS_MASK(1, 1)) ? c.m[1][1] * yy : yy;
168	0	y[i] += (mask & SWS_MASK(1, 2)) ? c.m[1][2] * zz : 0;
169	0	y[i] += (mask & SWS_MASK(1, 3)) ? c.m[1][3] * ww : 0;
170
171	0	z[i] = (mask & SWS_MASK_OFF(2)) ? c.k[2] : 0;
172	0	z[i] += (mask & SWS_MASK(2, 0)) ? c.m[2][0] * xx : 0;
173	0	z[i] += (mask & SWS_MASK(2, 1)) ? c.m[2][1] * yy : 0;
174	0	z[i] += (mask & SWS_MASK(2, 2)) ? c.m[2][2] * zz : zz;
175	0	z[i] += (mask & SWS_MASK(2, 3)) ? c.m[2][3] * ww : 0;
176
177	0	w[i] = (mask & SWS_MASK_OFF(3)) ? c.k[3] : 0;
178	0	w[i] += (mask & SWS_MASK(3, 0)) ? c.m[3][0] * xx : 0;
179	0	w[i] += (mask & SWS_MASK(3, 1)) ? c.m[3][1] * yy : 0;
180	0	w[i] += (mask & SWS_MASK(3, 2)) ? c.m[3][2] * zz : 0;
181	0	w[i] += (mask & SWS_MASK(3, 3)) ? c.m[3][3] * ww : ww;
182	0	}
183
184	0	CONTINUE(block_t, x, y, z, w);
185	0	}
186
187		#define WRAP_LINEAR(NAME, MASK) \
188	0	DECL_IMPL(linear_##NAME) \
189	0	{ \
190	0	CALL(linear_mask, MASK); \
191	0	} \ Unexecuted instantiation: ops_backend.c:linear_luma_f32 Unexecuted instantiation: ops_backend.c:linear_alpha_f32 Unexecuted instantiation: ops_backend.c:linear_lumalpha_f32 Unexecuted instantiation: ops_backend.c:linear_dot3_f32 Unexecuted instantiation: ops_backend.c:linear_row0_f32 Unexecuted instantiation: ops_backend.c:linear_row0a_f32 Unexecuted instantiation: ops_backend.c:linear_diag3_f32 Unexecuted instantiation: ops_backend.c:linear_diag4_f32 Unexecuted instantiation: ops_backend.c:linear_diagoff3_f32 Unexecuted instantiation: ops_backend.c:linear_matrix3_f32 Unexecuted instantiation: ops_backend.c:linear_affine3_f32 Unexecuted instantiation: ops_backend.c:linear_affine3a_f32 Unexecuted instantiation: ops_backend.c:linear_matrix4_f32 Unexecuted instantiation: ops_backend.c:linear_affine4_f32
192		\
193		DECL_ENTRY(linear_##NAME, \
194		.op = SWS_OP_LINEAR, \
195		.setup = fn(setup_linear), \
196		.free = av_free, \
197		.linear_mask = (MASK), \
198		);
199
200		WRAP_LINEAR(luma, SWS_MASK_LUMA)
201		WRAP_LINEAR(alpha, SWS_MASK_ALPHA)
202		WRAP_LINEAR(lumalpha, SWS_MASK_LUMA \| SWS_MASK_ALPHA)
203		WRAP_LINEAR(dot3, 0x7)
204		WRAP_LINEAR(row0, SWS_MASK_ROW(0))
205		WRAP_LINEAR(row0a, SWS_MASK_ROW(0) \| SWS_MASK_ALPHA)
206		WRAP_LINEAR(diag3, SWS_MASK_DIAG3)
207		WRAP_LINEAR(diag4, SWS_MASK_DIAG4)
208		WRAP_LINEAR(diagoff3, SWS_MASK_DIAG3 \| SWS_MASK_OFF3)
209		WRAP_LINEAR(matrix3, SWS_MASK_MAT3)
210		WRAP_LINEAR(affine3, SWS_MASK_MAT3 \| SWS_MASK_OFF3)
211		WRAP_LINEAR(affine3a, SWS_MASK_MAT3 \| SWS_MASK_OFF3 \| SWS_MASK_ALPHA)
212		WRAP_LINEAR(matrix4, SWS_MASK_MAT4)
213		WRAP_LINEAR(affine4, SWS_MASK_MAT4 \| SWS_MASK_OFF4)
214
215		static const SwsOpTable fn(op_table_float) = {
216		.block_size = SWS_BLOCK_SIZE,
217		.entries = {
218		REF_COMMON_PATTERNS(convert_uint8),
219		REF_COMMON_PATTERNS(convert_uint16),
220		REF_COMMON_PATTERNS(convert_uint32),
221
222		&fn(op_clear_1110),
223		REF_COMMON_PATTERNS(min),
224		REF_COMMON_PATTERNS(max),
225		REF_COMMON_PATTERNS(scale),
226
227		&fn(op_dither0),
228		&fn(op_dither1),
229		&fn(op_dither2),
230		&fn(op_dither3),
231		&fn(op_dither4),
232		&fn(op_dither5),
233		&fn(op_dither6),
234		&fn(op_dither7),
235		&fn(op_dither8),
236
237		&fn(op_clear_1110),
238		&fn(op_clear_0111),
239		&fn(op_clear_0011),
240
241		&fn(op_linear_luma),
242		&fn(op_linear_alpha),
243		&fn(op_linear_lumalpha),
244		&fn(op_linear_dot3),
245		&fn(op_linear_row0),
246		&fn(op_linear_row0a),
247		&fn(op_linear_diag3),
248		&fn(op_linear_diag4),
249		&fn(op_linear_diagoff3),
250		&fn(op_linear_matrix3),
251		&fn(op_linear_affine3),
252		&fn(op_linear_affine3a),
253		&fn(op_linear_matrix4),
254		&fn(op_linear_affine4),
255
256		NULL
257		},
258		};
259
260		#undef PIXEL_TYPE
261		#undef PIXEL_MAX
262		#undef PIXEL_MIN
263		#undef pixel_t
264		#undef block_t
265		#undef px
266
267		#undef FMT_CHAR
268		#undef IS_FLOAT