Fix rgbgfx's code style

Signed-off-by: obskyr <powpowd@gmail.com>

include/gfx/gb.h

@@ -15,11 +15,12 @@
 void raw_to_gb(const struct RawIndexedImage *raw_image, struct GBImage *gb);
 void output_file(const struct Options *opts, const struct GBImage *gb);
 int get_tile_index(uint8_t *tile, uint8_t **tiles, int num_tiles,
-                   int tile_size);
+		   int tile_size);
 void create_tilemap(const struct Options *opts, struct GBImage *gb,
-		            struct Tilemap *tilemap);
+		    struct Tilemap *tilemap);
 void output_tilemap_file(const struct Options *opts,
-			             const struct Tilemap *tilemap);
+			 const struct Tilemap *tilemap);
 void output_palette_file(const struct Options *opts,
-                         const struct RawIndexedImage *raw_image);
+			 const struct RawIndexedImage *raw_image);
+
 #endif

include/gfx/makepng.h

@@ -12,10 +12,10 @@
 #include "gfx/main.h"
 
 struct RawIndexedImage *input_png_file(const struct Options *opts,
-                                       struct ImageOptions *png_options);
+				       struct ImageOptions *png_options);
 void output_png_file(const struct Options *opts,
-                     const struct ImageOptions *png_options,
+		     const struct ImageOptions *png_options,
-                     const struct RawIndexedImage *raw_image);
+		     const struct RawIndexedImage *raw_image);
 void destroy_raw_image(struct RawIndexedImage **raw_image_ptr_ptr);
 
 #endif /* RGBDS_GFX_PNG_H */

src/gfx/gb.c

@@ -42,13 +42,8 @@ void raw_to_gb(const struct RawIndexedImage *raw_image, struct GBImage *gb)
 			index = raw_image->data[y][x];
 			index &= (1 << depth) - 1;
 
-			if (!gb->horizontal) {
+			byte = y * depth
-				byte = y * depth
+				+ x / 8 * raw_image->height / 8 * 8 * depth;
-				     + x / 8 * raw_image->height / 8 * 8 * depth;
-			} else {
-				byte = y * depth
-				     + x / 8 * raw_image->height / 8 * 8 * depth;
-			}
 			gb->data[byte] |= (index & 1) << (7 - x % 8);
 			if (depth == 2) {
 				gb->data[byte + 1] |=
@@ -154,7 +149,7 @@ void create_tilemap(const struct Options *opts, struct GBImage *gb,
 }
 
 void output_tilemap_file(const struct Options *opts,
-			             const struct Tilemap *tilemap)
+			 const struct Tilemap *tilemap)
 {
 	FILE *f;
 
@@ -170,21 +165,21 @@ void output_tilemap_file(const struct Options *opts,
 }
 
 void output_palette_file(const struct Options *opts,
-                         const struct RawIndexedImage *raw_image)
+			 const struct RawIndexedImage *raw_image)
 {
 	FILE *f;
 	int i, color;
 	uint8_t cur_bytes[2];
 
 	f = fopen(opts->palfile, "wb");
-	if (!f) {
+	if (!f)
-		err(1, "Opening palette file '%s' failed",
+		err(1, "Opening palette file '%s' failed", opts->palfile);
-		    opts->palfile);
+
-	}
 	for (i = 0; i < raw_image->num_colors; i++) {
-		color = raw_image->palette[i].blue  >> 3 << 10 |
+		color =
-		        raw_image->palette[i].green >> 3 <<  5 |
+			raw_image->palette[i].blue  >> 3 << 10 |
-				raw_image->palette[i].red   >> 3;
+			raw_image->palette[i].green >> 3 <<  5 |
+			raw_image->palette[i].red   >> 3;
 		cur_bytes[0] = color & 0xFF;
 		cur_bytes[1] = color >> 8;
 		fwrite(cur_bytes, 2, 1, f);

src/gfx/main.c

@@ -131,17 +131,17 @@ int main(int argc, char *argv[])
 	if (png_options.trim)
 		opts.trim = png_options.trim;
 
+
 	if (raw_image->width % 8 || raw_image->height % 8) {
-		errx(1, "Input PNG file %s not sized correctly. "
+		errx(1, "Input PNG file %s not sized correctly. The image's width and height must be multiples of 8.",
-		     "The image's width and height must be multiples of 8.",
+		     opts.infile);
-			 opts.infile);
 	}
 
 	if (opts.trim &&
 	    opts.trim > (raw_image->width / 8) * (raw_image->height / 8) - 1) {
 		errx(1, "Trim (%i) for input raw_image file '%s' too large (max: %i)",
-			opts.trim, opts.infile,
+		     opts.trim, opts.infile,
-			(raw_image->width / 8) * (raw_image->height / 8) - 1);
+		     (raw_image->width / 8) * (raw_image->height / 8) - 1);
 	}
 
 	if (strcmp(png_options.mapfile, opts.mapfile) != 0) {
@@ -236,9 +236,8 @@ int main(int argc, char *argv[])
 	if (*opts.palfile)
 		output_palette_file(&opts, raw_image);
 
-	if (opts.fix || opts.debug) {
+	if (opts.fix || opts.debug)
 		output_png_file(&opts, &png_options, raw_image);
-	}
 
 	destroy_raw_image(&raw_image);
 	free(gb.data);

src/gfx/makepng.c

@@ -18,42 +18,43 @@ static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img);
 static struct RawIndexedImage *grayscale_png_to_raw(struct PNGImage *img);
 static struct RawIndexedImage *truecolor_png_to_raw(struct PNGImage *img);
 static void get_text(const struct PNGImage *img,
-                     struct ImageOptions *png_options);
+		     struct ImageOptions *png_options);
 static void set_text(const struct PNGImage *img,
-                     const struct ImageOptions *png_options);
+		     const struct ImageOptions *png_options);
 static void free_png_data(const struct PNGImage *png);
 
 struct RawIndexedImage *input_png_file(const struct Options *opts,
-                                       struct ImageOptions *png_options)
+				       struct ImageOptions *png_options)
 {
 	struct PNGImage img;
 	struct RawIndexedImage *raw_image;
 	FILE *f;
- 
+
 	f = fopen(opts->infile, "rb");
 	if (!f)
 		err(1, "Opening input png file '%s' failed", opts->infile);
-	
+
 	initialize_png(&img, f);
 
 	if (img.depth != depth) {
 		if (opts->verbose) {
-			warnx("Image bit depth is not %i (is %i).", depth, img.depth);
+			warnx("Image bit depth is not %i (is %i).",
+			      depth, img.depth);
 		}
 	}
 
 	switch (img.type) {
-		case PNG_COLOR_TYPE_PALETTE:
+	case PNG_COLOR_TYPE_PALETTE:
-			raw_image = indexed_png_to_raw(&img); break;
+		raw_image = indexed_png_to_raw(&img); break;
-		case PNG_COLOR_TYPE_GRAY:
+	case PNG_COLOR_TYPE_GRAY:
-		case PNG_COLOR_TYPE_GRAY_ALPHA:
+	case PNG_COLOR_TYPE_GRAY_ALPHA:
-			raw_image = grayscale_png_to_raw(&img); break;
+		raw_image = grayscale_png_to_raw(&img); break;
-		case PNG_COLOR_TYPE_RGB:
+	case PNG_COLOR_TYPE_RGB:
-		case PNG_COLOR_TYPE_RGB_ALPHA:
+	case PNG_COLOR_TYPE_RGB_ALPHA:
-			raw_image = truecolor_png_to_raw(&img); break;
+		raw_image = truecolor_png_to_raw(&img); break;
-		default:
+	default:
-			/* Shouldn't happen, but might as well handle it just in case. */
+		/* Shouldn't happen, but might as well handle just in case. */
-			errx(1, "Input PNG file is of invalid color type.");
+		errx(1, "Input PNG file is of invalid color type.");
 	}
 
 	get_text(&img, png_options);
@@ -66,8 +67,8 @@ struct RawIndexedImage *input_png_file(const struct Options *opts,
 }
 
 void output_png_file(const struct Options *opts,
-                     const struct ImageOptions *png_options,
+		     const struct ImageOptions *png_options,
-                     const struct RawIndexedImage *raw_image)
+		     const struct RawIndexedImage *raw_image)
 {
 	FILE *f;
 	char *outfile;
@@ -91,7 +92,8 @@ void output_png_file(const struct Options *opts,
 	if (!f)
 		err(1, "Opening output png file '%s' failed", outfile);
 
-	img.png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	img.png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+					  NULL, NULL, NULL);
 	if (!img.png)
 		errx(1, "Creating png structure failed");
 
@@ -99,28 +101,26 @@ void output_png_file(const struct Options *opts,
 	if (!img.info)
 		errx(1, "Creating png info structure failed");
 
-	/* TODO: Better error handling here? */
 	if (setjmp(png_jmpbuf(img.png)))
 		exit(1);
 
 	png_init_io(img.png, f);
 
 	png_set_IHDR(img.png, img.info, raw_image->width, raw_image->height,
-				 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
+		     8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
-				 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+		     PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-	
+
 	png_palette = malloc(sizeof(png_color *) * raw_image->num_colors);
 	for (i = 0; i < raw_image->num_colors; i++) {
 		png_palette[i].red   = raw_image->palette[i].red;
 		png_palette[i].green = raw_image->palette[i].green;
 		png_palette[i].blue  = raw_image->palette[i].blue;
 	}
-    png_set_PLTE(img.png, img.info, png_palette, raw_image->num_colors);
+	png_set_PLTE(img.png, img.info, png_palette, raw_image->num_colors);
 	free(png_palette);
 
-	if (opts->fix) {
+	if (opts->fix)
 		set_text(&img, png_options);
-	}
 
 	png_write_info(img.png, img.info);
 
@@ -139,9 +139,9 @@ void destroy_raw_image(struct RawIndexedImage **raw_image_ptr_ptr)
 	int y;
 	struct RawIndexedImage *raw_image = *raw_image_ptr_ptr;
 
-	for (y = 0; y < raw_image->height; y++) {
+	for (y = 0; y < raw_image->height; y++)
 		free(raw_image->data[y]);
-	}
+
 	free(raw_image->data);
 	free(raw_image->palette);
 	free(raw_image);
@@ -150,7 +150,8 @@ void destroy_raw_image(struct RawIndexedImage **raw_image_ptr_ptr)
 
 static void initialize_png(struct PNGImage *img, FILE *f)
 {
-	img->png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	img->png = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+					  NULL, NULL, NULL);
 	if (!img->png)
 		errx(1, "Creating png structure failed");
 
@@ -158,10 +159,8 @@ static void initialize_png(struct PNGImage *img, FILE *f)
 	if (!img->info)
 		errx(1, "Creating png info structure failed");
 
-	/* TODO: Better error handling here? */
+	if (setjmp(png_jmpbuf(img->png)))
-	if (setjmp(png_jmpbuf(img->png))) {
 		exit(1);
-	}
 
 	png_init_io(img->png, f);
 
@@ -173,12 +172,11 @@ static void initialize_png(struct PNGImage *img, FILE *f)
 	img->type   = png_get_color_type(img->png, img->info);
 }
 
-
 static void read_png(struct PNGImage *img);
-static struct RawIndexedImage *create_raw_image(int width, int height, 
+static struct RawIndexedImage *create_raw_image(int width, int height,
-                                                int num_colors);
+						int num_colors);
 static void set_raw_image_palette(struct RawIndexedImage *raw_image,
-                                  const png_color *palette, int num_colors);
+				  const png_color *palette, int num_colors);
 
 static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img)
 {
@@ -193,9 +191,8 @@ static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img)
 	uint8_t *old_to_new_palette;
 	int i, x, y;
 
-	if (img->depth < 8) {
+	if (img->depth < 8)
 		png_set_packing(img->png);
-	}
 
 	png_get_PLTE(img->png, img->info, &palette, &colors_in_PLTE);
 
@@ -208,7 +205,7 @@ static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img)
 	 * to 4 normal colors.
 	 */
 	if (png_get_tRNS(img->png, img->info, &trans_alpha, &num_trans,
-		&trans_color)) {
+			 &trans_color)) {
 		original_palette = palette;
 		palette = malloc(sizeof(png_color) * colors_in_PLTE);
 		colors_in_new_palette = 0;
@@ -219,7 +216,8 @@ static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img)
 				old_to_new_palette[i] = 0;
 			} else {
 				old_to_new_palette[i] = colors_in_new_palette;
-				palette[colors_in_new_palette++] = original_palette[i];
+				palette[colors_in_new_palette++] =
+					original_palette[i];
 			}
 		}
 		for (i = num_trans; i < colors_in_PLTE; i++) {
@@ -229,19 +227,23 @@ static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img)
 
 		if (colors_in_new_palette != colors_in_PLTE) {
 			palette = realloc(palette,
-			                  sizeof(png_color) * colors_in_new_palette);
+					  sizeof(png_color) *
+					  colors_in_new_palette);
 		}
 
 		/*
-		 * Setting and validating palette before reading allows us to error out
+		 * Setting and validating palette before reading
-		 * *before* doing the data transformation if the palette is too long.
+		 * allows us to error out *before* doing the data
+		 * transformation if the palette is too long.
 		 */
-		set_raw_image_palette(raw_image, palette, colors_in_new_palette);
+		set_raw_image_palette(raw_image, palette,
+				      colors_in_new_palette);
 		read_png(img);
 
 		for (y = 0; y < img->height; y++) {
 			for (x = 0; x < img->width; x++) {
-				raw_image->data[y][x] = old_to_new_palette[img->data[y][x]];
+				raw_image->data[y][x] =
+					old_to_new_palette[img->data[y][x]];
 			}
 		}
 
@@ -251,9 +253,8 @@ static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img)
 		read_png(img);
 
 		for (y = 0; y < img->height; y++) {
-			for (x = 0; x < img->width; x++) {
+			for (x = 0; x < img->width; x++)
 				raw_image->data[y][x] = img->data[y][x];
-			}
 		}
 	}
 
@@ -262,17 +263,19 @@ static struct RawIndexedImage *indexed_png_to_raw(struct PNGImage *img)
 
 static struct RawIndexedImage *grayscale_png_to_raw(struct PNGImage *img)
 {
-	if (img->depth < 8) {
+	if (img->depth < 8)
 		png_set_expand_gray_1_2_4_to_8(img->png);
-	}
+
 	png_set_gray_to_rgb(img->png);
 	return truecolor_png_to_raw(img);
 }
 
 static void rgba_png_palette(struct PNGImage *img,
-                             png_color **palette_ptr_ptr, int *num_colors);
+			     png_color **palette_ptr_ptr, int *num_colors);
-static struct RawIndexedImage *processed_rgba_png_to_raw(
+static struct RawIndexedImage
-	struct PNGImage *img, const png_color *palette, int colors_in_palette);
+	*processed_rgba_png_to_raw(const struct PNGImage *img,
+				   const png_color *palette,
+				   int colors_in_palette);
 
 static struct RawIndexedImage *truecolor_png_to_raw(struct PNGImage *img)
 {
@@ -280,20 +283,19 @@ static struct RawIndexedImage *truecolor_png_to_raw(struct PNGImage *img)
 	png_color *palette;
 	int colors_in_palette;
 
-    if (img->depth == 16) {
+	if (img->depth == 16) {
 #if PNG_LIBPNG_VER >= 10504
-       png_set_scale_16(img->png);
+		png_set_scale_16(img->png);
 #else
-       png_set_strip_16(img->png);
+		png_set_strip_16(img->png);
 #endif
 	}
 
 	if (!(img->type & PNG_COLOR_MASK_ALPHA)) {
-		if (png_get_valid(img->png, img->info, PNG_INFO_tRNS)) {
+		if (png_get_valid(img->png, img->info, PNG_INFO_tRNS))
 			png_set_tRNS_to_alpha(img->png);
-		} else {
+		else
 			png_set_add_alpha(img->png, 0xFF, PNG_FILLER_AFTER);
-		}
 	}
 
 	read_png(img);
@@ -307,45 +309,45 @@ static struct RawIndexedImage *truecolor_png_to_raw(struct PNGImage *img)
 }
 
 static void rgba_PLTE_palette(struct PNGImage *img,
-                              png_color **palette_ptr_ptr, int *num_colors);
+			      png_color **palette_ptr_ptr, int *num_colors);
 static void rgba_build_palette(struct PNGImage *img,
-							   png_color **palette_ptr_ptr, int *num_colors);
+			       png_color **palette_ptr_ptr, int *num_colors);
 
 static void rgba_png_palette(struct PNGImage *img,
-                             png_color **palette_ptr_ptr, int *num_colors)
+			     png_color **palette_ptr_ptr, int *num_colors)
 {
-	if (png_get_valid(img->png, img->info, PNG_INFO_PLTE)) {
+	if (png_get_valid(img->png, img->info, PNG_INFO_PLTE))
 		return rgba_PLTE_palette(img, palette_ptr_ptr, num_colors);
-	} else {
+	else
 		return rgba_build_palette(img, palette_ptr_ptr, num_colors);
-	}
 }
 
 static void rgba_PLTE_palette(struct PNGImage *img,
-                              png_color **palette_ptr_ptr, int *num_colors)
+			      png_color **palette_ptr_ptr, int *num_colors)
 {
 	png_get_PLTE(img->png, img->info, palette_ptr_ptr, num_colors);
 	/*
 	 * Lets us free the palette manually instead of leaving it to libpng,
-	 * which lets us handle a PLTE palette and a built palette the same way.
+	 * which lets us handle a PLTE and a built palette the same way.
 	 */
 	png_data_freer(img->png, img->info,
-	               PNG_USER_WILL_FREE_DATA, PNG_FREE_PLTE);
+		       PNG_USER_WILL_FREE_DATA, PNG_FREE_PLTE);
 }
 
+static void update_built_palette(png_color *palette,
+				 const png_color *pixel_color, png_byte alpha,
+				 int *num_colors, bool *only_grayscale);
 static int fit_grayscale_palette(png_color *palette, int *num_colors);
 static void order_color_palette(png_color *palette, int num_colors);
 
 static void rgba_build_palette(struct PNGImage *img,
-							   png_color **palette_ptr_ptr, int *num_colors)
+			       png_color **palette_ptr_ptr, int *num_colors)
 {
 	png_color *palette;
-	int y, value_index, i;
+	int y, value_index;
 	png_color cur_pixel_color;
 	png_byte cur_alpha;
 	bool only_grayscale = true;
-	bool color_exists;
-	png_color cur_palette_color;
 
 	/*
 	 * By filling the palette up with black by default, if the image
@@ -363,55 +365,65 @@ static void rgba_build_palette(struct PNGImage *img,
 			cur_pixel_color.blue  = img->data[y][value_index++];
 			cur_alpha = img->data[y][value_index++];
 
-			/*
+			update_built_palette(palette, &cur_pixel_color,
-			 * Transparent pixels don't count toward the palette,
+					     cur_alpha,
-			 * as they'll be replaced with color #0 later.
+					     num_colors, &only_grayscale);
-			 */
-			if (cur_alpha == 0) {
-				continue;
-			}
-
-			if (only_grayscale &&
-			    !(cur_pixel_color.red == cur_pixel_color.green &&
-				  cur_pixel_color.red == cur_pixel_color.blue)) {
-				only_grayscale = false;
-			}
-
-			color_exists = false;
-			for (i = 0; i < *num_colors; i++) {
-				cur_palette_color = palette[i];
-				if (cur_pixel_color.red   == cur_palette_color.red   &&
-					cur_pixel_color.green == cur_palette_color.green &&
-					cur_pixel_color.blue  == cur_palette_color.blue) {
-					color_exists = true;
-					break;
-				}
-			}
-			if (!color_exists) {
-				if (*num_colors == colors) {
-					err(1, "Too many colors in input PNG file to fit into a "
-						"%d-bit palette (max %d).", depth, colors);
-				}
-				palette[*num_colors] = cur_pixel_color;
-				(*num_colors)++;
-			}
 		}
 	}
 
 	/* In order not to count 100% transparent images as grayscale. */
 	only_grayscale = *num_colors ? only_grayscale : false;
 
-	if (!only_grayscale || !fit_grayscale_palette(palette, num_colors)) {
+	if (!only_grayscale || !fit_grayscale_palette(palette, num_colors))
 		order_color_palette(palette, *num_colors);
+}
+
+static void update_built_palette(png_color *palette,
+				 const png_color *pixel_color, png_byte alpha,
+				 int *num_colors, bool *only_grayscale)
+{
+	bool color_exists;
+	png_color cur_palette_color;
+	int i;
+
+	/*
+	 * Transparent pixels don't count toward the palette,
+	 * as they'll be replaced with color #0 later.
+	 */
+	if (alpha == 0)
+		return;
+
+	if (*only_grayscale && !(pixel_color->red == pixel_color->green &&
+				 pixel_color->red == pixel_color->blue)) {
+		*only_grayscale = false;
+	}
+
+	color_exists = false;
+	for (i = 0; i < *num_colors; i++) {
+		cur_palette_color = palette[i];
+		if (pixel_color->red   == cur_palette_color.red   &&
+		    pixel_color->green == cur_palette_color.green &&
+		    pixel_color->blue  == cur_palette_color.blue) {
+			color_exists = true;
+			break;
+		}
+	}
+	if (!color_exists) {
+		if (*num_colors == colors) {
+			err(1, "Too many colors in input PNG file to fit into a %d-bit palette (max %d).",
+			    depth, colors);
+		}
+		palette[*num_colors] = *pixel_color;
+		(*num_colors)++;
 	}
 }
 
 static int fit_grayscale_palette(png_color *palette, int *num_colors)
 {
-	int i, shade_index;
 	int interval = 256 / colors;
 	png_color *fitted_palette = malloc(sizeof(png_color) * colors);
 	bool *set_indices = calloc(colors, sizeof(bool));
+	int i, shade_index;
 
 	fitted_palette[0].red   = 0xFF;
 	fitted_palette[0].green = 0xFF;
@@ -439,9 +451,8 @@ static int fit_grayscale_palette(png_color *palette, int *num_colors)
 		set_indices[shade_index] = true;
 	}
 
-	for (i = 0; i < colors; i++) {
+	for (i = 0; i < colors; i++)
 		palette[i] = fitted_palette[i];
-	}
 
 	*num_colors = colors;
 
@@ -458,18 +469,18 @@ struct ColorWithLuminance {
 
 static int compare_luminance(const void *a, const void *b)
 {
-	struct ColorWithLuminance *x = (struct ColorWithLuminance *) a;
+	struct ColorWithLuminance *x = (struct ColorWithLuminance *)a;
-	struct ColorWithLuminance *y = (struct ColorWithLuminance *) b;
+	struct ColorWithLuminance *y = (struct ColorWithLuminance *)b;
+
 	return y->luminance - x->luminance;
 }
 
 static void order_color_palette(png_color *palette, int num_colors)
 {
 	int i;
-	struct ColorWithLuminance *palette_with_luminance;
+	struct ColorWithLuminance *palette_with_luminance =
-
-	palette_with_luminance =
 		malloc(sizeof(struct ColorWithLuminance) * num_colors);
+
 	for (i = 0; i < num_colors; i++) {
 		/*
 		 * Normally this would be done with floats, but since it's only
@@ -477,49 +488,43 @@ static void order_color_palette(png_color *palette, int num_colors)
 		 */
 		palette_with_luminance[i].color = palette[i];
 		palette_with_luminance[i].luminance = 2126 * palette[i].red   +
-		                                      7152 * palette[i].green +
+						      7152 * palette[i].green +
-											   722 * palette[i].blue;
+						       722 * palette[i].blue;
 	}
 	qsort(palette_with_luminance, num_colors,
-			sizeof(struct ColorWithLuminance), compare_luminance);
+	      sizeof(struct ColorWithLuminance), compare_luminance);
-	for (i = 0; i < num_colors; i++) {
+	for (i = 0; i < num_colors; i++)
 		palette[i] = palette_with_luminance[i].color;
-	}
+
 	free(palette_with_luminance);
 }
 
-static uint8_t palette_index_of(const png_color *palette, int num_colors,
+static void put_raw_image_pixel(struct RawIndexedImage *raw_image,
-                                const png_color *color);
+				const struct PNGImage *img,
+				int *value_index, int x, int y,
+				const png_color *palette,
+				int colors_in_palette);
 
-static struct RawIndexedImage *processed_rgba_png_to_raw(
+static struct RawIndexedImage
-	struct PNGImage *img, const png_color *palette, int colors_in_palette)
+	*processed_rgba_png_to_raw(const struct PNGImage *img,
+				   const png_color *palette,
+				   int colors_in_palette)
 {
 	struct RawIndexedImage *raw_image;
 	int x, y, value_index;
-	png_color cur_color;
-	png_byte cur_alpha;
 
 	raw_image = create_raw_image(img->width, img->height, colors);
-	
+
 	set_raw_image_palette(raw_image, palette, colors_in_palette);
 
 	for (y = 0; y < img->height; y++) {
 		x = raw_image->width - 1;
 		value_index = img->width * 4 - 1;
-		
+
 		while (x >= 0) {
-			cur_alpha = img->data[y][value_index];
+			put_raw_image_pixel(raw_image, img,
-			if (cur_alpha == 0) {
+					    &value_index, x, y,
-				raw_image->data[y][x] = 0;
+					    palette, colors_in_palette);
-				value_index -= 4;
-			} else {
-				value_index--;
-				cur_color.blue  = img->data[y][value_index--];
-				cur_color.green = img->data[y][value_index--];
-				cur_color.red   = img->data[y][value_index--];
-				raw_image->data[y][x] =
-					palette_index_of(palette, colors_in_palette, &cur_color);
-			}
 			x--;
 		}
 	}
@@ -527,20 +532,46 @@ static struct RawIndexedImage *processed_rgba_png_to_raw(
 	return raw_image;
 }
 
-static uint8_t palette_index_of(const png_color *palette, int num_colors,
+static uint8_t palette_index_of(const png_color *palette,
-                                const png_color *color)
+				int num_colors, const png_color *color);
+
+static void put_raw_image_pixel(struct RawIndexedImage *raw_image,
+				const struct PNGImage *img,
+				int *value_index, int x, int y,
+				const png_color *palette,
+				int colors_in_palette)
+{
+	png_color pixel_color;
+	png_byte alpha;
+
+	alpha = img->data[y][*value_index];
+	if (alpha == 0) {
+		raw_image->data[y][x] = 0;
+		*value_index -= 4;
+	} else {
+		(*value_index)--;
+		pixel_color.blue  = img->data[y][(*value_index)--];
+		pixel_color.green = img->data[y][(*value_index)--];
+		pixel_color.red   = img->data[y][(*value_index)--];
+		raw_image->data[y][x] = palette_index_of(palette,
+							 colors_in_palette,
+							 &pixel_color);
+	}
+}
+
+static uint8_t palette_index_of(const png_color *palette,
+				int num_colors, const png_color *color)
 {
 	uint8_t i;
 
 	for (i = 0; i < num_colors; i++) {
 		if (palette[i].red   == color->red   &&
 		    palette[i].green == color->green &&
-			palette[i].blue  == color->blue) {
+		    palette[i].blue  == color->blue) {
 			return i;
 		}
 	}
-	errx(1, "The input PNG file contains colors that don't appear "
+	errx(1, "The input PNG file contains colors that don't appear in its embedded palette.");
-	        "in its embedded palette.");
 }
 
 static void read_png(struct PNGImage *img)
@@ -550,16 +581,15 @@ static void read_png(struct PNGImage *img)
 	png_read_update_info(img->png, img->info);
 
 	img->data = malloc(sizeof(png_byte *) * img->height);
-	for (y = 0; y < img->height; y++) {
+	for (y = 0; y < img->height; y++)
 		img->data[y] = malloc(png_get_rowbytes(img->png, img->info));
-	}
 
 	png_read_image(img->png, img->data);
 	png_read_end(img->png, img->info);
 }
 
-static struct RawIndexedImage *create_raw_image(int width, int height, 
+static struct RawIndexedImage *create_raw_image(int width, int height,
-                                                int num_colors)
+						int num_colors)
 {
 	struct RawIndexedImage *raw_image;
 	int y;
@@ -573,22 +603,21 @@ static struct RawIndexedImage *create_raw_image(int width, int height,
 	raw_image->palette = malloc(sizeof(struct RGBColor) * num_colors);
 
 	raw_image->data = malloc(sizeof(uint8_t *) * height);
-	for (y = 0; y < height; y++) {
+	for (y = 0; y < height; y++)
 		raw_image->data[y] = malloc(sizeof(uint8_t) * width);
-	}
 
 	return raw_image;
 }
 
 static void set_raw_image_palette(struct RawIndexedImage *raw_image,
-                                  const png_color *palette, int num_colors)
+				  const png_color *palette, int num_colors)
 {
 	int i;
 
 	if (num_colors > raw_image->num_colors) {
-		errx(1, "Too many colors in input PNG file's palette to fit into "
+		errx(1, "Too many colors in input PNG file's palette to fit into a %d-bit palette (%d in input palette, max %d).",
-		     "a %d-bit palette (%d in input palette, max %d).",
+		     raw_image->num_colors >> 1,
-			 raw_image->num_colors >> 1, num_colors, raw_image->num_colors);
+		     num_colors, raw_image->num_colors);
 	}
 
 	for (i = 0; i < num_colors; i++) {
@@ -604,7 +633,7 @@ static void set_raw_image_palette(struct RawIndexedImage *raw_image,
 }
 
 static void get_text(const struct PNGImage *img,
-                     struct ImageOptions *png_options)
+		     struct ImageOptions *png_options)
 {
 	png_text *text;
 	int i, numtxts, numremoved;
@@ -648,7 +677,7 @@ static void get_text(const struct PNGImage *img,
 }
 
 static void set_text(const struct PNGImage *img,
-                     const struct ImageOptions *png_options)
+		     const struct ImageOptions *png_options)
 {
 	png_text *text;
 	char buffer[3];