2023 April Retrospective

/*
	MIT LICENSE
	Copyright (c) 2023, Mihail Szabolcs
*/
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <memory.h>

#define STBI_NO_HDR
#define STBI_NO_LINEAR
#define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include "stb_image.h"
#include "stb_image_write.h"
#include "stb_image_resize.h"

#ifndef UNUSED
	#define UNUSED(x) (void)(x)
#endif

#ifndef DEFAULT_OUTPUT_IMAGE_WIDTH
	#define DEFAULT_OUTPUT_IMAGE_WIDTH 1920
#endif

#ifndef DEFAULT_OUTPUT_IMAGE_HEIGHT
	#define DEFAULT_OUTPUT_IMAGE_HEIGHT 1080
#endif

typedef union
{
	uint32_t rgba;
	struct
	{
		uint32_t r : 8;
		uint32_t g : 8;
		uint32_t b : 8;
		uint32_t a : 8;
	};
} rgba_t;

#define resize_image(input, iw, ih, output, ow, oh) \
	stbir_resize_uint8( \
		(const unsigned char *) input, \
		iw, \
		ih, \
		0, \
		(unsigned char *) output, \
		ow, \
		oh, \
		0, \
		sizeof(rgba_t) \
	)

static void fill_image(
    rgba_t *image,
    const int w,
    const int h,
    const rgba_t color
);
static void flip_image(rgba_t *image, const int w, const int h);

static void process(
	const rgba_t *restrict input,
	rgba_t *restrict output,
	const int iw,
	const int ih,
	const int ow,
	const int oh
);

int main(int argc, char *argv[])
{
	int i, iw, ih, rw, rh, ow, oh, bpp, ret;
	bool flip_input;
	rgba_t *input, *rinput, *output;

	if(argc < 3 || argc > 6)
	{
		fprintf(
			stderr,
            "usage: %s input.png output.png [arguments...]\n\n",
            argv[0]
        );
		fprintf(stderr, "arguments:\n");
		fprintf(stderr, "    --flip   - flip input image horizontally\n");
		fprintf(stderr, "    --width  - set width of output image\n");
		fprintf(stderr, "    --height - set height of output image\n");
		return EXIT_FAILURE;
	}

	flip_input = false;
	ow = DEFAULT_OUTPUT_IMAGE_WIDTH;
	oh = DEFAULT_OUTPUT_IMAGE_HEIGHT;

	for(i = 3; i < argc; i++)
	{
		if(!strcmp(argv[i], "--flip"))
		{
			flip_input = true;
		}
		else if(!strcmp(argv[i], "--width") && i + 1 < argc)
		{
			ow = atoi(argv[++i]);
			if(ow <= 0)
			{
				fprintf(
                	stderr,
                    "error: invalid value for '--width' argument"
                );
				return EXIT_FAILURE;
			}
		}
		else if(!strcmp(argv[i], "--height") && i + 1 < argc)
		{
			oh = atoi(argv[++i]);
			if(oh <= 0)
			{
				fprintf(
                	stderr,
                    "error: invalid value for '--height' argument"
                );
				return EXIT_FAILURE;
			}
		}
		else
		{
			fprintf(stderr, "error: invalid argument '%s'\n", argv[i]);
			return EXIT_FAILURE;
		}
	}

	input = (rgba_t *) stbi_load(argv[1], &iw, &ih, &bpp, sizeof(rgba_t));
	if(input == NULL)
	{
		fprintf(
            stderr,
            "failed to load input image: %s\n",
            stbi_failure_reason()
        );
		return EXIT_FAILURE;
	}

	rw = ow;
	rh = oh;

	if(ih > 0 && ih != rh)
	{
		rw = iw * ((double) rh / (double) ih);

		rinput = malloc(rw * rh * sizeof(rgba_t));
		if(rinput == NULL)
		{
			fprintf(
                stderr,
                "failed to allocate memory to resize input image\n"
            );
			free(input);
			return EXIT_FAILURE;
		}

		if(!resize_image(input, iw, ih, rinput, rw, rh))
		{
			fprintf(
                stderr,
                "failed to resize input image from %dx%d to %dx%d ...\n",
                iw,
                ih,
                rw,
                rh
            );
			free(rinput);
			free(input);
			return EXIT_FAILURE;
		}
        
        free(input);

		fprintf(
            stderr,
            "resized input image from %dx%d to %dx%d ...\n",
            iw,
            ih,
            rw,
            rh
        );

		input = rinput;
		iw = rw;
		ih = rh;
	}

	output = malloc(ow * oh * sizeof(rgba_t));
	if(output == NULL)
	{
		fprintf(stderr, "failed to allocate memory for output image\n");
		free(input);
		return EXIT_FAILURE;
	}

	fill_image(output, ow, oh, (rgba_t) { .a = 0xFF });

	if(flip_input)
	{
		flip_image(input, iw, ih);
		fprintf(stderr, "flipped input image horizontally ...\n");
	}

	process(input, output, iw, ih, ow, oh);

	ret = stbi_write_png(
        argv[2],
        ow,
        oh,
        sizeof(rgba_t),
        output,
        ow * sizeof(rgba_t)
    );
	if(ret == 0)
	{
		fprintf(stderr, "failed to write output image: '%s'\n", argv[2]);
		ret = EXIT_FAILURE;
	}
	else
	{
		fprintf(stdout, "wrote output image to '%s' ...\n", argv[2]);
		ret = EXIT_SUCCESS;
	}

	free(output);
	free(input);
	return ret;
}

static void fill_image(
    rgba_t *image,
    const int w,
    const int h,
    const rgba_t color
)
{
	for(rgba_t *c = image, *e = image + w * h; c != e; c++)
		*c = color;
}

static void flip_image(rgba_t *image, const int w, const int h)
{
	int x, y, ww, xw, yo, i, j;
	rgba_t c;

	ww = w - 1;
	xw = w >> 1;

	for(y = 0; y < h; y++)
	{
		yo = y * w;

		for(x = 0; x < xw; x++)
		{
			i = x + yo;
			j = (ww - x) + yo;

			c = image[i];
			image[i] = image[j];
			image[j] = c;
		}
	}
}

static void process(
	const rgba_t *restrict input,
	rgba_t *restrict output,
	const int iw,
	const int ih,
	const int ow,
	const int oh
)
{
	int x, y, ww, xi, xo;
	double t, tw;
	rgba_t c;

	UNUSED(oh);

	xi = 0;
	ww = iw;

	if(iw > ow)
	{
		xi = iw - ow;
		ww = ow;
		input = input + xi;
	}

	xo = ow - ww;
	output = output + xo;

	tw = 1.0 / iw;

	for(y = 0; y < ih; y++)
	{
		for(x = 0; x < ww; x++)
		{
			t = x * tw;

			c = *input++;

			c.r = c.r * t;
			c.g = c.g * t;
			c.b = c.b * t;

			*output++ = c;
		}

		input += xi;
		output += xo;
	}
}

/* vim: set ts=4 sw=4 sts=4 noet: */