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 int read_ppm_row(int fd,
 197                  int const row,
 198                  int const cols,
 199                  int const maxval,
 200                  int const format)
 201 {
 202     int col;
 203     int r, g, b;
 204     switch (format) {
 205             case PPM_FORMAT:
 206             for (col = 0; col < cols; ++col) {
 207                 r = ppm_getuint(fd);
 208                 g = ppm_getuint(fd);
 209                 b = ppm_getuint(fd);
 210
 211                 if (r == PLUGIN_ERROR || g == PLUGIN_ERROR ||
 212                     b == PLUGIN_ERROR)
 213                 {
 214                     return PLUGIN_ERROR;
 215                 }
 216                 buffer[(cols * row) + col] = LCD_RGBPACK(
 217                     (255 / maxval) * r,
 218                     (255 / maxval) * g,
 219                     (255 / maxval) * b);
 220             }
 221             break;
 222
 223             case RPPM_FORMAT:
 224             for (col = 0; col < cols; ++col) {
 225                 r = ppm_getrawsample(fd, maxval);
 226                 g = ppm_getrawsample(fd, maxval);
 227                 b = ppm_getrawsample(fd, maxval);
 228
 229                 if (r == PLUGIN_ERROR || g == PLUGIN_ERROR ||
 230                     b == PLUGIN_ERROR)
 231                 {
 232                     return PLUGIN_ERROR;
 233                 }
 234                 buffer[(cols * row) + col] = LCD_RGBPACK(
 235                     (255 / maxval) * r,
 236                     (255 / maxval) * g,
 237                     (255 / maxval) * b);
 238                 }
 239                 break;
 240
 241             default:
 242             ppm_error("What?!");
 243                 return PLUGIN_ERROR;
 244         }
 245         return 1;
 246 }
 247
 248 int read_ppm(int fd,
 249              int * const cols,
 250              int * const rows,
 251              int * const maxval)
 252 {
 253     int row;
 254     int format;
 255
 256     read_ppm_init(fd, cols, rows, maxval, &format);
 257
 258     if(format == PLUGIN_ERROR) {
 259         return PLUGIN_ERROR;
 260     }
 261
 262     for (row = 0; row < *rows; ++row) {
 263         if( read_ppm_row(fd, row, *cols, *maxval, format) == PLUGIN_ERROR) {
 264             return PLUGIN_ERROR;
 265         }
 266     }
 267     return 1;
 268 }
 269
 270 /* this is the plugin entry point */
 271 enum plugin_status plugin_start(const void* parameter)
 272 {
 273     static char filename[MAX_PATH];
 274     int fd;
 275
 276     int cols;
 277     int rows;
 278     int maxval;
 279
 280     int result;
 281
 282     struct bitmap small_bitmap, orig_bitmap;
 283
 284     if(!parameter) return PLUGIN_ERROR;
 285
 286     rb->strcpy(filename, parameter);
 287
 288     fd = rb->open(filename, O_RDONLY);
 289     if (fd < 0)
 290     {
 291         ppm_error("Couldnt open file: %s, %d", filename, fd);
 292         return PLUGIN_ERROR;
 293     }
 294
 295     result = read_ppm(fd, &cols, &rows, &maxval);
 296
 297     rb->close(fd);
 298     if(result == PLUGIN_ERROR) return PLUGIN_ERROR;
 299
 300     orig_bitmap.width = cols;
 301     orig_bitmap.height = rows;
 302     orig_bitmap.data = (char*)buffer;
 303
 304     if (cols > LCD_WIDTH || rows > LCD_HEIGHT)
 305     {
 306         if (cols > LCD_WIDTH) {
 307             small_bitmap.width = LCD_WIDTH;
 308             small_bitmap.height =
 309                 (int)(((float)LCD_WIDTH / (float)cols) * (float)rows);
 310
 311         } else { /* rows > LCD_HEIGHT */
 312
 313             small_bitmap.width =
 314                 (int)(((float)LCD_HEIGHT / (float)rows) * (float)cols);
 315             small_bitmap.height = LCD_HEIGHT;
 316         }
 317         small_bitmap.data = (char*)lcd_buf;
 318
 319         smooth_resize_bitmap( &orig_bitmap, &small_bitmap );
 320
 321         rb->lcd_bitmap((fb_data*)small_bitmap.data, 0, 0,
 322                        small_bitmap.width, small_bitmap.height);
 323     } else {
 324         rb->lcd_bitmap((fb_data*)orig_bitmap.data, 0, 0, cols, rows);
 325     }
 326     rb->lcd_update();
 327     rb->button_get(true);
 328
 329     return PLUGIN_OK;
 330 }
 331
 332 #endif