diff options
Diffstat (limited to 'subprojects/pixpat/pixpat-native/src')
31 files changed, 4544 insertions, 0 deletions
diff --git a/subprojects/pixpat/pixpat-native/src/color.h b/subprojects/pixpat/pixpat-native/src/color.h new file mode 100644 index 0000000..16dfb7d --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/color.h @@ -0,0 +1,199 @@ +#pragma once + +#include <algorithm> +#include <cstdint> +#include <cstring> + +#include "layout.h" + +namespace pixpat +{ + +// BT.601 / BT.709 / BT.2020 × Limited / Full range, dispatched at +// runtime via a small `ColorCoeffs` struct that the caller hoists out +// of the per-pixel loop. The convert and pattern entry points compute +// `coeffs_for(spec)` once before the stripe loop, then pass the +// resulting struct into every `ColorXfm::apply()` in the inner loop. +// This avoids per-pixel matrix branching and also the alternative of +// a 6×-instantiated template (would push the hot pivot from 121 to +// 726 `Converter` bodies). The coefficient values are loop-invariant +// broadcast scalars, so the compiler vectorizes the inner loop with +// vbroadcastss + vmulps in place of constant folds. +// +// Math runs in float. + +enum class Rec : uint8_t { BT601, BT709, BT2020 }; +enum class Range : uint8_t { Limited, Full }; + +struct ColorSpec { + Rec rec; + Range range; + constexpr bool operator==(const ColorSpec&) const = default; +}; + +inline constexpr ColorSpec kDefaultColorSpec{ Rec::BT601, Range::Limited }; + +struct ColorCoeffs { + // RGB->YUV + float kr, kg, kb; + float y_scale, y_offset; + float c_scale, c_offset; + float u_factor, v_factor; + // YUV->RGB + float y_inv, c_inv; + float gu, gv, ru, bv; + // normalized 16-bit scale (kNormMax in float, plus its inverse) + float norm_scale, norm_inv_scale; +}; + +namespace detail +{ +constexpr ColorCoeffs make_coeffs(float kr, float kg, float kb, bool full) noexcept +{ + const float y_min = full ? 0.0f : 16.0f / 255.0f; + const float y_max = full ? 1.0f : 235.0f / 255.0f; + const float c_min = full ? 0.0f : 16.0f / 255.0f; + const float c_max = full ? 1.0f : 240.0f / 255.0f; + + const float y_scale = y_max - y_min; + const float y_offset = y_min; + const float c_scale = c_max - c_min; + const float c_offset = (c_max + c_min) * 0.5f; + + const float u_factor = 1.0f / (2.0f * (1.0f - kb)); + const float v_factor = 1.0f / (2.0f * (1.0f - kr)); + const float y_inv = 1.0f / y_scale; + const float c_inv = 1.0f / c_scale; + const float gu = -2.0f * (1.0f - kb) * kb / kg; + const float gv = -2.0f * (1.0f - kr) * kr / kg; + const float ru = 2.0f * (1.0f - kr); + const float bv = 2.0f * (1.0f - kb); + + const float norm_scale = float(kNormMax); + const float norm_inv_scale = 1.0f / norm_scale; + + return ColorCoeffs{ + kr, kg, kb, + y_scale, y_offset, + c_scale, c_offset, + u_factor, v_factor, + y_inv, c_inv, + gu, gv, ru, bv, + norm_scale, norm_inv_scale, + }; +} +} // namespace detail + +constexpr ColorCoeffs coeffs_for(ColorSpec spec) noexcept +{ + const bool full = spec.range == Range::Full; + switch (spec.rec) { + case Rec::BT601: return detail::make_coeffs(0.299f, 0.587f, 0.114f, full); + case Rec::BT2020: return detail::make_coeffs(0.2627f, 0.6780f, 0.0593f, full); + default: return detail::make_coeffs(0.2126f, 0.7152f, 0.0722f, full); + } +} + +template <typename SrcPix, typename DstPix> +struct ColorXfm; + +template <> +struct ColorXfm<RGB16, RGB16> { + static constexpr RGB16 apply(RGB16 p) noexcept { + return p; + } + static constexpr RGB16 apply(RGB16 p, const ColorCoeffs&) noexcept { + return p; + } +}; + +template <> +struct ColorXfm<YUV16, YUV16> { + static constexpr YUV16 apply(YUV16 p) noexcept { + return p; + } + static constexpr YUV16 apply(YUV16 p, const ColorCoeffs&) noexcept { + return p; + } +}; + +// Cross-color-kind conversions reset `a` to kNormMax (sinks with X +// write 0; sinks with A see fully opaque pixels). Within the same +// color kind, identity ColorXfm propagates `a` unchanged. +template <> +struct ColorXfm<RGB16, YUV16> { + static YUV16 apply(RGB16 rgb, const ColorCoeffs& c) noexcept + { + const float r = float(rgb.r) * c.norm_inv_scale; + const float g = float(rgb.g) * c.norm_inv_scale; + const float b = float(rgb.b) * c.norm_inv_scale; + + const float yp = c.kr * r + c.kg * g + c.kb * b; + const float u = (b - yp) * c.u_factor; + const float v = (r - yp) * c.v_factor; + + // No clamp on RGB→YUV: for any uint16_t (RGB) input the + // output Y/U/V is structurally in [0, 1] (limited-range + // chroma stays within [c_min, c_max] ⊂ [0, 1]). The +0.5 + // rounds half-up before the integer cast. + return YUV16{ + uint16_t((yp * c.y_scale + c.y_offset) * c.norm_scale + 0.5f), + uint16_t((u * c.c_scale + c.c_offset) * c.norm_scale + 0.5f), + uint16_t((v * c.c_scale + c.c_offset) * c.norm_scale + 0.5f), + kNormMax, + }; + } +}; + +template <> +struct ColorXfm<YUV16, RGB16> { + static RGB16 apply(YUV16 yuv, const ColorCoeffs& c) noexcept + { + const float yp = (float(yuv.y) * c.norm_inv_scale - c.y_offset) * c.y_inv; + const float u = (float(yuv.u) * c.norm_inv_scale - c.c_offset) * c.c_inv; + const float v = (float(yuv.v) * c.norm_inv_scale - c.c_offset) * c.c_inv; + + const float r = yp + c.ru * v; + const float g = yp + c.gu * u + c.gv * v; + const float b = yp + c.bv * u; + + // Clamp on YUV→RGB: the inverse matrix produces out-of-range + // RGB for some valid YUV inputs. Written as min/max so it + // vectorizes to vminps/vmaxps; std::clamp can defeat that. + auto pack = [&](float x) -> uint16_t { + x = x * c.norm_scale + 0.5f; + x = std::min(std::max(x, 0.0f), c.norm_scale); + return uint16_t(x); + }; + + return RGB16{ + pack(r), pack(g), pack(b), + kNormMax, + }; + } +}; + +// In-place cross-color-kind passes over a normalized line buffer. +// RGB16 and YUV16 are both 4 uint16_t with identical layout, so we +// can memcpy through the same buffer pixel-by-pixel without aliasing. +inline void norm_rgb_to_yuv(uint8_t* buf, size_t n, const ColorCoeffs& c) noexcept +{ + for (size_t i = 0; i < n; ++i) { + RGB16 rgb; + std::memcpy(&rgb, buf + i * sizeof(RGB16), sizeof(RGB16)); + YUV16 yuv = ColorXfm<RGB16, YUV16>::apply(rgb, c); + std::memcpy(buf + i * sizeof(YUV16), &yuv, sizeof(YUV16)); + } +} + +inline void norm_yuv_to_rgb(uint8_t* buf, size_t n, const ColorCoeffs& c) noexcept +{ + for (size_t i = 0; i < n; ++i) { + YUV16 yuv; + std::memcpy(&yuv, buf + i * sizeof(YUV16), sizeof(YUV16)); + RGB16 rgb = ColorXfm<YUV16, RGB16>::apply(yuv, c); + std::memcpy(buf + i * sizeof(RGB16), &rgb, sizeof(RGB16)); + } +} + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/error.h b/subprojects/pixpat/pixpat-native/src/error.h new file mode 100644 index 0000000..83a3596 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/error.h @@ -0,0 +1,16 @@ +#pragma once + +#include <stdexcept> + +namespace pixpat +{ + +struct error : std::runtime_error { + using std::runtime_error::runtime_error; +}; + +struct invalid_argument : error { + using error::error; +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/format_catalog.h b/subprojects/pixpat/pixpat-native/src/format_catalog.h new file mode 100644 index 0000000..287d773 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/format_catalog.h @@ -0,0 +1,140 @@ +#pragma once + +// Catalog of every pixel format the C++ side handles. The X-macro is a +// flat list of names: +// +// X(name) +// +// `name` is the canonical format identifier — both an internal FormatId +// enum entry and the public string accepted by pixpat_buffer::format. +// Each name resolves to a struct in `pixpat::formats::` (defined under +// pixpat-native/src/formats/) that carries: +// +// - the layout (subsampling, planes, components) +// - nested `Source` / `Sink` aliases for the matching I/O templates +// +// Adding a format = a row here AND a struct in the right +// pixpat-native/src/formats/*.h. The codegen +// (pixpat-native/codegen/gen_pixpat.py) parses this X-macro to learn +// the format set; pixpat.cpp re-expands it to build s_format_info via +// `formats::name::Source` / `formats::name::Sink`. +// +// FormatId is internal — the public C ABI deals in format names only. + +#include <cstddef> + +namespace pixpat +{ + +#define PIXPAT_FORMAT_LIST(X) \ + X(XRGB8888) \ + X(ARGB8888) \ + X(XBGR8888) \ + X(ABGR8888) \ + X(RGBX8888) \ + X(RGBA8888) \ + X(BGRX8888) \ + X(BGRA8888) \ + X(RGB888) \ + X(BGR888) \ + X(RGB332) \ + X(RGB565) \ + X(BGR565) \ + X(XRGB1555) \ + X(ARGB1555) \ + X(XBGR1555) \ + X(ABGR1555) \ + X(XRGB4444) \ + X(ARGB4444) \ + X(XBGR4444) \ + X(ABGR4444) \ + X(RGBX4444) \ + X(RGBA4444) \ + X(XRGB2101010) \ + X(ARGB2101010) \ + X(XBGR2101010) \ + X(ABGR2101010) \ + X(RGBX1010102) \ + X(RGBA1010102) \ + X(BGRX1010102) \ + X(BGRA1010102) \ + X(ABGR16161616) \ + X(NV12) \ + X(NV21) \ + X(NV16) \ + X(NV61) \ + X(P030) \ + X(P230) \ + X(YUV420) \ + X(YVU420) \ + X(YUV422) \ + X(YVU422) \ + X(YUV444) \ + X(YVU444) \ + X(T430) \ + X(VUY888) \ + X(XVUY8888) \ + X(XVUY2101010) \ + X(AVUY16161616) \ + X(YUYV) \ + X(YVYU) \ + X(UYVY) \ + X(VYUY) \ + X(Y210) \ + X(Y212) \ + X(Y216) \ + X(Y8) \ + X(Y10) \ + X(Y12) \ + X(Y16) \ + X(R8) \ + X(XYYY2101010) \ + X(Y10P) \ + X(Y12P) \ + X(SRGGB8) \ + X(SBGGR8) \ + X(SGRBG8) \ + X(SGBRG8) \ + X(SRGGB10) \ + X(SBGGR10) \ + X(SGRBG10) \ + X(SGBRG10) \ + X(SRGGB12) \ + X(SBGGR12) \ + X(SGRBG12) \ + X(SGBRG12) \ + X(SRGGB16) \ + X(SBGGR16) \ + X(SGRBG16) \ + X(SGBRG16) \ + X(SRGGB10P) \ + X(SBGGR10P) \ + X(SGRBG10P) \ + X(SGBRG10P) \ + X(SRGGB12P) \ + X(SBGGR12P) \ + X(SGRBG12P) \ + X(SGBRG12P) + +enum class FormatId { +#define X(name) name, + PIXPAT_FORMAT_LIST(X) +#undef X + Unknown, +}; + +struct FormatEntry { + const char* name; + FormatId id; +}; + +inline constexpr FormatEntry s_format_table[] = { +#define X(name) { #name, FormatId::name }, + PIXPAT_FORMAT_LIST(X) +#undef X +}; + +inline constexpr size_t s_format_catalog_count = + sizeof(s_format_table) / sizeof(s_format_table[0]); + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/formats.h b/subprojects/pixpat/pixpat-native/src/formats.h new file mode 100644 index 0000000..68bdeec --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/formats.h @@ -0,0 +1,13 @@ +#pragma once + +// Aggregator: every named layout the X-macro registers lives in one of +// the headers under formats/, organized by color kind. Format names +// follow the kms++/pixutils convention (see formats/rgb.h for the +// longer note; the YUYV group is an exception, see formats/yuv_packed.h). + +#include "formats/rgb.h" +#include "formats/yuv_semiplanar.h" +#include "formats/yuv_planar.h" +#include "formats/yuv_packed.h" +#include "formats/grayscale.h" +#include "formats/bayer.h" diff --git a/subprojects/pixpat/pixpat-native/src/formats/bayer.h b/subprojects/pixpat/pixpat-native/src/formats/bayer.h new file mode 100644 index 0000000..057c342 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/formats/bayer.h @@ -0,0 +1,97 @@ +#pragma once + +// Bayer raw layouts. Each pixel carries one of R/G/B selected by +// (x mod 2, y mod 2) and BayerOrder; the pattern is on the +// BayerSource/BayerSink template, not the layout itself. Storage shape +// is single-component (C::Y reused as the storage tag) so the same +// 8/10/12/16-bit shapes apply across all four phase patterns. +// +// Each format is a distinct struct (rather than a type alias of one +// another) so each format type can carry its own pattern-specific +// Source/Sink aliases. The shared bit layout lives in a base struct per +// (depth,packing) combination. +// +// ColorKind is RGB because the normalized pixel passed through ColorXfm +// is RGB16 — the sink picks one of r/g/b at write time, and the +// source nearest-neighbor demosaics into RGB16 at read time. + +#include "../layout.h" +#include "../io/bayer.h" + +namespace pixpat::formats +{ + +namespace bayer_detail +{ + +// Per-(depth,packing) base layouts. Every Bayer format derives from +// one of these and pins its own pattern-specific I/O templates. +using Bayer8 = Layout<ColorKind::RGB, 1, 1, + Plane<uint8_t, Comp { C::Y, 8, 0 }> >; +using Bayer10 = Layout<ColorKind::RGB, 1, 1, + Plane<uint16_t, Comp { C::Y, 10, 0 }, Comp { C::X, 6, 10 }> >; +using Bayer12 = Layout<ColorKind::RGB, 1, 1, + Plane<uint16_t, Comp { C::Y, 12, 0 }, Comp { C::X, 4, 12 }> >; +using Bayer16 = Layout<ColorKind::RGB, 1, 1, + Plane<uint16_t, Comp { C::Y, 16, 0 }> >; +// MIPI CSI-2 packed Bayer (10P: 4 pix in 5 bytes; 12P: 2 pix in 3 +// bytes). The Layout doesn't capture the packed bit layout — the +// BayerPackedSink hand-rolls the byte writes. uint8_t plane shape is +// a placeholder so the dispatch plumbing is uniform. +using Bayer10P = Layout<ColorKind::RGB, 1, 1, + Plane<uint8_t, Comp { C::Y, 8, 0 }> >; +using Bayer12P = Layout<ColorKind::RGB, 1, 1, + Plane<uint8_t, Comp { C::Y, 8, 0 }> >; + +} // namespace bayer_detail + +// Unpacked Bayer (4 patterns × 4 bit depths). +#define PIXPAT_BAYER(name, base, pat) \ + struct name : bayer_detail::base { \ + using Source = BayerSource_ ## pat<name>; \ + using Sink = BayerSink_ ## pat<name>; \ + } + +PIXPAT_BAYER(SRGGB8, Bayer8, RGGB); +PIXPAT_BAYER(SBGGR8, Bayer8, BGGR); +PIXPAT_BAYER(SGRBG8, Bayer8, GRBG); +PIXPAT_BAYER(SGBRG8, Bayer8, GBRG); + +PIXPAT_BAYER(SRGGB10, Bayer10, RGGB); +PIXPAT_BAYER(SBGGR10, Bayer10, BGGR); +PIXPAT_BAYER(SGRBG10, Bayer10, GRBG); +PIXPAT_BAYER(SGBRG10, Bayer10, GBRG); + +PIXPAT_BAYER(SRGGB12, Bayer12, RGGB); +PIXPAT_BAYER(SBGGR12, Bayer12, BGGR); +PIXPAT_BAYER(SGRBG12, Bayer12, GRBG); +PIXPAT_BAYER(SGBRG12, Bayer12, GBRG); + +PIXPAT_BAYER(SRGGB16, Bayer16, RGGB); +PIXPAT_BAYER(SBGGR16, Bayer16, BGGR); +PIXPAT_BAYER(SGRBG16, Bayer16, GRBG); +PIXPAT_BAYER(SGBRG16, Bayer16, GBRG); + +#undef PIXPAT_BAYER + +// MIPI-packed Bayer: pattern + bit depth both encoded in the I/O +// template name (BayerPackedSource_RGGB10, ...). +#define PIXPAT_BAYER_PACKED(name, base, pat_depth) \ + struct name : bayer_detail::base { \ + using Source = BayerPackedSource_ ## pat_depth<name>; \ + using Sink = BayerPackedSink_ ## pat_depth<name>; \ + } + +PIXPAT_BAYER_PACKED(SRGGB10P, Bayer10P, RGGB10); +PIXPAT_BAYER_PACKED(SBGGR10P, Bayer10P, BGGR10); +PIXPAT_BAYER_PACKED(SGRBG10P, Bayer10P, GRBG10); +PIXPAT_BAYER_PACKED(SGBRG10P, Bayer10P, GBRG10); + +PIXPAT_BAYER_PACKED(SRGGB12P, Bayer12P, RGGB12); +PIXPAT_BAYER_PACKED(SBGGR12P, Bayer12P, BGGR12); +PIXPAT_BAYER_PACKED(SGRBG12P, Bayer12P, GRBG12); +PIXPAT_BAYER_PACKED(SGBRG12P, Bayer12P, GBRG12); + +#undef PIXPAT_BAYER_PACKED + +} // namespace pixpat::formats diff --git a/subprojects/pixpat/pixpat-native/src/formats/grayscale.h b/subprojects/pixpat/pixpat-native/src/formats/grayscale.h new file mode 100644 index 0000000..b1cd294 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/formats/grayscale.h @@ -0,0 +1,78 @@ +#pragma once + +// Single-component-per-pixel formats. Most are grayscale (Y) modeled as +// a YUV format with synthesized neutral chroma; R8 is the RGB-kind +// counterpart, modeled grey-style with G=B=R on read. Y10/Y12 carry an +// explicit X padding bitfield. XYYY2101010 is multi-pixel-per-word: 3 Y +// samples in 32 bits. + +#include "../layout.h" +#include "../io/gray.h" +#include "../io/gray_packed.h" +#include "../io/mono_rgb.h" + +namespace pixpat::formats +{ + +#define PIXPAT_GRAY(name, ...) \ + struct name : Layout<ColorKind::YUV, 1, 1, __VA_ARGS__> { \ + using Source = GraySource<name>; \ + using Sink = GraySink<name>; \ + } + +PIXPAT_GRAY(Y8, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>); + +PIXPAT_GRAY(Y10, + Plane<uint16_t, Comp{ C::Y, 10, 0 }, Comp{ C::X, 6, 10 }>); + +PIXPAT_GRAY(Y12, + Plane<uint16_t, Comp{ C::Y, 12, 0 }, Comp{ C::X, 4, 12 }>); + +PIXPAT_GRAY(Y16, + Plane<uint16_t, Comp{ C::Y, 16, 0 }>); + +#undef PIXPAT_GRAY + +// R8: single 8-bit R channel. Read synthesizes G=B=R; write encodes R +// and drops G/B/A. Symmetric to Y8 but ColorKind::RGB so cross-pipeline +// conversions go through the RGB->YUV ColorXfm direction. +struct R8 : Layout<ColorKind::RGB, 1, 1, + Plane<uint8_t, Comp{ C::R, 8, 0 }> > { + using Source = MonoRGBSource<R8>; + using Sink = MonoRGBSink<R8>; +}; + +struct XYYY2101010 : Layout<ColorKind::YUV, 1, 1, + Plane<uint32_t, + Comp{ C::Y, 10, 0 }, + Comp{ C::Y, 10, 10 }, + Comp{ C::Y, 10, 20 }, + Comp{ C::X, 2, 30 }> > { + using Source = MultiPixelGraySource<XYYY2101010>; + using Sink = MultiPixelGraySink<XYYY2101010>; +}; + +// MIPI CSI-2 packed grayscale (Y10P / Y12P). The Layout doesn't capture +// the packed bit layout — GrayPackedSource/Sink delegate to the shared +// CSI-2 helper (io/csi2.h). uint8_t plane shape is a placeholder so +// dispatch plumbing is uniform (mirrors bayer_detail::Bayer10P/12P). +namespace gray_csi2_detail +{ +using Gray10P = Layout<ColorKind::YUV, 1, 1, + Plane<uint8_t, Comp { C::Y, 8, 0 }> >; +using Gray12P = Layout<ColorKind::YUV, 1, 1, + Plane<uint8_t, Comp { C::Y, 8, 0 }> >; +} // namespace gray_csi2_detail + +struct Y10P : gray_csi2_detail::Gray10P { + using Source = GrayPackedSource<Y10P, 10>; + using Sink = GrayPackedSink<Y10P, 10>; +}; + +struct Y12P : gray_csi2_detail::Gray12P { + using Source = GrayPackedSource<Y12P, 12>; + using Sink = GrayPackedSink<Y12P, 12>; +}; + +} // namespace pixpat::formats diff --git a/subprojects/pixpat/pixpat-native/src/formats/rgb.h b/subprojects/pixpat/pixpat-native/src/formats/rgb.h new file mode 100644 index 0000000..19d007a --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/formats/rgb.h @@ -0,0 +1,267 @@ +#pragma once + +// RGB packed layouts: 8-bit / 16-bit (sub-byte) / 32-bit (10-bit) / +// 64-bit-normalized, all single-plane single-pixel-per-storage-word. +// Names follow the kms++/pixutils register-order convention (MSB-first +// in the storage word), so XRGB8888 has X at bits 31..24 and B at 7..0. + +#include "../layout.h" +#include "../io/packed.h" + +namespace pixpat::formats +{ + +// Helper: every format in this file pairs with PackedSource/PackedSink. +// Each format struct exposes Source / Sink aliases so the catalog row +// in format_catalog.h can stay name-only. +#define PIXPAT_RGB_PACKED(name, ...) \ + struct name : Layout<ColorKind::RGB, 1, 1, __VA_ARGS__> { \ + using Source = PackedSource<name>; \ + using Sink = PackedSink<name>; \ + } + +// --------------------------------------------------------------------- +// 32-bit packed RGB, 8-bit components. +// --------------------------------------------------------------------- + +PIXPAT_RGB_PACKED(XRGB8888, + Plane<uint32_t, + Comp{ C::B, 8, 0 }, + Comp{ C::G, 8, 8 }, + Comp{ C::R, 8, 16 }, + Comp{ C::X, 8, 24 }>); + +PIXPAT_RGB_PACKED(ARGB8888, + Plane<uint32_t, + Comp{ C::B, 8, 0 }, + Comp{ C::G, 8, 8 }, + Comp{ C::R, 8, 16 }, + Comp{ C::A, 8, 24 }>); + +PIXPAT_RGB_PACKED(XBGR8888, + Plane<uint32_t, + Comp{ C::R, 8, 0 }, + Comp{ C::G, 8, 8 }, + Comp{ C::B, 8, 16 }, + Comp{ C::X, 8, 24 }>); + +PIXPAT_RGB_PACKED(ABGR8888, + Plane<uint32_t, + Comp{ C::R, 8, 0 }, + Comp{ C::G, 8, 8 }, + Comp{ C::B, 8, 16 }, + Comp{ C::A, 8, 24 }>); + +PIXPAT_RGB_PACKED(RGBX8888, + Plane<uint32_t, + Comp{ C::X, 8, 0 }, + Comp{ C::B, 8, 8 }, + Comp{ C::G, 8, 16 }, + Comp{ C::R, 8, 24 }>); + +PIXPAT_RGB_PACKED(RGBA8888, + Plane<uint32_t, + Comp{ C::A, 8, 0 }, + Comp{ C::B, 8, 8 }, + Comp{ C::G, 8, 16 }, + Comp{ C::R, 8, 24 }>); + +PIXPAT_RGB_PACKED(BGRX8888, + Plane<uint32_t, + Comp{ C::X, 8, 0 }, + Comp{ C::R, 8, 8 }, + Comp{ C::G, 8, 16 }, + Comp{ C::B, 8, 24 }>); + +PIXPAT_RGB_PACKED(BGRA8888, + Plane<uint32_t, + Comp{ C::A, 8, 0 }, + Comp{ C::R, 8, 8 }, + Comp{ C::G, 8, 16 }, + Comp{ C::B, 8, 24 }>); + +// --------------------------------------------------------------------- +// 24-bit packed RGB, three bytes per pixel. storage_t is uint32_t but +// only bytes_per_pixel = 3 are read/written via memcpy. +// --------------------------------------------------------------------- + +PIXPAT_RGB_PACKED(RGB888, + Plane<uint32_t, + Comp{ C::B, 8, 0 }, + Comp{ C::G, 8, 8 }, + Comp{ C::R, 8, 16 }>); + +PIXPAT_RGB_PACKED(BGR888, + Plane<uint32_t, + Comp{ C::R, 8, 0 }, + Comp{ C::G, 8, 8 }, + Comp{ C::B, 8, 16 }>); + +// --------------------------------------------------------------------- +// 16-bit packed RGB, sub-byte components. +// --------------------------------------------------------------------- + +PIXPAT_RGB_PACKED(RGB565, + Plane<uint16_t, + Comp{ C::B, 5, 0 }, + Comp{ C::G, 6, 5 }, + Comp{ C::R, 5, 11 }>); + +PIXPAT_RGB_PACKED(BGR565, + Plane<uint16_t, + Comp{ C::R, 5, 0 }, + Comp{ C::G, 6, 5 }, + Comp{ C::B, 5, 11 }>); + +// 8-bit packed RGB: 3-bit R / 3-bit G / 2-bit B in a single byte. + +PIXPAT_RGB_PACKED(RGB332, + Plane<uint8_t, + Comp{ C::B, 2, 0 }, + Comp{ C::G, 3, 2 }, + Comp{ C::R, 3, 5 }>); + +PIXPAT_RGB_PACKED(XRGB1555, + Plane<uint16_t, + Comp{ C::B, 5, 0 }, + Comp{ C::G, 5, 5 }, + Comp{ C::R, 5, 10 }, + Comp{ C::X, 1, 15 }>); + +PIXPAT_RGB_PACKED(ARGB1555, + Plane<uint16_t, + Comp{ C::B, 5, 0 }, + Comp{ C::G, 5, 5 }, + Comp{ C::R, 5, 10 }, + Comp{ C::A, 1, 15 }>); + +PIXPAT_RGB_PACKED(XBGR1555, + Plane<uint16_t, + Comp{ C::R, 5, 0 }, + Comp{ C::G, 5, 5 }, + Comp{ C::B, 5, 10 }, + Comp{ C::X, 1, 15 }>); + +PIXPAT_RGB_PACKED(ABGR1555, + Plane<uint16_t, + Comp{ C::R, 5, 0 }, + Comp{ C::G, 5, 5 }, + Comp{ C::B, 5, 10 }, + Comp{ C::A, 1, 15 }>); + +PIXPAT_RGB_PACKED(XRGB4444, + Plane<uint16_t, + Comp{ C::B, 4, 0 }, + Comp{ C::G, 4, 4 }, + Comp{ C::R, 4, 8 }, + Comp{ C::X, 4, 12 }>); + +PIXPAT_RGB_PACKED(ARGB4444, + Plane<uint16_t, + Comp{ C::B, 4, 0 }, + Comp{ C::G, 4, 4 }, + Comp{ C::R, 4, 8 }, + Comp{ C::A, 4, 12 }>); + +PIXPAT_RGB_PACKED(XBGR4444, + Plane<uint16_t, + Comp{ C::R, 4, 0 }, + Comp{ C::G, 4, 4 }, + Comp{ C::B, 4, 8 }, + Comp{ C::X, 4, 12 }>); + +PIXPAT_RGB_PACKED(ABGR4444, + Plane<uint16_t, + Comp{ C::R, 4, 0 }, + Comp{ C::G, 4, 4 }, + Comp{ C::B, 4, 8 }, + Comp{ C::A, 4, 12 }>); + +PIXPAT_RGB_PACKED(RGBX4444, + Plane<uint16_t, + Comp{ C::X, 4, 0 }, + Comp{ C::B, 4, 4 }, + Comp{ C::G, 4, 8 }, + Comp{ C::R, 4, 12 }>); + +PIXPAT_RGB_PACKED(RGBA4444, + Plane<uint16_t, + Comp{ C::A, 4, 0 }, + Comp{ C::B, 4, 4 }, + Comp{ C::G, 4, 8 }, + Comp{ C::R, 4, 12 }>); + +// --------------------------------------------------------------------- +// 32-bit packed RGB, 10-bit components. +// --------------------------------------------------------------------- + +PIXPAT_RGB_PACKED(XRGB2101010, + Plane<uint32_t, + Comp{ C::B, 10, 0 }, + Comp{ C::G, 10, 10 }, + Comp{ C::R, 10, 20 }, + Comp{ C::X, 2, 30 }>); + +PIXPAT_RGB_PACKED(ARGB2101010, + Plane<uint32_t, + Comp{ C::B, 10, 0 }, + Comp{ C::G, 10, 10 }, + Comp{ C::R, 10, 20 }, + Comp{ C::A, 2, 30 }>); + +PIXPAT_RGB_PACKED(XBGR2101010, + Plane<uint32_t, + Comp{ C::R, 10, 0 }, + Comp{ C::G, 10, 10 }, + Comp{ C::B, 10, 20 }, + Comp{ C::X, 2, 30 }>); + +PIXPAT_RGB_PACKED(ABGR2101010, + Plane<uint32_t, + Comp{ C::R, 10, 0 }, + Comp{ C::G, 10, 10 }, + Comp{ C::B, 10, 20 }, + Comp{ C::A, 2, 30 }>); + +PIXPAT_RGB_PACKED(RGBX1010102, + Plane<uint32_t, + Comp{ C::X, 2, 0 }, + Comp{ C::B, 10, 2 }, + Comp{ C::G, 10, 12 }, + Comp{ C::R, 10, 22 }>); + +PIXPAT_RGB_PACKED(RGBA1010102, + Plane<uint32_t, + Comp{ C::A, 2, 0 }, + Comp{ C::B, 10, 2 }, + Comp{ C::G, 10, 12 }, + Comp{ C::R, 10, 22 }>); + +PIXPAT_RGB_PACKED(BGRX1010102, + Plane<uint32_t, + Comp{ C::X, 2, 0 }, + Comp{ C::R, 10, 2 }, + Comp{ C::G, 10, 12 }, + Comp{ C::B, 10, 22 }>); + +PIXPAT_RGB_PACKED(BGRA1010102, + Plane<uint32_t, + Comp{ C::A, 2, 0 }, + Comp{ C::R, 10, 2 }, + Comp{ C::G, 10, 12 }, + Comp{ C::B, 10, 22 }>); + +// --------------------------------------------------------------------- +// 64-bit normalized wide RGB (16 bits per component). +// --------------------------------------------------------------------- + +PIXPAT_RGB_PACKED(ABGR16161616, + Plane<uint64_t, + Comp{ C::R, 16, 0 }, + Comp{ C::G, 16, 16 }, + Comp{ C::B, 16, 32 }, + Comp{ C::A, 16, 48 }>); + +#undef PIXPAT_RGB_PACKED + +} // namespace pixpat::formats diff --git a/subprojects/pixpat/pixpat-native/src/formats/yuv_packed.h b/subprojects/pixpat/pixpat-native/src/formats/yuv_packed.h new file mode 100644 index 0000000..8e88f10 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/formats/yuv_packed.h @@ -0,0 +1,136 @@ +#pragma once + +// Packed YUV layouts: +// VUY888 — 1 pixel / 24-bit, 8-bit Y/U/V (storage uint32_t, +// bytes_per_pixel = 3; parallels BGR888 in the YUV +// register order) +// XVUY8888 — 1 pixel / 32-bit word, 8-bit Y/U/V + 8-bit padding +// XVUY2101010 — 1 pixel / 32-bit word, 10-bit Y/U/V + 2-bit padding +// AVUY16161616 — 1 pixel / 64-bit word, 16-bit Y/U/V/A (normalized) +// YUYV / YVYU / UYVY / VYUY — 4:2:2, 2 pixels / 32-bit word +// Y210 / Y212 / Y216 — 4:2:2, 2 pixels / 64-bit word, with +// each component MSB-aligned in a 16-bit slot +// +// XVUY/AVUY name is register MSB-first (X/A in the top bits). The +// YUYV names follow V4L2 / pixpat memory-byte order (Y0 in byte 0), +// so shifts ascend in name order — opposite of XRGB-style. + +#include "../layout.h" +#include "../io/packed.h" +#include "../io/packed_yuv.h" + +namespace pixpat::formats +{ + +// 1-pixel-per-word packed (single Pixel/Word; uses PackedSource/Sink). + +struct VUY888 : Layout<ColorKind::YUV, 1, 1, + Plane<uint32_t, + Comp{ C::Y, 8, 0 }, + Comp{ C::U, 8, 8 }, + Comp{ C::V, 8, 16 }> > { + using Source = PackedSource<VUY888>; + using Sink = PackedSink<VUY888>; +}; + +struct XVUY8888 : Layout<ColorKind::YUV, 1, 1, + Plane<uint32_t, + Comp{ C::Y, 8, 0 }, + Comp{ C::U, 8, 8 }, + Comp{ C::V, 8, 16 }, + Comp{ C::X, 8, 24 }> > { + using Source = PackedSource<XVUY8888>; + using Sink = PackedSink<XVUY8888>; +}; + +struct XVUY2101010 : Layout<ColorKind::YUV, 1, 1, + Plane<uint32_t, + Comp{ C::Y, 10, 0 }, + Comp{ C::U, 10, 10 }, + Comp{ C::V, 10, 20 }, + Comp{ C::X, 2, 30 }> > { + using Source = PackedSource<XVUY2101010>; + using Sink = PackedSink<XVUY2101010>; +}; + +struct AVUY16161616 : Layout<ColorKind::YUV, 1, 1, + Plane<uint64_t, + Comp{ C::Y, 16, 0 }, + Comp{ C::U, 16, 16 }, + Comp{ C::V, 16, 32 }, + Comp{ C::A, 16, 48 }> > { + using Source = PackedSource<AVUY16161616>; + using Sink = PackedSink<AVUY16161616>; +}; + +// 2-pixel-per-word 4:2:2 (uses PackedYUVSource/Sink). + +#define PIXPAT_PACKED_YUV422(name, ...) \ + struct name : Layout<ColorKind::YUV, 2, 1, \ + Plane<uint32_t, __VA_ARGS__> > { \ + using Source = PackedYUVSource<name>; \ + using Sink = PackedYUVSink<name>; \ + } + +PIXPAT_PACKED_YUV422(YUYV, + Comp{ C::Y, 8, 0 }, Comp{ C::U, 8, 8 }, + Comp{ C::Y, 8, 16 }, Comp{ C::V, 8, 24 }); + +PIXPAT_PACKED_YUV422(YVYU, + Comp{ C::Y, 8, 0 }, Comp{ C::V, 8, 8 }, + Comp{ C::Y, 8, 16 }, Comp{ C::U, 8, 24 }); + +PIXPAT_PACKED_YUV422(UYVY, + Comp{ C::U, 8, 0 }, Comp{ C::Y, 8, 8 }, + Comp{ C::V, 8, 16 }, Comp{ C::Y, 8, 24 }); + +PIXPAT_PACKED_YUV422(VYUY, + Comp{ C::V, 8, 0 }, Comp{ C::Y, 8, 8 }, + Comp{ C::U, 8, 16 }, Comp{ C::Y, 8, 24 }); + +#undef PIXPAT_PACKED_YUV422 + +// Y210 / Y212 / Y216: 4:2:2, 2 pixels per 64-bit word, MSB-aligned in +// 16-bit slots. Y210 has 6 unused LSBs per slot, Y212 has 4, Y216 has +// none. The X padding entries pad total_bits to 64 so bytes_per_pixel +// resolves to 8; PackedYUVSink leaves their slots zero via the +// value-array zero-init (see io/packed_yuv.h). +struct Y210 : Layout<ColorKind::YUV, 2, 1, + Plane<uint64_t, + Comp{ C::X, 6, 0 }, + Comp{ C::Y, 10, 6 }, + Comp{ C::X, 6, 16 }, + Comp{ C::U, 10, 22 }, + Comp{ C::X, 6, 32 }, + Comp{ C::Y, 10, 38 }, + Comp{ C::X, 6, 48 }, + Comp{ C::V, 10, 54 }> > { + using Source = PackedYUVSource<Y210>; + using Sink = PackedYUVSink<Y210>; +}; + +struct Y212 : Layout<ColorKind::YUV, 2, 1, + Plane<uint64_t, + Comp{ C::X, 4, 0 }, + Comp{ C::Y, 12, 4 }, + Comp{ C::X, 4, 16 }, + Comp{ C::U, 12, 20 }, + Comp{ C::X, 4, 32 }, + Comp{ C::Y, 12, 36 }, + Comp{ C::X, 4, 48 }, + Comp{ C::V, 12, 52 }> > { + using Source = PackedYUVSource<Y212>; + using Sink = PackedYUVSink<Y212>; +}; + +struct Y216 : Layout<ColorKind::YUV, 2, 1, + Plane<uint64_t, + Comp{ C::Y, 16, 0 }, + Comp{ C::U, 16, 16 }, + Comp{ C::Y, 16, 32 }, + Comp{ C::V, 16, 48 }> > { + using Source = PackedYUVSource<Y216>; + using Sink = PackedYUVSink<Y216>; +}; + +} // namespace pixpat::formats diff --git a/subprojects/pixpat/pixpat-native/src/formats/yuv_planar.h b/subprojects/pixpat/pixpat-native/src/formats/yuv_planar.h new file mode 100644 index 0000000..bb6a415 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/formats/yuv_planar.h @@ -0,0 +1,76 @@ +#pragma once + +// YUV planar layouts: 3 separate planes (Y, then U/V or V/U), 8-bit +// components. +// YUV420/YVU420 — h_sub=2, v_sub=2 (a.k.a. I420 / YV12) +// YUV422/YVU422 — h_sub=2, v_sub=1 +// YUV444/YVU444 — h_sub=1, v_sub=1 +// T430 — multi-pixel-per-word planar 4:4:4. + +#include "../layout.h" +#include "../io/planar.h" + +namespace pixpat::formats +{ + +#define PIXPAT_PLANAR(name, ...) \ + struct name : Layout<ColorKind::YUV, __VA_ARGS__> { \ + using Source = PlanarSource<name>; \ + using Sink = PlanarSink<name>; \ + } + +PIXPAT_PLANAR(YUV420, 2, 2, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint8_t, Comp{ C::U, 8, 0 }>, + Plane<uint8_t, Comp{ C::V, 8, 0 }>); + +PIXPAT_PLANAR(YVU420, 2, 2, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint8_t, Comp{ C::V, 8, 0 }>, + Plane<uint8_t, Comp{ C::U, 8, 0 }>); + +PIXPAT_PLANAR(YUV422, 2, 1, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint8_t, Comp{ C::U, 8, 0 }>, + Plane<uint8_t, Comp{ C::V, 8, 0 }>); + +PIXPAT_PLANAR(YVU422, 2, 1, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint8_t, Comp{ C::V, 8, 0 }>, + Plane<uint8_t, Comp{ C::U, 8, 0 }>); + +PIXPAT_PLANAR(YUV444, 1, 1, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint8_t, Comp{ C::U, 8, 0 }>, + Plane<uint8_t, Comp{ C::V, 8, 0 }>); + +PIXPAT_PLANAR(YVU444, 1, 1, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint8_t, Comp{ C::V, 8, 0 }>, + Plane<uint8_t, Comp{ C::U, 8, 0 }>); + +#undef PIXPAT_PLANAR + +// T430: 3-plane multi-pixel-per-word planar 4:4:4. Each plane carries +// 3 × 10-bit samples per uint32_t plus a 2-bit X padding bit-field. +struct T430 : Layout<ColorKind::YUV, 1, 1, + Plane<uint32_t, + Comp{ C::Y, 10, 0 }, + Comp{ C::Y, 10, 10 }, + Comp{ C::Y, 10, 20 }, + Comp{ C::X, 2, 30 }>, + Plane<uint32_t, + Comp{ C::U, 10, 0 }, + Comp{ C::U, 10, 10 }, + Comp{ C::U, 10, 20 }, + Comp{ C::X, 2, 30 }>, + Plane<uint32_t, + Comp{ C::V, 10, 0 }, + Comp{ C::V, 10, 10 }, + Comp{ C::V, 10, 20 }, + Comp{ C::X, 2, 30 }> > { + using Source = MultiPixelPlanarSource<T430>; + using Sink = MultiPixelPlanarSink<T430>; +}; + +} // namespace pixpat::formats diff --git a/subprojects/pixpat/pixpat-native/src/formats/yuv_semiplanar.h b/subprojects/pixpat/pixpat-native/src/formats/yuv_semiplanar.h new file mode 100644 index 0000000..34aea22 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/formats/yuv_semiplanar.h @@ -0,0 +1,79 @@ +#pragma once + +// YUV semiplanar layouts: Y plane + interleaved UV plane. +// NV12/NV21 — 4:2:0 (h_sub=2, v_sub=2) +// NV16/NV61 — 4:2:2 (h_sub=2, v_sub=1) +// P030/P230 — multi-pixel-per-word semiplanar (10-bit Y triplets). + +#include "../layout.h" +#include "../io/semiplanar.h" + +namespace pixpat::formats +{ + +struct NV12 : Layout<ColorKind::YUV, 2, 2, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint16_t, Comp{ C::U, 8, 0 }, Comp{ C::V, 8, 8 }> > { + using Source = SemiplanarSource<NV12>; + using Sink = SemiplanarSink<NV12>; +}; + +struct NV21 : Layout<ColorKind::YUV, 2, 2, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint16_t, Comp{ C::V, 8, 0 }, Comp{ C::U, 8, 8 }> > { + using Source = SemiplanarSource<NV21>; + using Sink = SemiplanarSink<NV21>; +}; + +struct NV16 : Layout<ColorKind::YUV, 2, 1, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint16_t, Comp{ C::U, 8, 0 }, Comp{ C::V, 8, 8 }> > { + using Source = SemiplanarSource<NV16>; + using Sink = SemiplanarSink<NV16>; +}; + +struct NV61 : Layout<ColorKind::YUV, 2, 1, + Plane<uint8_t, Comp{ C::Y, 8, 0 }>, + Plane<uint16_t, Comp{ C::V, 8, 0 }, Comp{ C::U, 8, 8 }> > { + using Source = SemiplanarSource<NV61>; + using Sink = SemiplanarSink<NV61>; +}; + +// Multi-pixel-per-word semiplanar (P030: 4:2:0, P230: 4:2:2). Y plane +// holds 3 × 10-bit Y samples per uint32_t (top 2 bits unused). UV plane +// holds 3 × (Cb,Cr) pairs per uint64_t (10 bits each, with 2-bit gaps +// at bits 30-31 and 62-63 — left implicit, no X declared). + +struct P030 : Layout<ColorKind::YUV, 2, 2, + Plane<uint32_t, + Comp{ C::Y, 10, 0 }, + Comp{ C::Y, 10, 10 }, + Comp{ C::Y, 10, 20 }>, + Plane<uint64_t, + Comp{ C::U, 10, 0 }, + Comp{ C::V, 10, 10 }, + Comp{ C::U, 10, 20 }, + Comp{ C::V, 10, 32 }, + Comp{ C::U, 10, 42 }, + Comp{ C::V, 10, 52 }> > { + using Source = MultiPixelSemiplanarSource<P030>; + using Sink = MultiPixelSemiplanarSink<P030>; +}; + +struct P230 : Layout<ColorKind::YUV, 2, 1, + Plane<uint32_t, + Comp{ C::Y, 10, 0 }, + Comp{ C::Y, 10, 10 }, + Comp{ C::Y, 10, 20 }>, + Plane<uint64_t, + Comp{ C::U, 10, 0 }, + Comp{ C::V, 10, 10 }, + Comp{ C::U, 10, 20 }, + Comp{ C::V, 10, 32 }, + Comp{ C::U, 10, 42 }, + Comp{ C::V, 10, 52 }> > { + using Source = MultiPixelSemiplanarSource<P230>; + using Sink = MultiPixelSemiplanarSink<P230>; +}; + +} // namespace pixpat::formats diff --git a/subprojects/pixpat/pixpat-native/src/io.h b/subprojects/pixpat/pixpat-native/src/io.h new file mode 100644 index 0000000..af24232 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io.h @@ -0,0 +1,13 @@ +#pragma once + +// Aggregator: every Source / Sink template lives in one of the +// per-iteration-shape headers under io/. Encode/decode helpers and +// load_word/store_word are in io/detail.h, used by all the others. + +#include "io/detail.h" +#include "io/packed.h" +#include "io/semiplanar.h" +#include "io/planar.h" +#include "io/packed_yuv.h" +#include "io/gray.h" +#include "io/bayer.h" diff --git a/subprojects/pixpat/pixpat-native/src/io/bayer.h b/subprojects/pixpat/pixpat-native/src/io/bayer.h new file mode 100644 index 0000000..6b30c0e --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/bayer.h @@ -0,0 +1,318 @@ +#pragma once + +// Bayer raw read/write support. +// +// Write side: each pixel carries one of R/G/B selected by (x mod 2, +// y mod 2) and a fixed BayerOrder. Two missing channels per pixel are +// dropped on encode. +// +// Read side: bilinear demosaic over a 3x3 window. The pixel's own +// channel comes from self; missing channels are averaged from the +// same-channel neighbours that the Bayer phase guarantees to exist: +// +// * At an R or B pixel, all four cardinal (N, E, S, W) neighbours +// carry G and all four diagonal (NE, NW, SE, SW) neighbours carry +// the other colour, so each missing channel averages four samples. +// * At a G pixel, one missing colour sits in the row neighbours +// (W, E) and the other in the column neighbours (N, S), so each +// missing channel averages two samples. +// +// Sampled coordinates are clamped to the image bounds. +// +// The Layout shape is the same as a Y-only single-plane format +// (storage carries one component plus optional X padding); the +// BayerOrder is a separate template parameter on the Source / Sink. + +#include <array> +#include <cstdint> + +#include "../layout.h" +#include "csi2.h" +#include "detail.h" + +namespace pixpat +{ + +enum class BayerOrder { RGGB, BGGR, GRBG, GBRG }; + +namespace detail +{ +constexpr C bayer_pick(BayerOrder o, bool x_even, bool y_even) noexcept +{ + switch (o) { + case BayerOrder::RGGB: + return y_even ? (x_even ? C::R : C::G) + : (x_even ? C::G : C::B); + case BayerOrder::BGGR: + return y_even ? (x_even ? C::B : C::G) + : (x_even ? C::G : C::R); + case BayerOrder::GRBG: + return y_even ? (x_even ? C::G : C::R) + : (x_even ? C::B : C::G); + case BayerOrder::GBRG: + return y_even ? (x_even ? C::G : C::B) + : (x_even ? C::R : C::G); + } + return C::G; +} + +constexpr size_t clamp_coord(int v, size_t max_excl) noexcept +{ + if (v < 0) + return 0; + if (size_t(v) >= max_excl) + return max_excl - 1; + return size_t(v); +} +} // namespace detail + +template <typename L, BayerOrder Order> +struct BayerSource { + using Layout = L; + using Pixel = RGB16; + + static_assert(L::kind == ColorKind::RGB); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t y_idx = P::template find_pos<C::Y>(); + static_assert(y_idx < P::num_comps); + + static uint16_t read_sample(const Buffer<1>& buf, size_t x, size_t y) noexcept + { + const uint8_t* p = buf.data[0] + y * buf.stride[0] + + x * P::bytes_per_pixel; + const auto vals = P::unpack(detail::load_word<P>(p)); + return detail::decode_norm(P::comps[y_idx].bits, vals[y_idx]); + } + + static RGB16 read(const Buffer<1>& buf, size_t x, size_t y, + size_t W, size_t H) noexcept + { + const bool x_even = (x & 1) == 0; + const bool y_even = (y & 1) == 0; + const C self = detail::bayer_pick(Order, x_even, y_even); + + const size_t xL = detail::clamp_coord(int(x) - 1, W); + const size_t xR = detail::clamp_coord(int(x) + 1, W); + const size_t yT = detail::clamp_coord(int(y) - 1, H); + const size_t yB = detail::clamp_coord(int(y) + 1, H); + + const uint16_t s = read_sample(buf, x, y); + + uint16_t r = 0, g = 0, b = 0; + + if (self == C::G) { + const C h_color = detail::bayer_pick(Order, !x_even, y_even); + const uint16_t h_avg = uint16_t( + (uint32_t(read_sample(buf, xL, y)) + + read_sample(buf, xR, y) + 1u) >> 1); + const uint16_t v_avg = uint16_t( + (uint32_t(read_sample(buf, x, yT)) + + read_sample(buf, x, yB) + 1u) >> 1); + g = s; + if (h_color == C::R) { r = h_avg; b = v_avg; } + else { b = h_avg; r = v_avg; } + } else { + const uint16_t g_avg = uint16_t( + (uint32_t(read_sample(buf, x, yT)) + + read_sample(buf, x, yB) + + read_sample(buf, xL, y) + + read_sample(buf, xR, y) + 2u) >> 2); + const uint16_t o_avg = uint16_t( + (uint32_t(read_sample(buf, xL, yT)) + + read_sample(buf, xR, yT) + + read_sample(buf, xL, yB) + + read_sample(buf, xR, yB) + 2u) >> 2); + g = g_avg; + if (self == C::R) { r = s; b = o_avg; } + else { b = s; r = o_avg; } + } + + return RGB16{ r, g, b, uint16_t(0) }; + } +}; + +template <typename L, BayerOrder Order> +struct BayerSink { + using Layout = L; + using Pixel = RGB16; + + static_assert(L::kind == ColorKind::RGB); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t y_idx = P::template find_pos<C::Y>(); + static constexpr size_t x_idx = P::template find_pos<C::X>(); + static constexpr bool has_x = (x_idx < P::num_comps); + static_assert(y_idx < P::num_comps); + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = 1; + + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const RGB16 (&block)[1][1]) noexcept + { + const C pick = detail::bayer_pick(Order, (bx & 1) == 0, + (by & 1) == 0); + const uint16_t val = pick == C::R ? block[0][0].r + : pick == C::G ? block[0][0].g + : block[0][0].b; + + std::array<uint16_t, P::num_comps> v{}; + v[y_idx] = detail::encode_norm(P::comps[y_idx].bits, val); + if constexpr (has_x) + v[x_idx] = 0; + + uint8_t* p = buf.data[0] + by * buf.stride[0] + + bx * P::bytes_per_pixel; + detail::store_word<P>(p, P::pack(v)); + } +}; + +// Aliases so X-macro can register without nested template-template params. +template <typename L> using BayerSource_RGGB = BayerSource<L, BayerOrder::RGGB>; +template <typename L> using BayerSource_BGGR = BayerSource<L, BayerOrder::BGGR>; +template <typename L> using BayerSource_GRBG = BayerSource<L, BayerOrder::GRBG>; +template <typename L> using BayerSource_GBRG = BayerSource<L, BayerOrder::GBRG>; + +template <typename L> using BayerSink_RGGB = BayerSink<L, BayerOrder::RGGB>; +template <typename L> using BayerSink_BGGR = BayerSink<L, BayerOrder::BGGR>; +template <typename L> using BayerSink_GRBG = BayerSink<L, BayerOrder::GRBG>; +template <typename L> using BayerSink_GBRG = BayerSink<L, BayerOrder::GBRG>; + +// MIPI CSI-2 packed Bayer. The bit layout doesn't fit +// `Plane<Storage, Comp...>` because each pixel's bits span two +// non-contiguous bytes, so we use the shared CSI-2 helper (io/csi2.h) +// to (un)pack samples. +// +// The Layout slot is a placeholder (matches the unpacked Bayer of the +// same bit-depth so the user-facing API can pick the right buffer +// shape); bytes_per_pixel from the Plane is unused. +template <typename L, BayerOrder Order, size_t BitDepth> +struct BayerPackedSource { + using Layout = L; + using Pixel = RGB16; + + static_assert(L::kind == ColorKind::RGB); + static_assert(L::num_planes == 1); + static_assert(BitDepth == 10 || BitDepth == 12); + + using Traits = detail::csi2::packed_traits<BitDepth>; + static constexpr size_t ppg = Traits::ppg; + static constexpr size_t bpg = Traits::bpg; + + // Stored N-bit value upshifts to normalized-16 by `<< (16-N)`, + // matching the unpacked Bayer source. + static constexpr unsigned shift = 16 - BitDepth; + + static uint16_t read_sample(const Buffer<1>& buf, size_t x, size_t y) noexcept + { + const uint8_t* src = buf.data[0] + y * buf.stride[0] + + (x / ppg) * bpg; + const uint16_t val = detail::csi2::unpack_sample<BitDepth>(src, x % ppg); + return uint16_t(val << shift); + } + + static RGB16 read(const Buffer<1>& buf, size_t x, size_t y, + size_t W, size_t H) noexcept + { + const bool x_even = (x & 1) == 0; + const bool y_even = (y & 1) == 0; + const C self = detail::bayer_pick(Order, x_even, y_even); + + const size_t xL = detail::clamp_coord(int(x) - 1, W); + const size_t xR = detail::clamp_coord(int(x) + 1, W); + const size_t yT = detail::clamp_coord(int(y) - 1, H); + const size_t yB = detail::clamp_coord(int(y) + 1, H); + + const uint16_t s = read_sample(buf, x, y); + + uint16_t r = 0, g = 0, b = 0; + + if (self == C::G) { + const C h_color = detail::bayer_pick(Order, !x_even, y_even); + const uint16_t h_avg = uint16_t( + (uint32_t(read_sample(buf, xL, y)) + + read_sample(buf, xR, y) + 1u) >> 1); + const uint16_t v_avg = uint16_t( + (uint32_t(read_sample(buf, x, yT)) + + read_sample(buf, x, yB) + 1u) >> 1); + g = s; + if (h_color == C::R) { r = h_avg; b = v_avg; } + else { b = h_avg; r = v_avg; } + } else { + const uint16_t g_avg = uint16_t( + (uint32_t(read_sample(buf, x, yT)) + + read_sample(buf, x, yB) + + read_sample(buf, xL, y) + + read_sample(buf, xR, y) + 2u) >> 2); + const uint16_t o_avg = uint16_t( + (uint32_t(read_sample(buf, xL, yT)) + + read_sample(buf, xR, yT) + + read_sample(buf, xL, yB) + + read_sample(buf, xR, yB) + 2u) >> 2); + g = g_avg; + if (self == C::R) { r = s; b = o_avg; } + else { b = s; r = o_avg; } + } + + return RGB16{ r, g, b, uint16_t(0) }; + } +}; + +template <typename L, BayerOrder Order, size_t BitDepth> +struct BayerPackedSink { + using Layout = L; + using Pixel = RGB16; + + static_assert(L::kind == ColorKind::RGB); + static_assert(L::num_planes == 1); + static_assert(BitDepth == 10 || BitDepth == 12); + + using Traits = detail::csi2::packed_traits<BitDepth>; + static constexpr size_t ppg = Traits::ppg; + static constexpr size_t bpg = Traits::bpg; + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = ppg; + + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const RGB16 (&block)[1][ppg]) noexcept + { + std::array<uint16_t, ppg> vals{}; + for (size_t i = 0; i < ppg; ++i) { + const C pick = detail::bayer_pick( + Order, ((bx + i) & 1) == 0, (by & 1) == 0); + const uint16_t norm = + pick == C::R ? block[0][i].r + : pick == C::G ? block[0][i].g + : block[0][i].b; + vals[i] = uint16_t(norm >> (16 - BitDepth)); + } + + uint8_t* dst = buf.data[0] + by * buf.stride[0] + + (bx / ppg) * bpg; + detail::csi2::pack_group<BitDepth>(dst, vals); + } +}; + +template <typename L> using BayerPackedSource_RGGB10 = BayerPackedSource<L, BayerOrder::RGGB, 10>; +template <typename L> using BayerPackedSource_BGGR10 = BayerPackedSource<L, BayerOrder::BGGR, 10>; +template <typename L> using BayerPackedSource_GRBG10 = BayerPackedSource<L, BayerOrder::GRBG, 10>; +template <typename L> using BayerPackedSource_GBRG10 = BayerPackedSource<L, BayerOrder::GBRG, 10>; +template <typename L> using BayerPackedSource_RGGB12 = BayerPackedSource<L, BayerOrder::RGGB, 12>; +template <typename L> using BayerPackedSource_BGGR12 = BayerPackedSource<L, BayerOrder::BGGR, 12>; +template <typename L> using BayerPackedSource_GRBG12 = BayerPackedSource<L, BayerOrder::GRBG, 12>; +template <typename L> using BayerPackedSource_GBRG12 = BayerPackedSource<L, BayerOrder::GBRG, 12>; + +template <typename L> using BayerPackedSink_RGGB10 = BayerPackedSink<L, BayerOrder::RGGB, 10>; +template <typename L> using BayerPackedSink_BGGR10 = BayerPackedSink<L, BayerOrder::BGGR, 10>; +template <typename L> using BayerPackedSink_GRBG10 = BayerPackedSink<L, BayerOrder::GRBG, 10>; +template <typename L> using BayerPackedSink_GBRG10 = BayerPackedSink<L, BayerOrder::GBRG, 10>; +template <typename L> using BayerPackedSink_RGGB12 = BayerPackedSink<L, BayerOrder::RGGB, 12>; +template <typename L> using BayerPackedSink_BGGR12 = BayerPackedSink<L, BayerOrder::BGGR, 12>; +template <typename L> using BayerPackedSink_GRBG12 = BayerPackedSink<L, BayerOrder::GRBG, 12>; +template <typename L> using BayerPackedSink_GBRG12 = BayerPackedSink<L, BayerOrder::GBRG, 12>; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/io/csi2.h b/subprojects/pixpat/pixpat-native/src/io/csi2.h new file mode 100644 index 0000000..59a8f8d --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/csi2.h @@ -0,0 +1,80 @@ +#pragma once + +// Shared MIPI CSI-2 byte (un)packing for the 10P / 12P forms used by +// Bayer raw and Y-only grayscale. +// +// 10P: 4 samples in 5 bytes — bytes 0..3 hold the high 8 bits of +// samples 0..3; byte 4 holds 4 x 2 LSBs (sample 0 in bits 6..7, +// sample 1 in bits 4..5, ...). +// 12P: 2 samples in 3 bytes — bytes 0..1 hold the high 8 bits of +// samples 0..1; byte 2 holds 2 x 4 LSBs (sample 0 in bits 4..7, +// sample 1 in bits 0..3). +// +// Helpers deal in the stored integer (low BitDepth bits set); +// normalization to/from the 16-bit pivot stays in the caller. + +#include <array> +#include <cstddef> +#include <cstdint> + +namespace pixpat::detail::csi2 +{ + +template <size_t BitDepth> +struct packed_traits; + +template <> +struct packed_traits<10> { + static constexpr size_t ppg = 4; + static constexpr size_t bpg = 5; +}; + +template <> +struct packed_traits<12> { + static constexpr size_t ppg = 2; + static constexpr size_t bpg = 3; +}; + +// Extract one BitDepth-bit sample from a packed group, where `i` is the +// in-group index (0..ppg-1). The returned value occupies the low +// BitDepth bits. +template <size_t BitDepth> +inline uint16_t unpack_sample(const uint8_t* src, size_t i) noexcept +{ + if constexpr (BitDepth == 10) { + const uint8_t hi = src[i]; + const uint8_t lsb = (src[4] >> ((3 - i) * 2)) & 0x03; + return uint16_t((hi << 2) | lsb); + } else { // 12 + const uint8_t hi = src[i]; + const uint8_t lsb = (i == 0) ? ((src[2] >> 4) & 0x0F) + : (src[2] & 0x0F); + return uint16_t((hi << 4) | lsb); + } +} + +// Write `ppg` BitDepth-bit samples (low BitDepth bits significant) into +// a packed group of `bpg` bytes. +template <size_t BitDepth> +inline void pack_group( + uint8_t* dst, + const std::array<uint16_t, packed_traits<BitDepth>::ppg>& vals) noexcept +{ + if constexpr (BitDepth == 10) { + dst[0] = (vals[0] >> 2) & 0xFF; + dst[1] = (vals[1] >> 2) & 0xFF; + dst[2] = (vals[2] >> 2) & 0xFF; + dst[3] = (vals[3] >> 2) & 0xFF; + dst[4] = ((vals[0] & 0x03) << 6) + | ((vals[1] & 0x03) << 4) + | ((vals[2] & 0x03) << 2) + | ((vals[3] & 0x03) << 0); + } else { // 12 + dst[0] = (vals[0] >> 4) & 0xFF; + dst[1] = (vals[1] >> 4) & 0xFF; + dst[2] = ((vals[0] & 0x0F) << 4) + | ((vals[1] & 0x0F) << 0); + } +} + +} // namespace pixpat::detail::csi2 diff --git a/subprojects/pixpat/pixpat-native/src/io/detail.h b/subprojects/pixpat/pixpat-native/src/io/detail.h new file mode 100644 index 0000000..cb2b9fb --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/detail.h @@ -0,0 +1,62 @@ +#pragma once + +// Per-component encode/decode against the descriptor + memcpy-based +// load/store_word helpers. Shared by every Source / Sink template. + +#include <cstdint> +#include <cstring> + +#include "../layout.h" + +namespace pixpat::detail +{ + +// Decode an N-bit stored value into the 16-bit normalized space and +// encode it back. Decode bit-replicates the stored value across the 16 +// bits so that N-bit max maps to normalized max (e.g. 8-bit 0xFF → +// 0xFFFF, not 0xFF00). Encode is a plain truncating right-shift: the +// replicated bits land in the low (16-N) bits and get dropped, so +// stored→norm→stored is exact for any N in [1, 16]. +// +// `bits` is taken at runtime; in every call site it traces back to a +// constexpr Plane::comps[I].bits read, which the optimizer constant- +// folds after inlining. + +constexpr uint16_t decode_norm(unsigned bits, uint16_t stored) noexcept +{ + const int N = int(bits); + // Loop, not a single OR: one replication only covers 2N bits, so + // N < 8 (RGB565, RGBA4444, 1-bit alpha, ...) needs multiple tiles. + uint32_t result = 0; + for (int s = 16 - N; s > -N; s -= N) { + if (s >= 0) + result |= uint32_t(stored) << s; + else + result |= uint32_t(stored) >> -s; + } + return uint16_t(result); +} + +constexpr uint16_t encode_norm(unsigned bits, uint16_t norm) noexcept +{ + return uint16_t(norm >> (16u - bits)); +} + +// Read one storage word from `p`. memcpy is uniform for tight and +// non-tight (e.g. BGR888 24-bit) layouts; the optimizer folds it to a +// single load when the size is constant. +template <typename Plane> +inline typename Plane::storage_t load_word(const uint8_t* p) noexcept +{ + typename Plane::storage_t word{}; + std::memcpy(&word, p, Plane::bytes_per_pixel); + return word; +} + +template <typename Plane> +inline void store_word(uint8_t* p, typename Plane::storage_t word) noexcept +{ + std::memcpy(p, &word, Plane::bytes_per_pixel); +} + +} // namespace pixpat::detail diff --git a/subprojects/pixpat/pixpat-native/src/io/gray.h b/subprojects/pixpat/pixpat-native/src/io/gray.h new file mode 100644 index 0000000..d175b68 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/gray.h @@ -0,0 +1,153 @@ +#pragma once + +// Grayscale (Y8 / Y10 / Y12 / Y16) and multi-pixel-per-word grayscale +// (XYYY2101010: 3 Y components in one uint32_t). Modeled as a YUV format +// with neutral chroma synthesized on read so cross-color-kind ColorXfm +// produces R=G=B=Y'. The sink encodes Y from YUV16 and ignores U/V. +// Y10/Y12 carry an X padding bitfield which we zero out on write. +// Neutral chroma in normalized-16 is 0x8000 (the midpoint of [0, 0xFFFF]). + +#include <array> + +#include "../layout.h" +#include "detail.h" + +namespace pixpat +{ + +template <typename L> +struct GraySource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t y_idx = P::template find_pos<C::Y>(); + static_assert(y_idx < P::num_comps); + + static YUV16 read(const Buffer<1>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const uint8_t* p = buf.data[0] + y * buf.stride[0] + + x * P::bytes_per_pixel; + const auto vals = P::unpack(detail::load_word<P>(p)); + return YUV16{ + detail::decode_norm(P::comps[y_idx].bits, vals[y_idx]), + 0x8000, 0x8000, uint16_t(0), + }; + } +}; + +template <typename L> +struct GraySink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t y_idx = P::template find_pos<C::Y>(); + static constexpr size_t x_idx = P::template find_pos<C::X>(); + static constexpr bool has_x = (x_idx < P::num_comps); + static_assert(y_idx < P::num_comps); + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = 1; + + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const YUV16 (&block)[1][1]) noexcept + { + std::array<uint16_t, P::num_comps> v{}; + v[y_idx] = detail::encode_norm(P::comps[y_idx].bits, block[0][0].y); + if constexpr (has_x) + v[x_idx] = 0; + + uint8_t* p = buf.data[0] + by * buf.stride[0] + + bx * P::bytes_per_pixel; + detail::store_word<P>(p, P::pack(v)); + } +}; + +// Multi-pixel-per-word grayscale. The Layout carries one C::Y entry per +// pixel in the group; pixels_per_word is derived from how many C::Y +// entries the layout has. All Y components must share the same bit width +// (so the encode/decode shift is shared). block_w = ppw so the sink +// writes one storage word per block. +template <typename L> +struct MultiPixelGraySource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t ppw = P::template component_count<C::Y>(); + static_assert(ppw >= 1); + + // All Y positions share the same bit width. + static constexpr unsigned y_bits = P::comps[P::template find_pos<C::Y>(0)].bits; + + static YUV16 read(const Buffer<1>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const size_t gx = x / ppw; + const size_t off = x % ppw; + const uint8_t* p = buf.data[0] + y * buf.stride[0] + + gx * P::bytes_per_pixel; + const auto vals = P::unpack(detail::load_word<P>(p)); + + // find_pos walks the comps array at runtime; comps is constexpr + // and num_comps is small (≤4 for these formats), so it inlines. + const size_t y_pos = P::template find_pos<C::Y>(off); + + return YUV16{ + detail::decode_norm(y_bits, vals[y_pos]), + 0x8000, 0x8000, uint16_t(0), + }; + } +}; + +template <typename L> +struct MultiPixelGraySink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t ppw = P::template component_count<C::Y>(); + static constexpr size_t x_idx = P::template find_pos<C::X>(); + static constexpr bool has_x = (x_idx < P::num_comps); + static_assert(ppw >= 1); + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = ppw; + + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const YUV16 (&block)[1][ppw]) noexcept + { + std::array<uint16_t, P::num_comps> v{}; + // All Y slots share the same bit width. + constexpr unsigned y_bits = P::comps[P::template find_pos<C::Y>(0)].bits; + for (size_t i = 0; i < ppw; ++i) { + const size_t pos = P::template find_pos<C::Y>(i); + v[pos] = detail::encode_norm(y_bits, block[0][i].y); + } + + if constexpr (has_x) + v[x_idx] = 0; + + uint8_t* p = buf.data[0] + by * buf.stride[0] + + (bx / ppw) * P::bytes_per_pixel; + detail::store_word<P>(p, P::pack(v)); + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/io/gray_packed.h b/subprojects/pixpat/pixpat-native/src/io/gray_packed.h new file mode 100644 index 0000000..dc1fa68 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/gray_packed.h @@ -0,0 +1,78 @@ +#pragma once + +// MIPI CSI-2 packed grayscale (Y10P / Y12P). Same byte packing as +// Bayer10P/Bayer12P (see io/csi2.h) but every sample is Y; the source +// emits neutral chroma to keep cross-color-kind ColorXfm consistent +// with GraySource. +// +// The Layout slot is a placeholder (matches the unpacked Y8 storage +// shape so dispatch plumbing is uniform); bytes_per_pixel from the +// Plane is unused. + +#include <array> +#include <cstdint> + +#include "../layout.h" +#include "csi2.h" + +namespace pixpat +{ + +template <typename L, size_t BitDepth> +struct GrayPackedSource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + static_assert(BitDepth == 10 || BitDepth == 12); + + using Traits = detail::csi2::packed_traits<BitDepth>; + static constexpr size_t ppg = Traits::ppg; + static constexpr size_t bpg = Traits::bpg; + static constexpr unsigned shift = 16 - BitDepth; + + static YUV16 read(const Buffer<1>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const uint8_t* src = buf.data[0] + y * buf.stride[0] + + (x / ppg) * bpg; + const uint16_t val = detail::csi2::unpack_sample<BitDepth>(src, x % ppg); + return YUV16{ + uint16_t(val << shift), + 0x8000, 0x8000, uint16_t(0), + }; + } +}; + +template <typename L, size_t BitDepth> +struct GrayPackedSink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + static_assert(BitDepth == 10 || BitDepth == 12); + + using Traits = detail::csi2::packed_traits<BitDepth>; + static constexpr size_t ppg = Traits::ppg; + static constexpr size_t bpg = Traits::bpg; + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = ppg; + + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const YUV16 (&block)[1][ppg]) noexcept + { + std::array<uint16_t, ppg> vals{}; + for (size_t i = 0; i < ppg; ++i) + vals[i] = uint16_t(block[0][i].y >> (16 - BitDepth)); + + uint8_t* dst = buf.data[0] + by * buf.stride[0] + + (bx / ppg) * bpg; + detail::csi2::pack_group<BitDepth>(dst, vals); + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/io/mono_rgb.h b/subprojects/pixpat/pixpat-native/src/io/mono_rgb.h new file mode 100644 index 0000000..f2f8206 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/mono_rgb.h @@ -0,0 +1,72 @@ +#pragma once + +// Single-channel RGB formats (R8). Storage carries one R component; +// MonoRGBSource synthesizes G=B=R on read so cross-color-kind ColorXfm +// produces sensible Y from R alone. MonoRGBSink encodes R and ignores +// G/B/A (and zeroes any X padding). Symmetric to GraySource/GraySink +// (io/gray.h) but for ColorKind::RGB on C::R. + +#include <array> + +#include "../layout.h" +#include "detail.h" + +namespace pixpat +{ + +template <typename L> +struct MonoRGBSource { + using Layout = L; + using Pixel = RGB16; + + static_assert(L::kind == ColorKind::RGB); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t r_idx = P::template find_pos<C::R>(); + static_assert(r_idx < P::num_comps); + + static RGB16 read(const Buffer<1>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const uint8_t* p = buf.data[0] + y * buf.stride[0] + + x * P::bytes_per_pixel; + const auto vals = P::unpack(detail::load_word<P>(p)); + const uint16_t r = detail::decode_norm(P::comps[r_idx].bits, vals[r_idx]); + return RGB16{ r, r, r, uint16_t(0) }; + } +}; + +template <typename L> +struct MonoRGBSink { + using Layout = L; + using Pixel = RGB16; + + static_assert(L::kind == ColorKind::RGB); + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr size_t r_idx = P::template find_pos<C::R>(); + static constexpr size_t x_idx = P::template find_pos<C::X>(); + static constexpr bool has_x = (x_idx < P::num_comps); + static_assert(r_idx < P::num_comps); + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = 1; + + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const RGB16 (&block)[1][1]) noexcept + { + std::array<uint16_t, P::num_comps> v{}; + v[r_idx] = detail::encode_norm(P::comps[r_idx].bits, block[0][0].r); + if constexpr (has_x) + v[x_idx] = 0; + + uint8_t* p = buf.data[0] + by * buf.stride[0] + + bx * P::bytes_per_pixel; + detail::store_word<P>(p, P::pack(v)); + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/io/packed.h b/subprojects/pixpat/pixpat-native/src/io/packed.h new file mode 100644 index 0000000..9d953bc --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/packed.h @@ -0,0 +1,106 @@ +#pragma once + +// Single-plane, single-pixel-per-storage-word formats. Works for both +// RGB layouts (XRGB8888, RGB565, ABGR16161616, ...) and YUV +// single-pixel layouts (XVUY2101010, AVUY16161616). Pixel type follows +// L::kind; the three mandatory components are R/G/B for RGB or Y/U/V +// for YUV. Both `RGB16` and `YUV16` are 4 uint16_t with the alpha last, +// so aggregate-init by position works for either. + +#include <array> +#include <type_traits> + +#include "../layout.h" +#include "detail.h" + +namespace pixpat +{ + +template <typename L> +struct PackedSource { + using Layout = L; + using Pixel = std::conditional_t<L::kind == ColorKind::RGB, RGB16, YUV16>; + + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr C c0 = (L::kind == ColorKind::RGB) ? C::R : C::Y; + static constexpr C c1 = (L::kind == ColorKind::RGB) ? C::G : C::U; + static constexpr C c2 = (L::kind == ColorKind::RGB) ? C::B : C::V; + + static constexpr size_t i0 = P::template find_pos<c0>(); + static constexpr size_t i1 = P::template find_pos<c1>(); + static constexpr size_t i2 = P::template find_pos<c2>(); + static constexpr size_t a_idx = P::template find_pos<C::A>(); + static constexpr bool has_a = (a_idx < P::num_comps); + static_assert(i0 < P::num_comps && i1 < P::num_comps && i2 < P::num_comps); + + static Pixel read(const Buffer<1>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const uint8_t* p = buf.data[0] + y * buf.stride[0] + x * P::bytes_per_pixel; + const auto vals = P::unpack(detail::load_word<P>(p)); + Pixel out{ + detail::decode_norm(P::comps[i0].bits, vals[i0]), + detail::decode_norm(P::comps[i1].bits, vals[i1]), + detail::decode_norm(P::comps[i2].bits, vals[i2]), + uint16_t(0), + }; + if constexpr (has_a) + out.a = detail::decode_norm(P::comps[a_idx].bits, vals[a_idx]); + return out; + } +}; + +template <typename L> +struct PackedSink { + using Layout = L; + using Pixel = std::conditional_t<L::kind == ColorKind::RGB, RGB16, YUV16>; + + static_assert(L::num_planes == 1); + + using P = typename L::template plane<0>; + static constexpr C c0 = (L::kind == ColorKind::RGB) ? C::R : C::Y; + static constexpr C c1 = (L::kind == ColorKind::RGB) ? C::G : C::U; + static constexpr C c2 = (L::kind == ColorKind::RGB) ? C::B : C::V; + + static constexpr size_t i0 = P::template find_pos<c0>(); + static constexpr size_t i1 = P::template find_pos<c1>(); + static constexpr size_t i2 = P::template find_pos<c2>(); + static constexpr size_t x_idx = P::template find_pos<C::X>(); + static constexpr size_t a_idx = P::template find_pos<C::A>(); + static constexpr bool has_x = (x_idx < P::num_comps); + static constexpr bool has_a = (a_idx < P::num_comps); + static_assert(i0 < P::num_comps && i1 < P::num_comps && i2 < P::num_comps); + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = 1; + + // Aggregate-init access to RGB16/YUV16 by position: .r/.y, .g/.u, .b/.v. + // We use the field names corresponding to L::kind. + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const Pixel (&block)[1][1]) noexcept + { + const Pixel& pix = block[0][0]; + std::array<uint16_t, P::num_comps> v{}; + if constexpr (L::kind == ColorKind::RGB) { + v[i0] = detail::encode_norm(P::comps[i0].bits, pix.r); + v[i1] = detail::encode_norm(P::comps[i1].bits, pix.g); + v[i2] = detail::encode_norm(P::comps[i2].bits, pix.b); + } else { + v[i0] = detail::encode_norm(P::comps[i0].bits, pix.y); + v[i1] = detail::encode_norm(P::comps[i1].bits, pix.u); + v[i2] = detail::encode_norm(P::comps[i2].bits, pix.v); + } + if constexpr (has_x) + v[x_idx] = 0; + if constexpr (has_a) + v[a_idx] = detail::encode_norm(P::comps[a_idx].bits, pix.a); + + uint8_t* p = buf.data[0] + by * buf.stride[0] + bx * P::bytes_per_pixel; + detail::store_word<P>(p, P::pack(v)); + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/io/packed_yuv.h b/subprojects/pixpat/pixpat-native/src/io/packed_yuv.h new file mode 100644 index 0000000..90c8b2f --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/packed_yuv.h @@ -0,0 +1,89 @@ +#pragma once + +// Packed YUV 4:2:2 (YUYV / YVYU / UYVY / VYUY): two pixels per 32-bit +// word, one shared chroma pair. The Layout uses two C::Y entries plus +// one each of C::U / C::V; we resolve the duplicate Y via +// find_pos<C::Y>(n). + +#include <array> + +#include "../layout.h" +#include "detail.h" + +namespace pixpat +{ + +template <typename L> +struct PackedYUVSource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + static_assert(L::h_sub == 2 && L::v_sub == 1); + + using P = typename L::template plane<0>; + static constexpr size_t y0_idx = P::template find_pos<C::Y>(0); + static constexpr size_t y1_idx = P::template find_pos<C::Y>(1); + static constexpr size_t u_idx = P::template find_pos<C::U>(); + static constexpr size_t v_idx = P::template find_pos<C::V>(); + + static YUV16 read(const Buffer<1>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const uint8_t* p = buf.data[0] + y * buf.stride[0] + + (x / 2) * P::bytes_per_pixel; + const auto vals = P::unpack(detail::load_word<P>(p)); + const size_t y_pick = (x & 1) ? y1_idx : y0_idx; + // Both Y components share the same bit width, so the bit-width + // for y0 and y1 is identical — pick either. + return YUV16{ + detail::decode_norm(P::comps[y0_idx].bits, vals[y_pick]), + detail::decode_norm(P::comps[u_idx].bits, vals[u_idx]), + detail::decode_norm(P::comps[v_idx].bits, vals[v_idx]), + uint16_t(0), + }; + } +}; + +template <typename L> +struct PackedYUVSink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 1); + static_assert(L::h_sub == 2 && L::v_sub == 1); + + using P = typename L::template plane<0>; + static constexpr size_t y0_idx = P::template find_pos<C::Y>(0); + static constexpr size_t y1_idx = P::template find_pos<C::Y>(1); + static constexpr size_t u_idx = P::template find_pos<C::U>(); + static constexpr size_t v_idx = P::template find_pos<C::V>(); + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = 2; + + static void write_block(Buffer<1>& buf, size_t bx, size_t by, + const YUV16 (&block)[1][2]) noexcept + { + std::array<uint16_t, P::num_comps> v{}; + v[y0_idx] = detail::encode_norm(P::comps[y0_idx].bits, block[0][0].y); + v[y1_idx] = detail::encode_norm(P::comps[y1_idx].bits, block[0][1].y); + // Integer chroma averaging in normalized-16 space. Truncates + // (no round-half-up). + v[u_idx] = detail::encode_norm(P::comps[u_idx].bits, uint16_t( + (uint32_t(block[0][0].u) + + uint32_t(block[0][1].u)) / 2)); + v[v_idx] = detail::encode_norm(P::comps[v_idx].bits, uint16_t( + (uint32_t(block[0][0].v) + + uint32_t(block[0][1].v)) / 2)); + + uint8_t* p = buf.data[0] + by * buf.stride[0] + + (bx / 2) * P::bytes_per_pixel; + detail::store_word<P>(p, P::pack(v)); + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/io/planar.h b/subprojects/pixpat/pixpat-native/src/io/planar.h new file mode 100644 index 0000000..0dab685 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/planar.h @@ -0,0 +1,257 @@ +#pragma once + +// 3-plane planar YUV. Two flavours: +// +// PlanarSource / PlanarSink — YUV/YVU 420/422/444, single Y per word, +// single chroma per word. Chroma is averaged over h_sub × v_sub +// on write. +// +// MultiPixelPlanarSource / MultiPixelPlanarSink — T430, multi-pixel- +// per-word planar 4:4:4 (3 samples per uint32_t in each of 3 +// planes, plus 2-bit X padding). block_w = ppw, block_h = 1. +// +// Plane indices for Y / U / V are looked up via Layout::find_plane<C>(), +// so swap_uv layouts (YVU vs YUV) work without separate templates. + +#include <array> + +#include "../layout.h" +#include "detail.h" + +namespace pixpat +{ + +template <typename L> +struct PlanarSource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 3); + + static constexpr size_t y_plane = L::template find_plane<C::Y>(); + static constexpr size_t u_plane = L::template find_plane<C::U>(); + static constexpr size_t v_plane = L::template find_plane<C::V>(); + + using YP = typename L::template plane<y_plane>; + using UP = typename L::template plane<u_plane>; + using VP = typename L::template plane<v_plane>; + + static YUV16 read(const Buffer<3>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const uint8_t* yp = buf.data[y_plane] + y * buf.stride[y_plane] + + x * YP::bytes_per_pixel; + const auto y_vals = YP::unpack(detail::load_word<YP>(yp)); + + const size_t cx = x / L::h_sub; + const size_t cy = y / L::v_sub; + const uint8_t* up = buf.data[u_plane] + cy * buf.stride[u_plane] + + cx * UP::bytes_per_pixel; + const uint8_t* vp = buf.data[v_plane] + cy * buf.stride[v_plane] + + cx * VP::bytes_per_pixel; + const auto u_vals = UP::unpack(detail::load_word<UP>(up)); + const auto v_vals = VP::unpack(detail::load_word<VP>(vp)); + + return YUV16{ + detail::decode_norm(YP::comps[0].bits, y_vals[0]), + detail::decode_norm(UP::comps[0].bits, u_vals[0]), + detail::decode_norm(VP::comps[0].bits, v_vals[0]), + uint16_t(0), + }; + } +}; + +template <typename L> +struct PlanarSink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 3); + + static constexpr size_t y_plane = L::template find_plane<C::Y>(); + static constexpr size_t u_plane = L::template find_plane<C::U>(); + static constexpr size_t v_plane = L::template find_plane<C::V>(); + + using YP = typename L::template plane<y_plane>; + using UP = typename L::template plane<u_plane>; + using VP = typename L::template plane<v_plane>; + + static constexpr size_t block_h = L::v_sub; + static constexpr size_t block_w = L::h_sub; + + static void write_block(Buffer<3>& buf, size_t bx, size_t by, + const YUV16 (&block)[block_h][block_w]) noexcept + { + // Y per pixel. + for (size_t dy = 0; dy < block_h; ++dy) { + uint8_t* y_row = buf.data[y_plane] + + (by + dy) * buf.stride[y_plane]; + for (size_t dx = 0; dx < block_w; ++dx) { + std::array<uint16_t, YP::num_comps> v{}; + v[0] = detail::encode_norm(YP::comps[0].bits, block[dy][dx].y); + detail::store_word<YP>( + y_row + (bx + dx) * YP::bytes_per_pixel, + YP::pack(v)); + } + } + + // One averaged U and V sample per block. Integer truncation + // (no round-half-up). + uint32_t u_sum = 0, v_sum = 0; + for (size_t dy = 0; dy < block_h; ++dy) { + for (size_t dx = 0; dx < block_w; ++dx) { + u_sum += block[dy][dx].u; + v_sum += block[dy][dx].v; + } + } + constexpr uint32_t n = block_h * block_w; + + const size_t cx = bx / L::h_sub; + const size_t cy = by / L::v_sub; + + std::array<uint16_t, UP::num_comps> uw{}; + uw[0] = detail::encode_norm(UP::comps[0].bits, uint16_t(u_sum / n)); + detail::store_word<UP>( + buf.data[u_plane] + cy * buf.stride[u_plane] + + cx * UP::bytes_per_pixel, + UP::pack(uw)); + + std::array<uint16_t, VP::num_comps> vw{}; + vw[0] = detail::encode_norm(VP::comps[0].bits, uint16_t(v_sum / n)); + detail::store_word<VP>( + buf.data[v_plane] + cy * buf.stride[v_plane] + + cx * VP::bytes_per_pixel, + VP::pack(vw)); + } +}; + +// T430-style 3-plane multi-pixel-per-word planar 4:4:4. Each plane has +// `ppw` samples of the same component (Y in plane 0, U in 1, V in 2 — +// or whichever ordering find_plane resolves) packed into a single +// storage word. block_w = ppw, block_h = 1. No chroma subsampling. +template <typename L> +struct MultiPixelPlanarSource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 3); + static_assert(L::h_sub == 1 && L::v_sub == 1); + + static constexpr size_t y_plane = L::template find_plane<C::Y>(); + static constexpr size_t u_plane = L::template find_plane<C::U>(); + static constexpr size_t v_plane = L::template find_plane<C::V>(); + + using YP = typename L::template plane<y_plane>; + using UP = typename L::template plane<u_plane>; + using VP = typename L::template plane<v_plane>; + + static constexpr size_t ppw = YP::template component_count<C::Y>(); + static_assert(ppw == UP::template component_count<C::U>()); + static_assert(ppw == VP::template component_count<C::V>()); + + // All same-tag positions share the same bit width. + static constexpr unsigned y_bits = YP::comps[YP::template find_pos<C::Y>(0)].bits; + static constexpr unsigned u_bits = UP::comps[UP::template find_pos<C::U>(0)].bits; + static constexpr unsigned v_bits = VP::comps[VP::template find_pos<C::V>(0)].bits; + + static YUV16 read(const Buffer<3>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const size_t gx = x / ppw; + const size_t off = x % ppw; + + const uint8_t* yp = buf.data[y_plane] + y * buf.stride[y_plane] + + gx * YP::bytes_per_pixel; + const uint8_t* up = buf.data[u_plane] + y * buf.stride[u_plane] + + gx * UP::bytes_per_pixel; + const uint8_t* vp = buf.data[v_plane] + y * buf.stride[v_plane] + + gx * VP::bytes_per_pixel; + + const auto y_vals = YP::unpack(detail::load_word<YP>(yp)); + const auto u_vals = UP::unpack(detail::load_word<UP>(up)); + const auto v_vals = VP::unpack(detail::load_word<VP>(vp)); + + return YUV16{ + detail::decode_norm(y_bits, y_vals[YP::template find_pos<C::Y>(off)]), + detail::decode_norm(u_bits, u_vals[UP::template find_pos<C::U>(off)]), + detail::decode_norm(v_bits, v_vals[VP::template find_pos<C::V>(off)]), + uint16_t(0), + }; + } +}; + +template <typename L> +struct MultiPixelPlanarSink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 3); + static_assert(L::h_sub == 1 && L::v_sub == 1); + + static constexpr size_t y_plane = L::template find_plane<C::Y>(); + static constexpr size_t u_plane = L::template find_plane<C::U>(); + static constexpr size_t v_plane = L::template find_plane<C::V>(); + + using YP = typename L::template plane<y_plane>; + using UP = typename L::template plane<u_plane>; + using VP = typename L::template plane<v_plane>; + + static constexpr size_t ppw = YP::template component_count<C::Y>(); + + static constexpr size_t y_x_idx = YP::template find_pos<C::X>(); + static constexpr size_t u_x_idx = UP::template find_pos<C::X>(); + static constexpr size_t v_x_idx = VP::template find_pos<C::X>(); + static constexpr bool y_has_x = (y_x_idx < YP::num_comps); + static constexpr bool u_has_x = (u_x_idx < UP::num_comps); + static constexpr bool v_has_x = (v_x_idx < VP::num_comps); + + static constexpr size_t block_h = 1; + static constexpr size_t block_w = ppw; + + static void write_block(Buffer<3>& buf, size_t bx, size_t by, + const YUV16 (&block)[1][ppw]) noexcept + { + std::array<uint16_t, YP::num_comps> yv{}; + std::array<uint16_t, UP::num_comps> uv{}; + std::array<uint16_t, VP::num_comps> vv{}; + + // All same-tag positions share the same bit width. + constexpr unsigned y_bits = YP::comps[YP::template find_pos<C::Y>(0)].bits; + constexpr unsigned u_bits = UP::comps[UP::template find_pos<C::U>(0)].bits; + constexpr unsigned v_bits = VP::comps[VP::template find_pos<C::V>(0)].bits; + for (size_t i = 0; i < ppw; ++i) { + yv[YP::template find_pos<C::Y>(i)] = + detail::encode_norm(y_bits, block[0][i].y); + uv[UP::template find_pos<C::U>(i)] = + detail::encode_norm(u_bits, block[0][i].u); + vv[VP::template find_pos<C::V>(i)] = + detail::encode_norm(v_bits, block[0][i].v); + } + + if constexpr (y_has_x) yv[y_x_idx] = 0; + if constexpr (u_has_x) uv[u_x_idx] = 0; + if constexpr (v_has_x) vv[v_x_idx] = 0; + + const size_t gx = bx / ppw; + detail::store_word<YP>( + buf.data[y_plane] + by * buf.stride[y_plane] + + gx * YP::bytes_per_pixel, + YP::pack(yv)); + detail::store_word<UP>( + buf.data[u_plane] + by * buf.stride[u_plane] + + gx * UP::bytes_per_pixel, + UP::pack(uv)); + detail::store_word<VP>( + buf.data[v_plane] + by * buf.stride[v_plane] + + gx * VP::bytes_per_pixel, + VP::pack(vv)); + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/io/semiplanar.h b/subprojects/pixpat/pixpat-native/src/io/semiplanar.h new file mode 100644 index 0000000..00e7731 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/io/semiplanar.h @@ -0,0 +1,242 @@ +#pragma once + +// 2-plane semiplanar YUV. Two flavours: +// +// SemiplanarSource / SemiplanarSink — NV12/NV21/NV16/NV61, single +// pixel per Y storage word, single chroma pair per chroma word. +// +// MultiPixelSemiplanarSource / MultiPixelSemiplanarSink — P030/P230, +// multiple Y pixels per Y word and multiple chroma pairs per +// chroma word. The Y plane has `ppw_y = component_count<Y>()` Y +// samples per storage word; the chroma plane has `pairs = +// component_count<U>()` U/V pairs per storage word. block_w = +// pairs × h_sub, block_h = v_sub — each block exactly fills one +// chroma word. + +#include <array> + +#include "../layout.h" +#include "detail.h" + +namespace pixpat +{ + +template <typename L> +struct SemiplanarSource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 2); + + using YP = typename L::template plane<0>; + using CP = typename L::template plane<1>; + static constexpr size_t y_idx = YP::template find_pos<C::Y>(); + static constexpr size_t u_idx = CP::template find_pos<C::U>(); + static constexpr size_t v_idx = CP::template find_pos<C::V>(); + + static YUV16 read(const Buffer<2>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + const uint8_t* yp = buf.data[0] + y * buf.stride[0] + x * YP::bytes_per_pixel; + const auto y_vals = YP::unpack(detail::load_word<YP>(yp)); + + const size_t cx = x / L::h_sub; + const size_t cy = y / L::v_sub; + const uint8_t* cp = buf.data[1] + cy * buf.stride[1] + cx * CP::bytes_per_pixel; + const auto c_vals = CP::unpack(detail::load_word<CP>(cp)); + + return YUV16{ + detail::decode_norm(YP::comps[y_idx].bits, y_vals[y_idx]), + detail::decode_norm(CP::comps[u_idx].bits, c_vals[u_idx]), + detail::decode_norm(CP::comps[v_idx].bits, c_vals[v_idx]), + uint16_t(0), + }; + } +}; + +template <typename L> +struct SemiplanarSink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 2); + + using YP = typename L::template plane<0>; + using CP = typename L::template plane<1>; + static constexpr size_t y_idx = YP::template find_pos<C::Y>(); + static constexpr size_t u_idx = CP::template find_pos<C::U>(); + static constexpr size_t v_idx = CP::template find_pos<C::V>(); + + static constexpr size_t block_h = L::v_sub; + static constexpr size_t block_w = L::h_sub; + + static void write_block(Buffer<2>& buf, size_t bx, size_t by, + const YUV16 (&block)[block_h][block_w]) noexcept + { + // Y per pixel. + for (size_t dy = 0; dy < block_h; ++dy) { + uint8_t* y_row = buf.data[0] + (by + dy) * buf.stride[0]; + for (size_t dx = 0; dx < block_w; ++dx) { + std::array<uint16_t, YP::num_comps> v{}; + v[y_idx] = detail::encode_norm(YP::comps[y_idx].bits, + block[dy][dx].y); + detail::store_word<YP>( + y_row + (bx + dx) * YP::bytes_per_pixel, + YP::pack(v)); + } + } + + // One averaged UV pair for the whole block. Integer truncation + // (no round-half-up). + uint32_t u_sum = 0, v_sum = 0; + for (size_t dy = 0; dy < block_h; ++dy) { + for (size_t dx = 0; dx < block_w; ++dx) { + u_sum += block[dy][dx].u; + v_sum += block[dy][dx].v; + } + } + constexpr uint32_t n = block_h * block_w; + const uint16_t u_avg = uint16_t(u_sum / n); + const uint16_t v_avg = uint16_t(v_sum / n); + + std::array<uint16_t, CP::num_comps> uv{}; + uv[u_idx] = detail::encode_norm(CP::comps[u_idx].bits, u_avg); + uv[v_idx] = detail::encode_norm(CP::comps[v_idx].bits, v_avg); + + const size_t cx = bx / L::h_sub; + const size_t cy = by / L::v_sub; + uint8_t* cp = buf.data[1] + cy * buf.stride[1] + cx * CP::bytes_per_pixel; + detail::store_word<CP>(cp, CP::pack(uv)); + } +}; + +// Multi-pixel-per-word semiplanar (P030: 4:2:0, P230: 4:2:2). All Y +// components share the same bit width; same for U and V. +template <typename L> +struct MultiPixelSemiplanarSource { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 2); + + using YP = typename L::template plane<0>; + using CP = typename L::template plane<1>; + static constexpr size_t ppw_y = YP::template component_count<C::Y>(); + static constexpr size_t pairs = CP::template component_count<C::U>(); + static_assert(ppw_y >= 1 && pairs >= 1); + static_assert(pairs == CP::template component_count<C::V>()); + + // All same-tag positions share the same bit width. + static constexpr unsigned y_bits = YP::comps[YP::template find_pos<C::Y>(0)].bits; + static constexpr unsigned u_bits = CP::comps[CP::template find_pos<C::U>(0)].bits; + static constexpr unsigned v_bits = CP::comps[CP::template find_pos<C::V>(0)].bits; + + static YUV16 read(const Buffer<2>& buf, size_t x, size_t y, + [[maybe_unused]] size_t W, + [[maybe_unused]] size_t H) noexcept + { + // Y read. + const size_t y_gx = x / ppw_y; + const size_t y_off = x % ppw_y; + const uint8_t* yp = buf.data[0] + y * buf.stride[0] + + y_gx * YP::bytes_per_pixel; + const auto y_vals = YP::unpack(detail::load_word<YP>(yp)); + + // Chroma read. + const size_t cx = x / L::h_sub; + const size_t cy = y / L::v_sub; + const size_t c_gx = cx / pairs; + const size_t c_off = cx % pairs; + const uint8_t* cp = buf.data[1] + cy * buf.stride[1] + + c_gx * CP::bytes_per_pixel; + const auto c_vals = CP::unpack(detail::load_word<CP>(cp)); + + return YUV16{ + detail::decode_norm(y_bits, y_vals[YP::template find_pos<C::Y>(y_off)]), + detail::decode_norm(u_bits, c_vals[CP::template find_pos<C::U>(c_off)]), + detail::decode_norm(v_bits, c_vals[CP::template find_pos<C::V>(c_off)]), + uint16_t(0), + }; + } +}; + +template <typename L> +struct MultiPixelSemiplanarSink { + using Layout = L; + using Pixel = YUV16; + + static_assert(L::kind == ColorKind::YUV); + static_assert(L::num_planes == 2); + + using YP = typename L::template plane<0>; + using CP = typename L::template plane<1>; + static constexpr size_t ppw_y = YP::template component_count<C::Y>(); + static constexpr size_t pairs = CP::template component_count<C::U>(); + static_assert(ppw_y >= 1 && pairs >= 1); + + // One block exactly fills one chroma word: `pairs` chroma pairs, + // each covering h_sub luma columns × v_sub rows. + static constexpr size_t block_w = pairs * L::h_sub; + static constexpr size_t block_h = L::v_sub; + static_assert(block_w % ppw_y == 0, + "block width must be a multiple of Y-pixels-per-word"); + static constexpr size_t y_words_per_row = block_w / ppw_y; + + // All same-tag positions share the same bit width. + static constexpr unsigned y_bits = YP::comps[YP::template find_pos<C::Y>(0)].bits; + static constexpr unsigned u_bits = CP::comps[CP::template find_pos<C::U>(0)].bits; + static constexpr unsigned v_bits = CP::comps[CP::template find_pos<C::V>(0)].bits; + + static void write_block(Buffer<2>& buf, size_t bx, size_t by, + const YUV16 (&block)[block_h][block_w]) noexcept + { + // Y plane: y_words_per_row Y-words per row, block_h rows. + for (size_t dy = 0; dy < block_h; ++dy) { + uint8_t* y_row = buf.data[0] + + (by + dy) * buf.stride[0]; + for (size_t w = 0; w < y_words_per_row; ++w) { + std::array<uint16_t, YP::num_comps> v{}; + for (size_t i = 0; i < ppw_y; ++i) { + const size_t pos = YP::template find_pos<C::Y>(i); + v[pos] = detail::encode_norm( + y_bits, block[dy][w * ppw_y + i].y); + } + detail::store_word<YP>( + y_row + (bx / ppw_y + w) + * YP::bytes_per_pixel, + YP::pack(v)); + } + } + + // One UV-word: `pairs` chroma pairs. Each pair averages h_sub + // horizontally × v_sub vertically luma values. + std::array<uint16_t, CP::num_comps> uv{}; + constexpr uint32_t n = L::h_sub * L::v_sub; + for (size_t p = 0; p < pairs; ++p) { + uint32_t u_sum = 0, v_sum = 0; + for (size_t dy = 0; dy < block_h; ++dy) { + for (size_t dx = 0; dx < L::h_sub; ++dx) { + u_sum += block[dy][p * L::h_sub + dx].u; + v_sum += block[dy][p * L::h_sub + dx].v; + } + } + uv[CP::template find_pos<C::U>(p)] = + detail::encode_norm(u_bits, uint16_t(u_sum / n)); + uv[CP::template find_pos<C::V>(p)] = + detail::encode_norm(v_bits, uint16_t(v_sum / n)); + } + + const size_t cy = by / L::v_sub; + const size_t uv_word_idx = bx / block_w; + detail::store_word<CP>( + buf.data[1] + cy * buf.stride[1] + + uv_word_idx * CP::bytes_per_pixel, + CP::pack(uv)); + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/layout.h b/subprojects/pixpat/pixpat-native/src/layout.h new file mode 100644 index 0000000..d092bb1 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/layout.h @@ -0,0 +1,141 @@ +#pragma once + +#include <array> +#include <cstddef> +#include <cstdint> +#include <tuple> + +namespace pixpat +{ + +enum class ColorKind { RGB, YUV }; + +// Normalized inter-stage pixel types. 16-bit-per-component integer. +// N-bit storage values bit-replicate up to normalized 16-bit (so +// N-bit max maps to 0xFFFF); encoding back is a truncating +// `normalized >> (16 - N)`. See io/detail.h for the round-trip +// argument. Sources without an A component emit a=0; cross-color-kind +// ColorXfm resets a=0xFFFF; sinks with X write 0, sinks with A +// encode `a`. +struct RGB16 { + static constexpr ColorKind kind = ColorKind::RGB; + uint16_t r, g, b, a; +}; + +struct YUV16 { + static constexpr ColorKind kind = ColorKind::YUV; + uint16_t y, u, v, a; +}; + +inline constexpr uint16_t kNormMax = 0xFFFF; + +enum class C : uint8_t { X, A, R, G, B, Y, U, V }; + +struct Comp { + C c; + uint8_t bits; + uint8_t shift; +}; + +template <typename Storage, Comp... Cs> +struct Plane { + using storage_t = Storage; + + static constexpr size_t num_comps = sizeof...(Cs); + static constexpr std::array<Comp, num_comps> comps{ Cs ... }; + static constexpr size_t total_bits = (size_t(Cs.bits) + ... + 0); + static constexpr size_t storage_bits = sizeof(Storage) * 8; + static constexpr size_t bytes_per_pixel = (total_bits + 7) / 8; + + static_assert(total_bits <= storage_bits, "components overflow storage word"); + + // Index of the n-th component matching Tag, or num_comps if absent. + template <C Tag> + static constexpr size_t find_pos(size_t n = 0) + { + for (size_t i = 0; i < num_comps; ++i) { + if (comps[i].c == Tag) { + if (n == 0) + return i; + --n; + } + } + return num_comps; + } + + // Count of components matching Tag. Used to derive + // pixels_per_word for multi-pixel-per-storage formats (XYYY2101010, + // P030, ...). + template <C Tag> + static constexpr size_t component_count() + { + size_t cnt = 0; + for (size_t i = 0; i < num_comps; ++i) + if (comps[i].c == Tag) + ++cnt; + return cnt; + } + + // Mask each input value to its bit-width and OR-shift it into the + // storage word. The loop trip count and the comps[i] reads are + // compile-time constant, so the optimizer unrolls and folds. + static constexpr Storage pack(const std::array<uint16_t, num_comps>& v) noexcept + { + Storage out{}; + for (size_t i = 0; i < num_comps; ++i) { + const Storage mask = (Storage{ 1 } << comps[i].bits) - 1; + out |= Storage(v[i] & mask) << comps[i].shift; + } + return out; + } + + // Mirror of `pack`. + static constexpr std::array<uint16_t, num_comps> unpack(Storage word) noexcept + { + std::array<uint16_t, num_comps> out{}; + for (size_t i = 0; i < num_comps; ++i) { + const Storage mask = (Storage{ 1 } << comps[i].bits) - 1; + out[i] = uint16_t((word >> comps[i].shift) & mask); + } + return out; + } +}; + +template <ColorKind Kind, size_t Hsub, size_t Vsub, typename ... Planes> +struct Layout { + static constexpr ColorKind kind = Kind; + static constexpr size_t h_sub = Hsub; + static constexpr size_t v_sub = Vsub; + static constexpr size_t num_planes = sizeof...(Planes); + + template <size_t N> + using plane = std::tuple_element_t<N, std::tuple<Planes...> >; + + // Index of the first plane containing component Tag, or num_planes + // if no plane has it. Lets PlanarSource/Sink map C::U / C::V to a + // plane regardless of YUV vs YVU ordering. + // Comma-fold over plane indices: for each plane I check if it has + // Tag, and on the first hit assign `found = I`. Subsequent hits are + // suppressed by the `found == num_planes` guard. The whole fold + // evaluates to a discarded list of int 0s; the `found` capture + // carries the result out. + template <C Tag> + static constexpr size_t find_plane() + { + return [&]<size_t... I>(std::index_sequence<I...>) { + size_t found = num_planes; + ((plane<I>::template find_pos<Tag>() < plane<I>::num_comps + ? (found == num_planes ? (found = I, 0) : 0) + : 0), ...); + return found; + } (std::make_index_sequence<num_planes>{}); + } +}; + +template <size_t N> +struct Buffer { + std::array<uint8_t*, N> data; + std::array<size_t, N> stride; +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/params.h b/subprojects/pixpat/pixpat-native/src/params.h new file mode 100644 index 0000000..aa2be67 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/params.h @@ -0,0 +1,219 @@ +#pragma once + +#include <cctype> +#include <cstddef> +#include <cstdint> +#include <optional> +#include <string> +#include <string_view> +#include <utility> +#include <vector> + +#include "layout.h" + +namespace pixpat +{ + +// Pattern-specific parameters parsed from pixpat_pattern_opts::params. +// The wire format is a comma-separated list of "key=value" items; +// whitespace around tokens is trimmed, keys and values are +// case-insensitive ASCII, and neither may contain ',' or '='. +// Malformed input leaves ok() returning false — the pattern dispatcher +// fails the call when that happens. +// +// Patterns query keys by name via get() / get_int() / get_hex_color(). +// Unknown keys are ignored: each pattern handles forward compatibility, +// not the parser. +class Params +{ +public: + explicit Params(const char* csv); + + bool ok() const noexcept { + return ok_; + } + + std::optional<std::string_view> get(std::string_view key) const noexcept; + std::optional<int> get_int(std::string_view key) const noexcept; + std::optional<RGB16> get_hex_color(std::string_view key) const noexcept; + +private: + std::vector<std::pair<std::string, std::string> > kv_; + bool ok_{ true }; +}; + +namespace detail +{ + +inline char ascii_tolower(char c) noexcept +{ + return (c >= 'A' && c <= 'Z') ? char(c + ('a' - 'A')) : c; +} + +inline std::string_view trim(std::string_view s) noexcept +{ + while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front()))) + s.remove_prefix(1); + while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back()))) + s.remove_suffix(1); + return s; +} + +inline bool ieq(std::string_view a, std::string_view b) noexcept +{ + if (a.size() != b.size()) + return false; + for (size_t i = 0; i < a.size(); ++i) + if (ascii_tolower(a[i]) != ascii_tolower(b[i])) + return false; + return true; +} + +} // namespace detail + + +inline Params::Params(const char* csv) +{ + if (!csv || *csv == '\0') + return; + + std::string_view s(csv); + while (!s.empty()) { + const size_t comma = s.find(','); + std::string_view item = (comma == std::string_view::npos) + ? s : s.substr(0, comma); + s = (comma == std::string_view::npos) + ? std::string_view{} : s.substr(comma + 1); + + item = detail::trim(item); + if (item.empty()) { + ok_ = false; + return; + } + + const size_t eq = item.find('='); + if (eq == std::string_view::npos) { + ok_ = false; + return; + } + const std::string_view k = detail::trim(item.substr(0, eq)); + const std::string_view v = detail::trim(item.substr(eq + 1)); + if (k.empty()) { + ok_ = false; + return; + } + kv_.emplace_back(std::string(k), std::string(v)); + } +} + +inline std::optional<std::string_view> +Params::get(std::string_view key) const noexcept +{ + for (const auto& [k, v] : kv_) + if (detail::ieq(k, key)) + return std::string_view(v); + return std::nullopt; +} + +inline std::optional<int> +Params::get_int(std::string_view key) const noexcept +{ + auto v = get(key); + if (!v || v->empty()) + return std::nullopt; + int sign = 1; + size_t i = 0; + if ((*v)[0] == '-') { sign = -1; ++i; } + else if ((*v)[0] == '+') { ++i; } + if (i == v->size()) + return std::nullopt; + int out = 0; + for (; i < v->size(); ++i) { + const char c = (*v)[i]; + if (c < '0' || c > '9') + return std::nullopt; + out = out * 10 + (c - '0'); + } + return sign * out; +} + +// Parses a hex color string. The optional `0x`/`0X` prefix is allowed. +// The number of hex digits after the prefix selects the layout: +// 6 digits — 8-bit RRGGBB (alpha defaults to opaque) +// 8 digits — 8-bit AARRGGBB (alpha-first) +// 12 digits — 16-bit RRRRGGGGBBBB (alpha defaults to opaque) +// 16 digits — 16-bit AAAARRRRGGGGBBBB (alpha-first) +// 8-bit components are byte-replicated to the normalized 16-bit form +// (0xFF → 0xFFFF); 16-bit components are stored directly. Any other +// length, malformed digits, or stray separators yield std::nullopt. +inline std::optional<RGB16> +Params::get_hex_color(std::string_view key) const noexcept +{ + auto v = get(key); + if (!v) + return std::nullopt; + + std::string_view s = *v; + if (s.size() >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) + s.remove_prefix(2); + + const auto digit = [](char c) -> int { + if (c >= '0' && c <= '9') return c - '0'; + if (c >= 'a' && c <= 'f') return c - 'a' + 10; + if (c >= 'A' && c <= 'F') return c - 'A' + 10; + return -1; + }; + const auto parse_n = [&](size_t off, size_t n) -> std::optional<unsigned> { + unsigned out = 0; + for (size_t i = 0; i < n; ++i) { + const int d = digit(s[off + i]); + if (d < 0) + return std::nullopt; + out = (out << 4) | unsigned(d); + } + return out; + }; + + bool has_alpha; + bool is_16bpc; + switch (s.size()) { + case 6: has_alpha = false; is_16bpc = false; break; + case 8: has_alpha = true; is_16bpc = false; break; + case 12: has_alpha = false; is_16bpc = true; break; + case 16: has_alpha = true; is_16bpc = true; break; + default: return std::nullopt; + } + + const size_t per = is_16bpc ? 4 : 2; + const unsigned full = is_16bpc ? 0xFFFFu : 0xFFu; + unsigned a = full, r, g, b; + size_t off = 0; + if (has_alpha) { + auto av = parse_n(off, per); + if (!av) return std::nullopt; + a = *av; + off += per; + } + auto rv = parse_n(off, per); + if (!rv) return std::nullopt; + r = *rv; + off += per; + auto gv = parse_n(off, per); + if (!gv) return std::nullopt; + g = *gv; + off += per; + auto bv = parse_n(off, per); + if (!bv) return std::nullopt; + b = *bv; + + if (is_16bpc) { + return RGB16{ uint16_t(r), uint16_t(g), uint16_t(b), uint16_t(a) }; + } else { + const auto rep = [](unsigned x) noexcept { + return uint16_t((x << 8) | x); + }; + return RGB16{ rep(r), rep(g), rep(b), rep(a) }; + } +} + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/pattern.h b/subprojects/pixpat/pixpat-native/src/pattern.h new file mode 100644 index 0000000..fbee683 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/pattern.h @@ -0,0 +1,597 @@ +#pragma once + +#include <cmath> +#include <cstdint> + +#include "color.h" +#include "layout.h" +#include "params.h" + +namespace pixpat::patterns +{ + +// Patterns emit opaque pixels (a=kNormMax) unless they encode their +// own alpha (e.g. `plain`'s ARGB form). Alpha-bearing sinks +// (ARGB8888 etc) therefore see the pattern's chosen alpha; convert +// paths propagate the source's actual `a` instead (a=0 for X-only +// sources). +// +// A pattern is an instance with: +// using Pixel = RGB16 | YUV16; +// explicit Pat(const Params&) noexcept; +// Pixel sample(size_t x, size_t y, size_t W, size_t H) const noexcept; +// bool ready() const noexcept; // optional, default true +// Patterns that don't read params ignore the constructor argument. + +namespace detail +{ +// 8-bit -> normalized 16 byte-replication. e.g. 255 -> 0xFFFF, +// 1 -> 0x0101. +constexpr RGB16 rgb8(uint8_t r, uint8_t g, uint8_t b) noexcept +{ + return RGB16{ + uint16_t((uint16_t(r) << 8) | r), + uint16_t((uint16_t(g) << 8) | g), + uint16_t((uint16_t(b) << 8) | b), + kNormMax, + }; +} + +// 12-bit -> normalized 16 bit-replication. +constexpr YUV16 yuv12(uint16_t y, uint16_t u, uint16_t v) noexcept +{ + return YUV16{ + uint16_t((y << 4) | (y >> 8)), + uint16_t((u << 4) | (u >> 8)), + uint16_t((v << 4) | (v >> 8)), + kNormMax, + }; +} +} // namespace detail + +// "kmstest" default pattern: white border + diagonals; blue rails on +// the top/left edges; red rails on the bottom/right; an 8-step color +// gradient block in the center. +struct Kmstest { + using Pixel = RGB16; + + explicit Kmstest(const Params&) noexcept { + } + + RGB16 sample(size_t x, size_t y, size_t W, size_t H) const noexcept + { + using detail::rgb8; + const size_t mw = 20; + const size_t xm1 = mw; + const size_t xm2 = W - mw - 1; + const size_t ym1 = mw; + const size_t ym2 = H - mw - 1; + + if (x == xm1 || x == xm2 || y == ym1 || y == ym2) + return rgb8(255, 255, 255); + if (x < xm1 && y < ym1) + return rgb8(255, 255, 255); + if ((x == 0 || x == W - 1) && (y < ym1 || y > ym2)) + return rgb8(255, 255, 255); + if ((y == 0 || y == H - 1) && (x < xm1 || x > xm2)) + return rgb8(255, 255, 255); + if (x < xm1 && (y > ym1 && y < ym2)) + return rgb8(0, 0, 255); + if (y < ym1 && (x > xm1 && x < xm2)) + return rgb8(0, 0, 255); + if (x > xm2 && (y > ym1 && y < ym2)) + return rgb8(255, 0, 0); + if (y > ym2 && (x > xm1 && x < xm2)) + return rgb8(255, 0, 0); + if (x > xm1 && x < xm2 && y > ym1 && y < ym2) { + if (x == y || W - x == H - y) + return rgb8(255, 255, 255); + if (W - x - 1 == y || x == H - y - 1) + return rgb8(255, 255, 255); + const int t = int((x - xm1 - 1) * 8 / (xm2 - xm1 - 1)); + const unsigned c = unsigned((y - ym1 - 1) % 256); + unsigned r = 0, g = 0, b = 0; + switch (t) { + case 0: r = c; break; + case 1: g = c; break; + case 2: b = c; break; + case 3: g = b = c; break; + case 4: r = b = c; break; + case 5: r = g = c; break; + case 6: r = g = b = c; break; + case 7: break; + } + return rgb8(uint8_t(r), uint8_t(g), uint8_t(b)); + } + return rgb8(0, 0, 0); + } +}; + +// SMPTE RP 219-1:2014 color bar pattern. Emits YUV directly with +// pixel values defined by the spec in BT.709 / Limited range. Pass +// `rec=BT709, range=Limited` for spec-correct output; other ColorSpec +// settings produce visibly-wrong colors when the sink crosses to RGB +// (the matrix the caller picked is applied to BT.709-encoded values). +// Callers are trusted — pixpat does not override the spec for them. +struct Smpte { + using Pixel = YUV16; + + explicit Smpte(const Params&) noexcept { + } + + YUV16 sample(size_t x, size_t y, size_t W, size_t H) const noexcept + { + using detail::yuv12; + constexpr YUV16 gray40 = yuv12(1658, 2048, 2048); + constexpr YUV16 white75 = yuv12(2884, 2048, 2048); + constexpr YUV16 yellow75 = yuv12(2694, 704, 2171); + constexpr YUV16 cyan75 = yuv12(2325, 2356, 704); + constexpr YUV16 green75 = yuv12(2136, 1012, 827); + constexpr YUV16 magenta75 = yuv12(1004, 3084, 3269); + constexpr YUV16 red75 = yuv12( 815, 1740, 3392); + constexpr YUV16 blue75 = yuv12( 446, 3392, 1925); + constexpr YUV16 cyan100 = yuv12(3015, 2459, 256); + constexpr YUV16 blue100 = yuv12( 509, 3840, 1884); + constexpr YUV16 yellow100 = yuv12(3507, 256, 2212); + constexpr YUV16 black = yuv12( 256, 2048, 2048); + constexpr YUV16 white100 = yuv12(3760, 2048, 2048); + constexpr YUV16 red100 = yuv12(1001, 1637, 3840); + constexpr YUV16 gray15 = yuv12( 782, 2048, 2048); + + constexpr YUV16 black_m2 = yuv12( 186, 2048, 2048); + constexpr YUV16 black_p2 = yuv12( 326, 2048, 2048); + constexpr YUV16 black_p4 = yuv12( 396, 2048, 2048); + + constexpr size_t M = 1024; + const size_t xs = x * M; + const size_t a = W * M; + const size_t c = (a * 3 / 4) / 7; + const size_t d = a / 8; + + const size_t pattern1_height = (H * 7) / 12; + const size_t pattern2_height = pattern1_height + (H / 12); + const size_t pattern3_height = pattern2_height + (H / 12); + + if (y < pattern1_height) { + if (xs < d || xs >= (a - d)) + return gray40; + const size_t bar = (xs - d) / c; + switch (bar) { + case 0: return white75; + case 1: return yellow75; + case 2: return cyan75; + case 3: return green75; + case 4: return magenta75; + case 5: return red75; + default: return blue75; + } + } + + if (y < pattern2_height) { + if (xs < d) return cyan100; + if (xs >= (a - d)) return blue100; + return white75; + } + + if (y < pattern3_height) { + if (xs < d) return yellow100; + if (xs >= (a - d)) return red100; + const size_t ramp_w = a - 2 * d; + const size_t ramp_x = xs - d; + const uint16_t y_val = uint16_t(256 + (3760 - 256) * ramp_x / ramp_w); + return yuv12(y_val, 2048, 2048); + } + + // pattern4 (PLUGE) + const size_t c0 = d; + const size_t c1 = c0 + c * 3 / 2; + const size_t c2 = c1 + 2 * c; + const size_t c3 = c2 + c * 5 / 6; + + if (xs < c0) return gray15; + if (xs < c1) return black; + if (xs < c2) return white100; + if (xs < c3) return black; + if (xs >= a - d) return gray15; + if (xs >= a - d - c) return black; + + const size_t step = (xs - c3) / (c / 3); + switch (step) { + case 0: return black_m2; + case 1: return black; + case 2: return black_p2; + case 3: return black; + default: return black_p4; + } + } +}; + +// Solid fill from a hex color string. Reads `color=<hex>` from +// params; the value is parsed by Params::get_hex_color (8/16-bpc, +// alpha-first if present, optional `0x` prefix). Missing or +// malformed `color` leaves ready()=false and the dispatcher fails +// the call. +struct Plain { + using Pixel = RGB16; + + explicit Plain(const Params& p) noexcept + { + if (auto c = p.get_hex_color("color")) { + color_ = *c; + ready_ = true; + } + } + + bool ready() const noexcept { + return ready_; + } + + RGB16 sample(size_t, size_t, size_t, size_t) const noexcept + { + return color_; + } + +private: + RGB16 color_{}; + bool ready_{ false }; +}; + +namespace detail +{ +// Linear ramp 0..kNormMax across [0, span-1]. span<=1 returns kNormMax. +constexpr uint16_t ramp16(size_t pos, size_t span) noexcept +{ + if (span <= 1) + return kNormMax; + return uint16_t((uint64_t(pos) * kNormMax) / (span - 1)); +} +} // namespace detail + +// Black/white checkerboard. Reads optional `cell=<N>` (positive +// integer; default 8) for cell size in pixels. +struct Checker { + using Pixel = RGB16; + + explicit Checker(const Params& p) noexcept + { + if (p.get("cell")) { + auto n = p.get_int("cell"); + if (!n || *n <= 0) { + ready_ = false; + return; + } + cell_ = size_t(*n); + } + } + + bool ready() const noexcept { + return ready_; + } + + RGB16 sample(size_t x, size_t y, size_t, size_t) const noexcept + { + const bool dark = (((x / cell_) ^ (y / cell_)) & 1u) != 0; + return dark ? RGB16{ 0, 0, 0, kNormMax } + : RGB16{ kNormMax, kNormMax, kNormMax, kNormMax }; + } + +private: + size_t cell_{ 8 }; + bool ready_{ true }; +}; + +namespace detail +{ +// Pick one of (R, G, B, gray) given a stripe index in [0, 4) and a +// scalar ramp value. Used by hramp/vramp. +constexpr RGB16 rgb_gray_stripe(size_t stripe, uint16_t v) noexcept +{ + switch (stripe) { + case 0: return RGB16{ v, 0, 0, kNormMax }; + case 1: return RGB16{ 0, v, 0, kNormMax }; + case 2: return RGB16{ 0, 0, v, kNormMax }; + default: return RGB16{ v, v, v, kNormMax }; + } +} +} // namespace detail + +// Four horizontal stripes — R, G, B, gray — each a 0..max ramp +// along x. Per-channel and luma quantization in one pattern. +struct Hramp { + using Pixel = RGB16; + + explicit Hramp(const Params&) noexcept { + } + + RGB16 sample(size_t x, size_t y, size_t W, size_t H) const noexcept + { + const size_t stripe = (H == 0) ? 0 : (y * 4) / H; + return detail::rgb_gray_stripe(stripe, detail::ramp16(x, W)); + } +}; + +// Four vertical columns — R, G, B, gray — each a 0..max ramp +// along y. Same coverage as hramp, rotated 90°. +struct Vramp { + using Pixel = RGB16; + + explicit Vramp(const Params&) noexcept { + } + + RGB16 sample(size_t x, size_t y, size_t W, size_t H) const noexcept + { + const size_t col = (W == 0) ? 0 : (x * 4) / W; + return detail::rgb_gray_stripe(col, detail::ramp16(y, H)); + } +}; + +// Diagonal RGB ramp: R sweeps with x, G with y, B with x+y. +struct Dramp { + using Pixel = RGB16; + + explicit Dramp(const Params&) noexcept { + } + + RGB16 sample(size_t x, size_t y, size_t W, size_t H) const noexcept + { + const uint16_t r = detail::ramp16(x, W); + const uint16_t g = detail::ramp16(y, H); + const size_t span = (W + H >= 2) ? (W + H - 1) : 1; + const uint16_t b = detail::ramp16(x + y, span); + return RGB16{ r, g, b, kNormMax }; + } +}; + +namespace detail +{ +// Seven-region color sequence used by hbar/vbar: +// white, red, white, green, white, blue, white. The white separators +// between R/G/B make per-channel offsets at the band boundaries +// visible. +constexpr RGB16 bar_color7(size_t band) noexcept +{ + switch (band) { + case 1: return rgb8(255, 0, 0); + case 3: return rgb8( 0, 255, 0); + case 5: return rgb8( 0, 0, 255); + default: return rgb8(255, 255, 255); + } +} +} // namespace detail + +// Vertical bar (full image height, narrow along x) over a black +// background. `pos` is the left edge in pixels (signed; negative +// values clip at the left edge); `width` is the bar thickness in +// pixels (default 32). The bar is split into 7 equal-height regions +// colored white/red/white/green/white/blue/white. +struct VBarRGB { + using Pixel = RGB16; + + explicit VBarRGB(const Params& p) noexcept + { + auto pp = p.get_int("pos"); + if (!pp) { + ready_ = false; + return; + } + pos_ = *pp; + if (p.get("width")) { + auto w = p.get_int("width"); + if (!w || *w <= 0) { + ready_ = false; + return; + } + width_ = size_t(*w); + } + } + + bool ready() const noexcept { + return ready_; + } + + RGB16 sample(size_t x, size_t y, size_t, size_t H) const noexcept + { + const long long sx = static_cast<long long>(x); + const long long lo = pos_; + const long long hi = lo + static_cast<long long>(width_); + if (sx < lo || sx >= hi) + return detail::rgb8(0, 0, 0); + const size_t band = (H == 0) ? 0 : (y * 7) / H; + return detail::bar_color7(band); + } + +private: + int pos_{}; + size_t width_{ 32 }; + bool ready_{ true }; +}; + +// Horizontal bar: vbar rotated 90°. `pos` is the top edge in pixels; +// `width` is the bar thickness in pixels (default 32). The bar spans +// the full image width and is split into 7 equal-width regions +// colored white/red/white/green/white/blue/white. +struct HBarRGB { + using Pixel = RGB16; + + explicit HBarRGB(const Params& p) noexcept + { + auto pp = p.get_int("pos"); + if (!pp) { + ready_ = false; + return; + } + pos_ = *pp; + if (p.get("width")) { + auto w = p.get_int("width"); + if (!w || *w <= 0) { + ready_ = false; + return; + } + width_ = size_t(*w); + } + } + + bool ready() const noexcept { + return ready_; + } + + RGB16 sample(size_t x, size_t y, size_t W, size_t) const noexcept + { + const long long sy = static_cast<long long>(y); + const long long lo = pos_; + const long long hi = lo + static_cast<long long>(width_); + if (sy < lo || sy >= hi) + return detail::rgb8(0, 0, 0); + const size_t band = (W == 0) ? 0 : (x * 7) / W; + return detail::bar_color7(band); + } + +private: + int pos_{}; + size_t width_{ 32 }; + bool ready_{ true }; +}; + +// Same shape as VBarRGB but emits YUV16 directly. The five unique colors +// (black bg + white/red/green/blue bar regions) are precomputed from +// `spec` at construction so the cross-kind pass is a no-op when the +// sink is YUV. Use the RGB-native `VBarRGB` for RGB sinks instead — it +// avoids the YUV→RGB pass that this variant would incur there. +struct VBarYUV { + using Pixel = YUV16; + + explicit VBarYUV(const Params& p, ColorSpec spec) noexcept + { + auto pp = p.get_int("pos"); + if (!pp) { + ready_ = false; + return; + } + pos_ = *pp; + if (p.get("width")) { + auto w = p.get_int("width"); + if (!w || *w <= 0) { + ready_ = false; + return; + } + width_ = size_t(*w); + } + const ColorCoeffs c = coeffs_for(spec); + using X = ColorXfm<RGB16, YUV16>; + bg_ = X::apply(detail::rgb8( 0, 0, 0), c); + bands_[0] = X::apply(detail::rgb8(255, 255, 255), c); + bands_[1] = X::apply(detail::rgb8(255, 0, 0), c); + bands_[2] = bands_[0]; + bands_[3] = X::apply(detail::rgb8( 0, 255, 0), c); + bands_[4] = bands_[0]; + bands_[5] = X::apply(detail::rgb8( 0, 0, 255), c); + bands_[6] = bands_[0]; + } + + bool ready() const noexcept { + return ready_; + } + + YUV16 sample(size_t x, size_t y, size_t, size_t H) const noexcept + { + const long long sx = static_cast<long long>(x); + const long long lo = pos_; + const long long hi = lo + static_cast<long long>(width_); + if (sx < lo || sx >= hi) + return bg_; + const size_t band = (H == 0) ? 0 : (y * 7) / H; + return bands_[band]; + } + +private: + YUV16 bg_{}; + YUV16 bands_[7]{}; + int pos_{}; + size_t width_{ 32 }; + bool ready_{ true }; +}; + +// YUV-native counterpart to HBarRGB. See VBarYUV. +struct HBarYUV { + using Pixel = YUV16; + + explicit HBarYUV(const Params& p, ColorSpec spec) noexcept + { + auto pp = p.get_int("pos"); + if (!pp) { + ready_ = false; + return; + } + pos_ = *pp; + if (p.get("width")) { + auto w = p.get_int("width"); + if (!w || *w <= 0) { + ready_ = false; + return; + } + width_ = size_t(*w); + } + const ColorCoeffs c = coeffs_for(spec); + using X = ColorXfm<RGB16, YUV16>; + bg_ = X::apply(detail::rgb8( 0, 0, 0), c); + bands_[0] = X::apply(detail::rgb8(255, 255, 255), c); + bands_[1] = X::apply(detail::rgb8(255, 0, 0), c); + bands_[2] = bands_[0]; + bands_[3] = X::apply(detail::rgb8( 0, 255, 0), c); + bands_[4] = bands_[0]; + bands_[5] = X::apply(detail::rgb8( 0, 0, 255), c); + bands_[6] = bands_[0]; + } + + bool ready() const noexcept { + return ready_; + } + + YUV16 sample(size_t x, size_t y, size_t W, size_t) const noexcept + { + const long long sy = static_cast<long long>(y); + const long long lo = pos_; + const long long hi = lo + static_cast<long long>(width_); + if (sy < lo || sy >= hi) + return bg_; + const size_t band = (W == 0) ? 0 : (x * 7) / W; + return bands_[band]; + } + +private: + YUV16 bg_{}; + YUV16 bands_[7]{}; + int pos_{}; + size_t width_{ 32 }; + bool ready_{ true }; +}; + +// Centered radial cosine zone plate: 0.5 + 0.5 * cos(k * (cx² + cy²)) +// with cx, cy measured from the image center and k chosen so the +// local frequency hits Nyquist at the longer edge — i.e. the pattern +// uses every spatial frequency the grid can resolve. +struct Zoneplate { + using Pixel = RGB16; + + explicit Zoneplate(const Params&) noexcept { + } + + RGB16 sample(size_t x, size_t y, size_t W, size_t H) const noexcept + { + const double max_dim = double(W > H ? W : H); + // Local frequency d(k r²)/dr = 2 k r. At r = max_dim/2 the + // frequency reaches π/pixel (Nyquist), giving k = π / max_dim. + const double k = 3.14159265358979323846 / (max_dim > 0 ? max_dim : 1.0); + const double cx = double(x) - 0.5 * double(W); + const double cy = double(y) - 0.5 * double(H); + const double phase = k * (cx * cx + cy * cy); + const double v = 0.5 + 0.5 * std::cos(phase); + const double scaled = v * 65535.0; + const uint16_t g = (scaled < 0.0) ? uint16_t(0) + : (scaled > 65535.0) ? kNormMax + : uint16_t(scaled + 0.5); + return RGB16{ g, g, g, kNormMax }; + } +}; + +} // namespace pixpat::patterns diff --git a/subprojects/pixpat/pixpat-native/src/pattern_catalog.h b/subprojects/pixpat/pixpat-native/src/pattern_catalog.h new file mode 100644 index 0000000..6576b2b --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/pattern_catalog.h @@ -0,0 +1,64 @@ +#pragma once + +// Catalog of every named pattern the C++ side knows. Mirrors the +// shape of format_catalog.h. The X-macro is a list of +// (Label, RgbType, YuvType, "name") rows: +// +// X(Label, RgbType, YuvType, "name") +// +// `Label` is the C++ identifier doubling as the PatternId enum value +// and the s_pattern_caps[] index. `RgbType` and `YuvType` resolve to +// classes in `pixpat::patterns::` (defined in pattern.h) that satisfy +// the pattern interface (sample(), Pixel) — one per color kind. Use +// `void` if the pattern has no variant in that kind. At least one +// must be non-void. When both are present, dispatch_draw_pattern +// picks the variant matching the sink's color kind so the cross-kind +// pass is a no-op; when only one is present, the pipeline runs the +// cross-kind pass for the opposite-kind sinks. `name` is the +// lowercase identifier exposed via the C ABI. +// +// Adding a pattern = a row here AND its class(es) in pattern.h. The +// codegen (pixpat-native/codegen/gen_pixpat.py) parses this X-macro +// to learn the pattern set; pixpat_pattern.cpp re-expands it to build +// the dispatch arms and the default-pattern fallback. + +#include <cstddef> +#include <cstdint> + +namespace pixpat +{ + +#define PIXPAT_PATTERN_LIST(X) \ + X(Kmstest, Kmstest, void, "kmstest") \ + X(Smpte, void, Smpte, "smpte") \ + X(Plain, Plain, void, "plain") \ + X(Checker, Checker, void, "checker") \ + X(Hramp, Hramp, void, "hramp") \ + X(Vramp, Vramp, void, "vramp") \ + X(HBar, HBarRGB, HBarYUV, "hbar") \ + X(VBar, VBarRGB, VBarYUV, "vbar") \ + X(Dramp, Dramp, void, "dramp") \ + X(Zoneplate, Zoneplate, void, "zoneplate") + +enum class PatternId : uint8_t { +#define X(label, rgb, yuv, name) label, + PIXPAT_PATTERN_LIST(X) +#undef X + Unknown, +}; + +struct PatternEntry { + const char* name; + PatternId id; +}; + +inline constexpr PatternEntry s_pattern_table[] = { +#define X(label, rgb, yuv, name) { name, PatternId::label }, + PIXPAT_PATTERN_LIST(X) +#undef X +}; + +inline constexpr size_t s_pattern_catalog_count = + sizeof(s_pattern_table) / sizeof(s_pattern_table[0]); + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/pipeline.h b/subprojects/pixpat/pixpat-native/src/pipeline.h new file mode 100644 index 0000000..09e13bc --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/pipeline.h @@ -0,0 +1,44 @@ +#pragma once + +#include <cstddef> + +#include "color.h" +#include "layout.h" + +// Inlined source → color → sink composition. The intermediate Pixel +// values stay in registers across stages; there is no normalized RGB16 +// or YUV16 buffer between source and sink. Block size is dictated by +// the sink: 1x1 for non-subsampled formats, h_sub × v_sub for chroma- +// subsampled ones. + +namespace pixpat +{ + +template <typename Source, typename Sink> +struct Converter { + using Xfm = ColorXfm<typename Source::Pixel, typename Sink::Pixel>; + static constexpr size_t bh = Sink::block_h; + static constexpr size_t bw = Sink::block_w; + + static void run(const Buffer<Source::Layout::num_planes>& src, + Buffer<Sink::Layout::num_planes>& dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) noexcept + { + const ColorCoeffs c = coeffs_for(spec); + for (size_t by = by_start; by < by_end; by += bh) { + for (size_t bx = 0; bx < W; bx += bw) { + typename Sink::Pixel block[bh][bw]; + for (size_t dy = 0; dy < bh; ++dy) + for (size_t dx = 0; dx < bw; ++dx) + block[dy][dx] = Xfm::apply( + Source::read(src, bx + dx, by + dy, + W, H), c); + Sink::write_block(dst, bx, by, block); + } + } + } +}; + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/pixpat.cpp b/subprojects/pixpat/pixpat-native/src/pixpat.cpp new file mode 100644 index 0000000..ac21fac --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/pixpat.cpp @@ -0,0 +1,355 @@ +// pixpat: extern "C" entry points + runtime format dispatch. +// +// The format catalog (X-macro PIXPAT_FORMAT_LIST + FormatId enum + +// s_format_table) is hand-written in format_catalog.h. The generator +// (pixpat-native/codegen/gen_pixpat.py) reads the same X-macro and +// the user TOML and emits the per-config bits: +// +// pixpat_config.h — PIXPAT_FEATURE_PATTERN / _CONVERT +// pixpat_caps.inc — s_format_caps[] (per-format readable / writable / +// hot_src / hot_dst, indexed by FormatId) and +// s_pattern_caps[] (per-pattern enabled flag). +// +// The convert and pattern dispatch (dispatch_convert in +// pixpat_convert.cpp, dispatch_draw_pattern in pixpat_pattern.cpp) is +// hand-written and consumes s_format_caps / s_pattern_caps via +// `if constexpr` on the per-row constexpr fields. +// +// s_format_info is built here, once, by re-expanding the catalog +// X-macro through unpack_for / pack_for / snk_block_h_for / +// snk_block_w_for. Those constexpr helpers use `if constexpr` on the +// per-format readable / writable flags from s_format_caps to either +// take the address of unpack_to_norm / pack_from_norm or fall back to +// nullptr (or 0). Because they're function templates, the discarded +// branch is never instantiated, so disabled-direction templates +// produce no code. +// +// Feature gating is meson-side: pixpat_pattern.cpp / pixpat_convert.cpp +// are added to the source list only when their feature is enabled. This +// file's entry points always exist; they call the bridge functions +// dispatch_draw_pattern / dispatch_convert under `if constexpr +// (kFeatureXxx)`. The discarded if-constexpr branch produces no symbol +// reference, so when the matching TU is absent the link still succeeds +// and the entry point returns -1 instead. + +#include <pixpat/pixpat.h> + +#include <algorithm> +#include <cstdint> +#include <cstring> + +#include "pixpat_config.h" + +#include "color.h" +#include "error.h" +#include "format_catalog.h" +#include "formats.h" +#include "io.h" +#include "layout.h" +#include "params.h" +#include "pattern.h" +#include "pixpat_internal.h" +#include "threading.h" + +namespace pixpat +{ + +inline constexpr bool kFeaturePattern = PIXPAT_FEATURE_PATTERN; +inline constexpr bool kFeatureConvert = PIXPAT_FEATURE_CONVERT; + +static FormatId lookup_format(const char* name) noexcept +{ + if (!name) + return FormatId::Unknown; + for (const auto& e : s_format_table) + if (std::strcmp(e.name, name) == 0) + return e.id; + return FormatId::Unknown; +} + +// Per-source: fill `bh` rows of normalized pixels by calling Src::read. +// Address is taken in s_format_info[] for every readable format. When +// no format is readable (convert disabled) no specialization is +// instantiated, so this template emits no code. +template <typename Src> +static void unpack_to_norm(uint8_t* norm, const pixpat_buffer* src, + size_t by, size_t bh, size_t W) noexcept +{ + using P = typename Src::Pixel; + auto sb = make_buffer<typename Src::Layout>(src); + auto* dst = reinterpret_cast<P*>(norm); + const size_t H = src->height; + for (size_t dy = 0; dy < bh; ++dy) + for (size_t x = 0; x < W; ++x) + dst[dy * W + x] = Src::read(sb, x, by + dy, W, H); +} + +// Per-sink: re-block `Snk::block_h × W` of normalized pixels and call +// Sink::write_block. Snk's block_h dictates how many normalized rows +// the caller has to have prepared. Used by the normalized pivot for +// both convert (cold path) and pattern. +template <typename Snk> +static void pack_from_norm(const pixpat_buffer* dst, + const uint8_t* norm, + size_t by, size_t W) noexcept +{ + using P = typename Snk::Pixel; + constexpr size_t bh = Snk::block_h; + constexpr size_t bw = Snk::block_w; + auto db = make_buffer<typename Snk::Layout>(dst); + auto* src = reinterpret_cast<const P*>(norm); + for (size_t bx = 0; bx < W; bx += bw) { + P block[bh][bw]; + for (size_t dy = 0; dy < bh; ++dy) + for (size_t dx = 0; dx < bw; ++dx) + block[dy][dx] = src[dy * W + bx + dx]; + Snk::write_block(db, bx, by, block); + } +} + +// Generated: s_format_caps[] indexed by FormatId, plus s_pattern_* / +// DefaultPattern (used only by pixpat_pattern.cpp; harmless here). +#include "pixpat_caps.inc" + +static_assert(sizeof(s_format_caps) / sizeof(s_format_caps[0]) == s_format_catalog_count, + "s_format_caps must cover the full catalog"); + +// `if constexpr` keeps disabled-direction function-template bodies +// uninstantiated. Taking `&unpack_to_norm<Src>` / `&pack_from_norm<Snk>` +// forces the function body to be emitted; without the gate every +// catalog format would carry unpack and pack code regardless of its +// readable / writable bit. Snk::block_h / Snk::block_w are constexpr +// scalars — no body, no emission — so they're inlined directly in the +// initializer below, without a helper. +template <bool Read, typename Src> +static constexpr UnpackFn unpack_for() noexcept +{ + if constexpr (Read) + return &unpack_to_norm<Src>; + else + return nullptr; +} + +template <bool Write, typename Snk> +static constexpr PackFn pack_for() noexcept +{ + if constexpr (Write) + return &pack_from_norm<Snk>; + else + return nullptr; +} + +const FormatInfo s_format_info[] = { +#define CAPS(name) s_format_caps[size_t(FormatId::name)] +#define X(name) \ + { \ + unpack_for<CAPS(name).readable, formats::name::Source>(), \ + pack_for<CAPS(name).writable, formats::name::Sink>(), \ + formats::name::kind, \ + uint8_t(formats::name::h_sub), \ + uint8_t(formats::name::v_sub), \ + uint8_t(formats::name::Sink::block_h), \ + uint8_t(formats::name::Sink::block_w), \ + }, + PIXPAT_FORMAT_LIST(X) +#undef X +#undef CAPS +}; +static_assert(sizeof(s_format_info) / sizeof(s_format_info[0]) == s_format_catalog_count, + "s_format_info must cover the full catalog"); + +// validate_* / parse_spec are only reached from inside the entry points' +// `if constexpr (kFeatureXxx)` true branches. With a feature disabled, +// its caller's branch is discarded and the helper becomes unreferenced; +// require_readable is convert-only. [[maybe_unused]] keeps +// -Wunused-function (and clang's -Wunneeded-internal-declaration) quiet. +[[maybe_unused]] static void validate_buffer(const pixpat_buffer* b) +{ + if (!b) + throw invalid_argument("null buffer"); + if (b->width == 0 || b->height == 0) + throw invalid_argument("zero-sized buffer"); +} + +[[maybe_unused]] static FormatId validate_format(const char* name) +{ + auto id = lookup_format(name); + if (id == FormatId::Unknown) + throw invalid_argument("unknown format"); + return id; +} + +[[maybe_unused]] static void require_writable(FormatId id) +{ + if (s_format_info[size_t(id)].pack == nullptr) + throw invalid_argument("format not enabled as a sink in this build"); +} + +[[maybe_unused]] static void require_readable(FormatId id) +{ + if (s_format_info[size_t(id)].unpack == nullptr) + throw invalid_argument("format not enabled as a source in this build"); +} + +[[maybe_unused]] static unsigned validate_thread_count(int n) +{ + if (n < 0) + throw invalid_argument("negative num_threads"); + return n > 0 ? static_cast<unsigned>(n) : default_thread_count(); +} + +// Map the C-side pixpat_rec / pixpat_range enums (defined in +// pixpat.h with explicit values 0/1/2 for rec, 0/1 for range) onto +// the internal pixpat::Rec / pixpat::Range. Out-of-range values fall +// back to BT.601 / Limited — matching the zero-initialised opts +// struct and kDefaultColorSpec. +[[maybe_unused]] static ColorSpec parse_spec(int rec_in, int range_in) noexcept +{ + Rec rec; + switch (rec_in) { + case PIXPAT_REC_BT709: rec = Rec::BT709; break; + case PIXPAT_REC_BT2020: rec = Rec::BT2020; break; + default: rec = Rec::BT601; break; + } + Range range = (range_in == PIXPAT_RANGE_FULL) ? Range::Full : Range::Limited; + return ColorSpec{ rec, range }; +} + +} // namespace pixpat + +// Marks the C entry points as part of the public ABI: restores default +// visibility against the build-wide -fvisibility=hidden, so they are +// exported from libpixpat.so. +#define PIXPAT_API __attribute__((visibility("default"))) + +extern "C" { + +PIXPAT_API int pixpat_draw_pattern(const pixpat_buffer* dst, + const char* pattern, + const pixpat_pattern_opts* opts) +{ + if constexpr (pixpat::kFeaturePattern) { + try { + pixpat::validate_buffer(dst); + auto id = pixpat::validate_format(dst->format); + pixpat::require_writable(id); + const auto& di = pixpat::s_format_info[size_t(id)]; + if (dst->width % di.snk_block_w != 0 || + dst->height % di.snk_block_h != 0) + throw pixpat::invalid_argument( + "dimensions not aligned to format block"); + const unsigned n_threads = opts + ? pixpat::validate_thread_count(opts->num_threads) + : pixpat::default_thread_count(); + const pixpat::ColorSpec spec = opts + ? pixpat::parse_spec(opts->rec, opts->range) + : pixpat::kDefaultColorSpec; + const pixpat::Params params(opts ? opts->params : nullptr); + if (!params.ok()) + throw pixpat::invalid_argument("malformed opts->params"); + + pixpat::run_stripes(dst->height, di.snk_block_h, n_threads, + [&](size_t y0, size_t y1) { + pixpat::dispatch_draw_pattern( + id, pattern, params, dst, + dst->width, dst->height, y0, y1, spec); + }); + return 0; + } catch (const std::exception&) { + return -1; + } + } else { + (void)dst; + (void)pattern; + (void)opts; + return -1; + } +} + +PIXPAT_API int pixpat_convert(const pixpat_buffer* dst, + const pixpat_buffer* src, + const pixpat_convert_opts* opts) +{ + if constexpr (pixpat::kFeatureConvert) { + try { + pixpat::validate_buffer(dst); + pixpat::validate_buffer(src); + if (src->width != dst->width || src->height != dst->height) + throw pixpat::invalid_argument("src/dst dimensions differ"); + + auto src_id = pixpat::validate_format(src->format); + auto dst_id = pixpat::validate_format(dst->format); + pixpat::require_readable(src_id); + pixpat::require_writable(dst_id); + + const auto& si = pixpat::s_format_info[size_t(src_id)]; + const auto& di = pixpat::s_format_info[size_t(dst_id)]; + // Each constraint must hold independently — checking only + // max() would miss e.g. h_sub=2 vs snk_block_w=3 with W=3. + if (src->width % si.h_sub != 0 || src->height % si.v_sub != 0 || + src->width % di.h_sub != 0 || src->height % di.v_sub != 0 || + src->width % di.snk_block_w != 0 || src->height % di.snk_block_h != 0) + throw pixpat::invalid_argument( + "dimensions not aligned to format subsampling"); + // run_stripes only needs the v dimension. Stripes must align + // to si.v_sub (source reads) and di.snk_block_h (sink block + // loop); for pixpat's catalog these are powers-of-two and + // max == LCM. + const unsigned vs = std::max({ unsigned(si.v_sub), + unsigned(di.v_sub), + unsigned(di.snk_block_h) }); + const unsigned n_threads = opts + ? pixpat::validate_thread_count(opts->num_threads) + : pixpat::default_thread_count(); + const pixpat::ColorSpec spec = opts + ? pixpat::parse_spec(opts->rec, opts->range) + : pixpat::kDefaultColorSpec; + + pixpat::run_stripes(src->height, vs, n_threads, + [&](size_t y0, size_t y1) { + pixpat::dispatch_convert(src_id, dst_id, src, dst, + src->width, src->height, + y0, y1, spec); + }); + return 0; + } catch (const std::exception&) { + return -1; + } + } else { + (void)dst; + (void)src; + (void)opts; + return -1; + } +} + +PIXPAT_API int pixpat_format_supported(const char* format) +{ + auto id = pixpat::lookup_format(format); + if (id == pixpat::FormatId::Unknown) + return 0; + return pixpat::s_format_caps[size_t(id)].enabled() ? 1 : 0; +} + +PIXPAT_API size_t pixpat_format_count(void) +{ + size_t n = 0; + for (const auto& c : pixpat::s_format_caps) + if (c.enabled()) + ++n; + return n; +} + +PIXPAT_API const char* pixpat_format_name(size_t idx) +{ + size_t n = 0; + for (size_t i = 0; i < pixpat::s_format_catalog_count; ++i) { + if (!pixpat::s_format_caps[i].enabled()) + continue; + if (n++ == idx) + return pixpat::s_format_table[i].name; + } + return nullptr; +} + +} // extern "C" diff --git a/subprojects/pixpat/pixpat-native/src/pixpat_convert.cpp b/subprojects/pixpat/pixpat-native/src/pixpat_convert.cpp new file mode 100644 index 0000000..63461d8 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/pixpat_convert.cpp @@ -0,0 +1,201 @@ +// Convert-feature TU: built only when PIXPAT_FEATURE_CONVERT is on +// (controlled by the meson source list). pixpat.cpp's pixpat_convert +// entry calls into dispatch_convert() below via if-constexpr; when the +// feature is off this file isn't compiled, the discarded if-constexpr +// branch emits no symbol reference, and the .so simply lacks these +// symbols. + +#include <cassert> +#include <cstdint> +#include <cstring> +#include <vector> + +#include "color.h" +#include "error.h" +#include "format_catalog.h" +#include "formats.h" +#include "io.h" +#include "layout.h" +#include "pattern.h" +#include "pipeline.h" +#include "pixpat_internal.h" + +namespace pixpat +{ + +template <typename Src, typename Snk> +static void run_convert_impl(const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + using SL = typename Src::Layout; + using DL = typename Snk::Layout; + // Entry point (pixpat_convert) validates W/H against each layout's + // h_sub / v_sub, plus the sink's block dims. + assert(W % SL::h_sub == 0 && W % DL::h_sub == 0); + assert(H % SL::v_sub == 0 && H % DL::v_sub == 0); + + auto sb = make_buffer<SL>(src); + auto db = make_buffer<DL>(dst); + Converter<Src, Snk>::run(sb, db, W, H, by_start, by_end, spec); +} + +static void run_norm(FormatId src_id, FormatId dst_id, + const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + const auto& si = s_format_info[size_t(src_id)]; + const auto& di = s_format_info[size_t(dst_id)]; + + const size_t bh = di.snk_block_h; + // Entry point (pixpat_convert) guarantees W/H alignment to each + // of si.h_sub / si.v_sub and di.snk_block_w / di.snk_block_h. + assert(W % si.h_sub == 0 && W % di.snk_block_w == 0); + assert(H % si.v_sub == 0 && H % bh == 0); + + // Per-thread normalized line buffer. RGB16 and YUV16 are both 8 + // bytes, so one allocation works for both. thread_local gives each + // worker its own buffer when called from run_stripes. + thread_local std::vector<uint8_t> norm; + norm.resize(bh * W * sizeof(RGB16)); + + const ColorCoeffs c = coeffs_for(spec); + for (size_t by = by_start; by < by_end; by += bh) { + si.unpack(norm.data(), src, by, bh, W); + if (si.kind != di.kind) { + const size_t n = bh * W; + if (si.kind == ColorKind::RGB) + norm_rgb_to_yuv(norm.data(), n, c); + else + norm_yuv_to_rgb(norm.data(), n, c); + } + di.pack(dst, norm.data(), by, W); + } +} + +// Generated: FormatCaps + s_format_caps[] (per-format readable/writable +// + hot_src/hot_dst), plus s_pattern_* / DefaultPattern. +#include "pixpat_caps.inc" + +// Per-Src dispatch: pick the right Sink for `dst_id` and call +// run_convert_impl. The X-macro emits one case per catalog format; +// `if constexpr (...writable)` discards the body for non-writable +// formats — those cases fall to the trailing throw. +template <typename Src> +static void dispatch_dst_convert(FormatId dst_id, + const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + switch (dst_id) { +#define CAPS(name) s_format_caps[size_t(FormatId::name)] +#define X(name) \ + case FormatId::name: \ + if constexpr (CAPS(name).writable) { \ + run_convert_impl<Src, formats::name::Sink>( \ + src, dst, W, H, by_start, by_end, spec); \ + return; \ + } \ + break; + PIXPAT_FORMAT_LIST(X) +#undef X +#undef CAPS + default: + break; + } + throw invalid_argument("destination format not enabled in this build"); +} + +// Per-Snk dispatch: mirror of dispatch_dst_convert. +template <typename Snk> +static void dispatch_src_convert(FormatId src_id, + const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + switch (src_id) { +#define CAPS(name) s_format_caps[size_t(FormatId::name)] +#define X(name) \ + case FormatId::name: \ + if constexpr (CAPS(name).readable) { \ + run_convert_impl<formats::name::Source, Snk>( \ + src, dst, W, H, by_start, by_end, spec); \ + return; \ + } \ + break; + PIXPAT_FORMAT_LIST(X) +#undef X +#undef CAPS + default: + break; + } + throw invalid_argument("source format not enabled in this build"); +} + +// Hot-pivot probes. The wrapper has to be a template so that the +// discarded `if constexpr` branch is not instantiated — otherwise +// dispatch_dst_convert<formats::X::Source> would be instantiated for +// every catalog format, not just hot pivots. +template <bool HotSrc, FormatId Id, typename Source> +static bool try_hot_src(FormatId src_id, FormatId dst_id, + const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + if constexpr (HotSrc) { + if (src_id == Id) { + dispatch_dst_convert<Source>( + dst_id, src, dst, W, H, by_start, by_end, spec); + return true; + } + } + return false; +} + +template <bool HotDst, FormatId Id, typename Sink> +static bool try_hot_dst(FormatId src_id, FormatId dst_id, + const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + if constexpr (HotDst) { + if (dst_id == Id) { + dispatch_src_convert<Sink>( + src_id, src, dst, W, H, by_start, by_end, spec); + return true; + } + } + return false; +} + +void dispatch_convert(FormatId src_id, FormatId dst_id, + const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ +#define CAPS(name) s_format_caps[size_t(FormatId::name)] +#define X(name) \ + if (try_hot_src<CAPS(name).hot_src, FormatId::name, \ + formats::name::Source>( \ + src_id, dst_id, src, dst, W, H, by_start, by_end, spec)) \ + return; \ + if (try_hot_dst<CAPS(name).hot_dst, FormatId::name, \ + formats::name::Sink>( \ + src_id, dst_id, src, dst, W, H, by_start, by_end, spec)) \ + return; + PIXPAT_FORMAT_LIST(X) +#undef X +#undef CAPS + + run_norm(src_id, dst_id, src, dst, W, H, by_start, by_end, spec); +} + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/pixpat_internal.h b/subprojects/pixpat/pixpat-native/src/pixpat_internal.h new file mode 100644 index 0000000..50d3405 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/pixpat_internal.h @@ -0,0 +1,89 @@ +#pragma once + +// Internal interface shared between the always-built pixpat.cpp and the +// optional pixpat_pattern.cpp / pixpat_convert.cpp TUs. The feature +// gate is meson-side: pixpat_pattern.cpp is in the source list iff +// PIXPAT_FEATURE_PATTERN, and likewise for convert. The bridge +// declarations below are unconditional; pixpat.cpp's entry points call +// them inside `if constexpr (kFeatureXxx)`, and the discarded branch +// emits no symbol reference, so absent definitions don't cause link +// failures. + +#include <cstddef> +#include <cstdint> + +#include <pixpat/pixpat.h> + +#include "color.h" +#include "format_catalog.h" +#include "layout.h" +#include "pattern_catalog.h" + +namespace pixpat +{ + +template <typename Layout> +inline Buffer<Layout::num_planes> make_buffer(const pixpat_buffer* b) noexcept +{ + Buffer<Layout::num_planes> out{}; + for (size_t i = 0; i < Layout::num_planes; ++i) { + out.data[i] = static_cast<uint8_t*>(b->planes[i]); + out.stride[i] = b->strides[i]; + } + return out; +} + +using UnpackFn = void (*)(uint8_t*, const pixpat_buffer*, size_t, size_t, size_t); +using PackFn = void (*)(const pixpat_buffer*, const uint8_t*, size_t, size_t); + +struct FormatInfo { + UnpackFn unpack; + PackFn pack; + ColorKind kind; + uint8_t h_sub; + uint8_t v_sub; + uint8_t snk_block_h; + uint8_t snk_block_w; +}; + +extern const FormatInfo s_format_info[]; + +// Per-format build capabilities. Defined once per build by the +// generator into s_format_caps[] (in pixpat_caps.inc); the schema is +// here so that file is pure data. +struct FormatCaps { + bool readable; + bool writable; + bool hot_src; + bool hot_dst; + + constexpr bool enabled() const noexcept + { + return readable || writable; + } +}; + +// Per-pattern build capabilities. Generator emits s_pattern_caps[] +// indexed by PatternId, plus a separate s_default_pattern_id singleton +// (the fallback when pattern_name doesn't match any enabled arm). +// Used only when PIXPAT_FEATURE_PATTERN — pixpat_pattern.cpp consumes +// both. +struct PatternCaps { + bool enabled; +}; + +class Params; + +// Bridge into pixpat_pattern.cpp (defined there iff PIXPAT_FEATURE_PATTERN). +void dispatch_draw_pattern(FormatId id, const char* pattern_name, + const Params& params, + const pixpat_buffer* dst, size_t W, size_t H, + size_t by_start, size_t by_end, ColorSpec spec); + +// Bridge into pixpat_convert.cpp (defined there iff PIXPAT_FEATURE_CONVERT). +void dispatch_convert(FormatId src_id, FormatId dst_id, + const pixpat_buffer* src, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, ColorSpec spec); + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/pixpat_pattern.cpp b/subprojects/pixpat/pixpat-native/src/pixpat_pattern.cpp new file mode 100644 index 0000000..e8ac780 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/pixpat_pattern.cpp @@ -0,0 +1,168 @@ +// Pattern-feature TU: built only when PIXPAT_FEATURE_PATTERN is on +// (controlled by the meson source list). pixpat.cpp's pixpat_draw_pattern +// entry calls into dispatch_draw_pattern() below via if-constexpr; when +// the feature is off this file isn't compiled, the discarded if-constexpr +// branch emits no symbol reference, and the .so simply lacks these +// symbols. + +#include <cassert> +#include <cstdint> +#include <string_view> +#include <type_traits> +#include <vector> + +#include "color.h" +#include "error.h" +#include "params.h" +#include "pattern.h" +#include "pattern_catalog.h" +#include "pipeline.h" +#include "pixpat_internal.h" + +namespace pixpat +{ + +// Generated: s_pattern_* enable flags + DefaultPattern alias. Included +// inside namespace pixpat so the unqualified FormatId / s_format_catalog_count +// references resolve. +#include "pixpat_caps.inc" + +// Cold pattern path: fill a per-thread normalized line buffer with +// Pattern samples in the pattern's native color kind, run a cross- +// color-kind pass over the buffer if the sink wants the other kind, +// then hand the buffer to the destination's per-format pack via +// s_format_info. Same shape as run_norm in pixpat_convert.cpp. +template <typename Pattern> +static void run_pattern_norm(const Pattern& pat, + FormatId dst_id, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + using P = typename Pattern::Pixel; + constexpr bool pat_is_rgb = std::is_same_v<P, RGB16>; + + const auto& di = s_format_info[size_t(dst_id)]; + const size_t bh = di.snk_block_h; + // Entry point (pixpat_draw_pattern) validates W%bw / H%bh. + assert(W % di.snk_block_w == 0 && H % bh == 0); + + thread_local std::vector<uint8_t> norm; + norm.resize(bh * W * sizeof(RGB16)); // RGB16 / YUV16 same size + + const ColorCoeffs c = coeffs_for(spec); + const bool need_xfm = (pat_is_rgb && di.kind == ColorKind::YUV) || + (!pat_is_rgb && di.kind == ColorKind::RGB); + + for (size_t by = by_start; by < by_end; by += bh) { + auto* px = reinterpret_cast<P*>(norm.data()); + for (size_t dy = 0; dy < bh; ++dy) + for (size_t x = 0; x < W; ++x) + px[dy * W + x] = pat.sample(x, by + dy, W, H); + if (need_xfm) { + const size_t n = bh * W; + if constexpr (pat_is_rgb) + norm_rgb_to_yuv(norm.data(), n, c); + else + norm_yuv_to_rgb(norm.data(), n, c); + } + di.pack(dst, norm.data(), by, W); + } +} + +// Construct, ready-check, and run a pattern. Patterns whose colors +// depend on the call's ColorSpec (e.g. native-YUV bar variants) opt +// in by exposing a (Params, ColorSpec) constructor; the rest take +// Params only and stay unchanged. +template <typename Pattern> +static void run_one_pattern(const Params& params, + FormatId id, const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + auto pat = [&] { + if constexpr (std::is_constructible_v< + Pattern, const Params&, ColorSpec>) + return Pattern(params, spec); + else + return Pattern(params); + }(); + if constexpr (requires { pat.ready(); }) { + if (!pat.ready()) + throw invalid_argument("pattern parameters not accepted"); + } + run_pattern_norm(pat, id, dst, W, H, by_start, by_end, spec); +} + +// Per-pattern dispatch arm. Templated on the catalog row's RGB and +// YUV variants (either may be `void` if the pattern has no variant +// in that kind). When both are present, the sink kind picks the +// matching variant so the cross-kind pass is a no-op; when only one +// is present, the pipeline runs the cross-kind pass for opposite- +// kind sinks. +// +// Wrapping in a templated helper is what keeps the binary size down: +// `if constexpr (Enabled = false)` discards the run_pattern_norm +// reference, and because try_pattern is itself a template, the +// discarded branch is *not instantiated* — so disabled patterns +// emit no code, and the `void` arms of partial patterns never +// instantiate `Pattern::Pixel` or run_pattern_norm<void>. +template <bool Enabled, typename Rgb, typename Yuv> +static bool try_pattern(std::string_view name, std::string_view want, + const Params& params, + FormatId id, ColorKind sink_kind, + const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + if constexpr (Enabled) { + if (name == want) { + constexpr bool has_rgb = !std::is_void_v<Rgb>; + constexpr bool has_yuv = !std::is_void_v<Yuv>; + static_assert(has_rgb || has_yuv, + "pattern needs at least one variant"); + if constexpr (has_rgb && has_yuv) { + if (sink_kind == ColorKind::YUV) + run_one_pattern<Yuv>(params, id, dst, W, H, + by_start, by_end, spec); + else + run_one_pattern<Rgb>(params, id, dst, W, H, + by_start, by_end, spec); + } else if constexpr (has_rgb) { + run_one_pattern<Rgb>(params, id, dst, W, H, + by_start, by_end, spec); + } else { + run_one_pattern<Yuv>(params, id, dst, W, H, + by_start, by_end, spec); + } + return true; + } + } + return false; +} + +void dispatch_draw_pattern(FormatId id, const char* pattern_name, + const Params& params, + const pixpat_buffer* dst, + size_t W, size_t H, + size_t by_start, size_t by_end, + ColorSpec spec) +{ + using namespace patterns; + // NULL pattern_name selects the default ("kmstest"); see pixpat.h. + const std::string_view name = pattern_name ? pattern_name : "kmstest"; + const ColorKind kind = s_format_info[size_t(id)].kind; + +#define X(label, rgb, yuv, str) \ + if (try_pattern<s_pattern_caps[size_t(PatternId::label)].enabled, rgb, yuv>( \ + name, str, params, id, kind, dst, W, H, by_start, by_end, spec)) \ + return; + PIXPAT_PATTERN_LIST(X) +#undef X + + throw invalid_argument("unknown or disabled pattern name"); +} + +} // namespace pixpat diff --git a/subprojects/pixpat/pixpat-native/src/threading.h b/subprojects/pixpat/pixpat-native/src/threading.h new file mode 100644 index 0000000..5e7fc01 --- /dev/null +++ b/subprojects/pixpat/pixpat-native/src/threading.h @@ -0,0 +1,95 @@ +#pragma once + +#include <unistd.h> + +#include <cassert> +#include <cstddef> +#include <exception> +#include <thread> +#include <vector> + +namespace pixpat +{ + +inline unsigned default_thread_count() +{ + long n = sysconf(_SC_NPROCESSORS_ONLN); + if (n < 1) + return 1; + // Cap to keep per-stripe work meaningful and avoid heavy + // oversubscription on large NUMA hosts. + if (n > 16) + n = 16; + return static_cast<unsigned>(n); +} + +/* + * Run `fn(start_y, end_y)` over `[0, height)` partitioned into stripes + * aligned to `v_sub`. Half-open ranges, matching the `for (by = 0; + * by < H; by += bh)` block-loop style. + * + * `fn` must be callable as `void(size_t start_y, size_t end_y)` and is + * invoked concurrently from multiple threads — it must be safe to call + * with disjoint Y-ranges in parallel. Exceptions thrown from a worker + * are captured and the first (by stripe index) is rethrown after all + * workers join. + * + * When `n_threads <= 1`, `fn` is called inline on the calling thread — + * no `std::thread` is spawned, no allocation occurs. + */ +template<typename F> +void run_stripes(size_t height, unsigned v_sub, unsigned n_threads, F&& fn) +{ + if (height == 0 || v_sub == 0) + return; + + // Callers (pixpat_convert / pixpat_draw_pattern) validate divisibility + // at the entry point. + assert(height % v_sub == 0); + + const size_t max_useful = height / v_sub; + if (n_threads == 0) + n_threads = 1; + if (static_cast<size_t>(n_threads) > max_useful) + n_threads = static_cast<unsigned>(max_useful); + + if (n_threads <= 1) { + fn(size_t{ 0 }, height); + return; + } + + // Stripe height rounded up to v_sub; last stripe absorbs the + // remainder. + size_t part_height = (height + n_threads - 1) / n_threads; + part_height = (part_height + v_sub - 1) / v_sub * v_sub; + + std::vector<std::exception_ptr> errors(n_threads); + std::vector<std::thread> workers; + workers.reserve(n_threads); + + for (unsigned i = 0; i < n_threads; i++) { + size_t start = i * part_height; + if (start >= height) + break; + size_t end = start + part_height; + if (i == n_threads - 1 || end > height) + end = height; + + workers.emplace_back([&, i, start, end] { + try { + fn(start, end); + } catch (...) { + errors[i] = std::current_exception(); + } + }); + } + + for (auto& t : workers) + t.join(); + + for (auto& e : errors) + if (e) + std::rethrow_exception(e); +} + +} // namespace pixpat |