ref: 825fa915eec17a74eb74d7f2130547de838c859a
parent: 885e8ea24aa8a5444da0ff268b792f260ab83cff
author: obskyr <[email protected]>
date: Tue Feb 20 04:37:07 EST 2018
Fix rgbgfx's code style Signed-off-by: obskyr <[email protected]>
--- a/include/gfx/gb.h
+++ b/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
--- a/include/gfx/makepng.h
+++ b/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 RawIndexedImage *raw_image);
+ const struct ImageOptions *png_options,
+ const struct RawIndexedImage *raw_image);
void destroy_raw_image(struct RawIndexedImage **raw_image_ptr_ptr);
#endif /* RGBDS_GFX_PNG_H */
--- a/src/gfx/gb.c
+++ b/src/gfx/gb.c
@@ -42,13 +42,8 @@
index = raw_image->data[y][x];
index &= (1 << depth) - 1;
- if (!gb->horizontal) {- byte = y * depth
- + x / 8 * raw_image->height / 8 * 8 * depth;
- } else {- byte = y * depth
- + x / 8 * raw_image->height / 8 * 8 * depth;
- }
+ 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 output_tilemap_file(const struct Options *opts,
- const struct Tilemap *tilemap)
+ const struct Tilemap *tilemap)
{FILE *f;
@@ -170,7 +165,7 @@
}
void output_palette_file(const struct Options *opts,
- const struct RawIndexedImage *raw_image)
+ const struct RawIndexedImage *raw_image)
{FILE *f;
int i, color;
@@ -177,14 +172,14 @@
uint8_t cur_bytes[2];
f = fopen(opts->palfile, "wb");
- if (!f) {- err(1, "Opening palette file '%s' failed",
- opts->palfile);
- }
+ if (!f)
+ err(1, "Opening palette file '%s' failed", opts->palfile);
+
for (i = 0; i < raw_image->num_colors; i++) {- color = raw_image->palette[i].blue >> 3 << 10 |
- raw_image->palette[i].green >> 3 << 5 |
- raw_image->palette[i].red >> 3;
+ color =
+ raw_image->palette[i].blue >> 3 << 10 |
+ 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);
--- a/src/gfx/main.c
+++ b/src/gfx/main.c
@@ -131,17 +131,17 @@
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. "
- "The image's width and height must be multiples of 8.",
- opts.infile);
+ errx(1, "Input PNG file %s not sized correctly. The image's width and height must be multiples of 8.",
+ 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,
- (raw_image->width / 8) * (raw_image->height / 8) - 1);
+ opts.trim, opts.infile,
+ (raw_image->width / 8) * (raw_image->height / 8) - 1);
}
if (strcmp(png_options.mapfile, opts.mapfile) != 0) {@@ -236,9 +236,8 @@
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);
--- a/src/gfx/makepng.c
+++ b/src/gfx/makepng.c
@@ -18,42 +18,43 @@
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:
- raw_image = indexed_png_to_raw(&img); break;
- case PNG_COLOR_TYPE_GRAY:
- case PNG_COLOR_TYPE_GRAY_ALPHA:
- raw_image = grayscale_png_to_raw(&img); break;
- case PNG_COLOR_TYPE_RGB:
- case PNG_COLOR_TYPE_RGB_ALPHA:
- raw_image = truecolor_png_to_raw(&img); break;
- default:
- /* Shouldn't happen, but might as well handle it just in case. */
- errx(1, "Input PNG file is of invalid color type.");
+ case PNG_COLOR_TYPE_PALETTE:
+ raw_image = indexed_png_to_raw(&img); break;
+ case PNG_COLOR_TYPE_GRAY:
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ raw_image = grayscale_png_to_raw(&img); break;
+ case PNG_COLOR_TYPE_RGB:
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ raw_image = truecolor_png_to_raw(&img); break;
+ default:
+ /* Shouldn't happen, but might as well handle just in case. */
+ errx(1, "Input PNG file is of invalid color type.");
}
get_text(&img, png_options);
@@ -66,8 +67,8 @@
}
void output_png_file(const struct Options *opts,
- const struct ImageOptions *png_options,
- const struct RawIndexedImage *raw_image)
+ const struct ImageOptions *png_options,
+ const struct RawIndexedImage *raw_image)
{FILE *f;
char *outfile;
@@ -91,7 +92,8 @@
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,7 +101,6 @@
if (!img.info)
errx(1, "Creating png info structure failed");
- /* TODO: Better error handling here? */
if (setjmp(png_jmpbuf(img.png)))
exit(1);
@@ -106,9 +107,9 @@
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,
- PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-
+ 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
+ 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;
@@ -115,12 +116,11 @@
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 @@
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 @@
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 @@
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 @@
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,
- int num_colors);
+static struct RawIndexedImage *create_raw_image(int width, int height,
+ 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 @@
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 @@
* 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 @@
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 @@
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
- * *before* doing the data transformation if the palette is too long.
+ * Setting and validating palette before reading
+ * 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 @@
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 *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);
-static struct RawIndexedImage *processed_rgba_png_to_raw(
- struct PNGImage *img, const png_color *palette, int colors_in_palette);
+ png_color **palette_ptr_ptr, int *num_colors);
+static struct RawIndexedImage
+ *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 @@
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 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,38 +365,9 @@
cur_pixel_color.blue = img->data[y][value_index++];
cur_alpha = img->data[y][value_index++];
- /*
- * Transparent pixels don't count toward the palette,
- * as they'll be replaced with color #0 later.
- */
- 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)++;
- }
+ update_built_palette(palette, &cur_pixel_color,
+ cur_alpha,
+ num_colors, &only_grayscale);
}
}
@@ -401,17 +374,56 @@
/* 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 @@
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,8 +469,9 @@
static int compare_luminance(const void *a, const void *b)
{- struct ColorWithLuminance *x = (struct ColorWithLuminance *) a;
- struct ColorWithLuminance *y = (struct ColorWithLuminance *) b;
+ struct ColorWithLuminance *x = (struct ColorWithLuminance *)a;
+ struct ColorWithLuminance *y = (struct ColorWithLuminance *)b;
+
return y->luminance - x->luminance;
}
@@ -466,10 +478,9 @@
static void order_color_palette(png_color *palette, int num_colors)
{int i;
- struct ColorWithLuminance *palette_with_luminance;
-
- palette_with_luminance =
+ struct ColorWithLuminance *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 @@
*/
palette_with_luminance[i].color = palette[i];
palette_with_luminance[i].luminance = 2126 * palette[i].red +
- 7152 * palette[i].green +
- 722 * palette[i].blue;
+ 7152 * palette[i].green +
+ 722 * palette[i].blue;
}
qsort(palette_with_luminance, num_colors,
- sizeof(struct ColorWithLuminance), compare_luminance);
- for (i = 0; i < num_colors; i++) {+ sizeof(struct ColorWithLuminance), compare_luminance);
+ 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,
- 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);
-static struct RawIndexedImage *processed_rgba_png_to_raw(
- struct PNGImage *img, const png_color *palette, int colors_in_palette)
+static struct RawIndexedImage
+ *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];
- if (cur_alpha == 0) {- raw_image->data[y][x] = 0;
- 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);
- }
+ put_raw_image_pixel(raw_image, img,
+ &value_index, x, y,
+ palette, colors_in_palette);
x--;
}
}
@@ -527,20 +532,46 @@
return raw_image;
}
-static uint8_t palette_index_of(const png_color *palette, int num_colors,
- const png_color *color)
+static uint8_t palette_index_of(const png_color *palette,
+ 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 "
- "in its embedded palette.");
+ errx(1, "The input PNG file contains colors that don't appear in its embedded palette.");
}
static void read_png(struct PNGImage *img)
@@ -550,16 +581,15 @@
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,
- int num_colors)
+static struct RawIndexedImage *create_raw_image(int width, int height,
+ int num_colors)
{struct RawIndexedImage *raw_image;
int y;
@@ -573,22 +603,21 @@
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 "
- "a %d-bit palette (%d in input palette, max %d).",
- raw_image->num_colors >> 1, num_colors, raw_image->num_colors);
+ errx(1, "Too many colors in input PNG file's palette to fit into a %d-bit palette (%d in input palette, max %d).",
+ raw_image->num_colors >> 1,
+ num_colors, raw_image->num_colors);
}
for (i = 0; i < num_colors; i++) {@@ -604,7 +633,7 @@
}
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 set_text(const struct PNGImage *img,
- const struct ImageOptions *png_options)
+ const struct ImageOptions *png_options)
{png_text *text;
char buffer[3];