Libzimg: AddressSanitizer: SEGV

Во-первых, на основе примера C и make-файла для примеры в zimg можно писать C как обычно (#include <stdio.h>) и скомпилируйте с помощью gcc; вам просто нужно обязательно использовать ссылку g++, например:

CFLAGS = -Wall -Werror -g
test: test.o
    g++ test.o -pthread $$(pkg-config --libs libjpeg zimg) -o test
test.o: test.c
    gcc -std=c11 $(CFLAGS) -pthread $$(pkg-config --cflags libjpeg zimg) -c test.c

Основная проблема с кодом заключается в том, что чтение и копирование строк развертки Возврат через libjpeg создает в памяти следующее расположение пикселей:

scanline 1
R G B R G B R G B ...
scanline 2
R G B R G B R G B ...
scanline 3
R G B R G B R G B ...
...

С другой стороны, zimg рассчитывает работать с каждым каналом отдельно, то есть:

buf.plane[0]:
R R R R R R R R ...
R R R R R R R R ...
...
buf.plane[1]:
G G G G G G G G ...
G G G G G G G G ...
...
buf.plane[2]:
B B B B B B B B ...
B B B B B B B B ...
...

Где каждая строка канала выровнена по 32 байта. Таким образом, вместо того, чтобы копировать каждый строки сканирования при чтении JPEG, вам следует извлечь каждый компонент пикселя в соответствующая плоскость Зимга.

Кроме того, вы распаковали входной JPEG и записали пиксели как есть в файл. выходной файл. Чтобы записать JPEG, вам нужно использовать libjpeg для повторного сжатия. После масштабируя с помощью zimg, пиксели можно снова собрать в строки сканирования RGB для дальнейшего использования. с компрессором.

Собираем все это вместе:

#include <errno.h>
#include <setjmp.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <jpeglib.h>
#include <zimg.h>

static JDIMENSION dimension_arg(const char *arg) {
    long value;
    char *end;
    errno = 0;
    value = strtol(arg, &end, 10);
    if (errno != 0 || end == arg || *end != '\0' || value < 1 || value > JPEG_MAX_DIMENSION) {
        (void)fprintf(
            stderr, "Invalid JPEG dimension (range [1-%ld]): %s\n", JPEG_MAX_DIMENSION, arg
        );
        return 0;
    }
    return value;
}

struct image {
    struct zimg_image_format format;
    uint8_t *data;
    uint8_t *plane[3];
    unsigned int stride;
};

#define PAD32(x) (((x) + 0x1f) & ~0x1f)

static int image_init(struct image *image, unsigned int width, unsigned int height) {
    zimg_image_format_default(&image->format, ZIMG_API_VERSION);
    image->format.width = width;
    image->format.height = height;
    image->format.pixel_type = ZIMG_PIXEL_BYTE;
    image->format.color_family = ZIMG_COLOR_RGB;
    image->format.pixel_range = ZIMG_RANGE_FULL;

    image->stride = PAD32(width);
    size_t plane_size = (size_t)image->stride * height;
    image->data = aligned_alloc(32, plane_size * 3);
    if (image->data == NULL) {
        (void)fputs("Failed to allocate image memory\n", stderr);
        return 0;
    }
    for (int i = 0; i < 3; ++i)
        image->plane[i] = image->data + plane_size * i;

    return 1;
}

static void image_free(struct image *image) {
    free(image->data);
}

static void handle_jpeg_error(j_common_ptr cinfo) {
    (*cinfo->err->output_message)(cinfo);
    jmp_buf *env = cinfo->client_data;
    jpeg_destroy(cinfo);
    longjmp(*env, 1);
}

static int read_jpeg(const char *path, struct image *image) {
    FILE *file = fopen(path, "rb");
    if (file == NULL) {
        (void)fprintf(stderr, "Failed to open input JPEG %s: %s\n", path, strerror(errno));
        return 0;
    }

    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;

    cinfo.err = jpeg_std_error(&jerr);
    jerr.error_exit = handle_jpeg_error;

    volatile int allocated_image = 0;
    jmp_buf env;
    cinfo.client_data = &env;
    if (setjmp(env)) {
        // Fatal libjpeg error; we've already destroyed cinfo.
        (void)fclose(file);
        if (allocated_image)
            image_free(image);
        return 0;
    }

    jpeg_create_decompress(&cinfo);
    // We are using a non-suspending data source (stdio), so the return value of read_header,
    // start_decompress, and finish_decompress can be ignored.
    jpeg_stdio_src(&cinfo, file);

    (void)jpeg_read_header(&cinfo, 1);
#ifdef DEBUG
    fprintf(
        stderr, "Input JPEG: dim=%ux%u, space=%d, components=%d\n",
        cinfo.image_width, cinfo.image_height, cinfo.jpeg_color_space, cinfo.num_components
    );
#endif
    // Always decompress to RGB. This means we will have 3 output components.
    cinfo.out_color_space = JCS_RGB;

    // Start decompress: fills out cinfo.out*.
    (void)jpeg_start_decompress(&cinfo);

    if (!image_init(image, cinfo.output_width, cinfo.output_height))
        goto err_destroy_jpeg;
    allocated_image = 1;

    // libjpeg-managed scanline buffer, freed on cinfo destroy. Assume cinfo.rec_outbuf_height is
    // just 1 line since we use the default decompression.
    JDIMENSION scan_size = cinfo.output_width * sizeof(JSAMPLE) * 3;
    JSAMPARRAY scan_buf =
        (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo, JPOOL_IMAGE, scan_size, 1);

    size_t line_start = 0;
    while (cinfo.output_scanline < cinfo.output_height) {
        (void)jpeg_read_scanlines(&cinfo, scan_buf, 1);
        JSAMPROW p = scan_buf[0];
        for (JDIMENSION i = 0; i < cinfo.output_width; ++i) {
            image->plane[0][line_start + i] = p[0];
            image->plane[1][line_start + i] = p[1];
            image->plane[2][line_start + i] = p[2];
            p += 3;
        }
        line_start += image->stride;
    }

    (void)jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);
    (void)fclose(file);
    return 1;

err_destroy_jpeg:
    jpeg_destroy_decompress(&cinfo);
    (void)fclose(file);
    return 0;
}

static int write_jpeg(const char *path, struct image *image) {
    FILE *file = fopen(path, "wb");
    if (file == NULL) {
        (void)fprintf(stderr, "Failed to open path for writing %s: %s\n", path, strerror(errno));
        return 0;
    }

    // See comments in read_jpeg for libjpeg operation details.
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;

    cinfo.err = jpeg_std_error(&jerr);
    jerr.error_exit = handle_jpeg_error;

    jmp_buf env;
    cinfo.client_data = &env;
    if (setjmp(env)) {
        (void)fclose(file);
        return 0;
    }

    jpeg_create_compress(&cinfo);
    jpeg_stdio_dest(&cinfo, file);

    cinfo.image_width = image->format.width;
    cinfo.image_height = image->format.height;
    cinfo.input_components = 3;
    cinfo.in_color_space = JCS_RGB;

    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, 80, 1);

    jpeg_start_compress(&cinfo, 1);

    JDIMENSION scan_size = cinfo.image_width * sizeof(JSAMPLE) * 3;
    JSAMPARRAY scan_buf =
        (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo, JPOOL_IMAGE, scan_size, 1);

    size_t line_start = 0;
    while (cinfo.next_scanline < cinfo.image_height) {
        JSAMPROW p = scan_buf[0];
        for (JDIMENSION i = 0; i < cinfo.image_width; ++i) {
            p[0] = image->plane[0][line_start + i];
            p[1] = image->plane[1][line_start + i];
            p[2] = image->plane[2][line_start + i];
            p += 3;
        }
        (void)jpeg_write_scanlines(&cinfo, scan_buf, 1);
        line_start += image->stride;
    }

    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
    if (fclose(file) == EOF) {
        (void)fprintf(stderr, "Failed to finish writing %s: %s\n", path, strerror(errno));
        return 0;
    }

    return 1;
}

static void output_zimg_error(const char *func) {
    char buf[1024];
    enum zimg_error_code_e zerr = zimg_get_last_error(buf, sizeof(buf));
    (void)fprintf(stderr, "%s: error %d: %s\n", func, zerr, buf);
}

static int scale(struct image *in, struct image *out) {
    struct zimg_graph_builder_params params;
    zimg_graph_builder_params_default(&params, ZIMG_API_VERSION);
    params.resample_filter = ZIMG_RESIZE_LANCZOS;
    params.resample_filter_uv = ZIMG_RESIZE_LANCZOS;

    struct zimg_filter_graph *graph = zimg_filter_graph_build(&in->format, &out->format, &params);
    if (graph == NULL) {
        output_zimg_error("zimg_filter_graph_build");
        goto err;
    }

    enum zimg_error_code_e zerr;
    size_t tmp_size;
    zerr = zimg_filter_graph_get_tmp_size(graph, &tmp_size);
    if (zerr != ZIMG_ERROR_SUCCESS) {
        output_zimg_error("zimg_filter_graph_get_tmp_size");
        goto err_free_graph;
    }

    void *tmp = aligned_alloc(32, tmp_size);
    if (tmp == NULL) {
        (void)fputs("Failed to allocate memory for zimg graph processing\n", stderr);
        goto err_free_graph;
    }

    struct zimg_image_buffer_const src;
    struct zimg_image_buffer dst;
    src.version = dst.version = ZIMG_API_VERSION;
    for (int p = 0; p < 3; ++p) {
        src.plane[p].data = in->plane[p];
        src.plane[p].stride = in->stride;
        src.plane[p].mask = ZIMG_BUFFER_MAX;

        dst.plane[p].data = out->plane[p];
        dst.plane[p].stride = out->stride;
        dst.plane[p].mask = ZIMG_BUFFER_MAX;
    }

    zerr = zimg_filter_graph_process(graph, &src, &dst, tmp, NULL, NULL, NULL, NULL);
    if (zerr != ZIMG_ERROR_SUCCESS) {
        output_zimg_error("zimg_filter_graph_process");
        goto err_free_tmp;
    }

    free(tmp);
    zimg_filter_graph_free(graph);
    return 1;

err_free_tmp:
    free(tmp);
err_free_graph:
    zimg_filter_graph_free(graph);
err:
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 5) {
        (void)fprintf(stderr, "Usage: %s <in JPEG> <out JPEG> <out width> <out height>\n", argv[0]);
        return 2;
    }

    const char *in_path = argv[1];
    const char *out_path = argv[2];
    JDIMENSION out_width = dimension_arg(argv[3]);
    if (out_width == 0)
        return 2;
    JDIMENSION out_height = dimension_arg(argv[4]);
    if (out_height == 0)
        return 2;

    struct image out;
    if (!image_init(&out, out_width, out_height))
        goto err;

    struct image in;
    if (!read_jpeg(in_path, &in))
        goto err_free_out;

    printf("Scaling %s to %ux%u...\n", in_path, out_width, out_height);
    if (!scale(&in, &out))
        goto err_free_in;

    if (!write_jpeg(out_path, &out))
        goto err_free_in;
    printf("Wrote scaled image to %s\n", out_path);

    image_free(&in);
    image_free(&out);

    return 0;

err_free_in:
    image_free(&in);
err_free_out:
    image_free(&out);
err:
    return 1;
}