mirror of
https://git.ffmpeg.org/ffmpeg.git
synced 2026-04-19 00:50:23 +00:00
8b346363aa
If you place the branch inside the loop, gcc at least reverts back to scalar code, so better to just split up and guard the entire loop. Signed-off-by: Niklas Haas <git@haasn.dev>
268 lines
9.1 KiB
C
268 lines
9.1 KiB
C
/**
|
|
* 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
|