debayer_cpu.h

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2023, Linaro Ltd
 * Copyright (C) 2023-2025 Red Hat Inc.
 *
 * Authors:
 * Hans de Goede <hdegoede@redhat.com>
 *
 * CPU based debayering header
 */

#pragma once

#include <memory>
#include <stdint.h>
#include <vector>

#include <libcamera/base/object.h>

#include "libcamera/internal/bayer_format.h"

#include "debayer.h"
#include "swstats_cpu.h"

namespace libcamera {

class DebayerCpu : public Debayer, public Object
{
public:
    DebayerCpu(std::unique_ptr<SwStatsCpu> stats);
    ~DebayerCpu();

    int configure(const StreamConfiguration &inputCfg,
              const std::vector<std::reference_wrapper<StreamConfiguration>> &outputCfgs,
              bool ccmEnabled);
    Size patternSize(PixelFormat inputFormat);
    std::vector<PixelFormat> formats(PixelFormat input);
    std::tuple<unsigned int, unsigned int>
    strideAndFrameSize(const PixelFormat &outputFormat, const Size &size);
    void process(uint32_t frame, FrameBuffer *input, FrameBuffer *output, DebayerParams params);
    SizeRange sizes(PixelFormat inputFormat, const Size &inputSize);

    const SharedFD &getStatsFD() { return stats_->getStatsFD(); }

    unsigned int frameSize() { return outputConfig_.frameSize; }

private:
    using debayerFn = void (DebayerCpu::*)(uint8_t *dst, const uint8_t *src[]);

    /* 8-bit raw bayer format */
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer8_BGBG_BGR888(uint8_t *dst, const uint8_t *src[]);
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer8_GRGR_BGR888(uint8_t *dst, const uint8_t *src[]);
    /* unpacked 10-bit raw bayer format */
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer10_BGBG_BGR888(uint8_t *dst, const uint8_t *src[]);
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer10_GRGR_BGR888(uint8_t *dst, const uint8_t *src[]);
    /* unpacked 12-bit raw bayer format */
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer12_BGBG_BGR888(uint8_t *dst, const uint8_t *src[]);
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer12_GRGR_BGR888(uint8_t *dst, const uint8_t *src[]);
    /* CSI-2 packed 10-bit raw bayer format (all the 4 orders) */
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer10P_BGBG_BGR888(uint8_t *dst, const uint8_t *src[]);
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer10P_GRGR_BGR888(uint8_t *dst, const uint8_t *src[]);
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer10P_GBGB_BGR888(uint8_t *dst, const uint8_t *src[]);
    template<bool addAlphaByte, bool ccmEnabled>
    void debayer10P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[]);

    struct DebayerInputConfig {
        Size patternSize;
        unsigned int bpp; /* Memory used per pixel, not precision */
        unsigned int stride;
        std::vector<PixelFormat> outputFormats;
    };

    struct DebayerOutputConfig {
        unsigned int bpp; /* Memory used per pixel, not precision */
        unsigned int stride;
        unsigned int frameSize;
    };

    int getInputConfig(PixelFormat inputFormat, DebayerInputConfig &config);
    int getOutputConfig(PixelFormat outputFormat, DebayerOutputConfig &config);
    int setupStandardBayerOrder(BayerFormat::Order order);
    int setDebayerFunctions(PixelFormat inputFormat,
                PixelFormat outputFormat,
                bool ccmEnabled);
    void setupInputMemcpy(const uint8_t *linePointers[]);
    void shiftLinePointers(const uint8_t *linePointers[], const uint8_t *src);
    void memcpyNextLine(const uint8_t *linePointers[]);
    void process2(const uint8_t *src, uint8_t *dst);
    void process4(const uint8_t *src, uint8_t *dst);

    /* Max. supported Bayer pattern height is 4, debayering this requires 5 lines */
    static constexpr unsigned int kMaxLineBuffers = 5;

    DebayerParams::LookupTable red_;
    DebayerParams::LookupTable green_;
    DebayerParams::LookupTable blue_;
    DebayerParams::CcmLookupTable redCcm_;
    DebayerParams::CcmLookupTable greenCcm_;
    DebayerParams::CcmLookupTable blueCcm_;
    DebayerParams::LookupTable gammaLut_;
    debayerFn debayer0_;
    debayerFn debayer1_;
    debayerFn debayer2_;
    debayerFn debayer3_;
    Rectangle window_;
    DebayerInputConfig inputConfig_;
    DebayerOutputConfig outputConfig_;
    std::unique_ptr<SwStatsCpu> stats_;
    std::vector<uint8_t> lineBuffers_[kMaxLineBuffers];
    unsigned int lineBufferLength_;
    unsigned int lineBufferPadding_;
    unsigned int lineBufferIndex_;
    unsigned int xShift_; /* Offset of 0/1 applied to window_.x */
    bool enableInputMemcpy_;
    bool swapRedBlueGains_;
    unsigned int measuredFrames_;
    int64_t frameProcessTime_;
    /* Skip 30 frames for things to stabilize then measure 30 frames */
    static constexpr unsigned int kFramesToSkip = 30;
    static constexpr unsigned int kLastFrameToMeasure = 60;
};

} /* namespace libcamera */