830 lines
25 KiB
C
830 lines
25 KiB
C
/**
|
|
* Copyright (C) 2026 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/bswap.h>
|
|
|
|
#include "uops_tmpl.h"
|
|
|
|
#ifndef BIT_DEPTH
|
|
# define BIT_DEPTH 8
|
|
#endif
|
|
|
|
#if IS_FLOAT && BIT_DEPTH == 32
|
|
# define PIXEL_TYPE SWS_PIXEL_F32
|
|
# define pixel_t float
|
|
# define inter_t float
|
|
# define PX F32
|
|
# define px f32
|
|
#elif BIT_DEPTH == 32
|
|
# define PIXEL_MAX 0xFFFFFFFFu
|
|
# define PIXEL_SWAP av_bswap32
|
|
# define pixel_t uint32_t
|
|
# define inter_t int64_t
|
|
# define PX U32
|
|
# define px u32
|
|
#elif BIT_DEPTH == 16
|
|
# define PIXEL_MAX 0xFFFFu
|
|
# define PIXEL_SWAP av_bswap16
|
|
# define pixel_t uint16_t
|
|
# define inter_t int64_t
|
|
# define PX U16
|
|
# define px u16
|
|
#elif BIT_DEPTH == 8
|
|
# define PIXEL_MAX 0xFFu
|
|
# define pixel_t uint8_t
|
|
# define inter_t int32_t
|
|
# define PX U8
|
|
# define px u8
|
|
#else
|
|
# error Invalid BIT_DEPTH
|
|
#endif
|
|
|
|
/*********************************
|
|
* Generic read/write operations *
|
|
*********************************/
|
|
|
|
DECL_READ(read_planar, const SwsCompMask mask)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] = in0[i];
|
|
if (Y) y[i] = in1[i];
|
|
if (Z) z[i] = in2[i];
|
|
if (W) w[i] = in3[i];
|
|
}
|
|
|
|
if (X) iter->in[0] += SIZEOF_BLOCK;
|
|
if (Y) iter->in[1] += SIZEOF_BLOCK;
|
|
if (Z) iter->in[2] += SIZEOF_BLOCK;
|
|
if (W) iter->in[3] += SIZEOF_BLOCK;
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_READ(read_packed, const SwsCompMask mask)
|
|
{
|
|
const int elems = W ? 4 : Z ? 3 : Y ? 2 : 1;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] = in0[elems * i + 0];
|
|
if (Y) y[i] = in0[elems * i + 1];
|
|
if (Z) z[i] = in0[elems * i + 2];
|
|
if (W) w[i] = in0[elems * i + 3];
|
|
}
|
|
|
|
iter->in[0] += SIZEOF_BLOCK * elems;
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_WRITE(write_planar, const SwsCompMask mask)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) out0[i] = x[i];
|
|
if (Y) out1[i] = y[i];
|
|
if (Z) out2[i] = z[i];
|
|
if (W) out3[i] = w[i];
|
|
}
|
|
|
|
if (X) iter->out[0] += SIZEOF_BLOCK;
|
|
if (Y) iter->out[1] += SIZEOF_BLOCK;
|
|
if (Z) iter->out[2] += SIZEOF_BLOCK;
|
|
if (W) iter->out[3] += SIZEOF_BLOCK;
|
|
}
|
|
|
|
DECL_WRITE(write_packed, const SwsCompMask mask)
|
|
{
|
|
const int elems = W ? 4 : Z ? 3 : Y ? 2 : 1;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) out0[elems * i + 0] = x[i];
|
|
if (Y) out0[elems * i + 1] = y[i];
|
|
if (Z) out0[elems * i + 2] = z[i];
|
|
if (W) out0[elems * i + 3] = w[i];
|
|
}
|
|
|
|
iter->out[0] += SIZEOF_BLOCK * elems;
|
|
}
|
|
|
|
#if BIT_DEPTH == 8
|
|
|
|
DECL_READ(read_bit, const SwsCompMask mask)
|
|
{
|
|
av_assert2(mask == SWS_COMP_ELEMS(1));
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i += 8) {
|
|
const pixel_t val = ((const pixel_t *) in0)[i >> 3];
|
|
x[i + 0] = (val >> 7) & 1;
|
|
x[i + 1] = (val >> 6) & 1;
|
|
x[i + 2] = (val >> 5) & 1;
|
|
x[i + 3] = (val >> 4) & 1;
|
|
x[i + 4] = (val >> 3) & 1;
|
|
x[i + 5] = (val >> 2) & 1;
|
|
x[i + 6] = (val >> 1) & 1;
|
|
x[i + 7] = (val >> 0) & 1;
|
|
}
|
|
|
|
iter->in[0] += SIZEOF_BLOCK >> 3;
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_READ(read_nibble, const SwsCompMask mask)
|
|
{
|
|
av_assert2(mask == SWS_COMP_ELEMS(1));
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i += 2) {
|
|
const pixel_t val = in0[i >> 1];
|
|
x[i + 0] = val >> 4; /* high nibble */
|
|
x[i + 1] = val & 0xF; /* low nibble */
|
|
}
|
|
|
|
iter->in[0] += SIZEOF_BLOCK >> 1;
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_READ(read_palette, const SwsCompMask mask)
|
|
{
|
|
av_assert2(mask == SWS_COMP_ELEMS(4));
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
const pixel_t index = in0[i];
|
|
const pixel_t *value = &in1[index * 4];
|
|
x[i] = value[0];
|
|
y[i] = value[1];
|
|
z[i] = value[2];
|
|
w[i] = value[3];
|
|
}
|
|
|
|
iter->in[0] += SIZEOF_BLOCK;
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_WRITE(write_bit, const SwsCompMask mask)
|
|
{
|
|
av_assert2(mask == SWS_COMP_ELEMS(1));
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i += 8) {
|
|
out0[i >> 3] = x[i + 0] << 7 |
|
|
x[i + 1] << 6 |
|
|
x[i + 2] << 5 |
|
|
x[i + 3] << 4 |
|
|
x[i + 4] << 3 |
|
|
x[i + 5] << 2 |
|
|
x[i + 6] << 1 |
|
|
x[i + 7];
|
|
}
|
|
|
|
iter->out[0] += SIZEOF_BLOCK >> 3;
|
|
}
|
|
|
|
DECL_WRITE(write_nibble, const SwsCompMask mask)
|
|
{
|
|
av_assert2(mask == SWS_COMP_ELEMS(1));
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i += 2)
|
|
out0[i >> 1] = x[i] << 4 | x[i + 1];
|
|
|
|
iter->out[0] += SIZEOF_BLOCK >> 1;
|
|
}
|
|
|
|
#endif /* BIT_DEPTH == 8 */
|
|
|
|
SWS_FOR(PX, READ_PLANAR, DECL_IMPL_READ, read_planar)
|
|
SWS_FOR(PX, READ_PACKED, DECL_IMPL_READ, read_packed)
|
|
SWS_FOR(PX, READ_NIBBLE, DECL_IMPL_READ, read_nibble)
|
|
SWS_FOR(PX, READ_BIT, DECL_IMPL_READ, read_bit)
|
|
SWS_FOR(PX, READ_PALETTE, DECL_IMPL_READ, read_palette)
|
|
SWS_FOR(PX, WRITE_PLANAR, DECL_IMPL_WRITE, write_planar)
|
|
SWS_FOR(PX, WRITE_PACKED, DECL_IMPL_WRITE, write_packed)
|
|
SWS_FOR(PX, WRITE_NIBBLE, DECL_IMPL_WRITE, write_nibble)
|
|
SWS_FOR(PX, WRITE_BIT, DECL_IMPL_WRITE, write_bit)
|
|
|
|
SWS_FOR_STRUCT(PX, READ_PLANAR, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, READ_PACKED, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, READ_NIBBLE, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, READ_BIT, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, READ_PALETTE, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, WRITE_PLANAR, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, WRITE_PACKED, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, WRITE_NIBBLE, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, WRITE_BIT, DECL_ENTRY)
|
|
|
|
/*****************************
|
|
* Scaling / filtering reads *
|
|
*****************************/
|
|
|
|
DECL_SETUP(setup_filter_v, params, out)
|
|
{
|
|
if (params->uop->par.filter.type != SWS_PIXEL_F32)
|
|
return AVERROR(ENOTSUP);
|
|
|
|
const SwsFilterWeights *filter = params->uop->data.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(read_planar_fv, const SwsCompMask mask, const SwsPixelType type)
|
|
{
|
|
av_assert2(type == SWS_PIXEL_F32);
|
|
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;
|
|
|
|
block_t xs, ys, zs, ws;
|
|
if (X) memset(&xs.f32, 0, sizeof(xs.f32));
|
|
if (Y) memset(&ys.f32, 0, sizeof(ys.f32));
|
|
if (Z) memset(&zs.f32, 0, sizeof(zs.f32));
|
|
if (W) memset(&ws.f32, 0, sizeof(ws.f32));
|
|
|
|
for (int j = 0; j < filter_size; j++) {
|
|
const float weight = weights[j];
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) xs.f32[i] += weight * in0[i];
|
|
if (Y) ys.f32[i] += weight * in1[i];
|
|
if (Z) zs.f32[i] += weight * in2[i];
|
|
if (W) ws.f32[i] += weight * in3[i];
|
|
}
|
|
|
|
if (X) in0 = bump_ptr(in0, exec->in_stride[0]);
|
|
if (Y) in1 = bump_ptr(in1, exec->in_stride[1]);
|
|
if (Z) in2 = bump_ptr(in2, exec->in_stride[2]);
|
|
if (W) in3 = bump_ptr(in3, exec->in_stride[3]);
|
|
}
|
|
|
|
if (X) iter->in[0] += SIZEOF_BLOCK;
|
|
if (Y) iter->in[1] += SIZEOF_BLOCK;
|
|
if (Z) iter->in[2] += SIZEOF_BLOCK;
|
|
if (W) iter->in[3] += SIZEOF_BLOCK;
|
|
|
|
CONTINUE(&xs, &ys, &zs, &ws);
|
|
}
|
|
|
|
DECL_SETUP(setup_filter_h, params, out)
|
|
{
|
|
if (params->uop->par.filter.type != SWS_PIXEL_F32)
|
|
return AVERROR(ENOTSUP);
|
|
|
|
SwsFilterWeights *filter = params->uop->data.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(read_planar_fh, const SwsCompMask mask, const SwsPixelType type)
|
|
{
|
|
av_assert2(type == SWS_PIXEL_F32);
|
|
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;
|
|
|
|
block_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];
|
|
if (X) sx += weight * start0[j];
|
|
if (Y) sy += weight * start1[j];
|
|
if (Z) sz += weight * start2[j];
|
|
if (W) sw += weight * start3[j];
|
|
}
|
|
|
|
if (X) xs.f32[i] = (float) sx * scale;
|
|
if (Y) ys.f32[i] = (float) sy * scale;
|
|
if (Z) zs.f32[i] = (float) sz * scale;
|
|
if (W) ws.f32[i] = (float) sw * scale;
|
|
|
|
weights += filter_size;
|
|
}
|
|
|
|
CONTINUE(&xs, &ys, &zs, &ws);
|
|
}
|
|
|
|
SWS_FOR(PX, READ_PLANAR_FV, DECL_IMPL_READ, read_planar_fv)
|
|
SWS_FOR(PX, READ_PLANAR_FH, DECL_IMPL_READ, read_planar_fh)
|
|
SWS_FOR_STRUCT(PX, READ_PLANAR_FV, DECL_ENTRY, .setup = fn(setup_filter_v) )
|
|
SWS_FOR_STRUCT(PX, READ_PLANAR_FH, DECL_ENTRY, .setup = fn(setup_filter_h) )
|
|
|
|
/***************************
|
|
* Permutation and copying *
|
|
***************************/
|
|
|
|
/* Permute by directly swapping the order of arguments to the continuation. */
|
|
#define DECL_PERMUTE(DUMMY, NAME, TYPE, UOP, MASK, IDX0, IDX1, IDX2, IDX3) \
|
|
static void NAME##_c(SwsOpIter *restrict iter, \
|
|
const SwsOpImpl *restrict impl, \
|
|
void *restrict in0, void *restrict in1, \
|
|
void *restrict in2, void *restrict in3) \
|
|
{ \
|
|
CONTINUE(in##IDX0, in##IDX1, in##IDX2, in##IDX3); \
|
|
}
|
|
|
|
#define DECL_COPY(DUMMY, NAME, TYPE, UOP, MASK, IDX0, IDX1, IDX2, IDX3) \
|
|
static void NAME##_c(SwsOpIter *restrict iter, \
|
|
const SwsOpImpl *restrict impl, \
|
|
void *restrict in0, void *restrict in1, \
|
|
void *restrict in2, void *restrict in3) \
|
|
{ \
|
|
const SwsCompMask mask = (MASK); \
|
|
block_t x, y, z, w; \
|
|
\
|
|
if (X) memcpy(&x.px, in##IDX0, SIZEOF_BLOCK); \
|
|
if (Y) memcpy(&y.px, in##IDX1, SIZEOF_BLOCK); \
|
|
if (Z) memcpy(&z.px, in##IDX2, SIZEOF_BLOCK); \
|
|
if (W) memcpy(&w.px, in##IDX3, SIZEOF_BLOCK); \
|
|
\
|
|
CONTINUE(X ? &x : in0, Y ? &y : in1, Z ? &z : in2, W ? &w : in3); \
|
|
}
|
|
|
|
SWS_FOR(PX, PERMUTE, DECL_PERMUTE)
|
|
SWS_FOR(PX, COPY, DECL_COPY)
|
|
SWS_FOR_STRUCT(PX, PERMUTE, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, COPY, DECL_ENTRY)
|
|
|
|
/*********************
|
|
* Format conversion *
|
|
*********************/
|
|
|
|
#define DECL_CAST(DST, dst) \
|
|
DECL_FUNC(to_##dst, const SwsCompMask mask) \
|
|
{ \
|
|
block_t xx, yy, zz, ww; \
|
|
\
|
|
SWS_LOOP \
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) { \
|
|
if (X) xx.dst[i] = x[i]; \
|
|
if (Y) yy.dst[i] = y[i]; \
|
|
if (Z) zz.dst[i] = z[i]; \
|
|
if (W) ww.dst[i] = w[i]; \
|
|
} \
|
|
\
|
|
CONTINUE(&xx, &yy, &zz, &ww); \
|
|
} \
|
|
\
|
|
SWS_FOR(PX, TO_##DST, DECL_IMPL, to_##dst) \
|
|
SWS_FOR_STRUCT(PX, TO_##DST, DECL_ENTRY)
|
|
|
|
DECL_CAST(U8, u8)
|
|
DECL_CAST(U16, u16)
|
|
DECL_CAST(U32, u32)
|
|
DECL_CAST(F32, f32)
|
|
|
|
/********************
|
|
* Bit manipulation *
|
|
********************/
|
|
|
|
#if !IS_FLOAT
|
|
DECL_FUNC(lshift, const SwsCompMask mask, const uint8_t amount)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] <<= amount;
|
|
if (Y) y[i] <<= amount;
|
|
if (Z) z[i] <<= amount;
|
|
if (W) w[i] <<= amount;
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_FUNC(rshift, const SwsCompMask mask, const uint8_t amount)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] >>= amount;
|
|
if (Y) y[i] >>= amount;
|
|
if (Z) z[i] >>= amount;
|
|
if (W) w[i] >>= amount;
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
#endif
|
|
|
|
SWS_FOR(PX, LSHIFT, DECL_IMPL, lshift)
|
|
SWS_FOR(PX, RSHIFT, DECL_IMPL, rshift)
|
|
|
|
SWS_FOR_STRUCT(PX, LSHIFT, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, RSHIFT, DECL_ENTRY)
|
|
|
|
#ifdef PIXEL_SWAP
|
|
DECL_FUNC(swap_bytes, const SwsCompMask mask)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] = PIXEL_SWAP(x[i]);
|
|
if (Y) y[i] = PIXEL_SWAP(y[i]);
|
|
if (Z) z[i] = PIXEL_SWAP(z[i]);
|
|
if (W) w[i] = PIXEL_SWAP(w[i]);
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
#endif /* PIXEL_SWAP */
|
|
|
|
SWS_FOR(PX, SWAP_BYTES, DECL_IMPL, swap_bytes)
|
|
SWS_FOR_STRUCT(PX, SWAP_BYTES, DECL_ENTRY)
|
|
|
|
#ifdef PIXEL_MAX
|
|
DECL_FUNC(expand_bit, const SwsCompMask mask)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] = x[i] ? PIXEL_MAX : 0;
|
|
if (Y) y[i] = y[i] ? PIXEL_MAX : 0;
|
|
if (Z) z[i] = z[i] ? PIXEL_MAX : 0;
|
|
if (W) w[i] = w[i] ? PIXEL_MAX : 0;
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
#endif
|
|
|
|
#if BIT_DEPTH == 8
|
|
DECL_FUNC(expand_pair, const SwsCompMask mask)
|
|
{
|
|
block_t x16, y16, z16, w16;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x16.u16[i] = x[i] << 8 | x[i];
|
|
if (Y) y16.u16[i] = y[i] << 8 | y[i];
|
|
if (Z) z16.u16[i] = z[i] << 8 | z[i];
|
|
if (W) w16.u16[i] = w[i] << 8 | w[i];
|
|
}
|
|
|
|
CONTINUE(&x16, &y16, &z16, &w16);
|
|
}
|
|
|
|
DECL_FUNC(expand_quad, const SwsCompMask mask)
|
|
{
|
|
block_t x32, y32, z32, w32;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x32.u32[i] = (uint32_t) x[i] << 24 | x[i] << 16 | x[i] << 8 | x[i];
|
|
if (Y) y32.u32[i] = (uint32_t) y[i] << 24 | y[i] << 16 | y[i] << 8 | y[i];
|
|
if (Z) z32.u32[i] = (uint32_t) z[i] << 24 | z[i] << 16 | z[i] << 8 | z[i];
|
|
if (W) w32.u32[i] = (uint32_t) w[i] << 24 | w[i] << 16 | w[i] << 8 | w[i];
|
|
}
|
|
|
|
CONTINUE(&x32, &y32, &z32, &w32);
|
|
}
|
|
#endif /* BIT_DEPTH == 8 */
|
|
|
|
SWS_FOR(PX, EXPAND_BIT, DECL_IMPL, expand_bit)
|
|
SWS_FOR(PX, EXPAND_PAIR, DECL_IMPL, expand_pair)
|
|
SWS_FOR(PX, EXPAND_QUAD, DECL_IMPL, expand_quad)
|
|
SWS_FOR_STRUCT(PX, EXPAND_BIT, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, EXPAND_PAIR, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, EXPAND_QUAD, DECL_ENTRY)
|
|
|
|
/*************************
|
|
* Packing and unpacking *
|
|
************************/
|
|
|
|
#if !IS_FLOAT
|
|
DECL_FUNC(unpack, const SwsCompMask mask,
|
|
const uint8_t bx, const uint8_t by,
|
|
const uint8_t bz, const uint8_t bw)
|
|
{
|
|
const uint8_t sx = bw + bz + by;
|
|
const uint8_t sy = bw + bz;
|
|
const uint8_t sz = bw;
|
|
const uint8_t sw = 0;
|
|
|
|
const pixel_t mx = (1 << bx) - 1;
|
|
const pixel_t my = (1 << by) - 1;
|
|
const pixel_t mz = (1 << bz) - 1;
|
|
const pixel_t mw = (1 << bw) - 1;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
const pixel_t val = x[i];
|
|
if (X) x[i] = (val >> sx) & mx;
|
|
if (Y) y[i] = (val >> sy) & my;
|
|
if (Z) z[i] = (val >> sz) & mz;
|
|
if (W) w[i] = (val >> sw) & mw;
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
DECL_FUNC(pack, const SwsCompMask mask,
|
|
const uint8_t bx, const uint8_t by,
|
|
const uint8_t bz, const uint8_t bw)
|
|
{
|
|
const uint8_t sx = bw + bz + by;
|
|
const uint8_t sy = bw + bz;
|
|
const uint8_t sz = bw;
|
|
const uint8_t sw = 0;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
pixel_t val = 0;
|
|
if (X) val |= x[i] << sx;
|
|
if (Y) val |= y[i] << sy;
|
|
if (Z) val |= z[i] << sz;
|
|
if (W) val |= w[i] << sw;
|
|
x[i] = val;
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
#endif /* !IS_FLOAT */
|
|
|
|
SWS_FOR(PX, UNPACK, DECL_IMPL, unpack)
|
|
SWS_FOR(PX, PACK, DECL_IMPL, pack)
|
|
SWS_FOR_STRUCT(PX, UNPACK, DECL_ENTRY)
|
|
SWS_FOR_STRUCT(PX, PACK, DECL_ENTRY)
|
|
|
|
/***********************
|
|
* Pixel data clearing *
|
|
***********************/
|
|
|
|
#ifdef PIXEL_MAX
|
|
DECL_FUNC(clear, const SwsCompMask mask, const SwsCompMask one,
|
|
const SwsCompMask zero)
|
|
{
|
|
#define ONE(N) SWS_COMP_TEST(one, N)
|
|
#define ZERO(N) SWS_COMP_TEST(zero, N)
|
|
const pixel_t cx = ONE(0) ? PIXEL_MAX : ZERO(0) ? 0 : impl->priv.px[0];
|
|
const pixel_t cy = ONE(1) ? PIXEL_MAX : ZERO(1) ? 0 : impl->priv.px[1];
|
|
const pixel_t cz = ONE(2) ? PIXEL_MAX : ZERO(2) ? 0 : impl->priv.px[2];
|
|
const pixel_t cw = ONE(3) ? PIXEL_MAX : ZERO(3) ? 0 : impl->priv.px[3];
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] = cx;
|
|
if (Y) y[i] = cy;
|
|
if (Z) z[i] = cz;
|
|
if (W) w[i] = cw;
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
#endif
|
|
|
|
SWS_FOR(PX, CLEAR, DECL_IMPL, clear)
|
|
SWS_FOR_STRUCT(PX, CLEAR, DECL_ENTRY, .setup = ff_sws_setup_vec4)
|
|
|
|
/*************************
|
|
* Arithmetic operations *
|
|
*************************/
|
|
|
|
DECL_FUNC(scale, const SwsCompMask mask)
|
|
{
|
|
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);
|
|
}
|
|
|
|
DECL_FUNC(add, const SwsCompMask mask)
|
|
{
|
|
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);
|
|
}
|
|
|
|
DECL_FUNC(min, const SwsCompMask mask)
|
|
{
|
|
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_FUNC(max, const SwsCompMask mask)
|
|
{
|
|
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);
|
|
}
|
|
|
|
SWS_FOR(PX, SCALE, DECL_IMPL, scale)
|
|
SWS_FOR(PX, ADD, DECL_IMPL, add)
|
|
SWS_FOR(PX, MIN, DECL_IMPL, min)
|
|
SWS_FOR(PX, MAX, DECL_IMPL, max)
|
|
SWS_FOR_STRUCT(PX, SCALE, DECL_ENTRY, .setup = ff_sws_setup_scalar )
|
|
SWS_FOR_STRUCT(PX, ADD, DECL_ENTRY, .setup = ff_sws_setup_vec4 )
|
|
SWS_FOR_STRUCT(PX, MIN, DECL_ENTRY, .setup = ff_sws_setup_vec4 )
|
|
SWS_FOR_STRUCT(PX, MAX, DECL_ENTRY, .setup = ff_sws_setup_vec4 )
|
|
|
|
/*************
|
|
* Dithering *
|
|
*************/
|
|
|
|
DECL_SETUP(setup_dither, params, out)
|
|
{
|
|
const SwsUOp *uop = params->uop;
|
|
const SwsDitherUOp *dither = &uop->par.dither;
|
|
const int size = 1 << dither->size_log2;
|
|
if (size >= SWS_BLOCK_SIZE) {
|
|
/* No extra padding needed */
|
|
out->priv.ptr = av_refstruct_ref(uop->data.ptr);
|
|
out->free = ff_op_priv_unref;
|
|
return 0;
|
|
}
|
|
|
|
const int stride = FFMAX(size, SWS_BLOCK_SIZE);
|
|
const int height = ff_sws_dither_height(dither);
|
|
pixel_t *matrix = av_malloc(sizeof(pixel_t) * height * stride);
|
|
if (!matrix)
|
|
return AVERROR(ENOMEM);
|
|
out->priv.ptr = matrix;
|
|
out->free = ff_op_priv_free;
|
|
|
|
/* Pad to multiple of block size. We don't need extra padding for the
|
|
* height because ff_sws_dither_height() already includes any padding
|
|
* necessary for the y_offset */
|
|
for (int y = 0; y < height; y++) {
|
|
pixel_t *row = &matrix[y * stride];
|
|
for (int x = 0; x < size; x++)
|
|
row[x] = uop->data.ptr[y * size + x].px;
|
|
for (int x = size; x < stride; x++)
|
|
row[x] = row[x % size];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
DECL_FUNC(dither, const SwsCompMask mask,
|
|
const uint8_t off0, const uint8_t off1,
|
|
const uint8_t off2, const uint8_t off3,
|
|
const uint8_t size_log2)
|
|
{
|
|
const int size = 1 << size_log2;
|
|
const int stride = FFMAX(size, SWS_BLOCK_SIZE);
|
|
|
|
const pixel_t *matrix = impl->priv.ptr;
|
|
matrix += (iter->y & (size - 1)) * stride;
|
|
matrix += (iter->x & (size - 1)) & ~(SWS_BLOCK_SIZE - 1);
|
|
|
|
const pixel_t *const row0 = &matrix[off0 * stride];
|
|
const pixel_t *const row1 = &matrix[off1 * stride];
|
|
const pixel_t *const row2 = &matrix[off2 * stride];
|
|
const pixel_t *const row3 = &matrix[off3 * stride];
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X) x[i] += row0[i];
|
|
if (Y) y[i] += row1[i];
|
|
if (Z) z[i] += row2[i];
|
|
if (W) w[i] += row3[i];
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
SWS_FOR(PX, DITHER, DECL_IMPL, dither)
|
|
SWS_FOR_STRUCT(PX, DITHER, DECL_ENTRY, .setup = fn(setup_dither) )
|
|
|
|
/*********************
|
|
* Linear operations *
|
|
*********************/
|
|
|
|
typedef struct {
|
|
/* Stored in split form for convenience */
|
|
pixel_t m[4][4];
|
|
pixel_t k[4];
|
|
} fn(LinCoeffs);
|
|
|
|
DECL_SETUP(setup_linear, params, out)
|
|
{
|
|
const SwsUOp *uop = params->uop;
|
|
fn(LinCoeffs) c;
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
for (int j = 0; j < 4; j++)
|
|
c.m[i][j] = uop->data.mat4[i][j].px;
|
|
c.k[i] = uop->data.mat4[i][4].px;
|
|
}
|
|
|
|
out->priv.ptr = av_memdup(&c, sizeof(c));
|
|
out->free = ff_op_priv_free;
|
|
return out->priv.ptr ? 0 : AVERROR(ENOMEM);
|
|
}
|
|
|
|
/**
|
|
* 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, const SwsCompMask mask, const uint32_t one, const uint32_t zero)
|
|
{
|
|
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];
|
|
|
|
#define LIN_VAL(I, J, val) \
|
|
((one & SWS_MASK(I, J)) ? (val) : c.m[I][J] * (val))
|
|
|
|
#define LIN_ROW(I, var) do { \
|
|
var[i] = (zero & SWS_MASK(I, 4)) ? 0 : c.k[I]; \
|
|
if (!(zero & SWS_MASK(I, 0))) var[i] += LIN_VAL(I, 0, xx); \
|
|
if (!(zero & SWS_MASK(I, 1))) var[i] += LIN_VAL(I, 1, yy); \
|
|
if (!(zero & SWS_MASK(I, 2))) var[i] += LIN_VAL(I, 2, zz); \
|
|
if (!(zero & SWS_MASK(I, 3))) var[i] += LIN_VAL(I, 3, ww); \
|
|
} while (0)
|
|
|
|
if (X) LIN_ROW(0, x);
|
|
if (Y) LIN_ROW(1, y);
|
|
if (Z) LIN_ROW(2, z);
|
|
if (W) LIN_ROW(3, w);
|
|
}
|
|
|
|
CONTINUE(x, y, z, w);
|
|
}
|
|
|
|
SWS_FOR(PX, LINEAR, DECL_IMPL, linear)
|
|
SWS_FOR_STRUCT(PX, LINEAR, DECL_ENTRY, .setup = fn(setup_linear) )
|
|
|
|
#undef PIXEL_MAX
|
|
#undef PIXEL_SWAP
|
|
#undef pixel_t
|
|
#undef inter_t
|
|
#undef block_t
|
|
#undef PX
|
|
#undef px
|