SA-014 Metal Shader Extraction Report

attribute vec3 aVertexPosition;
attribute vec2 aTextureCoord;
uniform sampler2D SamplerY;
uniform sampler2D SamplerUV;
uniform highp mat3 colorConversionMatrix;
uniform mat4 uMVMatrix;
uniform mat4 uPMatrix;
varying highp vec2 vTextureCoord;
varying highp vec3 vPos;
varying lowp float vRecompute;
varying highp vec2 vOffset;

highp vec2 EquirectPart(highp vec3 p);
highp vec2 FacePart(highp vec3 p);
lowp vec4 FragColor(highp vec2 textureCoord);

// STEGANOGRAPHIC BIT EXTRACTION FUNCTION
highp vec4 extractFromSample(highp vec4 c) {
    highp float minC = min(0.5, min(c.r, min(c.g, c.b)));
    highp float diffC = max(0.5, max(c.r, max(c.g, c.b))) - minC + 0.001;
    return step(0.5, (c - minC) / diffC);
}

// IEEE 754 FLOATING-POINT RECONSTRUCTION FROM PIXELS
highp vec2 parseOffset() {
    highp float calculated_offsetX;
    highp float calculated_offsetZ;
    highp float offset_v;    // Mantissa value
    highp float offset_e;    // Exponent value
    highp float offset_sig;  // Sign bit

    highp vec4 texCoordsX[7];
    highp vec4 texCoordsZ[7];

    // OFFSET X: Sample 7 pixel locations along horizontal strip at Y=1.0
    texCoordsX[0] = extractFromSample(FragColor(vec2(0.396, 1.0)));
    texCoordsX[1] = extractFromSample(FragColor(vec2(0.404, 1.0)));
    texCoordsX[2] = extractFromSample(FragColor(vec2(0.412, 1.0)));
    texCoordsX[3] = extractFromSample(FragColor(vec2(0.420, 1.0)));
    texCoordsX[4] = extractFromSample(FragColor(vec2(0.428, 1.0)));
    texCoordsX[5] = extractFromSample(FragColor(vec2(0.436, 1.0)));
    texCoordsX[6] = extractFromSample(FragColor(vec2(0.444, 1.0)));

    // Reconstruct IEEE 754 mantissa (bits 0-22)
    offset_v = texCoordsX[0].r * 0.0009765625 +
        dot(texCoordsX[1].bgr, vec3(0.001953125, 0.00390625, 0.0078125)) +
        dot(texCoordsX[2].bgr, vec3(0.015625, 0.03125, 0.0625)) +
        dot(texCoordsX[3].bgr, vec3(0.125, 0.25, 0.5)) + 1.0;

    // Reconstruct IEEE 754 exponent (bits 23-30)
    offset_e = dot(texCoordsX[4].bgr, vec3(1.0, 2.0, 4.0)) +
        dot(texCoordsX[5].bgr, vec3(8.0, 16.0, 32.0)) +
        dot(texCoordsX[6].bg, vec2(64.0, 128.0)) - 127.0;

    // Sign bit (bit 31)
    offset_sig = -2.0 * texCoordsX[6].r + 1.0;

    // Final IEEE 754 reconstruction: sign * (1 + mantissa) * 2^exponent
    calculated_offsetX = offset_sig * offset_v * pow(2.0, offset_e);

    // OFFSET Z: Sample 7 different pixel locations
    texCoordsZ[0] = extractFromSample(FragColor(vec2(0.572, 1.0)));
    texCoordsZ[1] = extractFromSample(FragColor(vec2(0.580, 1.0)));
    texCoordsZ[2] = extractFromSample(FragColor(vec2(0.588, 1.0)));
    texCoordsZ[3] = extractFromSample(FragColor(vec2(0.596, 1.0)));
    texCoordsZ[4] = extractFromSample(FragColor(vec2(0.604, 1.0)));
    texCoordsZ[5] = extractFromSample(FragColor(vec2(0.612, 1.0)));
    texCoordsZ[6] = extractFromSample(FragColor(vec2(0.620, 1.0)));

    // Reconstruct second float (Z offset) using different bit packing
    offset_v = dot(texCoordsZ[0].bgr, vec3(0.0009765625, 0.001953125, 0.00390625)) +
        dot(texCoordsZ[1].bgr, vec3(0.0078125, 0.015625, 0.03125)) +
        dot(texCoordsZ[2].bgr, vec3(0.0625, 0.125, 0.25)) +
        texCoordsZ[3].b * 0.5 + 1.0;

    offset_e = dot(texCoordsZ[3].gr, vec2(1.0, 2.0)) +
        dot(texCoordsZ[4].bgr, vec3(4.0, 8.0, 16.0)) +
        dot(texCoordsZ[5].bgr, vec3(32.0, 64.0, 128.0)) - 127.0;

    offset_sig = 2.0 * texCoordsZ[6].b - 1.0;

    calculated_offsetZ = offset_sig * offset_v * pow(2.0, offset_e);

    return vec2(calculated_offsetX, calculated_offsetZ);
}

const float eps = 0.03;

void main(void) {
    gl_Position = uPMatrix * vec4(aVertexPosition, 1.0);
    vPos = (uMVMatrix * vec4(aVertexPosition, 1.0)).xyz;
    lowp vec2 tmp = aTextureCoord.xy;
    highp vec3 v = normalize(vPos);

    // Extract steganographic offset from pixel data
    vOffset = parseOffset();

    // Apply offset to view direction (360 video camera correction)
    highp float d = length(v.xz);
    highp vec2 t = normalize(v.xz / d + vOffset) * d;
    v.xz = t.xy;

    vRecompute = 0.0;
    if (abs(v.y) < 0.707106781) {
        vTextureCoord = EquirectPart(v);
        vRecompute += float(vTextureCoord.x < eps * 0.5 || vTextureCoord.x > 0.8 - eps * 0.5);
    } else {
        vTextureCoord = FacePart(v);
        vRecompute += float(abs(v.y) > 1.0 - eps);
    }
    vRecompute += float(abs(v.y) < 0.707106781 + eps && abs(v.y) > 0.707106781 - eps);
}

varying highp vec2 vTextureCoord;
varying highp vec3 vPos;
varying lowp float vRecompute;
varying highp vec2 vOffset;
uniform sampler2D SamplerY;
uniform sampler2D SamplerUV;
uniform highp mat3 colorConversionMatrix;

highp vec2 EquirectPart(highp vec3 p);
highp vec2 FacePart(highp vec3 p);
lowp vec4 FragColor(highp vec2 textureCoord);

void main() {
    if (vRecompute > 0.0) {
        highp vec3 v = normalize(vPos);
        highp float d = length(v.xz);
        highp vec2 t = normalize(v.xz / d + vOffset) * d;
        v.xz = t.xy;
        highp vec2 o;
        if (abs(v.y) < 0.707106781) {
            o = EquirectPart(v);
        } else {
            o = FacePart(v);
        }
        gl_FragColor = FragColor(o);
    } else {
        gl_FragColor = FragColor(vTextureCoord);
    }
}

highp vec2 EquirectPart(highp vec3 p) {
    highp float xz = sqrt(p.x * p.x + p.z * p.z);
    highp float lat = -atan(p.y, xz);
    highp float t = lat / 1.57079633 / 1.01 + 0.5;
    highp float s = atan(p.x, -p.z) / 1.01 / (2.5 * 3.1415927) + 0.4;
    highp vec2 st = vec2(s, t);
    return st;
}

highp vec2 FacePart(highp vec3 p) {
    highp vec2 t = p.xz / p.y;
    highp float s = sign(p.y);
    return vec2(0.9 + t.x * s * 0.099009901, 0.5 - s * 0.25 - t.y * 0.247524752);
}

lowp vec4 FragColor(highp vec2 texCoord) {
    mediump vec3 yuv;
    yuv.x = (texture2D(SamplerY, texCoord).r - (16.0 / 255.0)) * 1.0;
    yuv.yz = (texture2D(SamplerUV, texCoord).rg - vec2(0.5, 0.5)) * 1.0;
    lowp vec3 rgb = colorConversionMatrix * yuv;
    return vec4(rgb, 1);
}

X:  0                                                               1920
    |----------[X STRIP]-----------|---gap---|---[Z STRIP]-----------|
               ^                                  ^
           760-852px                          1098-1190px
            (~39.6-44.4%)                      (~57.2-62.0%)

Input: RGBA color value c (0.0 - 1.0 per channel)
Process:
  1. minC = min(0.5, min(c.r, min(c.g, c.b)))
  2. diffC = max(0.5, max(c.r, max(c.g, c.b))) - minC + 0.001
  3. normalized = (c - minC) / diffC
  4. binary = step(0.5, normalized)  // 0 or 1 per channel
Output: vec4 with binary values (0.0 or 1.0) for R, G, B, A

float_value = sign * (1.0 + mantissa) * 2^(exponent - 127)

Where:
  sign = -2.0 * sign_bit + 1.0  (yields +1 or -1)
  mantissa = sum of fractional bit weights
  exponent = sum of exponent bit weights

Bits 0-9:   Mantissa (10 bits from pixels 0-3)
Bits 10-17: Exponent (8 bits from pixels 4-6)
Bit 18:     Sign (1 bit from pixel 6 R channel)

Total: 19 bits actively encoded per float
       (IEEE 754 uses 32 bits, this is a compressed subset)

using namespace metal;
typedef struct {
    float2 position [[attribute(0)]];
    float3 color [[attribute(1)]];
} VertexData;

typedef struct {
    float4 position [[position]];
    float4 color;
} RasterizerData;

typedef struct {
    float4x4 u_modelViewProjectionMatrix;
    float4x4 u_angleMatrix;
    float strength;
} Uniforms;

vertex RasterizerData vertexShader(VertexData vertexIn [[stage_in]],
                                    constant Uniforms& uniforms [[buffer(1)]]) {
    RasterizerData vertexOut;
    float4x4 flipYMatrix = float4x4(float4(1., 0., 0., 0.),
                                     float4(0., -1., 0., 0.),
                                     float4(0., 0., 1., 0.),
                                     float4(0., 0., 0., 1.));
    vertexOut.position = uniforms.u_modelViewProjectionMatrix * flipYMatrix *
                         uniforms.u_angleMatrix * float4(vertexIn.position, 0.0, 1.0);
    vertexOut.color = float4(vertexIn.color, 1.0);
    return vertexOut;
}

fragment float4 fragmentShader(RasterizerData fragmentIn [[stage_in]]) {
    return fragmentIn.color;
}

def embed_offset(frame, offset_x, offset_z):
    """Embed IEEE 754 floats into pixel BGR channels"""

    # Convert float to mantissa, exponent, sign
    mantissa_x, exponent_x, sign_x = decompose_ieee754(offset_x)
    mantissa_z, exponent_z, sign_z = decompose_ieee754(offset_z)

    # X offset pixels (0.396 to 0.444 at Y=1.0)
    x_pixels = [0.396, 0.404, 0.412, 0.420, 0.428, 0.436, 0.444]
    encode_bits(frame, x_pixels, mantissa_x, exponent_x, sign_x)

    # Z offset pixels (0.572 to 0.620 at Y=1.0)
    z_pixels = [0.572, 0.580, 0.588, 0.596, 0.604, 0.612, 0.620]
    encode_bits(frame, z_pixels, mantissa_z, exponent_z, sign_z)

    return frame

def encode_bits(frame, pixel_coords, mantissa, exponent, sign):
    """Modify pixel BGR to encode binary values"""
    # Each pixel encodes 3 bits via BGR channels
    # Set channel > 0.5 for 1, < 0.5 for 0
    # Use contrast to ensure robustness to compression