apps/plugins/ppmviewer.c

   1 /*****************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _// __ \_/ ___\|  |/ /| __ \ / __ \  \/  /
   5  *   Jukebox    |    |   ( (__) )  \___|    ( | \_\ ( (__) )    (
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 Alexander Papst
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "plugin.h"
  23 #include "lib/pluginlib_bmp.h"
  24
  25 #if defined(HAVE_LCD_COLOR)
  26
  27 PLUGIN_HEADER
  28
  29 /* Magic constants. */
  30 #define PPM_MAGIC1 'P'
  31 #define PPM_MAGIC2 '3'
  32 #define RPPM_MAGIC2 '6'
  33 #define PPM_FORMAT (PPM_MAGIC1 * 256 + PPM_MAGIC2)
  34 #define RPPM_FORMAT (PPM_MAGIC1 * 256 + RPPM_MAGIC2)
  35
  36 #define PPM_OVERALLMAXVAL 65535
  37 #define PPM_MAXSIZE (300*1024)/sizeof(fb_data)
  38
  39 #define ppm_error(...) rb->splashf(HZ*2, __VA_ARGS__ )
  40
  41 static fb_data buffer[PPM_MAXSIZE];
  42 static fb_data lcd_buf[LCD_WIDTH * LCD_HEIGHT];
  43
  44 int ppm_read_magic_number(int fd)
  45 {
  46     char i1, i2;
  47     if(!rb->read(fd, &i1, 1) || !rb->read(fd, &i2, 1))
  48     {
  49         ppm_error( "Error reading magic number from ppm image stream. "\
  50                    "Most often, this means your input file is empty." );
  51         return PLUGIN_ERROR;
  52     }
  53     return i1 * 256 + i2;
  54 }
  55
  56 char ppm_getc(int fd)
  57 {
  58     char ch;
  59
  60     if (!rb->read(fd, &ch, 1)) {
  61         ppm_error("EOF. Read error reading a byte");
  62         return PLUGIN_ERROR;
  63     }
  64
  65     if (ch == '#') {
  66         do {
  67             if (!rb->read(fd, &ch, 1)) {
  68                 ppm_error("EOF. Read error reading a byte");
  69                 return PLUGIN_ERROR;
  70             }
  71         } while (ch != '\n' && ch != '\r');
  72     }
  73     return ch;
  74 }
  75
  76 int ppm_getuint(int fd)
  77 {
  78     char ch;
  79     int i;
  80     int digitVal;
  81
  82     do {
  83         ch = ppm_getc(fd);
  84     } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
  85
  86     if (ch < '0' || ch > '9') {
  87         ppm_error("Junk (%c) in file where an integer should be.", ch);
  88         return PLUGIN_ERROR;
  89     }
  90
  91     i = 0;
  92
  93     do {
  94         digitVal = ch - '0';
  95
  96         if (i > INT_MAX/10 - digitVal) {
  97             ppm_error("ASCII decimal integer in file is "\
  98                       "too large to be processed.");
  99             return PLUGIN_ERROR;
 100         }
 101
 102         i = i * 10 + digitVal;
 103         ch = ppm_getc(fd);
 104
 105     } while (ch >= '0' && ch <= '9');
 106
 107     return i;
 108 }
 109
 110 int ppm_getrawbyte(int fd)
 111 {
 112     unsigned char by;
 113
 114     if (!rb->read(fd, &by, 1)) {
 115         ppm_error("EOF. Read error while reading a one-byte sample.");
 116         return PLUGIN_ERROR;
 117     }
 118
 119     return (int)by;
 120 }
 121
 122 int ppm_getrawsample(int fd, int const maxval)
 123 {
 124     if (maxval < 256) {
 125         /* The sample is just one byte. Read it. */
 126         return(ppm_getrawbyte(fd));
 127     } else {
 128         /* The sample is two bytes. Read both. */
 129         unsigned char byte_pair[2];
 130
 131         if (!rb->read(fd, byte_pair, 2)) {
 132             ppm_error("EOF. Read error while reading a long sample.");
 133             return PLUGIN_ERROR;
 134         }
 135         return((byte_pair[0]<<8) | byte_pair[1]);
 136     }
 137 }
 138
 139 int read_ppm_init_rest(int fd,
 140                        int * const cols,
 141                        int * const rows,
 142                        int * const maxval)
 143 {
 144     /* Read size. */
 145     *cols = ppm_getuint(fd);
 146     *rows = ppm_getuint(fd);
 147
 148     if ((long unsigned int)(*cols * *rows) > PPM_MAXSIZE) {
 149         ppm_error("Imagesize (%ld pixels) is too large. "\
 150                   "The maximum allowed is %ld.",
 151                   (long unsigned int)(*cols * *rows),
 152                   (long unsigned int)PPM_MAXSIZE);
 153         return PLUGIN_ERROR;
 154     }
 155
 156     /* Read maxval. */
 157     *maxval = ppm_getuint(fd);
 158
 159     if (*maxval > PPM_OVERALLMAXVAL) {
 160         ppm_error("maxval of input image (%u) is too large. "\
 161                   "The maximum allowed by the PPM is %u.",
 162                   *maxval, PPM_OVERALLMAXVAL);
 163         return PLUGIN_ERROR;
 164     }
 165     if (*maxval == 0) {
 166         ppm_error("maxval of input image is zero.");
 167         return PLUGIN_ERROR;
 168     }
 169     return 1;
 170 }
 171
 172 void read_ppm_init(int fd,
 173                    int * const cols,
 174                    int * const rows,
 175                    int * const maxval,
 176                    int * const format)
 177 {
 178     /* Check magic number. */
 179     *format = ppm_read_magic_number( fd );
 180
 181     if (*format == PLUGIN_ERROR) return;
 182     switch (*format) {
 183         case PPM_FORMAT:
 184         case RPPM_FORMAT:
 185             if(read_ppm_init_rest(fd, cols, rows, maxval) == PLUGIN_ERROR) {
 186                 *format = PLUGIN_ERROR;
 187             }
 188             break;
 189
 190         default:
 191             ppm_error( "Bad magic number - not a ppm or rppm file." );
 192             *format = PLUGIN_ERROR;
 193     }
 194 }
 195
 196 #if   defined(LCD_STRIDEFORMAT) && LCD_STRIDEFORMAT == VERTICAL_STRIDE
 197 #define BUFADDR(x, y, width, height) ( buffer + height*(x) + (y))
 198 #else
 199 #define BUFADDR(x, y, width, height) ( buffer + width*(y) + (x))
 200 #endif
 201
 202 int read_ppm_row(int fd,
 203                  int const row,
 204                  int const cols,
 205                  int const rows,
 206                  int const maxval,
 207                  int const format)
 208 {
 209 #if   !(defined(LCD_STRIDEFORMAT) && LCD_STRIDEFORMAT == VERTICAL_STRIDE)
 210     (void) rows;
 211 #endif
 212
 213     int col;
 214     int r, g, b;
 215     switch (format) {
 216         case PPM_FORMAT:
 217             for (col = 0; col < cols; ++col) {
 218                 r = ppm_getuint(fd);
 219                 g = ppm_getuint(fd);
 220                 b = ppm_getuint(fd);
 221
 222                 if (r == PLUGIN_ERROR || g == PLUGIN_ERROR ||
 223                     b == PLUGIN_ERROR)
 224                 {
 225                     return PLUGIN_ERROR;
 226                 }
 227                 *BUFADDR(col, row, cols, rows) = LCD_RGBPACK(
 228                     (255 / maxval) * r,
 229                     (255 / maxval) * g,
 230                     (255 / maxval) * b);
 231             }
 232             break;
 233
 234         case RPPM_FORMAT:
 235             for (col = 0; col < cols; ++col) {
 236                 r = ppm_getrawsample(fd, maxval);
 237                 g = ppm_getrawsample(fd, maxval);
 238                 b = ppm_getrawsample(fd, maxval);
 239
 240                 if (r == PLUGIN_ERROR || g == PLUGIN_ERROR ||
 241                     b == PLUGIN_ERROR)
 242                 {
 243                     return PLUGIN_ERROR;
 244                 }
 245                 *BUFADDR(col, row, cols, rows) = LCD_RGBPACK(
 246                     (255 / maxval) * r,
 247                     (255 / maxval) * g,
 248                     (255 / maxval) * b);
 249             }
 250             break;
 251
 252         default:
 253             ppm_error("What?!");
 254             return PLUGIN_ERROR;
 255     }
 256     return 1;
 257 }
 258
 259 int read_ppm(int fd,
 260              int * const cols,
 261              int * const rows,
 262              int * const maxval)
 263 {
 264     int row;
 265     int format;
 266
 267     read_ppm_init(fd, cols, rows, maxval, &format);
 268
 269     if(format == PLUGIN_ERROR) {
 270         return PLUGIN_ERROR;
 271     }
 272
 273     for (row = 0; row < *rows; ++row) {
 274         if( read_ppm_row(fd, row, *cols, *rows, *maxval, format) == PLUGIN_ERROR) {
 275             return PLUGIN_ERROR;
 276         }
 277     }
 278     return 1;
 279 }
 280
 281 /* this is the plugin entry point */
 282 enum plugin_status plugin_start(const void* parameter)
 283 {
 284     static char filename[MAX_PATH];
 285     int fd;
 286
 287     int cols;
 288     int rows;
 289     int maxval;
 290
 291     int result;
 292
 293     struct bitmap small_bitmap, orig_bitmap;
 294
 295     if(!parameter) return PLUGIN_ERROR;
 296
 297     rb->strcpy(filename, parameter);
 298
 299     fd = rb->open(filename, O_RDONLY);
 300     if (fd < 0)
 301     {
 302         ppm_error("Couldnt open file: %s, %d", filename, fd);
 303         return PLUGIN_ERROR;
 304     }
 305
 306     result = read_ppm(fd, &cols, &rows, &maxval);
 307
 308     rb->close(fd);
 309     if(result == PLUGIN_ERROR) return PLUGIN_ERROR;
 310
 311     orig_bitmap.width = cols;
 312     orig_bitmap.height = rows;
 313     orig_bitmap.data = (char*)buffer;
 314
 315     if (cols > LCD_WIDTH || rows > LCD_HEIGHT)
 316     {
 317         if (cols > LCD_WIDTH) {
 318             small_bitmap.width = LCD_WIDTH;
 319             small_bitmap.height =
 320                 (int)(((float)LCD_WIDTH / (float)cols) * (float)rows);
 321
 322         } else { /* rows > LCD_HEIGHT */
 323
 324             small_bitmap.width =
 325                 (int)(((float)LCD_HEIGHT / (float)rows) * (float)cols);
 326             small_bitmap.height = LCD_HEIGHT;
 327         }
 328         small_bitmap.data = (char*)lcd_buf;
 329
 330         smooth_resize_bitmap( &orig_bitmap, &small_bitmap );
 331
 332         rb->lcd_bitmap((fb_data*)small_bitmap.data, 0, 0,
 333                        small_bitmap.width, small_bitmap.height);
 334     } else {
 335         rb->lcd_bitmap((fb_data*)orig_bitmap.data, 0, 0, cols, rows);
 336     }
 337     rb->lcd_update();
 338     rb->button_get(true);
 339
 340     return PLUGIN_OK;
 341 }
 342
 343 #endif