tools/checkwps/checkwps.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 by Dave Chapman
  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 <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include "config.h"
  26 #include "checkwps.h"
  27 #include "resize.h"
  28 #include "wps.h"
  29 #include "skin_engine.h"
  30 #include "wps_internals.h"
  31 #include "settings.h"
  32 #include "viewport.h"
  33 #include "file.h"
  34
  35 bool debug_wps = true;
  36 int wps_verbose_level = 0;
  37
  38 int errno;
  39
  40 const struct settings_list *settings;
  41 const int nb_settings = 0;
  42
  43 /* static endianness conversion */
  44 #define SWAP_16(x) ((typeof(x))(unsigned short)(((unsigned short)(x) >> 8) | \
  45                                                 ((unsigned short)(x) << 8)))
  46
  47 #define SWAP_32(x) ((typeof(x))(unsigned long)( ((unsigned long)(x) >> 24) | \
  48                                                (((unsigned long)(x) & 0xff0000ul) >> 8) | \
  49                                                (((unsigned long)(x) & 0xff00ul) << 8) | \
  50                                                 ((unsigned long)(x) << 24)))
  51
  52 #ifndef letoh16
  53 unsigned short letoh16(unsigned short x)
  54 {
  55     unsigned short n = 0x1234;
  56     unsigned char* ch = (unsigned char*)&n;
  57
  58     if (*ch == 0x34)
  59     {
  60         /* Little-endian */
  61         return x;
  62     } else {
  63         return SWAP_16(x);
  64     }
  65 }
  66 #endif
  67
  68 #ifndef letoh32
  69 unsigned short letoh32(unsigned short x)
  70 {
  71     unsigned short n = 0x1234;
  72     unsigned char* ch = (unsigned char*)&n;
  73
  74     if (*ch == 0x34)
  75     {
  76         /* Little-endian */
  77         return x;
  78     } else {
  79         return SWAP_32(x);
  80     }
  81 }
  82 #endif
  83
  84 #ifndef htole32
  85 unsigned int htole32(unsigned int x)
  86 {
  87     unsigned short n = 0x1234;
  88     unsigned char* ch = (unsigned char*)&n;
  89
  90     if (*ch == 0x34)
  91     {
  92         /* Little-endian */
  93         return x;
  94     } else {
  95         return SWAP_32(x);
  96     }
  97 }
  98 #endif
  99
 100 int read_line(int fd, char* buffer, int buffer_size)
 101 {
 102     int count = 0;
 103     int num_read = 0;
 104
 105     errno = 0;
 106
 107     while (count < buffer_size)
 108     {
 109         unsigned char c;
 110
 111         if (1 != read(fd, &c, 1))
 112             break;
 113
 114         num_read++;
 115
 116         if ( c == '\n' )
 117             break;
 118
 119         if ( c == '\r' )
 120             continue;
 121
 122         buffer[count++] = c;
 123     }
 124
 125     buffer[MIN(count, buffer_size - 1)] = 0;
 126
 127     return errno ? -1 : num_read;
 128 }
 129
 130 bool load_wps_backdrop(const char* filename)
 131 {
 132     return true;
 133 }
 134
 135 bool load_remote_wps_backdrop(const char* filename)
 136 {
 137     return true;
 138 }
 139
 140 int recalc_dimension(struct dim *dst, struct dim *src)
 141 {
 142     return 0;
 143 }
 144
 145 #ifdef HAVE_ALBUMART
 146 int playback_claim_aa_slot(struct dim *dim)
 147 {
 148     return 0;
 149 }
 150
 151 void playback_release_aa_slot(int slot)
 152 {
 153     return;
 154 }
 155 #endif
 156
 157 int resize_on_load(struct bitmap *bm, bool dither,
 158                    struct dim *src, struct rowset *tmp_row,
 159                    unsigned char *buf, unsigned int len,
 160                    const struct custom_format *cformat,
 161                    IF_PIX_FMT(int format_index,)
 162                    struct img_part* (*store_part)(void *args),
 163                    void *args)
 164 {
 165     return 0;
 166 }
 167
 168 int audio_status(void)
 169 {
 170     return 0;
 171 }
 172
 173 struct mp3entry* audio_current_track(void)
 174 {
 175     return NULL;
 176 }
 177
 178 void audio_stop(void)
 179 {
 180 }
 181
 182 void audio_play(long offset)
 183 {
 184 }
 185
 186 static char pluginbuf[PLUGIN_BUFFER_SIZE];
 187
 188 static unsigned dummy_func2(void)
 189 {
 190     return 0;
 191 }
 192
 193 void* plugin_get_buffer(size_t *buffer_size)
 194 {
 195     *buffer_size = PLUGIN_BUFFER_SIZE;
 196     return pluginbuf;
 197 }
 198
 199 struct user_settings global_settings = {
 200     .statusbar = true,
 201 #ifdef HAVE_LCD_COLOR
 202     .bg_color = LCD_DEFAULT_BG,
 203     .fg_color = LCD_DEFAULT_FG,
 204 #endif
 205 };
 206
 207 int getwidth(void) { return LCD_WIDTH; }
 208 int getheight(void) { return LCD_HEIGHT; }
 209 #ifdef HAVE_REMOTE_LCD
 210 int remote_getwidth(void) { return LCD_REMOTE_WIDTH; }
 211 int remote_getheight(void) { return LCD_REMOTE_HEIGHT; }
 212 #endif
 213
 214 struct screen screens[NB_SCREENS] =
 215 {
 216     {
 217         .screen_type=SCREEN_MAIN,
 218         .lcdwidth=LCD_WIDTH,
 219         .lcdheight=LCD_HEIGHT,
 220         .depth=LCD_DEPTH,
 221 #ifdef HAVE_LCD_COLOR
 222         .is_color=true,
 223 #else
 224         .is_color=false,
 225 #endif
 226         .getwidth = getwidth,
 227         .getheight = getheight,
 228 #if LCD_DEPTH > 1
 229         .get_foreground=dummy_func2,
 230         .get_background=dummy_func2,
 231 #endif
 232         .backdrop_load=backdrop_load,
 233     },
 234 #ifdef HAVE_REMOTE_LCD
 235     {
 236         .screen_type=SCREEN_REMOTE,
 237         .lcdwidth=LCD_REMOTE_WIDTH,
 238         .lcdheight=LCD_REMOTE_HEIGHT,
 239         .depth=LCD_REMOTE_DEPTH,
 240         .is_color=false,/* No color remotes yet */
 241         .getwidth=remote_getwidth,
 242         .getheight=remote_getheight,
 243 #if LCD_REMOTE_DEPTH > 1
 244         .get_foreground=dummy_func2,
 245         .get_background=dummy_func2,
 246 #endif
 247         .backdrop_load=backdrop_load,
 248     }
 249 #endif
 250 };
 251
 252 #ifdef HAVE_LCD_BITMAP
 253 void screen_clear_area(struct screen * display, int xstart, int ystart,
 254                        int width, int height)
 255 {
 256     display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 257     display->fillrect(xstart, ystart, width, height);
 258     display->set_drawmode(DRMODE_SOLID);
 259 }
 260 #endif
 261
 262 /* From skin_display.c */
 263 void skin_data_init(struct wps_data *wps_data)
 264 {
 265 #ifdef HAVE_LCD_BITMAP
 266     wps_data->wps_sb_tag = false;
 267     wps_data->show_sb_on_wps = false;
 268     wps_data->peak_meter_enabled = false;
 269     wps_data->images = NULL;
 270     wps_data->progressbars = NULL;
 271     /* progress bars */
 272 #else /* HAVE_LCD_CHARCELLS */
 273     int i;
 274     for (i = 0; i < 8; i++)
 275     {
 276         wps_data->wps_progress_pat[i] = 0;
 277     }
 278     wps_data->full_line_progressbar = false;
 279 #endif
 280     wps_data->button_time_volume = 0;
 281     wps_data->wps_loaded = false;
 282 }
 283
 284 #ifdef HAVE_LCD_BITMAP
 285 struct gui_img* find_image(char label, struct wps_data *data)
 286 {
 287     struct skin_token_list *list = data->images;
 288     while (list)
 289     {
 290         struct gui_img *img = (struct gui_img *)list->token->value.data;
 291         if (img->label == label)
 292             return img;
 293         list = list->next;
 294     }
 295     return NULL;
 296 }
 297 #endif
 298
 299 struct skin_viewport* find_viewport(char label, struct wps_data *data)
 300 {
 301     struct skin_token_list *list = data->viewports;
 302     while (list)
 303     {
 304         struct skin_viewport *vp = (struct skin_viewport *)list->token->value.data;
 305         if (vp->label == label)
 306             return vp;
 307         list = list->next;
 308     }
 309     return NULL;
 310 }
 311
 312 int main(int argc, char **argv)
 313 {
 314     int res;
 315     int filearg = 1;
 316
 317     struct wps_data wps;
 318
 319     /* No arguments -> print the help text
 320      * Also print the help text upon -h or --help */
 321     if( (argc < 2) ||
 322         strcmp(argv[1],"-h") == 0 ||
 323         strcmp(argv[1],"--help") == 0 )
 324     {
 325         printf("Usage: checkwps [OPTIONS] filename.wps [filename2.wps]...\n");
 326         printf("\nOPTIONS:\n");
 327         printf("\t-v\t\tverbose\n");
 328         printf("\t-vv\t\tmore verbose\n");
 329         printf("\t-vvv\t\tvery verbose\n");
 330         printf("\t-h,\t--help\tshow this message\n");
 331         return 1;
 332     }
 333
 334     if (argv[1][0] == '-') {
 335         filearg++;
 336         int i = 1;
 337         while (argv[1][i] && argv[1][i] == 'v') {
 338             i++;
 339             wps_verbose_level++;
 340         }
 341     }
 342
 343     skin_buffer_init();
 344
 345     /* Go through every wps that was thrown at us, error out at the first
 346      * flawed wps */
 347     while (argv[filearg]) {
 348         printf("Checking %s...\n", argv[filearg]);
 349 #ifdef HAVE_REMOTE_LCD
 350         if(strcmp(&argv[filearg][strlen(argv[filearg])-4], "rwps") == 0)
 351         {
 352             wps_screen = &screens[SCREEN_REMOTE];
 353             wps.remote_wps = true;
 354         }
 355         else
 356         {
 357             wps_screen = &screens[SCREEN_MAIN];
 358             wps.remote_wps = false;
 359         }
 360 #endif
 361
 362         res = skin_data_load(&wps, argv[filearg], true);
 363
 364         if (!res) {
 365             printf("WPS parsing failure\n");
 366             return 3;
 367         }
 368
 369         printf("WPS parsed OK\n\n");
 370         filearg++;
 371     }
 372     return 0;
 373 }