将数组分配给结构中的数组时出现分段错误

Question

I get segmentation fault from this code. It's a function for vertical flipping of a BMP image. I am trying to assign an array to another array in a structure. I would appreciate your help.

struct bmp_image *flip_horizontally(const struct bmp_image *image) {
    if (image == NULL)
    {
        return NULL;
    }

    struct bmp_image *transformed = NULL;
    transformed = (struct bmp_image *)calloc(1, sizeof(image->data) + sizeof(image->header));

    transformed->header = image->header;

    struct pixel data_array[image->header->height][image->header->width];

    int index = 0;
    for (int i = 0; i < image->header->height; i++)
    {
        for (int j = (int)image->header->width - 1; j >= 0; j--)
        {
            data_array[i][j].blue = image->data[index].blue;
            data_array[i][j].green = image->data[index].green;
            data_array[i][j].red = image->data[index].red;
            index++;
        }
    }

    struct pixel *transformed_data = calloc((image->header->width * image->header->height), sizeof(struct pixel));

    index = 0;
    // I think that the code after this line causes the segmentation fault
    for (int i = 0; i < image->header->height; i++)
    {
        for (int j = 0; j < image->header->width; j++)
        {
            transformed_data[index].blue = data_array[i][j].blue;
            transformed_data[index].green = data_array[i][j].green;
            transformed_data[index].red = data_array[i][j].red;
            index++;
        }
    }
    transformed->data = transformed_data;

    return transformed;
}

Answer 1

In my opinion... I would create a single array per row of pixels in the bmp image, and an array of pointers to arrays of pixels, pointing each to each of the successive rows of your image. Then flipping the rows is just going from the extremes of the array with two indices, and swapping the pointers, until both indices meed at the middle of the array. Then encode again the array and you will have done this without having to copy all the pixels up and down.

+-------+      +-----+-----+-----+-----+-----+-----+-----+-----+-----+
| P[0] =======>| Pxl | Pxl | ... |     |     |     |     |     |     |
+-------+      +-----+-----+-----+-----+-----+-----+-----+-----+-----+
| P[1] =======>|     |     |     |     |     |     |     |     |     |
+-------+      +-----+-----+-----+-----+-----+-----+-----+-----+-----+
  ...
+-------+      +-----+-----+-----+-----+-----+-----+-----+-----+-----+
| P[N] =======>|     |     |     |     |     |     |     |     |     |
+-------+      +-----+-----+-----+-----+-----+-----+-----+-----+-----+

As you have not posted complete code, it's impossible for me to tweak your code to make it simpler and show a solution by modifying it. But something like (beware, this code is not tested):

void bitimage_swap(struct pixel **to_swap, size_t nrows)
{
    struct pixel **start = to_swap, **end = to_swap + nrows;
    while (start < --end) {
        struct pixel *temp = *start;
        *start++ = *end;
        *end = temp;
    }
}