Проблема с динамическим выделением памяти во вспомогательной функции, в заголовочном файле

Жаль, что прототип для размытия не дан, но, вероятно, что-то вроде void blur(RGBTRIPLE *image, int width, int height)

Похоже, вы хотите обновить содержимое изображения напрямую, а не создавать новое.

В этом случае ваш последний оператор image = temp присвоит новое значение локальной копии указателя изображения, но не повлияет на исходное значение.

Вы хотите скопировать содержимое temp обратно в изображение с помощью memcpy: memcpy(image, temp, width*height*sizeof(RGBTRIPLE);

После этого вам нужно будет free temp перед возвратом, иначе у вас останется утечка памяти.

Синтаксис указателей на массивы немного странный. Вы можете передать указатель на массив высоты и ширины и выделить один массив высоты и ширины:

#include <stdlib.h>
#include <stdio.h>
typedef int RGBTRIPLE;
void blur(int height, int width, RGBTRIPLE (**image)[height][width]) {
    RGBTRIPLE (*temp)[height][width] = calloc(1, sizeof(*temp));
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            (*temp)[i][j] = i * 100 + j;
        }
    }
    *image = temp;
}

int main() {
    int height = 3;
    int width = 4;
    RGBTRIPLE (*arr)[height][width];
    blur(height, width, &arr);
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            printf("[%d][%d] = %d\n", i, j, (*arr)[i][j]);
        }
    }
    free(arr);
}

(Вы можете использовать arr[0][i][j] вместо (*arr)[i][j] для облегчения набора текста и большей путаницы). Вы также можете передать указатель на массив ширины и выделить высоту массивов ширины:

#include <stdlib.h>
#include <stdio.h>
typedef int RGBTRIPLE;
void blur(int height, int width, RGBTRIPLE (**image)[width]) {
    RGBTRIPLE (*temp)[width] = calloc(height, sizeof(*temp));
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            temp[i][j] = i * 100 + j;
        }
    }
    *image = temp;
}

int main() {
    int height = 3;
    int width = 4;
    RGBTRIPLE (*arr)[width];
    blur(height, width, &arr);
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            printf("[%d][%d] = %d\n", i, j, arr[i][j]);
        }
    }
    free(arr);
}

Но в целом, если вы только изучаете язык и у вас нет особых требований к использованию указателя на VLA, я бы настоятельно рекомендовал просто использовать указатель на указатель. Не будьте 3-звездочным программистом и используйте структуру или возвращаемое значение для передачи результата. Такой код будет ясен и понятен любому программисту.

#include <stdlib.h>
#include <stdio.h>
typedef int RGBTRIPLE;
RGBTRIPLE **blur(int height, int width) {
    RGBTRIPLE **temp = calloc(height, sizeof(*temp));
    for (int i = 0; i < height; ++i) {
        temp[i] = calloc(width, sizeof(*temp[i]));
    }

    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            temp[i][j] = i * 100 + j;
        }
    }
    return temp;
}

int main() {
    int height = 3;
    int width = 4;
    RGBTRIPLE **arr = blur(height, width);
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            printf("[%d][%d] = %d\n", i, j, arr[i][j]);
        }
    }

    for (int i = 0; i < height; ++i) {
        free(arr[i]);
    }
    free(arr);
}

В реальном коде я бы предпочел сделать RGBTRIPLE более непрозрачным типом и написать метод доступа к элементу, чтобы он мог проверять доступ за пределами границ и сделать дизайн более объектно-ориентированным, где RGBTRIPLE — это объект, над которым мы работаем. Что-то вдоль:

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

typedef int RGBTRIPLE;

struct rgbtriple_s {
    RGBTRIPLE **vals;
    size_t height;
    size_t width;
};

int rgbtriple_blur(struct rgbtriple_s *t, size_t height, size_t width) {
    RGBTRIPLE **temp = calloc(height, sizeof(*temp));
    // ERROR CHECKING!
    for (size_t i = 0; i < height; ++i) {
        temp[i] = calloc(width, sizeof(*temp[i]));
        // ERROR CHECKING!
    }

    for (size_t i = 0; i < height; ++i) {
        for (size_t j = 0; j < width; ++j) {
            temp[i][j] = i * 100 + j;
        }
    }

    t->vals = temp;
    t->height = height;
    t->width = width;

    return 0;
}

/// Get reference to.
int *rgbtriple_getr(struct rgbtriple_s *t, size_t x, size_t y) {
    assert(x < t->height);
    assert(y < t->width);
    return &t->vals[x][y];
}

int rgbtriple_get(struct rgbtriple_s *t, size_t x, size_t y) {
    return *rgbtriple_getr(t, x, y);
}


void rgbtriple_free(struct rgbtriple_s *t) {
    if (t->vals == NULL) return;
    for (size_t i = 0; i < t->height; ++i) {
        free(t->vals[i]);
    }
    free(t->vals);
    t->vals = NULL;
}

int main() {
    const size_t height = 3;
    const size_t width = 4;
    struct rgbtriple_s data = {0};
    rgbtriple_blur(&data, height, width);
    for (size_t i = 0; i < height; ++i) {
        for (size_t j = 0; j < width; ++j) {
            printf("[%zu][%zu] = %d\n", i, j, rgbtriple_get(&data, i, j));
        }
    }
    rgbtriple_free(&data);
}

Обратите внимание, что во всем вышеприведенном коде проверка ошибок не была включена, скажем так, для краткости, а на самом деле потому, что мне лень это писать.