ops_backend.c

Go to the documentation of this file.

/**
 * 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"
 
/**
 * We want to disable FP contraction because this is a reference backend that
 * establishes a bit-exact reference result.
 */
#ifdef __clang__
#pragma STDC FP_CONTRACT OFF
#elif AV_GCC_VERSION_AT_LEAST(4, 8)
#pragma GCC optimize ("fp-contract=off")
#elif defined(_MSC_VER)
#pragma fp_contract (off)
#endif
 
#if AV_GCC_VERSION_AT_LEAST(4, 4)
#pragma GCC optimize ("finite-math-only")
#endif
 
/* Array-based reference implementation */
 
#ifndef SWS_BLOCK_SIZE
#  define SWS_BLOCK_SIZE 32
#endif
 
typedef  uint8_t  u8block_t[SWS_BLOCK_SIZE];
typedef uint16_t u16block_t[SWS_BLOCK_SIZE];
typedef uint32_t u32block_t[SWS_BLOCK_SIZE];
typedef    float f32block_t[SWS_BLOCK_SIZE];
 
#define BIT_DEPTH 8
# include "ops_tmpl_int.c"
#undef BIT_DEPTH
 
#define BIT_DEPTH 16
# include "ops_tmpl_int.c"
#undef BIT_DEPTH
 
#define BIT_DEPTH 32
# include "ops_tmpl_int.c"
# include "ops_tmpl_float.c"
#undef BIT_DEPTH
 
static const SwsOpTable *const tables[] = {
    &bitfn(op_table_int,    u8),
    &bitfn(op_table_int,   u16),
    &bitfn(op_table_int,   u32),
    &bitfn(op_table_float, f32),
};
 
static int compile(SwsContext *ctx, SwsOpList *ops, SwsCompiledOp *out)
{
    int ret;
 
    SwsOpChain *chain = ff_sws_op_chain_alloc();
    if (!chain)
        return AVERROR(ENOMEM);
 
    av_assert0(ops->num_ops > 0);
    const SwsPixelType read_type = ops->ops[0].type;
 
    for (int i = 0; i < ops->num_ops; i++) {
        ret = ff_sws_op_compile_tables(ctx, tables, FF_ARRAY_ELEMS(tables),
                                       ops, i, SWS_BLOCK_SIZE, chain);
        if (ret < 0) {
            av_log(ctx, AV_LOG_TRACE, "Failed to compile op %d\n", i);
            ff_sws_op_chain_free(chain);
            return ret;
        }
    }
 
    *out = (SwsCompiledOp) {
        .slice_align = 1,
        .block_size  = SWS_BLOCK_SIZE,
        .cpu_flags   = chain->cpu_flags,
        .over_read   = chain->over_read,
        .over_write  = chain->over_write,
        .priv        = chain,
        .free        = ff_sws_op_chain_free_cb,
    };
 
    switch (read_type) {
    case SWS_PIXEL_U8:  out->func = process_u8;  break;
    case SWS_PIXEL_U16: out->func = process_u16; break;
    case SWS_PIXEL_U32: out->func = process_u32; break;
    case SWS_PIXEL_F32: out->func = process_f32; break;
    default: av_unreachable("Invalid pixel type!");
    }
 
    return 0;
}
 
const SwsOpBackend backend_c = {
    .name       = "c",
    .compile    = compile,
    .hw_format  = AV_PIX_FMT_NONE,
};