git.mutantstargoat.com Git - gbajam22/blob - tools/pngdump/main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <math.h>
   5 #include <errno.h>
   6 #include <assert.h>
   7 #include "image.h"
   8
   9 enum {
  10         MODE_PIXELS,
  11         MODE_CMAP,
  12         MODE_PNG,
  13         MODE_INFO
  14 };
  15
  16 void conv_gba_image(struct image *img);
  17 void dump_colormap(struct image *img, int text, FILE *fp);
  18 void print_usage(const char *argv0);
  19
  20 int main(int argc, char **argv)
  21 {
  22         int i, j, mode = 0;
  23         int text = 0;
  24         int renibble = 0;
  25         char *outfname = 0;
  26         char *slut_fname = 0, *cmap_fname = 0;
  27         char *infiles[256];
  28         int num_infiles = 0;
  29         struct image img, tmpimg;
  30         FILE *out = stdout;
  31         FILE *aux_out;
  32         int *shade_lut = 0;
  33         int *lutptr;
  34         int shade_levels = 8;
  35         int maxcol = 0;
  36         int lvl;
  37         int conv_555 = 0;
  38         int gbacolors = 0;
  39
  40         for(i=1; i<argc; i++) {
  41                 if(argv[i][0] == '-') {
  42                         if(argv[i][2] == 0) {
  43                                 switch(argv[i][1]) {
  44                                 case 'P':
  45                                         mode = MODE_PNG;
  46                                         break;
  47
  48                                 case 'p':
  49                                         mode = MODE_PIXELS;
  50                                         break;
  51
  52                                 case 'c':
  53                                         mode = MODE_CMAP;
  54                                         break;
  55
  56                                 case 'i':
  57                                         mode = MODE_INFO;
  58                                         break;
  59
  60                                 case 'C':
  61                                         if(!argv[++i] || (maxcol = atoi(argv[i])) < 2 || maxcol > 256) {
  62                                                 fprintf(stderr, "-C must be followed by the number of colors to reduce down to\n");
  63                                                 return 1;
  64                                         }
  65                                         break;
  66
  67                                 case 's':
  68                                         if(!argv[++i] || (shade_levels = atoi(argv[i])) == 0) {
  69                                                 fprintf(stderr, "-s must be followed by the number of shade levels\n");
  70                                                 return 1;
  71                                         }
  72                                         break;
  73
  74                                 case 't':
  75                                         text = 1;
  76                                         break;
  77
  78                                 case 'n':
  79                                         renibble = 1;
  80                                         break;
  81
  82                                 case 'g':
  83                                         gbacolors = 1;
  84                                         break;
  85
  86                                 case 'o':
  87                                         if(!argv[++i]) {
  88                                                 fprintf(stderr, "%s must be followed by a filename\n", argv[i - 1]);
  89                                                 return 1;
  90                                         }
  91                                         outfname = argv[i];
  92                                         break;
  93
  94                                 case 'h':
  95                                         print_usage(argv[0]);
  96                                         return 0;
  97
  98                                 default:
  99                                         fprintf(stderr, "invalid option: %s\n", argv[i]);
 100                                         print_usage(argv[0]);
 101                                         return 1;
 102                                 }
 103                         } else {
 104                                 if(strcmp(argv[i], "-oc") == 0) {
 105                                         if(!argv[++i]) {
 106                                                 fprintf(stderr, "-oc must be followed by a filename\n");
 107                                                 return 1;
 108                                         }
 109                                         cmap_fname = argv[i];
 110
 111                                 } else if(strcmp(argv[i], "-os") == 0) {
 112                                         if(!argv[++i]) {
 113                                                 fprintf(stderr, "-os must be followed by a filename\n");
 114                                                 return 1;
 115                                         }
 116                                         slut_fname = argv[i];
 117
 118                                 } else if(strcmp(argv[i], "-555") == 0) {
 119                                         conv_555 = 1;
 120
 121                                 } else {
 122                                         fprintf(stderr, "invalid option: %s\n", argv[i]);
 123                                         print_usage(argv[0]);
 124                                         return 1;
 125                                 }
 126                         }
 127                 } else {
 128                         infiles[num_infiles++] = argv[i];
 129                 }
 130         }
 131
 132         if(!num_infiles) {
 133                 fprintf(stderr, "pass the filename of a PNG file\n");
 134                 return 1;
 135         }
 136         if(load_image(&img, infiles[0]) == -1) {
 137                 fprintf(stderr, "failed to load PNG file: %s\n", infiles[0]);
 138                 return 1;
 139         }
 140
 141         if(gbacolors) {
 142                 conv_gba_image(&img);
 143         }
 144
 145         for(i=1; i<num_infiles; i++) {
 146                 if(load_image(&tmpimg, infiles[i]) == -1) {
 147                         fprintf(stderr, "failed to load PNG file: %s\n", infiles[i]);
 148                         return 1;
 149                 }
 150                 if(tmpimg.width != img.width || tmpimg.height != img.height) {
 151                         fprintf(stderr, "size mismatch: first image (%s) is %dx%d, %s is %dx%d\n",
 152                                         infiles[0], img.width, img.height, infiles[i], tmpimg.width, tmpimg.height);
 153                         return 1;
 154                 }
 155                 if(tmpimg.bpp != img.bpp) {
 156                         fprintf(stderr, "bpp mismatch: first image (%s) is %d bpp, %s is %d bpp\n",
 157                                         infiles[0], img.bpp, infiles[i], img.bpp);
 158                         return 1;
 159                 }
 160
 161                 overlay_key(&tmpimg, 0, &img);
 162         }
 163
 164         /* generate shading LUT and quantize image as necessary */
 165         if(slut_fname) {
 166                 if(img.bpp > 8) {
 167                         fprintf(stderr, "shading LUT generation is only supported for indexed color images\n");
 168                         return 1;
 169                 }
 170                 if(!(aux_out = fopen(slut_fname, "wb"))) {
 171                         fprintf(stderr, "failed to open shading LUT output file: %s: %s\n", slut_fname, strerror(errno));
 172                         return 1;
 173                 }
 174
 175                 if(!maxcol) maxcol = 256;
 176
 177                 if(!(shade_lut = malloc(maxcol * shade_levels * sizeof *shade_lut))) {
 178                         fprintf(stderr, "failed to allocate shading look-up table\n");
 179                         return 1;
 180                 }
 181
 182                 gen_shades(&img, shade_levels, maxcol, shade_lut);
 183
 184                 lutptr = shade_lut;
 185                 for(i=0; i<maxcol; i++) {
 186                         for(j=0; j<shade_levels; j++) {
 187                                 lvl = lutptr[shade_levels - j - 1];
 188                                 if(text) {
 189                                         fprintf(aux_out, "%d%c", lvl, j < shade_levels - 1 ? ' ' : '\n');
 190                                 } else {
 191                                         fputc(lvl, aux_out);
 192                                 }
 193                         }
 194                         lutptr += shade_levels;
 195                 }
 196                 fclose(aux_out);
 197
 198         } else if(maxcol) {
 199                 /* perform any color reductions if requested */
 200                 if(img.bpp <= 8 && img.cmap_ncolors <= maxcol) {
 201                         fprintf(stderr, "requested reduction to %d colors, but image has %d colors\n", maxcol, img.cmap_ncolors);
 202                         return 1;
 203                 }
 204                 quantize_image(&img, maxcol);
 205         }
 206
 207         if(cmap_fname) {
 208                 if(img.bpp > 8) {
 209                         fprintf(stderr, "colormap output works only for indexed color images\n");
 210                         return 1;
 211                 }
 212                 if(!(aux_out = fopen(cmap_fname, "wb"))) {
 213                         fprintf(stderr, "failed to open colormap output file: %s: %s\n", cmap_fname, strerror(errno));
 214                         return 1;
 215                 }
 216                 dump_colormap(&img, text, aux_out);
 217                 fclose(aux_out);
 218         }
 219
 220         if(img.bpp == 4 && renibble) {
 221                 unsigned char *ptr = img.pixels;
 222                 for(i=0; i<img.width * img.height; i++) {
 223                         unsigned char p = *ptr;
 224                         *ptr++ = (p << 4) | (p >> 4);
 225                 }
 226         }
 227
 228         if(conv_555) {
 229                 struct image img555;
 230                 unsigned int rgb24[3], rgb15;
 231
 232                 if(alloc_image(&img555, img.width, img.height, 15) == -1) {
 233                         fprintf(stderr, "failed to allocate temporary %dx%d image for 555 conversion\n",
 234                                         img.width, img.height);
 235                         return 1;
 236                 }
 237
 238                 for(i=0; i<img.height; i++) {
 239                         for(j=0; j<img.width; j++) {
 240                                 get_pixel_rgb(&img, j, i, rgb24);
 241                                 rgb15 = ((rgb24[0] >> 3) & 0x1f) | ((rgb24[1] << 2) & 0x3e0) |
 242                                         ((rgb24[2] << 7) & 0x7c00);
 243                                 put_pixel(&img555, j, i, rgb15);
 244                         }
 245                 }
 246                 free(img.pixels);
 247                 img = img555;
 248         }
 249
 250         if(outfname) {
 251                 if(!(out = fopen(outfname, "wb"))) {
 252                         fprintf(stderr, "failed to open output file: %s: %s\n", outfname, strerror(errno));
 253                         return 1;
 254                 }
 255         }
 256
 257         switch(mode) {
 258         case MODE_PNG:
 259                 save_image_file(&img, out);
 260                 break;
 261
 262         case MODE_PIXELS:
 263                 fwrite(img.pixels, 1, img.scansz * img.height, out);
 264                 break;
 265
 266         case MODE_CMAP:
 267                 dump_colormap(&img, text, out);
 268                 break;
 269
 270         case MODE_INFO:
 271                 printf("size: %dx%d\n", img.width, img.height);
 272                 printf("bit depth: %d\n", img.bpp);
 273                 printf("scanline size: %d bytes\n", img.scansz);
 274                 if(img.cmap_ncolors > 0) {
 275                         printf("colormap entries: %d\n", img.cmap_ncolors);
 276                 } else {
 277                         printf("color channels: %d\n", img.nchan);
 278                 }
 279                 break;
 280         }
 281
 282         fclose(out);
 283         return 0;
 284 }
 285
 286 #define MIN(a, b)                       ((a) < (b) ? (a) : (b))
 287 #define MIN3(a, b, c)           ((a) < (b) ? MIN(a, c) : MIN(b, c))
 288 #define MAX(a, b)                       ((a) > (b) ? (a) : (b))
 289 #define MAX3(a, b, c)           ((a) > (b) ? MAX(a, c) : MAX(b, c))
 290
 291 void rgb_to_hsv(float *rgb, float *hsv)
 292 {
 293         float min, max, delta;
 294
 295         min = MIN3(rgb[0], rgb[1], rgb[2]);
 296         max = MAX3(rgb[0], rgb[1], rgb[2]);
 297         delta = max - min;
 298
 299         if(max == 0) {
 300                 hsv[0] = hsv[1] = hsv[2] = 0;
 301                 return;
 302         }
 303
 304         hsv[2] = max;                   /* value */
 305         hsv[1] = delta / max;   /* saturation */
 306
 307         if(delta == 0.0f) {
 308                 hsv[0] = 0.0f;
 309         } else if(max == rgb[0]) {
 310                 hsv[0] = (rgb[1] - rgb[2]) / delta;
 311         } else if(max == rgb[1]) {
 312                 hsv[0] = 2.0f + (rgb[2] - rgb[0]) / delta;
 313         } else {
 314                 hsv[0] = 4.0f + (rgb[0] - rgb[1]) / delta;
 315         }
 316         /*
 317         hsv[0] /= 6.0f;
 318
 319         if(hsv[0] < 0.0f) hsv[0] += 1.0f;
 320         */
 321         hsv[0] *= 60.0f;
 322         if(hsv[0] < 0) hsv[0] += 360;
 323         hsv[0] /= 360.0f;
 324 }
 325
 326 #define RETRGB(r, g, b) \
 327         do { \
 328                 rgb[0] = r; \
 329                 rgb[1] = g; \
 330                 rgb[2] = b; \
 331                 return; \
 332         } while(0)
 333
 334 void hsv_to_rgb(float *hsv, float *rgb)
 335 {
 336         float sec, frac, o, p, q;
 337         int hidx;
 338
 339         if(hsv[1] == 0.0f) {
 340                 rgb[0] = rgb[1] = rgb[2] = hsv[2];      /* value */
 341         }
 342
 343         sec = floor(hsv[0] * (360.0f / 60.0f));
 344         frac = (hsv[0] * (360.0f / 60.0f)) - sec;
 345
 346         o = hsv[2] * (1.0f - hsv[1]);
 347         p = hsv[2] * (1.0f - hsv[1] * frac);
 348         q = hsv[2] * (1.0f - hsv[1] * (1.0f - frac));
 349
 350         hidx = (int)sec;
 351         switch(hidx) {
 352         default:
 353         case 0: RETRGB(hsv[2], q, o);
 354         case 1: RETRGB(p, hsv[2], o);
 355         case 2: RETRGB(o, hsv[2], q);
 356         case 3: RETRGB(o, p, hsv[2]);
 357         case 4: RETRGB(q, o, hsv[2]);
 358         case 5: RETRGB(hsv[2], o, p);
 359         }
 360 }
 361
 362 void gba_color(struct cmapent *color)
 363 {
 364         float rgb[3], hsv[3];
 365
 366         rgb[0] = pow((float)color->r / 255.0f, 2.2);
 367         rgb[1] = pow((float)color->g / 255.0f, 2.2);
 368         rgb[2] = pow((float)color->b / 255.0f, 2.2);
 369
 370         /* saturate colors */
 371         rgb_to_hsv(rgb, hsv);
 372         hsv[1] *= 1.2f;
 373         hsv[2] *= 2.0f;
 374         if(hsv[1] > 1.0f) hsv[1] = 1.0f;
 375         if(hsv[2] > 1.0f) hsv[2] = 1.0f;
 376         hsv_to_rgb(hsv, rgb);
 377
 378         rgb[0] = pow(rgb[0], 1.0 / 2.6);
 379         rgb[1] = pow(rgb[1], 1.0 / 2.6);
 380         rgb[2] = pow(rgb[2], 1.0 / 2.6);
 381
 382         color->r = (int)(rgb[0] * 255.0f);
 383         color->g = (int)(rgb[1] * 255.0f);
 384         color->b = (int)(rgb[2] * 255.0f);
 385 }
 386
 387 void conv_gba_image(struct image *img)
 388 {
 389         int i;
 390
 391         if(img->cmap_ncolors) {
 392                 for(i=0; i<img->cmap_ncolors; i++) {
 393                         gba_color(img->cmap + i);
 394                 }
 395         } else {
 396                 /* TODO */
 397         }
 398 }
 399
 400 void dump_colormap(struct image *img, int text, FILE *fp)
 401 {
 402         int i;
 403
 404         if(text) {
 405                 for(i=0; i<img->cmap_ncolors; i++) {
 406                         fprintf(fp, "%d %d %d\n", img->cmap[i].r, img->cmap[i].g, img->cmap[i].b);
 407                 }
 408         } else {
 409                 fwrite(img->cmap, sizeof img->cmap[0], 1 << img->bpp, fp);
 410         }
 411 }
 412
 413 void print_usage(const char *argv0)
 414 {
 415         printf("Usage: %s [options] <input file>\n", argv0);
 416         printf("Options:\n");
 417         printf(" -o <output file>: specify output file (default: stdout)\n");
 418         printf(" -oc <cmap file>: output colormap to separate file\n");
 419         printf(" -os <lut file>: generate and output shading LUT\n");
 420         printf(" -p: dump pixels (default)\n");
 421         printf(" -P: output in PNG format\n");
 422         printf(" -c: dump colormap (palette) entries\n");
 423         printf(" -C <colors>: reduce image down to specified number of colors\n");
 424         printf(" -s <shade levels>: used in conjunction with -os (default: 8)\n");
 425         printf(" -i: print image information\n");
 426         printf(" -t: output as text when possible\n");
 427         printf(" -n: swap the order of nibbles (for 4bpp)\n");
 428         printf(" -555: convert to BGR555\n");
 429         printf(" -h: print usage and exit\n");
 430 }