// daedalus-fourier — H.264 luma intra (bS=4) H deblock — V3D 7.1.
//
// Sibling of v3d_h264deblock_luma_v_intra.comp transposed to the
// horizontal axis: lane → row, reads pix[-4..+3] (cols) instead of
// pix[-4*stride..+3*stride] (rows).  Same strong/weak filter
// selector + same write-back algebra.
//
// dst_off contract: (m.x % stride) ≥ 4 (kernel reads p3 at pix[-4]).
//
// License: BSD-2-Clause.

#version 450
#extension GL_EXT_shader_8bit_storage              : require
#extension GL_EXT_shader_explicit_arithmetic_types : require

layout(local_size_x = 256, local_size_y = 1, local_size_z = 1) in;
layout(binding = 0) readonly buffer Meta { uvec4 meta[]; } u_meta;
layout(binding = 1) buffer Dst { uint8_t dst[]; } u_dst;
layout(push_constant) uniform PC {
    uint n_edges, dst_stride_u8, _p0, _p1;
} pc;

void main()
{
    uint lane_in_wg  = gl_GlobalInvocationID.x & 255u;
    uint edge_in_wg  = lane_in_wg >> 4;
    uint row_in_edge = lane_in_wg & 15u;
    uint edge_idx    = gl_WorkGroupID.x * 16u + edge_in_wg;
    if (edge_idx >= pc.n_edges) return;

    uvec4 m = u_meta.meta[edge_idx];
    uint stride = pc.dst_stride_u8;
    uint dst_off = m.x + row_in_edge * stride;
    int alpha = int(m.y & 0xffu);
    int beta  = int((m.y >> 8) & 0xffu);
    if ((alpha | beta) == 0) return;

    int p3 = int(u_dst.dst[dst_off - 4u]);
    int p2 = int(u_dst.dst[dst_off - 3u]);
    int p1 = int(u_dst.dst[dst_off - 2u]);
    int p0 = int(u_dst.dst[dst_off - 1u]);
    int q0 = int(u_dst.dst[dst_off       ]);
    int q1 = int(u_dst.dst[dst_off + 1u]);
    int q2 = int(u_dst.dst[dst_off + 2u]);
    int q3 = int(u_dst.dst[dst_off + 3u]);

    if (abs(p0 - q0) >= alpha) return;
    if (abs(p1 - p0) >= beta)  return;
    if (abs(q1 - q0) >= beta)  return;

    bool strong_common = abs(p0 - q0) < (alpha >> 2) + 2;
    bool strong_p = strong_common && abs(p2 - p0) < beta;
    bool strong_q = strong_common && abs(q2 - q0) < beta;

    if (strong_p) {
        u_dst.dst[dst_off - 1u] = uint8_t(clamp((p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4) >> 3, 0, 255));
        u_dst.dst[dst_off - 2u] = uint8_t(clamp((p2 + p1 + p0 + q0 + 2) >> 2, 0, 255));
        u_dst.dst[dst_off - 3u] = uint8_t(clamp((2*p3 + 3*p2 + p1 + p0 + q0 + 4) >> 3, 0, 255));
    } else {
        u_dst.dst[dst_off - 1u] = uint8_t(clamp((2*p1 + p0 + q1 + 2) >> 2, 0, 255));
    }

    if (strong_q) {
        u_dst.dst[dst_off       ] = uint8_t(clamp((q2 + 2*q1 + 2*q0 + 2*p0 + p1 + 4) >> 3, 0, 255));
        u_dst.dst[dst_off + 1u] = uint8_t(clamp((q2 + q1 + q0 + p0 + 2) >> 2, 0, 255));
        u_dst.dst[dst_off + 2u] = uint8_t(clamp((2*q3 + 3*q2 + q1 + q0 + p0 + 4) >> 3, 0, 255));
    } else {
        u_dst.dst[dst_off       ] = uint8_t(clamp((2*q1 + q0 + p1 + 2) >> 2, 0, 255));
    }
}