1#version 450
2// Draws a solid fill, a client dmabuf (sampled image) or a client wl_shm
3// buffer (B8G8R8A8 words in a storage buffer). Client pixels are
4// premultiplied, as Wayland buffers are: the pipeline blends ONE,
5// ONE_MINUS_SRC_ALPHA. Scaled draws filter linearly; 1:1 draws read the
6// texel under the fragment, pixel exact.
7
8layout(push_constant) uniform Draw {
9 ivec4 rect;
10 vec4 map;
11 vec4 mapy;
12 vec4 color;
13 vec4 crop;
14 uvec4 buf;
15 uvec4 misc;
16} d;
17
18layout(set = 0, binding = 0) uniform sampler2D tex;
19layout(std430, set = 0, binding = 1) readonly buffer Pixels { uint pixels[]; };
20layout(set = 0, binding = 2) uniform sampler2D chromaTex;
21
22layout(location = 0) out vec4 color;
23
24const uint modeSolid = 0u;
25const uint modeImage = 1u;
26const uint flagOpaque = 1u;
27const uint flagExact = 2u;
28const uint flagPQ = 4u;
29const uint flagExtendedLinear = 8u;
30const uint flagYUV = 16u;
31const uint flagP010 = 32u;
32// flagSmooth averages four samples a quarter of a target pixel around the
33// point: a thumbnail shrunk under half size keeps thin lines and text.
34const uint flagSmooth = 64u;
35
36// The HDR composition target holds linear BT.709 in SDR-white units.
37vec3 decodeSRGB(vec3 v) {
38 return mix(v / 12.92, pow((v + 0.055) / 1.055, vec3(2.4)), greaterThan(v, vec3(0.04045)));
39}
40vec3 pqToLinear709(vec3 v, float whiteNits) {
41 vec3 p = pow(clamp(v, 0.0, 1.0), vec3(32.0 / 2523.0));
42 vec3 nits = pow(max(p - vec3(3424.0 / 4096.0), vec3(0.0)) /
43 max(vec3(2413.0 / 128.0) - p * (2392.0 / 128.0), vec3(0.00001)), vec3(16384.0 / 2610.0)) * 10000.0;
44 return vec3(
45 dot(nits, vec3(1.660491, -0.587641, -0.072850)),
46 dot(nits, vec3(-0.124550, 1.132900, -0.008349)),
47 dot(nits, vec3(-0.018151, -0.100579, 1.118730))
48 ) / whiteNits;
49}
50
51// H.273 Y'CbCr 4:2:0 reconstruction in electrical (non-linear) light.
52// Type 0 places chroma at x=even luma and halfway between luma rows.
53// vec2 coordinates are normalized to the chroma image for linear filtering.
54vec4 sampleYUV(vec2 src) {
55 ivec2 size = textureSize(tex, 0);
56 vec2 luma = clamp(src, d.crop.xy + 0.5, d.crop.zw - 0.5);
57 float y = texture(tex, luma / vec2(size)).r;
58 // Type 0 chroma is shifted half a luma pixel in x. Clamp in
59 // half-resolution texel space before filtering the chroma plane.
60 vec2 chroma = clamp((src + vec2(0.5, 0.0)) * 0.5,
61 d.crop.xy * 0.5 + 0.5, d.crop.zw * 0.5 - 0.5);
62 vec2 chromaUV = chroma * 2.0 / vec2(size);
63 vec2 cbcr = texture(chromaTex, chromaUV).rg;
64 bool tenBit = (d.misc.y & flagP010) != 0u;
65 bool limited = ((d.buf.w >> 8) & 255u) == 2u;
66 float maxCode = tenBit ? 1023.0 : 255.0;
67 // Packed 10-bit plane views normalize directly to the 0..1023 code range.
68 float yOff = limited ? (tenBit ? 64.0 : 16.0) / maxCode : 0.0;
69 float yScale = limited ? maxCode / (tenBit ? 876.0 : 219.0) : 1.0;
70 float cScale = limited ? maxCode / (tenBit ? 896.0 : 224.0) : 1.0;
71 float yy = (y - yOff) * yScale;
72 vec2 cc = (cbcr - vec2(tenBit ? 512.0/1023.0 : 128.0/255.0)) * cScale;
73 uint coeff = d.buf.w & 255u;
74 float kr = coeff == 4u ? 0.299 : coeff == 6u ? 0.2627 : 0.2126;
75 float kb = coeff == 4u ? 0.114 : coeff == 6u ? 0.0593 : 0.0722;
76 vec3 rgb = vec3(yy + 2.0*(1.0-kr)*cc.y,
77 yy - 2.0*kb*(1.0-kb)/(1.0-kr-kb)*cc.x - 2.0*kr*(1.0-kr)/(1.0-kr-kb)*cc.y,
78 yy + 2.0*(1.0-kb)*cc.x);
79 return vec4(rgb, 1.0);
80}
81
82// texel reads buffer pixel p, clamped to the buffer (clamp to edge).
83vec4 texel(ivec2 p) {
84 p = clamp(p, ivec2(floor(d.crop.xy)), min(ivec2(d.buf.yz) - 1, ivec2(ceil(d.crop.zw)) - 1));
85 // Little-endian B,G,R,A bytes: unpack yields (B, G, R, A).
86 return unpackUnorm4x8(pixels[d.buf.x + uint(p.y) * d.buf.y + uint(p.x)]).zyxw;
87}
88
89// sampleBuffer reads the client buffer at src (buffer pixels).
90vec4 sampleBuffer(vec2 src, bool exact) {
91 if (d.misc.x == modeImage && (d.misc.y & flagYUV) != 0u) {
92 return sampleYUV(src);
93 }
94 if (d.misc.x == modeImage) {
95 ivec2 size = textureSize(tex, 0);
96 vec2 p = clamp(src, d.crop.xy + 0.5, d.crop.zw - 0.5);
97 return exact ? texelFetch(tex, clamp(ivec2(floor(p)), ivec2(0), size - 1), 0) : texture(tex, p / vec2(size));
98 }
99 if (exact) {
100 return texel(ivec2(floor(src)));
101 }
102 // Bilinear: four texel reads around the sample point.
103 vec2 p = src - 0.5;
104 ivec2 i = ivec2(floor(p));
105 vec2 f = p - vec2(i);
106 return mix(mix(texel(i), texel(i + ivec2(1, 0)), f.x), mix(texel(i + ivec2(0, 1)), texel(i + ivec2(1, 1)), f.x), f.y);
107}
108
109void main() {
110 vec2 src = d.map.xy + gl_FragCoord.x * d.map.zw + gl_FragCoord.y * d.mapy.xy;
111 bool exact = (d.misc.y & flagExact) != 0u;
112 vec4 c;
113 if (d.misc.x == modeSolid) {
114 c = vec4(decodeSRGB(d.color.rgb), d.color.a);
115 } else if ((d.misc.y & flagSmooth) != 0u) {
116 // Premultiplied samples average without fringes.
117 vec2 dx = d.map.zw * 0.25, dy = d.mapy.xy * 0.25;
118 c = (sampleBuffer(src - dx - dy, false) + sampleBuffer(src + dx - dy, false) +
119 sampleBuffer(src - dx + dy, false) + sampleBuffer(src + dx + dy, false)) * 0.25;
120 } else {
121 c = sampleBuffer(src, exact);
122 }
123 if ((d.misc.y & flagOpaque) != 0u) {
124 c.a = 1.0;
125 }
126 if (c.a > 0.0 && d.misc.x != modeSolid) {
127 // ext_linear has the protocol's default 80 cd/m² reference white.
128 // Keep negative and above-white values in fp16 until the HDR pass.
129 vec3 v = c.rgb / c.a;
130 bool srgb = (d.misc.y & (flagPQ | flagExtendedLinear)) == 0u;
131 if (srgb && d.mapy.z > 0.0) {
132 // Focus pulse: the SDR lift, on sRGB-encoded values before
133 // decoding, so it looks the same as on an SDR output.
134 v += d.mapy.z * (1.0 - v);
135 }
136 vec3 linearRGB = (d.misc.y & flagPQ) != 0u ? pqToLinear709(v, d.color.x) :
137 (d.misc.y & flagExtendedLinear) != 0u ? v * (80.0 / d.color.x) : decodeSRGB(v);
138 c.rgb = linearRGB * c.a;
139 }
140 if (d.misc.x != modeSolid) {
141 // The surface's alpha modifier; premultiplied, it scales all four.
142 c *= d.color.a;
143 }
144 color = c;
145}