mirror of
https://mirror.skon.top/https://github.com/FFmpeg/FFmpeg
synced 2026-04-20 21:00:41 +08:00
1092852406
The glue code doesn't care about types, so long the functions are chained correctly. Let's not pretend there is any type safety there, as the function pointers were casted anyway from unrelated types. Particularly some f32 and u32 are shared. This fixes errors like so: src/libswscale/ops_tmpl_int.c:471:1: runtime error: call to function linear_diagoff3_f32 through pointer to incorrect function type 'void (*)(struct SwsOpIter *, const struct SwsOpImpl *, unsigned int *, unsigned int *, unsigned int *, unsigned int *)' libswscale/ops_tmpl_float.c:208: note: linear_diagoff3_f32 defined here Fixes: #22332
350 lines
12 KiB
C
350 lines
12 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 "ops_backend.h"
|
|
|
|
#ifndef BIT_DEPTH
|
|
# error Should only be included from ops_tmpl_*.c!
|
|
#endif
|
|
|
|
#define WRAP_CONVERT_UINT(N) \
|
|
DECL_PATTERN(convert_uint##N) \
|
|
{ \
|
|
u##N##block_t xu, yu, zu, wu; \
|
|
\
|
|
SWS_LOOP \
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) { \
|
|
if (X) \
|
|
xu[i] = x[i]; \
|
|
if (Y) \
|
|
yu[i] = y[i]; \
|
|
if (Z) \
|
|
zu[i] = z[i]; \
|
|
if (W) \
|
|
wu[i] = w[i]; \
|
|
} \
|
|
\
|
|
CONTINUE(xu, yu, zu, wu); \
|
|
} \
|
|
\
|
|
WRAP_COMMON_PATTERNS(convert_uint##N, \
|
|
.op = SWS_OP_CONVERT, \
|
|
.convert.to = SWS_PIXEL_U##N, \
|
|
);
|
|
|
|
#if BIT_DEPTH != 8
|
|
WRAP_CONVERT_UINT(8)
|
|
#endif
|
|
|
|
#if BIT_DEPTH != 16
|
|
WRAP_CONVERT_UINT(16)
|
|
#endif
|
|
|
|
#if BIT_DEPTH != 32 || defined(IS_FLOAT)
|
|
WRAP_CONVERT_UINT(32)
|
|
#endif
|
|
|
|
DECL_PATTERN(clear)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (!X)
|
|
x[i] = impl->priv.px[0];
|
|
if (!Y)
|
|
y[i] = impl->priv.px[1];
|
|
if (!Z)
|
|
z[i] = impl->priv.px[2];
|
|
if (!W)
|
|
w[i] = impl->priv.px[3];
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
#define WRAP_CLEAR(X, Y, Z, W) \
|
|
DECL_IMPL(clear, clear##_##X##Y##Z##W, X, Y, Z, W) \
|
|
\
|
|
DECL_ENTRY(clear##_##X##Y##Z##W, \
|
|
.setup = ff_sws_setup_clear, \
|
|
.op = SWS_OP_CLEAR, \
|
|
.flexible = true, \
|
|
.unused = { !X, !Y, !Z, !W }, \
|
|
);
|
|
|
|
WRAP_CLEAR(1, 1, 1, 0) /* rgba alpha */
|
|
WRAP_CLEAR(0, 1, 1, 1) /* argb alpha */
|
|
WRAP_CLEAR(1, 0, 1, 1) /* ya alpha */
|
|
|
|
WRAP_CLEAR(0, 0, 1, 1) /* vuya chroma */
|
|
WRAP_CLEAR(1, 0, 0, 1) /* yuva chroma */
|
|
WRAP_CLEAR(1, 1, 0, 0) /* ayuv chroma */
|
|
WRAP_CLEAR(0, 1, 0, 1) /* uyva chroma */
|
|
WRAP_CLEAR(1, 0, 1, 0) /* xvyu chroma */
|
|
|
|
WRAP_CLEAR(1, 0, 0, 0) /* gray -> yuva */
|
|
WRAP_CLEAR(0, 1, 0, 0) /* gray -> ayuv */
|
|
WRAP_CLEAR(0, 0, 1, 0) /* gray -> vuya */
|
|
|
|
DECL_PATTERN(min)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X)
|
|
x[i] = FFMIN(x[i], impl->priv.px[0]);
|
|
if (Y)
|
|
y[i] = FFMIN(y[i], impl->priv.px[1]);
|
|
if (Z)
|
|
z[i] = FFMIN(z[i], impl->priv.px[2]);
|
|
if (W)
|
|
w[i] = FFMIN(w[i], impl->priv.px[3]);
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_PATTERN(max)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X)
|
|
x[i] = FFMAX(x[i], impl->priv.px[0]);
|
|
if (Y)
|
|
y[i] = FFMAX(y[i], impl->priv.px[1]);
|
|
if (Z)
|
|
z[i] = FFMAX(z[i], impl->priv.px[2]);
|
|
if (W)
|
|
w[i] = FFMAX(w[i], impl->priv.px[3]);
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
WRAP_COMMON_PATTERNS(min,
|
|
.op = SWS_OP_MIN,
|
|
.setup = ff_sws_setup_clamp,
|
|
.flexible = true,
|
|
);
|
|
|
|
WRAP_COMMON_PATTERNS(max,
|
|
.op = SWS_OP_MAX,
|
|
.setup = ff_sws_setup_clamp,
|
|
.flexible = true,
|
|
);
|
|
|
|
DECL_PATTERN(scale)
|
|
{
|
|
const pixel_t scale = impl->priv.px[0];
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X)
|
|
x[i] *= scale;
|
|
if (Y)
|
|
y[i] *= scale;
|
|
if (Z)
|
|
z[i] *= scale;
|
|
if (W)
|
|
w[i] *= scale;
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
WRAP_COMMON_PATTERNS(scale,
|
|
.op = SWS_OP_SCALE,
|
|
.setup = ff_sws_setup_scale,
|
|
.flexible = true,
|
|
);
|
|
|
|
DECL_SETUP(setup_filter_v, params, out)
|
|
{
|
|
const SwsFilterWeights *filter = params->op->rw.kernel;
|
|
static_assert(sizeof(out->priv.ptr) <= sizeof(int32_t[2]),
|
|
">8 byte pointers not supported");
|
|
|
|
/* Pre-convert weights to float */
|
|
float *weights = av_calloc(filter->num_weights, sizeof(float));
|
|
if (!weights)
|
|
return AVERROR(ENOMEM);
|
|
|
|
for (int i = 0; i < filter->num_weights; i++)
|
|
weights[i] = (float) filter->weights[i] / SWS_FILTER_SCALE;
|
|
|
|
out->priv.ptr = weights;
|
|
out->priv.i32[2] = filter->filter_size;
|
|
out->free = ff_op_priv_free;
|
|
return 0;
|
|
}
|
|
|
|
/* Fully general vertical planar filter case */
|
|
DECL_READ(filter_v, const int elems)
|
|
{
|
|
const SwsOpExec *exec = iter->exec;
|
|
const float *restrict weights = impl->priv.ptr;
|
|
const int filter_size = impl->priv.i32[2];
|
|
weights += filter_size * iter->y;
|
|
|
|
f32block_t xs, ys, zs, ws;
|
|
memset(xs, 0, sizeof(xs));
|
|
if (elems > 1)
|
|
memset(ys, 0, sizeof(ys));
|
|
if (elems > 2)
|
|
memset(zs, 0, sizeof(zs));
|
|
if (elems > 3)
|
|
memset(ws, 0, sizeof(ws));
|
|
|
|
for (int j = 0; j < filter_size; j++) {
|
|
const float weight = weights[j];
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
xs[i] += weight * in0[i];
|
|
if (elems > 1)
|
|
ys[i] += weight * in1[i];
|
|
if (elems > 2)
|
|
zs[i] += weight * in2[i];
|
|
if (elems > 3)
|
|
ws[i] += weight * in3[i];
|
|
}
|
|
|
|
in0 = bump_ptr(in0, exec->in_stride[0]);
|
|
if (elems > 1)
|
|
in1 = bump_ptr(in1, exec->in_stride[1]);
|
|
if (elems > 2)
|
|
in2 = bump_ptr(in2, exec->in_stride[2]);
|
|
if (elems > 3)
|
|
in3 = bump_ptr(in3, exec->in_stride[3]);
|
|
}
|
|
|
|
for (int i = 0; i < elems; i++)
|
|
iter->in[i] += sizeof(block_t);
|
|
|
|
CONTINUE(xs, ys, zs, ws);
|
|
}
|
|
|
|
DECL_SETUP(setup_filter_h, params, out)
|
|
{
|
|
SwsFilterWeights *filter = params->op->rw.kernel;
|
|
out->priv.ptr = av_refstruct_ref(filter->weights);
|
|
out->priv.i32[2] = filter->filter_size;
|
|
out->free = ff_op_priv_unref;
|
|
return 0;
|
|
}
|
|
|
|
/* Fully general horizontal planar filter case */
|
|
DECL_READ(filter_h, const int elems)
|
|
{
|
|
const SwsOpExec *exec = iter->exec;
|
|
const int *restrict weights = impl->priv.ptr;
|
|
const int filter_size = impl->priv.i32[2];
|
|
const float scale = 1.0f / SWS_FILTER_SCALE;
|
|
const int xpos = iter->x;
|
|
weights += filter_size * iter->x;
|
|
|
|
f32block_t xs, ys, zs, ws;
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
const int offset = exec->in_offset_x[xpos + i];
|
|
pixel_t *start0 = bump_ptr(in0, offset);
|
|
pixel_t *start1 = bump_ptr(in1, offset);
|
|
pixel_t *start2 = bump_ptr(in2, offset);
|
|
pixel_t *start3 = bump_ptr(in3, offset);
|
|
|
|
inter_t sx = 0, sy = 0, sz = 0, sw = 0;
|
|
for (int j = 0; j < filter_size; j++) {
|
|
const int weight = weights[j];
|
|
sx += weight * start0[j];
|
|
if (elems > 1)
|
|
sy += weight * start1[j];
|
|
if (elems > 2)
|
|
sz += weight * start2[j];
|
|
if (elems > 3)
|
|
sw += weight * start3[j];
|
|
}
|
|
|
|
xs[i] = (float) sx * scale;
|
|
if (elems > 1)
|
|
ys[i] = (float) sy * scale;
|
|
if (elems > 2)
|
|
zs[i] = (float) sz * scale;
|
|
if (elems > 3)
|
|
ws[i] = (float) sw * scale;
|
|
|
|
weights += filter_size;
|
|
}
|
|
|
|
CONTINUE(xs, ys, zs, ws);
|
|
}
|
|
|
|
#define WRAP_FILTER(FUNC, DIR, ELEMS, SUFFIX) \
|
|
static av_flatten void fn(FUNC##ELEMS##SUFFIX)(SwsOpIter *restrict iter, \
|
|
const SwsOpImpl *restrict impl, \
|
|
void *restrict x, void *restrict y,\
|
|
void *restrict z, void *restrict w)\
|
|
{ \
|
|
CALL_READ(FUNC##SUFFIX, ELEMS); \
|
|
} \
|
|
\
|
|
DECL_ENTRY(FUNC##ELEMS##SUFFIX, \
|
|
.op = SWS_OP_READ, \
|
|
.setup = fn(setup_filter##SUFFIX), \
|
|
.rw.elems = ELEMS, \
|
|
.rw.filter = SWS_OP_FILTER_##DIR, \
|
|
);
|
|
|
|
WRAP_FILTER(filter, V, 1, _v)
|
|
WRAP_FILTER(filter, V, 2, _v)
|
|
WRAP_FILTER(filter, V, 3, _v)
|
|
WRAP_FILTER(filter, V, 4, _v)
|
|
|
|
WRAP_FILTER(filter, H, 1, _h)
|
|
WRAP_FILTER(filter, H, 2, _h)
|
|
WRAP_FILTER(filter, H, 3, _h)
|
|
WRAP_FILTER(filter, H, 4, _h)
|
|
|
|
static void fn(process)(const SwsOpExec *exec, const void *priv,
|
|
const int bx_start, const int y_start,
|
|
int bx_end, int y_end)
|
|
{
|
|
const SwsOpChain *chain = priv;
|
|
const SwsOpImpl *impl = chain->impl;
|
|
u32block_t x, y, z, w; /* allocate enough space for any intermediate */
|
|
|
|
SwsOpIter iterdata;
|
|
SwsOpIter *iter = &iterdata; /* for CONTINUE() macro to work */
|
|
iter->exec = exec;
|
|
for (int i = 0; i < 4; i++) {
|
|
iter->in[i] = (uintptr_t) exec->in[i];
|
|
iter->out[i] = (uintptr_t) exec->out[i];
|
|
}
|
|
|
|
for (iter->y = y_start; iter->y < y_end; iter->y++) {
|
|
for (int block = bx_start; block < bx_end; block++) {
|
|
iter->x = block * SWS_BLOCK_SIZE;
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
const int y_bump = exec->in_bump_y ? exec->in_bump_y[iter->y] : 0;
|
|
for (int i = 0; i < 4; i++) {
|
|
iter->in[i] += exec->in_bump[i] + y_bump * exec->in_stride[i];
|
|
iter->out[i] += exec->out_bump[i];
|
|
}
|
|
}
|
|
}
|