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 "readpng.h"
  17 #include "lprintf.h"
  18
  19 int readpng(void *dest, const char *fname, readpng_what what, int req_w, int req_h)
  20 {
  21         FILE *fp;
  22         png_structp png_ptr = NULL;
  23         png_infop info_ptr = NULL;
  24         png_bytepp row_ptr = NULL;
  25         int ret = -1;
  26
  27         if (dest == NULL || fname == NULL)
  28         {
  29                 return -1;
  30         }
  31
  32         fp = fopen(fname, "rb");
  33         if (fp == NULL)
  34         {
  35                 lprintf(__FILE__ ": failed to open: %s\n", fname);
  36                 return -1;
  37         }
  38
  39         png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  40         if (!png_ptr)
  41         {
  42                 lprintf(__FILE__ ": png_create_read_struct() failed\n");
  43                 fclose(fp);
  44                 return -1;
  45         }
  46
  47         info_ptr = png_create_info_struct(png_ptr);
  48         if (!info_ptr)
  49         {
  50                 lprintf(__FILE__ ": png_create_info_struct() failed\n");
  51                 goto done;
  52         }
  53
  54         // Start reading
  55         png_init_io(png_ptr, fp);
  56         png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING, NULL);
  57         row_ptr = png_get_rows(png_ptr, info_ptr);
  58         if (row_ptr == NULL)
  59         {
  60                 lprintf(__FILE__ ": png_get_rows() failed\n");
  61                 goto done;
  62         }
  63
  64         // lprintf("%s: %ix%i @ %ibpp\n", fname, (int)png_get_image_width(png_ptr, info_ptr),
  65         //      (int)png_get_image_height(png_ptr, info_ptr), png_get_bit_depth(png_ptr, info_ptr));
  66
  67         switch (what)
  68         {
  69                 case READPNG_BG:
  70                 {
  71                         int height, width, h, x_ofs = 0, y_ofs = 0;
  72                         unsigned short *dst = dest;
  73
  74                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
  75                         {
  76                                 lprintf(__FILE__ ": bg image uses %ibpc, needed 8bpc\n", png_get_bit_depth(png_ptr, info_ptr));
  77                                 break;
  78                         }
  79                         width = png_get_image_width(png_ptr, info_ptr);
  80                         if (width > req_w) {
  81                                 x_ofs = (width - req_w) / 2;
  82                                 width = req_w;
  83                         } else
  84                                 dst += (req_w - width) / 2;
  85                         height = png_get_image_height(png_ptr, info_ptr);
  86                         if (height > req_h) {
  87                                 y_ofs = (height - req_h) / 2;
  88                                 height = req_h;
  89                         } else
  90                                 dst += (req_h - height) / 2 * req_w;
  91
  92                         for (h = 0; h < height; h++)
  93                         {
  94                                 unsigned char *src = row_ptr[h + y_ofs] + x_ofs * 3;
  95                                 int len = width;
  96                                 while (len--)
  97                                 {
  98 #ifdef PSP
  99                                         *dst++ = ((src[2]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[0] >> 3); // BGR
 100 #else
 101                                         *dst++ = ((src[0]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[2] >> 3); // RGB
 102 #endif
 103                                         src += 3;
 104                                 }
 105                                 dst += req_w - width;
 106                         }
 107                         break;
 108                 }
 109
 110                 case READPNG_FONT:
 111                 {
 112                         int x, y, x1, y1;
 113                         unsigned char *dst = dest;
 114                         if (png_get_image_width(png_ptr, info_ptr) != req_w || png_get_image_height(png_ptr, info_ptr) != req_h)
 115                         {
 116                                 lprintf(__FILE__ ": unexpected font image size %dx%d, needed %dx%d\n",
 117                                         (int)png_get_image_width(png_ptr, info_ptr), (int)png_get_image_height(png_ptr, info_ptr), req_w, req_h);
 118                                 break;
 119                         }
 120                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
 121                         {
 122                                 lprintf(__FILE__ ": font image uses %ibpp, needed 8bpp\n", png_get_bit_depth(png_ptr, info_ptr));
 123                                 break;
 124                         }
 125                         for (y = 0; y < 16; y++)
 126                         {
 127                                 for (x = 0; x < 16; x++)
 128                                 {
 129                                         /* 16x16 grid of syms */
 130                                         int sym_w = req_w / 16;
 131                                         int sym_h = req_h / 16;
 132                                         for (y1 = 0; y1 < sym_h; y1++)
 133                                         {
 134                                                 unsigned char *src = row_ptr[y*sym_h + y1] + x*sym_w;
 135                                                 for (x1 = sym_w/2; x1 > 0; x1--, src+=2)
 136                                                         *dst++ = ((src[0]^0xff) & 0xf0) | ((src[1]^0xff) >> 4);
 137                                         }
 138                                 }
 139                         }
 140                         break;
 141                 }
 142
 143                 case READPNG_SELECTOR:
 144                 {
 145                         int x1, y1;
 146                         unsigned char *dst = dest;
 147                         if (png_get_image_width(png_ptr, info_ptr) != req_w || png_get_image_height(png_ptr, info_ptr) != req_h)
 148                         {
 149                                 lprintf(__FILE__ ": unexpected selector image size %ix%i, needed %dx%d\n",
 150                                         (int)png_get_image_width(png_ptr, info_ptr), (int)png_get_image_height(png_ptr, info_ptr), req_w, req_h);
 151                                 break;
 152                         }
 153                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
 154                         {
 155                                 lprintf(__FILE__ ": selector image uses %ibpp, needed 8bpp\n", png_get_bit_depth(png_ptr, info_ptr));
 156                                 break;
 157                         }
 158                         for (y1 = 0; y1 < req_h; y1++)
 159                         {
 160                                 unsigned char *src = row_ptr[y1];
 161                                 for (x1 = req_w/2; x1 > 0; x1--, src+=2)
 162                                         *dst++ = ((src[0]^0xff) & 0xf0) | ((src[1]^0xff) >> 4);
 163                         }
 164                         break;
 165                 }
 166
 167                 case READPNG_24:
 168                 {
 169                         int height, width, h;
 170                         unsigned char *dst = dest;
 171                         if (png_get_bit_depth(png_ptr, info_ptr) != 8)
 172                         {
 173                                 lprintf(__FILE__ ": image uses %ibpc, needed 8bpc\n", png_get_bit_depth(png_ptr, info_ptr));
 174                                 break;
 175                         }
 176                         width = png_get_image_width(png_ptr, info_ptr);
 177                         if (width > req_w)
 178                                 width = req_w;
 179                         height = png_get_image_height(png_ptr, info_ptr);
 180                         if (height > req_h)
 181                                 height = req_h;
 182
 183                         for (h = 0; h < height; h++)
 184                         {
 185                                 int len = width;
 186                                 unsigned char *src = row_ptr[h];
 187                                 dst += (req_w - width) * 3;
 188                                 for (len = width; len > 0; len--, dst+=3, src+=3)
 189                                         dst[0] = src[2], dst[1] = src[1], dst[2] = src[0];
 190                         }
 191                         break;
 192                 }
 193         }
 194
 195
 196         ret = 0;
 197 done:
 198         png_destroy_read_struct(&png_ptr, info_ptr ? &info_ptr : NULL, (png_infopp)NULL);
 199         fclose(fp);
 200         return ret;
 201 }
 202
 203 int writepng(const char *fname, unsigned short *src, int w, int h)
 204 {
 205         png_structp png_ptr = NULL;
 206         png_infop info_ptr = NULL;
 207         png_bytepp row_pointers;
 208         int i, j, ret = -1;
 209         FILE *f;
 210
 211         f = fopen(fname, "wb");
 212         if (f == NULL) {
 213                 lprintf(__FILE__ ": failed to open \"%s\"\n", fname);
 214                 return -1;
 215         }
 216
 217         row_pointers = calloc(h, sizeof(row_pointers[0]));
 218         if (row_pointers == NULL)
 219                 goto end1;
 220
 221         for (i = 0; i < h; i++) {
 222                 unsigned char *dst = malloc(w * 3);
 223                 if (dst == NULL)
 224                         goto end2;
 225                 row_pointers[i] = dst;
 226                 for (j = 0; j < w; j++, src++, dst += 3) {
 227                         dst[0] = (*src & 0xf800) >> 8;
 228                         dst[1] = (*src & 0x07e0) >> 3;
 229                         dst[2] = (*src & 0x001f) << 3;
 230                 }
 231         }
 232
 233         /* initialize stuff */
 234         png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 235         if (png_ptr == NULL) {
 236                 fprintf(stderr, "png_create_write_struct() failed");
 237                 goto end2;
 238         }
 239
 240         info_ptr = png_create_info_struct(png_ptr);
 241         if (info_ptr == NULL) {
 242                 fprintf(stderr, "png_create_info_struct() failed");
 243                 goto end3;
 244         }
 245
 246         if (setjmp(png_jmpbuf(png_ptr)) != 0) {
 247                 fprintf(stderr, "error in png code\n");
 248                 goto end4;
 249         }
 250
 251         png_init_io(png_ptr, f);
 252
 253         png_set_IHDR(png_ptr, info_ptr, w, h,
 254                 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
 255                 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 256
 257         png_write_info(png_ptr, info_ptr);
 258         png_write_image(png_ptr, row_pointers);
 259         png_write_end(png_ptr, NULL);
 260
 261         ret = 0;
 262
 263 end4:
 264 //      png_destroy_info_struct(png_ptr, &info_ptr); // freed below
 265 end3:
 266         png_destroy_write_struct(&png_ptr, &info_ptr);
 267 end2:
 268         for (i = 0; i < h; i++)
 269                 free(row_pointers[i]);
 270         free(row_pointers);
 271 end1:
 272         fclose(f);
 273         return ret;
 274 }
 275