How to copy a pixel buffer into a larger one - c++

Question

I’m trying to copy a set of pixels into a larger pixel buffer. Clearly, I’m calculating the coordinates wrong, probably with the strides, but I can’t find what I’m missing. I get a completely messed up result.
So in essence, what I try to achieve is to copy a RGBA pixel array into a larger RGB array (alpha gets discarded), keeping the strides correctly. See the image below for a visual representation of the expected result.
void draw(const uint8_t* tileRGBA, uint8_t* canvasRGB, const int canvasStride,
const int tileWidth, const int tileHeight)
{
for (int y = 0; y < tileHeight; y++)
{
for (int x = 0; x < tileWidth; x++)
{
long tileIndex = (4 * x) + (y * tileWidth);
long canvasIndex = (3 * x) + (y * canvasStride);
canvasRGB[canvasIndex] = tileRGBA[tileIndex];
canvasRGB[canvasIndex + 1] = tileRGBA[tileIndex + 1];
canvasRGB[canvasIndex + 2] = tileRGBA[tileIndex + 2];
}
}
}
uint8_t* test(uint32_t* tileRGBA, const int tileWidth, const int tileHeight)
{
int canvasStride = tileWidth * 5; // 5 is just an arbitrary value for this example, in this case a canvas 5 times the width of the tile
uint8_t* canvasRGB = new uint8_t[canvasStride * tileHeight * 3];
draw((uint8_t*)tileRGBA, canvasRGB, canvasStride, tileWidth, tileHeight);
return canvasRGB;
}
SOLVED: Thanks to the comments of Johnny Mopp. It was a matter of brackets.
This:
long tileIndex = (4 * x) + (y * tileWidth)
long canvasIndex = (3 * x) + (y * canvasStride);
Must be really this:
long tileIndex = 4 * (x + y * tileWidth);
long canvasIndex = 3 * (x + y * canvasStride);

Answer 1

The problem is in your calculation of the indexes.
To get a 2D index (row,col) in a 1D array you would do:
index = ((number_of_columns * row) + col) * sizeof(data)
Where number_of_columns is the intended number of "columns" in the data - in this case the width of the image. And sizeof(data) is the size in bytes of one item in the array - in this case, 4 bytes for RGBA and 3 for RGB. So, as you have determined, it should be:
long tileIndex = 4 * (x + y * tileWidth);
long canvasIndex = 3 * (x + y * canvasStride);
You can do away with the sizeof multiplication if you can represent the data as a single item. For example, in your case, create 2 structs:
struct RGB {
uint8_t r,g,b;
};
struct RGBA {
uint8_t r,g,b,a;
};
Then pass the parameters as arrays of these structs:
void draw(const RGBA* tileRGBA, RGB* canvasRGB, const int canvasStride, const int tileWidth, const int tileHeight)
Then the calculation simplifies to:
long tileIndex = x + y * tileWidth;
long canvasIndex = x + y * canvasStride;