readpng.c

   1 /*
   2  * (C) Gražvydas "notaz" Ignotas, 2008-2011
   3  *
   4  * This work is licensed under the terms of any of these licenses
   5  * (at your option):
   6  *  - GNU GPL, version 2 or later.
   7  *  - GNU LGPL, version 2.1 or later.
   8  *  - MAME license.
   9  * See the COPYING file in the top-level directory.
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <png.h>
  16 #include "plat.h"
  17 #include "readpng.h"
  18 #include "lprintf.h"
  19
  20 int readpng(void *dest, const char *fname, readpng_what what, int req_w, int req_h)
  21 {
  22         FILE *fp;
  23         png_structp png_ptr = NULL;
  24         png_infop info_ptr = NULL;
  25         png_bytepp row_ptr = NULL;
  26         int ret = -1;
  27
  28         if (dest == NULL || fname == NULL)
  29         {
  30                 return -1;
  31         }
  32
  33         fp = fopen(fname, "rb");
  34         if (fp == NULL)
  35         {
  36                 lprintf(__FILE__ ": failed to open: %s\n", fname);
  37                 return -1;
  38         }
  39
  40         png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  41         if (!png_ptr)
  42         {
  43                 lprintf(__FILE__ ": png_create_read_struct() failed\n");
  44                 fclose(fp);
  45                 return -1;
  46         }
  47
  48         info_ptr = png_create_info_struct(png_ptr);
  49         if (!info_ptr)
  50         {
  51                 lprintf(__FILE__ ": png_create_info_struct() failed\n");
  52                 goto done;
  53         }
  54
  55         // Start reading
  56         png_init_io(png_ptr, fp);
  57         png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING, NULL);
  58         row_ptr = png_get_rows(png_ptr, info_ptr);
  59         if (row_ptr == NULL)
  60         {
  61                 lprintf(__FILE__ ": png_get_rows() failed\n");
  62                 goto done;
  63         }
  64
  65         // lprintf("%s: %ix%i @ %ibpp\n", fname, (int)png_get_image_width(png_ptr, info_ptr),
  66         //      (int)png_get_image_height(png_ptr, info_ptr), png_get_bit_depth(png_ptr, info_ptr));
  67
  68         switch (what)
  69         {
  70                 case READPNG_SCALE:
  71                 {
  72                         int height, width, x_ofs = 0, y_ofs = 0;
  73                         unsigned short *dst = dest;
  74                         int x_scale, y_scale, x_pos, y_pos; // Q16
  75
  76                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
  77                         {
  78                                 lprintf(__FILE__ ": scaled image uses %ibpc, needed 8bpc\n", png_get_bit_depth(png_ptr, info_ptr));
  79                                 goto done;
  80                         }
  81                         width = png_get_image_width(png_ptr, info_ptr);
  82                         x_scale = width*65536 / req_w;
  83                         height = png_get_image_height(png_ptr, info_ptr);
  84                         y_scale = height*65536 / req_h;
  85                         if (x_scale < y_scale)
  86                                 x_scale = y_scale;
  87                         else    y_scale = x_scale;
  88                         x_ofs = req_w - width*65536 / x_scale;
  89                         y_ofs = req_h - height*65536 / y_scale;
  90
  91                         dst += y_ofs/2*req_w + x_ofs/2;
  92                         for (y_pos = 0; y_pos < height*65536; y_pos += y_scale+1)
  93                         {
  94                                 unsigned char *src = row_ptr[y_pos >> 16];
  95                                 int len = 0;
  96                                 for (x_pos = 0; x_pos < width*65536; x_pos += x_scale+1, len++)
  97                                 {
  98                                         int o = 3*(x_pos >> 16);
  99                                         // TODO: could use bilinear if upsampling?
 100                                         *dst++ = PXMAKE(src[o], src[o+1], src[o+2]);
 101                                 }
 102                                 dst += req_w - len;
 103                         }
 104                         break;
 105                 }
 106
 107                 case READPNG_BG:
 108                 {
 109                         int height, width, h, x_ofs = 0, y_ofs = 0;
 110                         unsigned short *dst = dest;
 111
 112                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
 113                         {
 114                                 lprintf(__FILE__ ": bg image uses %ibpc, needed 8bpc\n", png_get_bit_depth(png_ptr, info_ptr));
 115                                 goto done;
 116                         }
 117                         width = png_get_image_width(png_ptr, info_ptr);
 118                         if (width > req_w) {
 119                                 x_ofs = (width - req_w) / 2;
 120                                 width = req_w;
 121                         } else
 122                                 dst += (req_w - width) / 2;
 123                         height = png_get_image_height(png_ptr, info_ptr);
 124                         if (height > req_h) {
 125                                 y_ofs = (height - req_h) / 2;
 126                                 height = req_h;
 127                         } else
 128                                 dst += (req_h - height) / 2 * req_w;
 129
 130                         for (h = 0; h < height; h++)
 131                         {
 132                                 unsigned char *src = row_ptr[h + y_ofs] + x_ofs * 3;
 133                                 int len = width;
 134                                 while (len--)
 135                                 {
 136                                         *dst++ = PXMAKE(src[0], src[1], src[2]);
 137                                         src += 3;
 138                                 }
 139                                 dst += req_w - width;
 140                         }
 141                         break;
 142                 }
 143
 144                 case READPNG_FONT:
 145                 {
 146                         int x, y, x1, y1;
 147                         unsigned char *dst = dest;
 148                         if (png_get_image_width(png_ptr, info_ptr) != req_w || png_get_image_height(png_ptr, info_ptr) != req_h)
 149                         {
 150                                 lprintf(__FILE__ ": unexpected font image size %dx%d, needed %dx%d\n",
 151                                         (int)png_get_image_width(png_ptr, info_ptr), (int)png_get_image_height(png_ptr, info_ptr), req_w, req_h);
 152                                 goto done;
 153                         }
 154                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
 155                         {
 156                                 lprintf(__FILE__ ": font image uses %ibpp, needed 8bpp\n", png_get_bit_depth(png_ptr, info_ptr));
 157                                 goto done;
 158                         }
 159                         for (y = 0; y < 16; y++)
 160                         {
 161                                 for (x = 0; x < 16; x++)
 162                                 {
 163                                         /* 16x16 grid of syms */
 164                                         int sym_w = req_w / 16;
 165                                         int sym_h = req_h / 16;
 166                                         for (y1 = 0; y1 < sym_h; y1++)
 167                                         {
 168                                                 unsigned char *src = row_ptr[y*sym_h + y1] + x*sym_w;
 169                                                 for (x1 = sym_w/2; x1 > 0; x1--, src+=2)
 170                                                         *dst++ = ((src[0]^0xff) & 0xf0) | ((src[1]^0xff) >> 4);
 171                                         }
 172                                 }
 173                         }
 174                         break;
 175                 }
 176
 177                 case READPNG_SELECTOR:
 178                 {
 179                         int x1, y1;
 180                         unsigned char *dst = dest;
 181                         if (png_get_image_width(png_ptr, info_ptr) != req_w || png_get_image_height(png_ptr, info_ptr) != req_h)
 182                         {
 183                                 lprintf(__FILE__ ": unexpected selector image size %ix%i, needed %dx%d\n",
 184                                         (int)png_get_image_width(png_ptr, info_ptr), (int)png_get_image_height(png_ptr, info_ptr), req_w, req_h);
 185                                 goto done;
 186                         }
 187                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
 188                         {
 189                                 lprintf(__FILE__ ": selector image uses %ibpp, needed 8bpp\n", png_get_bit_depth(png_ptr, info_ptr));
 190                                 goto done;
 191                         }
 192                         for (y1 = 0; y1 < req_h; y1++)
 193                         {
 194                                 unsigned char *src = row_ptr[y1];
 195                                 for (x1 = req_w/2; x1 > 0; x1--, src+=2)
 196                                         *dst++ = ((src[0]^0xff) & 0xf0) | ((src[1]^0xff) >> 4);
 197                         }
 198                         break;
 199                 }
 200
 201                 case READPNG_24:
 202                 {
 203                         int height, width, h;
 204                         unsigned char *dst = dest;
 205                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
 206                         {
 207                                 lprintf(__FILE__ ": image uses %ibpc, needed 8bpc\n", png_get_bit_depth(png_ptr, info_ptr));
 208                                 goto done;
 209                         }
 210                         width = png_get_image_width(png_ptr, info_ptr);
 211                         if (width > req_w)
 212                                 width = req_w;
 213                         height = png_get_image_height(png_ptr, info_ptr);
 214                         if (height > req_h)
 215                                 height = req_h;
 216
 217                         for (h = 0; h < height; h++)
 218                         {
 219                                 int len = width;
 220                                 unsigned char *src = row_ptr[h];
 221                                 dst += (req_w - width) * 3;
 222                                 for (len = width; len > 0; len--, dst+=3, src+=3)
 223                                         dst[0] = src[2], dst[1] = src[1], dst[2] = src[0];
 224                         }
 225                         break;
 226                 }
 227         }
 228
 229
 230         ret = 0;
 231 done:
 232         png_destroy_read_struct(&png_ptr, info_ptr ? &info_ptr : NULL, (png_infopp)NULL);
 233         fclose(fp);
 234         return ret;
 235 }
 236
 237 int writepngpp(const char *fname, unsigned short *src, int w, int h, int pitch)
 238 {
 239         png_structp png_ptr = NULL;
 240         png_infop info_ptr = NULL;
 241         png_bytepp row_pointers;
 242         int i, j, ret = -1;
 243         FILE *f;
 244
 245         f = fopen(fname, "wb");
 246         if (f == NULL) {
 247                 lprintf(__FILE__ ": failed to open \"%s\"\n", fname);
 248                 return -1;
 249         }
 250
 251         row_pointers = calloc(h, sizeof(row_pointers[0]));
 252         if (row_pointers == NULL)
 253                 goto end1;
 254
 255         for (i = 0; i < h; i++) {
 256                 unsigned char *dst = malloc(w * 3);
 257                 if (dst == NULL)
 258                         goto end2;
 259                 row_pointers[i] = dst;
 260                 for (j = 0; j < w; j++, src++, dst += 3) {
 261                         dst[0] = PXGETR(*src);
 262                         dst[1] = PXGETG(*src);
 263                         dst[2] = PXGETB(*src);
 264                 }
 265                 src += pitch-w;
 266         }
 267
 268         /* initialize stuff */
 269         png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 270         if (png_ptr == NULL) {
 271                 fprintf(stderr, "png_create_write_struct() failed");
 272                 goto end2;
 273         }
 274
 275         info_ptr = png_create_info_struct(png_ptr);
 276         if (info_ptr == NULL) {
 277                 fprintf(stderr, "png_create_info_struct() failed");
 278                 goto end3;
 279         }
 280
 281         if (setjmp(png_jmpbuf(png_ptr)) != 0) {
 282                 fprintf(stderr, "error in png code\n");
 283                 goto end4;
 284         }
 285
 286         png_init_io(png_ptr, f);
 287
 288         png_set_IHDR(png_ptr, info_ptr, w, h,
 289                 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
 290                 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 291
 292         png_write_info(png_ptr, info_ptr);
 293         png_write_image(png_ptr, row_pointers);
 294         png_write_end(png_ptr, NULL);
 295
 296         ret = 0;
 297
 298 end4:
 299 //      png_destroy_info_struct(png_ptr, &info_ptr); // freed below
 300 end3:
 301         png_destroy_write_struct(&png_ptr, &info_ptr);
 302 end2:
 303         for (i = 0; i < h; i++)
 304                 free(row_pointers[i]);
 305         free(row_pointers);
 306 end1:
 307         fclose(f);
 308         return ret;
 309 }
 310
 311 int writepng(const char *fname, unsigned short *src, int w, int h)
 312 {
 313         return writepngpp(fname, src, w, h, w);
 314 }