git.mutantstargoat.com Git - retroray/blob - libs/imago/src/fileppm.c

   1 /*
   2 libimago - a multi-format image file input/output library.
   3 Copyright (C) 2010-2017 John Tsiombikas <nuclear@member.fsf.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published
   7 by the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 /* -- Portable Pixmap (PPM) module (also supports PGM) -- */
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24 #include "imago2.h"
  25 #include "ftmodule.h"
  26 #include "byteord.h"
  27
  28 static int check(struct img_io *io);
  29 static int read(struct img_pixmap *img, struct img_io *io);
  30 static int write(struct img_pixmap *img, struct img_io *io);
  31
  32 int img_register_ppm(void)
  33 {
  34         static struct ftype_module mod = {".ppm:.pgm:.pnm", check, read, write};
  35         return img_register_module(&mod);
  36 }
  37
  38
  39 static int check(struct img_io *io)
  40 {
  41         char id[2];
  42         int res = -1;
  43         long pos = io->seek(0, SEEK_CUR, io->uptr);
  44
  45         if(io->read(id, 2, io->uptr) < 2) {
  46                 io->seek(pos, SEEK_SET, io->uptr);
  47                 return -1;
  48         }
  49
  50         if(id[0] == 'P' && (id[1] == '6' || id[1] == '3' || id[1] == '5')) {
  51                 res = 0;
  52         }
  53         io->seek(pos, SEEK_SET, io->uptr);
  54         return res;
  55 }
  56
  57 static int iofgetc(struct img_io *io)
  58 {
  59         char c;
  60         return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
  61 }
  62
  63 static char *iofgets(char *buf, int size, struct img_io *io)
  64 {
  65         int c;
  66         char *ptr = buf;
  67
  68         while(--size > 0 && (c = iofgetc(io)) != -1) {
  69                 *ptr++ = c;
  70                 if(c == '\n') break;
  71         }
  72         *ptr = 0;
  73
  74         return ptr == buf ? 0 : buf;
  75 }
  76
  77 static int read(struct img_pixmap *img, struct img_io *io)
  78 {
  79         char buf[256];
  80         int xsz, ysz, maxval, got_hdrlines = 1;
  81         int i, greyscale, numval, valsize, fbsize, text;
  82         enum img_fmt fmt;
  83
  84         if(!iofgets(buf, sizeof buf, io)) {
  85                 return -1;
  86         }
  87         if(!(buf[0] == 'P' && (buf[1] == '6' || buf[1] == '3' || buf[1] == '5'))) {
  88                 return -1;
  89         }
  90         greyscale = buf[1] == '5' ? 1 : 0;
  91         text = buf[1] == '3' ? 1 : 0;
  92
  93         while(got_hdrlines < 3 && iofgets(buf, sizeof buf, io)) {
  94                 if(buf[0] == '#') continue;
  95
  96                 switch(got_hdrlines) {
  97                 case 1:
  98                         if(sscanf(buf, "%d %d\n", &xsz, &ysz) < 2) {
  99                                 return -1;
 100                         }
 101                         break;
 102
 103                 case 2:
 104                         if(sscanf(buf, "%d\n", &maxval) < 1) {
 105                                 return -1;
 106                         }
 107                 default:
 108                         break;
 109                 }
 110                 got_hdrlines++;
 111         }
 112
 113         if(xsz < 1 || ysz < 1 || maxval <= 0 || maxval > 65535) {
 114                 return -1;
 115         }
 116
 117         valsize = maxval < 256 ? 1 : 2;
 118         numval = xsz * ysz * (greyscale ? 1 : 3);
 119         fbsize = numval * valsize;
 120
 121         if(valsize > 1) {
 122                 fmt = greyscale ? IMG_FMT_GREYF : IMG_FMT_RGBF;
 123         } else {
 124                 fmt = greyscale ? IMG_FMT_GREY8 : IMG_FMT_RGB24;
 125         }
 126
 127         if(img_set_pixels(img, xsz, ysz, fmt, 0) == -1) {
 128                 return -1;
 129         }
 130
 131         if(!text) {
 132                 if(io->read(img->pixels, fbsize, io->uptr) < (unsigned int)fbsize) {
 133                         return -1;
 134                 }
 135                 if(maxval == 255) {
 136                         return 0;       /* we're done, no conversion necessary */
 137                 }
 138
 139                 if(maxval < 256) {
 140                         unsigned char *ptr = img->pixels;
 141                         for(i=0; i<numval; i++) {
 142                                 unsigned char c = *ptr * 255 / maxval;
 143                                 *ptr++ = c;
 144                         }
 145                 } else {
 146                         /* we allocated a floating point framebuffer, and dropped the 16bit pixels
 147                          * into it. To convert it in-place we'll iterate backwards from the end, since
 148                          * otherwise each 32bit floating point value we store, would overwrite the next
 149                          * pixel.
 150                          */
 151                         uint16_t *src = (uint16_t*)img->pixels + numval;
 152                         float *dest = (float*)img->pixels + numval;
 153
 154                         for(i=0; i<numval; i++) {
 155                                 uint16_t val = *--src;
 156 #ifdef IMAGO_LITTLE_ENDIAN
 157                                 val = (val >> 8) | (val << 8);
 158 #endif
 159                                 *--dest = (float)val / (float)maxval;
 160                         }
 161                 }
 162         } else {
 163                 char *pptr = img->pixels;
 164                 int c = iofgetc(io);
 165
 166                 for(i=0; i<numval; i++) {
 167                         char *valptr = buf;
 168
 169                         while(c != -1 && isspace(c)) {
 170                                 c = iofgetc(io);
 171                         }
 172
 173                         while(c != -1 && !isspace(c) && valptr - buf < sizeof buf - 1) {
 174                                 *valptr++ = c;
 175                                 c = iofgetc(io);
 176                         }
 177                         if(c == -1) break;
 178                         *valptr = 0;
 179
 180                         *pptr++ = atoi(buf) * 255 / maxval;
 181                 }
 182         }
 183         return 0;
 184 }
 185
 186 static int write(struct img_pixmap *img, struct img_io *io)
 187 {
 188         int i, sz, nval, res = -1;
 189         char buf[256];
 190         float *fptr, maxfval;
 191         struct img_pixmap tmpimg;
 192         static const char *fmt = "P%d\n#written by libimago2\n%d %d\n%d\n";
 193         int greyscale = img_is_greyscale(img);
 194
 195         nval = greyscale ? 1 : 3;
 196
 197         img_init(&tmpimg);
 198
 199         switch(img->fmt) {
 200         case IMG_FMT_RGBA32:
 201                 if(img_copy(&tmpimg, img) == -1) {
 202                         goto done;
 203                 }
 204                 if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
 205                         goto done;
 206                 }
 207                 img = &tmpimg;
 208
 209         case IMG_FMT_RGB24:
 210         case IMG_FMT_GREY8:
 211                 sprintf(buf, fmt, greyscale ? 5 : 6, img->width, img->height, 255);
 212                 if(io->write(buf, strlen(buf), io->uptr) < strlen(buf)) {
 213                         goto done;
 214                 }
 215                 sz = img->width * img->height * nval;
 216                 if(io->write(img->pixels, sz, io->uptr) < (unsigned int)sz) {
 217                         goto done;
 218                 }
 219                 res = 0;
 220                 break;
 221
 222         case IMG_FMT_RGBAF:
 223                 if(img_copy(&tmpimg, img) == -1) {
 224                         goto done;
 225                 }
 226                 if(img_convert(&tmpimg, IMG_FMT_RGBF) == -1) {
 227                         goto done;
 228                 }
 229                 img = &tmpimg;
 230
 231         case IMG_FMT_RGBF:
 232         case IMG_FMT_GREYF:
 233                 sprintf(buf, fmt, greyscale ? 5 : 6, img->width, img->height, 65535);
 234                 if(io->write(buf, strlen(buf), io->uptr) < strlen(buf)) {
 235                         goto done;
 236                 }
 237                 fptr = img->pixels;
 238                 maxfval = 0;
 239                 for(i=0; i<img->width * img->height * nval; i++) {
 240                         float val = *fptr++;
 241                         if(val > maxfval) maxfval = val;
 242                 }
 243                 fptr = img->pixels;
 244                 for(i=0; i<img->width * img->height * nval; i++) {
 245                         uint16_t val = (uint16_t)(*fptr++ / maxfval * 65535.0);
 246                         img_write_uint16_be(io, val);
 247                 }
 248                 res = 0;
 249                 break;
 250
 251         default:
 252                 break;
 253         }
 254
 255 done:
 256         img_destroy(&tmpimg);
 257         return res;
 258 }