You've already forked FFmpeg
mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2025-11-23 21:54:53 +02:00
604 lines
20 KiB
C
604 lines
20 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 "libavutil/bswap.h"
|
|
|
|
#include "ops_backend.h"
|
|
|
|
#ifndef BIT_DEPTH
|
|
# define BIT_DEPTH 8
|
|
#endif
|
|
|
|
#if BIT_DEPTH == 32
|
|
# define PIXEL_TYPE SWS_PIXEL_U32
|
|
# define PIXEL_MAX 0xFFFFFFFFu
|
|
# define SWAP_BYTES av_bswap32
|
|
# define pixel_t uint32_t
|
|
# define block_t u32block_t
|
|
# define px u32
|
|
#elif BIT_DEPTH == 16
|
|
# define PIXEL_TYPE SWS_PIXEL_U16
|
|
# define PIXEL_MAX 0xFFFFu
|
|
# define SWAP_BYTES av_bswap16
|
|
# define pixel_t uint16_t
|
|
# define block_t u16block_t
|
|
# define px u16
|
|
#elif BIT_DEPTH == 8
|
|
# define PIXEL_TYPE SWS_PIXEL_U8
|
|
# define PIXEL_MAX 0xFFu
|
|
# define pixel_t uint8_t
|
|
# define block_t u8block_t
|
|
# define px u8
|
|
#else
|
|
# error Invalid BIT_DEPTH
|
|
#endif
|
|
|
|
#define IS_FLOAT 0
|
|
#define FMT_CHAR u
|
|
#define PIXEL_MIN 0
|
|
#include "ops_tmpl_common.c"
|
|
|
|
DECL_READ(read_planar, const int elems)
|
|
{
|
|
block_t x, y, z, w;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
x[i] = in0[i];
|
|
if (elems > 1)
|
|
y[i] = in1[i];
|
|
if (elems > 2)
|
|
z[i] = in2[i];
|
|
if (elems > 3)
|
|
w[i] = in3[i];
|
|
}
|
|
|
|
CONTINUE(block_t, x, y, z, w);
|
|
}
|
|
|
|
DECL_READ(read_packed, const int elems)
|
|
{
|
|
block_t x, y, z, w;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
x[i] = in0[elems * i + 0];
|
|
if (elems > 1)
|
|
y[i] = in0[elems * i + 1];
|
|
if (elems > 2)
|
|
z[i] = in0[elems * i + 2];
|
|
if (elems > 3)
|
|
w[i] = in0[elems * i + 3];
|
|
}
|
|
|
|
CONTINUE(block_t, x, y, z, w);
|
|
}
|
|
|
|
DECL_WRITE(write_planar, const int elems)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
out0[i] = x[i];
|
|
if (elems > 1)
|
|
out1[i] = y[i];
|
|
if (elems > 2)
|
|
out2[i] = z[i];
|
|
if (elems > 3)
|
|
out3[i] = w[i];
|
|
}
|
|
}
|
|
|
|
DECL_WRITE(write_packed, const int elems)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
out0[elems * i + 0] = x[i];
|
|
if (elems > 1)
|
|
out0[elems * i + 1] = y[i];
|
|
if (elems > 2)
|
|
out0[elems * i + 2] = z[i];
|
|
if (elems > 3)
|
|
out0[elems * i + 3] = w[i];
|
|
}
|
|
}
|
|
|
|
#define WRAP_READ(FUNC, ELEMS, FRAC, PACKED) \
|
|
DECL_IMPL_READ(FUNC##ELEMS) \
|
|
{ \
|
|
CALL_READ(FUNC, ELEMS); \
|
|
for (int i = 0; i < (PACKED ? 1 : ELEMS); i++) \
|
|
iter->in[i] += sizeof(block_t) * (PACKED ? ELEMS : 1) >> FRAC; \
|
|
} \
|
|
\
|
|
DECL_ENTRY(FUNC##ELEMS, \
|
|
.op = SWS_OP_READ, \
|
|
.rw = { \
|
|
.elems = ELEMS, \
|
|
.packed = PACKED, \
|
|
.frac = FRAC, \
|
|
}, \
|
|
);
|
|
|
|
WRAP_READ(read_planar, 1, 0, false)
|
|
WRAP_READ(read_planar, 2, 0, false)
|
|
WRAP_READ(read_planar, 3, 0, false)
|
|
WRAP_READ(read_planar, 4, 0, false)
|
|
WRAP_READ(read_packed, 2, 0, true)
|
|
WRAP_READ(read_packed, 3, 0, true)
|
|
WRAP_READ(read_packed, 4, 0, true)
|
|
|
|
#define WRAP_WRITE(FUNC, ELEMS, FRAC, PACKED) \
|
|
DECL_IMPL(FUNC##ELEMS) \
|
|
{ \
|
|
CALL_WRITE(FUNC, ELEMS); \
|
|
for (int i = 0; i < (PACKED ? 1 : ELEMS); i++) \
|
|
iter->out[i] += sizeof(block_t) * (PACKED ? ELEMS : 1) >> FRAC; \
|
|
} \
|
|
\
|
|
DECL_ENTRY(FUNC##ELEMS, \
|
|
.op = SWS_OP_WRITE, \
|
|
.rw = { \
|
|
.elems = ELEMS, \
|
|
.packed = PACKED, \
|
|
.frac = FRAC, \
|
|
}, \
|
|
);
|
|
|
|
WRAP_WRITE(write_planar, 1, 0, false)
|
|
WRAP_WRITE(write_planar, 2, 0, false)
|
|
WRAP_WRITE(write_planar, 3, 0, false)
|
|
WRAP_WRITE(write_planar, 4, 0, false)
|
|
WRAP_WRITE(write_packed, 2, 0, true)
|
|
WRAP_WRITE(write_packed, 3, 0, true)
|
|
WRAP_WRITE(write_packed, 4, 0, true)
|
|
|
|
#if BIT_DEPTH == 8
|
|
DECL_READ(read_nibbles, const int elems)
|
|
{
|
|
block_t x, y, z, w;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i += 2) {
|
|
const pixel_t val = ((const pixel_t *) in0)[i >> 1];
|
|
x[i + 0] = val >> 4; /* high nibble */
|
|
x[i + 1] = val & 0xF; /* low nibble */
|
|
}
|
|
|
|
CONTINUE(block_t, x, y, z, w);
|
|
}
|
|
|
|
DECL_READ(read_bits, const int elems)
|
|
{
|
|
block_t x, y, z, w;
|
|
|
|
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;
|
|
}
|
|
|
|
CONTINUE(block_t, x, y, z, w);
|
|
}
|
|
|
|
WRAP_READ(read_nibbles, 1, 1, false)
|
|
WRAP_READ(read_bits, 1, 3, false)
|
|
|
|
DECL_WRITE(write_nibbles, const int elems)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i += 2)
|
|
out0[i >> 1] = x[i] << 4 | x[i + 1];
|
|
}
|
|
|
|
DECL_WRITE(write_bits, const int elems)
|
|
{
|
|
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];
|
|
}
|
|
}
|
|
|
|
WRAP_WRITE(write_nibbles, 1, 1, false)
|
|
WRAP_WRITE(write_bits, 1, 3, false)
|
|
#endif /* BIT_DEPTH == 8 */
|
|
|
|
#ifdef SWAP_BYTES
|
|
DECL_PATTERN(swap_bytes)
|
|
{
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X)
|
|
x[i] = SWAP_BYTES(x[i]);
|
|
if (Y)
|
|
y[i] = SWAP_BYTES(y[i]);
|
|
if (Z)
|
|
z[i] = SWAP_BYTES(z[i]);
|
|
if (W)
|
|
w[i] = SWAP_BYTES(w[i]);
|
|
}
|
|
|
|
CONTINUE(block_t, x, y, z, w);
|
|
}
|
|
|
|
WRAP_COMMON_PATTERNS(swap_bytes, .op = SWS_OP_SWAP_BYTES);
|
|
#endif /* SWAP_BYTES */
|
|
|
|
#if BIT_DEPTH == 8
|
|
DECL_PATTERN(expand16)
|
|
{
|
|
u16block_t x16, y16, z16, w16;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
if (X)
|
|
x16[i] = x[i] << 8 | x[i];
|
|
if (Y)
|
|
y16[i] = y[i] << 8 | y[i];
|
|
if (Z)
|
|
z16[i] = z[i] << 8 | z[i];
|
|
if (W)
|
|
w16[i] = w[i] << 8 | w[i];
|
|
}
|
|
|
|
CONTINUE(u16block_t, x16, y16, z16, w16);
|
|
}
|
|
|
|
WRAP_COMMON_PATTERNS(expand16,
|
|
.op = SWS_OP_CONVERT,
|
|
.convert.to = SWS_PIXEL_U16,
|
|
.convert.expand = true,
|
|
);
|
|
|
|
DECL_PATTERN(expand32)
|
|
{
|
|
u32block_t x32, y32, z32, w32;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
x32[i] = x[i] << 24 | x[i] << 16 | x[i] << 8 | x[i];
|
|
y32[i] = y[i] << 24 | y[i] << 16 | y[i] << 8 | y[i];
|
|
z32[i] = z[i] << 24 | z[i] << 16 | z[i] << 8 | z[i];
|
|
w32[i] = w[i] << 24 | w[i] << 16 | w[i] << 8 | w[i];
|
|
}
|
|
|
|
CONTINUE(u32block_t, x32, y32, z32, w32);
|
|
}
|
|
|
|
WRAP_COMMON_PATTERNS(expand32,
|
|
.op = SWS_OP_CONVERT,
|
|
.convert.to = SWS_PIXEL_U32,
|
|
.convert.expand = true,
|
|
);
|
|
#endif
|
|
|
|
#define WRAP_PACK_UNPACK(X, Y, Z, W) \
|
|
inline DECL_IMPL(pack_##X##Y##Z##W) \
|
|
{ \
|
|
SWS_LOOP \
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) { \
|
|
x[i] = x[i] << (Y+Z+W); \
|
|
if (Y) \
|
|
x[i] |= y[i] << (Z+W); \
|
|
if (Z) \
|
|
x[i] |= z[i] << W; \
|
|
if (W) \
|
|
x[i] |= w[i]; \
|
|
} \
|
|
\
|
|
CONTINUE(block_t, x, y, z, w); \
|
|
} \
|
|
\
|
|
DECL_ENTRY(pack_##X##Y##Z##W, \
|
|
.op = SWS_OP_PACK, \
|
|
.pack.pattern = { X, Y, Z, W }, \
|
|
); \
|
|
\
|
|
inline DECL_IMPL(unpack_##X##Y##Z##W) \
|
|
{ \
|
|
SWS_LOOP \
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) { \
|
|
const pixel_t val = x[i]; \
|
|
x[i] = val >> (Y+Z+W); \
|
|
if (Y) \
|
|
y[i] = (val >> (Z+W)) & ((1 << Y) - 1); \
|
|
if (Z) \
|
|
z[i] = (val >> W) & ((1 << Z) - 1); \
|
|
if (W) \
|
|
w[i] = val & ((1 << W) - 1); \
|
|
} \
|
|
\
|
|
CONTINUE(block_t, x, y, z, w); \
|
|
} \
|
|
\
|
|
DECL_ENTRY(unpack_##X##Y##Z##W, \
|
|
.op = SWS_OP_UNPACK, \
|
|
.pack.pattern = { X, Y, Z, W }, \
|
|
);
|
|
|
|
WRAP_PACK_UNPACK( 3, 3, 2, 0)
|
|
WRAP_PACK_UNPACK( 2, 3, 3, 0)
|
|
WRAP_PACK_UNPACK( 1, 2, 1, 0)
|
|
WRAP_PACK_UNPACK( 5, 6, 5, 0)
|
|
WRAP_PACK_UNPACK( 5, 5, 5, 0)
|
|
WRAP_PACK_UNPACK( 4, 4, 4, 0)
|
|
WRAP_PACK_UNPACK( 2, 10, 10, 10)
|
|
WRAP_PACK_UNPACK(10, 10, 10, 2)
|
|
|
|
#if BIT_DEPTH != 8
|
|
DECL_PATTERN(lshift)
|
|
{
|
|
const uint8_t amount = impl->priv.u8[0];
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
x[i] <<= amount;
|
|
y[i] <<= amount;
|
|
z[i] <<= amount;
|
|
w[i] <<= amount;
|
|
}
|
|
|
|
CONTINUE(block_t, x, y, z, w);
|
|
}
|
|
|
|
DECL_PATTERN(rshift)
|
|
{
|
|
const uint8_t amount = impl->priv.u8[0];
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
x[i] >>= amount;
|
|
y[i] >>= amount;
|
|
z[i] >>= amount;
|
|
w[i] >>= amount;
|
|
}
|
|
|
|
CONTINUE(block_t, x, y, z, w);
|
|
}
|
|
|
|
WRAP_COMMON_PATTERNS(lshift,
|
|
.op = SWS_OP_LSHIFT,
|
|
.setup = ff_sws_setup_u8,
|
|
.flexible = true,
|
|
);
|
|
|
|
WRAP_COMMON_PATTERNS(rshift,
|
|
.op = SWS_OP_RSHIFT,
|
|
.setup = ff_sws_setup_u8,
|
|
.flexible = true,
|
|
);
|
|
#endif /* BIT_DEPTH != 8 */
|
|
|
|
DECL_PATTERN(convert_float)
|
|
{
|
|
f32block_t xf, yf, zf, wf;
|
|
|
|
SWS_LOOP
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
|
|
xf[i] = x[i];
|
|
yf[i] = y[i];
|
|
zf[i] = z[i];
|
|
wf[i] = w[i];
|
|
}
|
|
|
|
CONTINUE(f32block_t, xf, yf, zf, wf);
|
|
}
|
|
|
|
WRAP_COMMON_PATTERNS(convert_float,
|
|
.op = SWS_OP_CONVERT,
|
|
.convert.to = SWS_PIXEL_F32,
|
|
);
|
|
|
|
/**
|
|
* Swizzle by directly swapping the order of arguments to the continuation.
|
|
* Note that this is only safe to do if no arguments are duplicated.
|
|
*/
|
|
#define DECL_SWIZZLE(X, Y, Z, W) \
|
|
static SWS_FUNC void \
|
|
fn(swizzle_##X##Y##Z##W)(SwsOpIter *restrict iter, \
|
|
const SwsOpImpl *restrict impl, \
|
|
block_t c0, block_t c1, block_t c2, block_t c3) \
|
|
{ \
|
|
CONTINUE(block_t, c##X, c##Y, c##Z, c##W); \
|
|
} \
|
|
\
|
|
DECL_ENTRY(swizzle_##X##Y##Z##W, \
|
|
.op = SWS_OP_SWIZZLE, \
|
|
.swizzle.in = { X, Y, Z, W }, \
|
|
);
|
|
|
|
DECL_SWIZZLE(3, 0, 1, 2)
|
|
DECL_SWIZZLE(3, 0, 2, 1)
|
|
DECL_SWIZZLE(2, 1, 0, 3)
|
|
DECL_SWIZZLE(3, 2, 1, 0)
|
|
DECL_SWIZZLE(3, 1, 0, 2)
|
|
DECL_SWIZZLE(3, 2, 0, 1)
|
|
DECL_SWIZZLE(1, 2, 0, 3)
|
|
DECL_SWIZZLE(1, 0, 2, 3)
|
|
DECL_SWIZZLE(2, 0, 1, 3)
|
|
DECL_SWIZZLE(2, 3, 1, 0)
|
|
DECL_SWIZZLE(2, 1, 3, 0)
|
|
DECL_SWIZZLE(1, 2, 3, 0)
|
|
DECL_SWIZZLE(1, 3, 2, 0)
|
|
DECL_SWIZZLE(0, 2, 1, 3)
|
|
DECL_SWIZZLE(0, 2, 3, 1)
|
|
DECL_SWIZZLE(0, 3, 1, 2)
|
|
DECL_SWIZZLE(3, 1, 2, 0)
|
|
DECL_SWIZZLE(0, 3, 2, 1)
|
|
|
|
/* Broadcast luma -> rgb (only used for y(a) -> rgb(a)) */
|
|
#define DECL_EXPAND_LUMA(X, W, T0, T1) \
|
|
static SWS_FUNC void \
|
|
fn(expand_luma_##X##W)(SwsOpIter *restrict iter, \
|
|
const SwsOpImpl *restrict impl, \
|
|
block_t c0, block_t c1, block_t c2, block_t c3) \
|
|
{ \
|
|
SWS_LOOP \
|
|
for (int i = 0; i < SWS_BLOCK_SIZE; i++) \
|
|
T0[i] = T1[i] = c0[i]; \
|
|
\
|
|
CONTINUE(block_t, c##X, T0, T1, c##W); \
|
|
} \
|
|
\
|
|
DECL_ENTRY(expand_luma_##X##W, \
|
|
.op = SWS_OP_SWIZZLE, \
|
|
.swizzle.in = { X, 0, 0, W }, \
|
|
);
|
|
|
|
DECL_EXPAND_LUMA(0, 3, c1, c2)
|
|
DECL_EXPAND_LUMA(3, 0, c1, c2)
|
|
DECL_EXPAND_LUMA(1, 0, c2, c3)
|
|
DECL_EXPAND_LUMA(0, 1, c2, c3)
|
|
|
|
static const SwsOpTable fn(op_table_int) = {
|
|
.block_size = SWS_BLOCK_SIZE,
|
|
.entries = {
|
|
&fn(op_read_planar1),
|
|
&fn(op_read_planar2),
|
|
&fn(op_read_planar3),
|
|
&fn(op_read_planar4),
|
|
&fn(op_read_packed2),
|
|
&fn(op_read_packed3),
|
|
&fn(op_read_packed4),
|
|
|
|
&fn(op_write_planar1),
|
|
&fn(op_write_planar2),
|
|
&fn(op_write_planar3),
|
|
&fn(op_write_planar4),
|
|
&fn(op_write_packed2),
|
|
&fn(op_write_packed3),
|
|
&fn(op_write_packed4),
|
|
|
|
#if BIT_DEPTH == 8
|
|
&fn(op_read_bits1),
|
|
&fn(op_read_nibbles1),
|
|
&fn(op_write_bits1),
|
|
&fn(op_write_nibbles1),
|
|
|
|
&fn(op_pack_1210),
|
|
&fn(op_pack_2330),
|
|
&fn(op_pack_3320),
|
|
|
|
&fn(op_unpack_1210),
|
|
&fn(op_unpack_2330),
|
|
&fn(op_unpack_3320),
|
|
|
|
REF_COMMON_PATTERNS(expand16),
|
|
REF_COMMON_PATTERNS(expand32),
|
|
#elif BIT_DEPTH == 16
|
|
&fn(op_pack_4440),
|
|
&fn(op_pack_5550),
|
|
&fn(op_pack_5650),
|
|
&fn(op_unpack_4440),
|
|
&fn(op_unpack_5550),
|
|
&fn(op_unpack_5650),
|
|
#elif BIT_DEPTH == 32
|
|
&fn(op_pack_2101010),
|
|
&fn(op_pack_1010102),
|
|
&fn(op_unpack_2101010),
|
|
&fn(op_unpack_1010102),
|
|
#endif
|
|
|
|
#ifdef SWAP_BYTES
|
|
REF_COMMON_PATTERNS(swap_bytes),
|
|
#endif
|
|
|
|
REF_COMMON_PATTERNS(min),
|
|
REF_COMMON_PATTERNS(max),
|
|
REF_COMMON_PATTERNS(scale),
|
|
REF_COMMON_PATTERNS(convert_float),
|
|
|
|
&fn(op_clear_1110),
|
|
&fn(op_clear_0111),
|
|
&fn(op_clear_0011),
|
|
&fn(op_clear_1001),
|
|
&fn(op_clear_1100),
|
|
&fn(op_clear_0101),
|
|
&fn(op_clear_1010),
|
|
&fn(op_clear_1000),
|
|
&fn(op_clear_0100),
|
|
&fn(op_clear_0010),
|
|
|
|
&fn(op_swizzle_3012),
|
|
&fn(op_swizzle_3021),
|
|
&fn(op_swizzle_2103),
|
|
&fn(op_swizzle_3210),
|
|
&fn(op_swizzle_3102),
|
|
&fn(op_swizzle_3201),
|
|
&fn(op_swizzle_1203),
|
|
&fn(op_swizzle_1023),
|
|
&fn(op_swizzle_2013),
|
|
&fn(op_swizzle_2310),
|
|
&fn(op_swizzle_2130),
|
|
&fn(op_swizzle_1230),
|
|
&fn(op_swizzle_1320),
|
|
&fn(op_swizzle_0213),
|
|
&fn(op_swizzle_0231),
|
|
&fn(op_swizzle_0312),
|
|
&fn(op_swizzle_3120),
|
|
&fn(op_swizzle_0321),
|
|
|
|
&fn(op_expand_luma_03),
|
|
&fn(op_expand_luma_30),
|
|
&fn(op_expand_luma_10),
|
|
&fn(op_expand_luma_01),
|
|
|
|
#if BIT_DEPTH != 8
|
|
REF_COMMON_PATTERNS(lshift),
|
|
REF_COMMON_PATTERNS(rshift),
|
|
REF_COMMON_PATTERNS(convert_uint8),
|
|
#endif /* BIT_DEPTH != 8 */
|
|
|
|
#if BIT_DEPTH != 16
|
|
REF_COMMON_PATTERNS(convert_uint16),
|
|
#endif
|
|
#if BIT_DEPTH != 32
|
|
REF_COMMON_PATTERNS(convert_uint32),
|
|
#endif
|
|
|
|
NULL
|
|
},
|
|
};
|
|
|
|
#undef PIXEL_TYPE
|
|
#undef PIXEL_MAX
|
|
#undef PIXEL_MIN
|
|
#undef SWAP_BYTES
|
|
#undef pixel_t
|
|
#undef block_t
|
|
#undef px
|
|
|
|
#undef FMT_CHAR
|
|
#undef IS_FLOAT
|