Question

I’m writing a C++ library for an image format that is based on PNG. One stopping point for me is that I’m unsure as to how I ought to lay out the pixel data in memory; as far as I’m aware, there are two practical approaches:

1. An array of size (width * height); each pixel can be accessed by array[y*width + x].
2. An array of size (height), containing pointers to arrays of size (width).

The standard reference implementation for PNG (libpng) uses method 2 of the above, while I’ve seen others use method 1. Is one better than the other, or is each a method with its own pros and cons, to where a compromise must be made? Further, which format do most graphical display systems use (perhaps for ease of using the output of my library into other APIs)?

Answer 1

Off the top of my head:

• The one thing that would make me choose #2 is the fact that your memory requirements are a little relaxed. If you were to go for #1, the system will need to be able to allocate height * width amount of contiguous memory. Whereas, in case of #2, it has the freedom to allocate smaller chunks of contiguous memory of size width (could as well be height) off of areas that are free. (When you factor in the channels per pixel, the #1 may fail for even moderately sized images.)
• Further, it may be slightly better when swapping rows (or columns) if required for image manipulation purposes (pointer swap suffices).
• The downside for #2 is of course an extra level of indirection that seeps in for every access and the array of pointers to be maintained. But this is hardly a matter given todays processor speed and memory.
• The second downside for #2 is that the data isn’t necessarily next to each other, which makes it harder for the processor the load the right memory pages into the cache.