As with everything that should be trivial this becomes fairly non-trivial upon contact with reality.

At the most fundamental level you need three lookup tables with one entry per sub-pixel. On a 1920 x 1080 display that means a little over two million entries for each, R, G and B. In other words, six million entries.

Pixel period at 60Hz is going to be in the sub-10 ns range. This means you would need lookup table memory that can be randomly indexed and respond within less than 10 ns in order to be able to grab a correction value for each and every subpixel being displayed. Due to latency and other realities of DDR SDRAM this is impossible. DDR SDRAM does far better for burst access of sequential blocks of data within a row. It does not do well for fully random access of single memory locations. DDR4 can't do full random single location access at these data rates.

Wikipedia article on SDRAM basics:

https://en.wikipedia.org/wiki/Synchronous_dynamic_random-acc...

Other memory technologies (QDR SRAM and RLD RAM) do exist that can accomplish the above requirement. They are extremely expensive and so they are not commonly seen in products such as televisions.

Yes, custom chips or an FPGA would be required in order to manage the process.

Even then, the problem isn't resolved.

The next issue is one of differential quantization. Each subpixel is either going to be driven by an 8 or 10 bit data stream. I'll use 8 bits for this example.

Say a blue sub-pixel is 25% "worn out". Assuming a linear transfer function (it isn't) this means that in order for all other blue sub-pixels on the entire screen need to be limited to a max of 75% output in order to not be brighter than that one blue sub-pixel.

Yet, the problem doesn't end there.

We also need to knock down all red and green pixels to limit them to a maximum of 75% output. Why? Because, in order to make white light you now have to compensate all color channels, otherwise you'd have too much red and green against a weak blue output.

It very quickly becomes a lowest common denominator problem.

Going back to quantization. When we started with a fresh OLED display we had 256 levels from black to white. Now we are down to 192 due to the necessary compensation.

But, that's not all! There's more!

Let's say green sub-pixels on the opposite side of the screen have now "worn out" down to 60% max output. Now the entire screen needs to be brought down to this new limit. And total quantization levels are now down to 153.

The practical result of losing quantization levels is image degradation due to an inability to smoothly map input to output.

On first inspection this might seem to indicate that a high speed three channel lookup table isn't really necessary. If we trim the output of all pixels down to the worst case pixel, well, just adjust the entire display. Except this won't work. If you bring all pixels down to 60% you are also bringing down the bad pixels that could not produce full light output. The end results is that, yes, you do need a high speed lookup table in order to leave bad pixels alone (not quite) and adjust good pixels to match the bad pixels.

And yet, we are not done with this. There's a fundamental issue that hasn't been addressed, even after throwing all that technology at it: Calibration.

In order to be able to populate three lookup tables (red, green and blue) we need to be able to measure wear at the sub-pixel level. This is extremely time consuming and most definitely well outside the realm of consumers. At the factory? Sure. At home? Not likely. I can see gross measurement. For example, manually measure sixteen zones and accept the fact that the image might have visible color differences due to this. Or, maybe, use a high resolution sensor to measure a few hundred zones. And this is when, to reach for the popular saying, you start to find yourself up to your ass in alligators when all you wanted to do was drain the swamp.

Funny how things work.

EDIT: Forgot to add. A lifetime "on" time counter won't work. The degradation of OLED pixels isn't purely a function of time. You can end-up with pixels that have been active for exactly the same time and one is significantly brighter than the other. You have to measure.