<div dir="ltr">You can store in 8 bits and still convert to/from linear values when computing compositing. Squaring the number is likely close enough and can simplify the math. Also GPUs have built-in instructions to convert between 8 bits and floating point as sRGB.<div> <div> </div></div></div> <div class="gmail_quote"><div dir="ltr" class="gmail_attr">On Mon, Dec 25, 2023 at 11:25 PM Bandi-T <<a href="mailto:bandit@surfnonstop.com">bandit@surfnonstop.com</a>> wrote: </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">Greetings, Is Cairo antialiasing/compositing in linear light? I am drawing graphs into onto on-screen areas using Cairo/GTK4 (Gtk::DrawingArea)/Win10, and the edges of my slanted (non-vertical/horizontal) lines (straight line segments) look jagged... like they might not have been antialiased in linear light, but in gamma-space. If my observation is correct, I am proposing enhancing Cairo to be able to perform anti-aliasing/compositing in linear light. This would switch internal pixel representation to linear light (float or at least 12-13 bits/component – so practically uint16), and then only upon a snapshotting (outputting the result) would it generate a 8 bit sRGB representation for legacy environments that still expect sRGB, or pass through the 16 bit linear representation for more modern environments (e.g. GPU textures). Please see this article with visual demonstrations and discussion about the potential improvements: <a href="https://pixls.us/articles/users-guide-to-high-bit-depth-gimp-2-9-2-part-2/" rel="noreferrer" target="_blank">https://pixls.us/articles/users-guide-to-high-bit-depth-gimp-2-9-2-part-2/</a> Conceptually, this would * convert all incoming legacy color (= color specified in gamma-encoded spaces, e.g. sRGB – be it from image pixels, or user-speficied pen/fill colors, etc.) into linear light * internally, always work (draw/paint/antialias/composite) in linear light * when a gamma-encoded output is needed, render a gamma-encoded snapshot of the result For sRGB (which I assume is going to be the most common case) the needed maths is elaborated in the Wikipedia article of sRGB. Because this needs extra buffering, plus implies non-zero computational cost, it would be behind a higher quality antialias flag, so that users who don't care would not pay the extra computational costs. (However my hope is that the cost on modern hardware versus the quality improvement would eventually make this the default mode.) This is orthogonal to whole-pixel versus sub-pixel antialiasing, so both of those modes could/would/should benefit from it. How viable is this proposal? (For example I am only considering the case where Cairo is rendering into a pixel-based memory buffer that eventually gets copied on-screen, and am unaware of what this might mean for other scenarios.) Thank you in advance. </blockquote></div>