The usual thing that starts happening very quickly is that you see banding in broad tonal ramps.
It's easy to show how posterization banding can, and necessarily does,
happen. Take a series of increasing values to represent the gradient
in a tonal ramp:
To keep this simple, I'll use a 3:1 compression on 6 values
not a 4:1 compression on 8 values, and I'll average them linearly
not using an area simple as JPEG does. This avoids round-off
error or resorting to non-integer arithmetic, and is easier to see.
Each set of 3 values averages to the middle value in each triple:
and so when 1:3 uncompressed, back into:
Now apply a simple transformation that doubles each value,
perhaps a +1 EV digital boost. The original series becomes:
But doubling the compressed series becomes:
which uncompresses out to (anti-aliasing would help here):
The transformed original series is clearly smoother than the transformed
compressed series is. But is it much smoother? Can one discern a jump of
6? Maybe, maybe not. Remember the sudden jump by 6 in previously
smooth data is an artifact of 3:1 compression. In real image data with
4:1, 8:1, or 16:1 compression, it's even worse. And this is just a
single transformation; problems accumulate with further manipulation.
This is why posterization necessarily arises from JPEG compression, and
also shows why 16-bit data is less prone to posterization than 8-bit data.
The place consumers most frequently encounter this problem is larger prints
that include blue skies, where it's exacerbated by red-channel noise. But
as you point out, any area with a smooth tonal gradient is vulnerable to
the problem outlined above. Shots straight from the camera will show this
problem provided the compression is high enough and the print large enough;
and if they've edited the image, it's even worse.
Similar demonstrations can be devised to show how round-off error creeps
into your image due to integer arithmetic, and why you're less likely to
notice it in 16 bits than you are in 8. Even keeping 14-bit data safe
using 16-bit registers only is tricky. Working in floating-point is safer,
but also slower.
--tom
