gbdev/rgbds
1
0
Fork 0
mirror of https://github.com/gbdev/rgbds.git synced 2025-11-20 18:22:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix rgbgfx's code style

Browse Source 
Signed-off-by: obskyr <powpowd@gmail.com>
This commit is contained in:
obskyr
2018-02-20 09:37:07 +01:00
parent 885e8ea24a
commit 825fa915ee
5 changed files with 209 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
include/gfx/gb.h
View File

@@ -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

6
include/gfx/makepng.h
View File

@@ -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 */

27
src/gfx/gb.c
View File

@@ -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
+ 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 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) {
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);

13
src/gfx/main.c
View File

@@ -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. "
"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 @@ 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);

339
src/gfx/makepng.c
View File

@@ -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:
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 @@ struct RawIndexedImage *input_png_file(const struct Options *opts,
}
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 @@ 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,
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;
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,
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 @@ 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
* *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 @@ 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);
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 @@ 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++];
/*
* 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);
}
}
/* 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 *y = (struct ColorWithLuminance *) b;
struct ColorWithLuminance *x = (struct ColorWithLuminance *)a;
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;
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 @@ 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 +
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 @@ static struct RawIndexedImage *processed_rgba_png_to_raw(
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 @@ 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,
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 @@ 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 "
"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 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];