apps/plugins/imageviewer/imageviewer.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * user intereface of image viewers (jpeg, png, etc.)
  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/playback_control.h>
  24 #include <lib/helper.h>
  25 #include <lib/configfile.h>
  26 #include "imageviewer.h"
  27
  28 PLUGIN_HEADER
  29
  30 #ifdef USEGSLIB
  31 GREY_INFO_STRUCT
  32 #endif
  33
  34 /* Headings */
  35 #define DIR_PREV  1
  36 #define DIR_NEXT -1
  37 #define DIR_NONE  0
  38
  39 /******************************* Globals ***********************************/
  40
  41 bool slideshow_enabled = false;   /* run slideshow */
  42 bool running_slideshow = false;   /* loading image because of slideshow */
  43 #ifdef DISK_SPINDOWN
  44 bool immediate_ata_off = false;   /* power down disk after loading */
  45 #endif
  46 #ifdef USE_PLUG_BUF
  47 /* are we using the plugin buffer or the audio buffer? */
  48 bool plug_buf = true;
  49 #endif
  50
  51 /* Persistent configuration */
  52 #define IMGVIEW_CONFIGFILE          "imageviewer.cfg"
  53 #define IMGVIEW_SETTINGS_MINVERSION 1
  54 #define IMGVIEW_SETTINGS_VERSION    2
  55
  56 /* Slideshow times */
  57 #define SS_MIN_TIMEOUT      1
  58 #define SS_MAX_TIMEOUT      20
  59 #define SS_DEFAULT_TIMEOUT  5
  60
  61 #ifdef HAVE_LCD_COLOR
  62 /* needed for value of settings */
  63 #include "jpeg/yuv2rgb.h"
  64 #endif
  65
  66 /* jpeg use this */
  67 struct imgview_settings settings =
  68 {
  69 #ifdef HAVE_LCD_COLOR
  70     COLOURMODE_COLOUR,
  71     DITHER_NONE,
  72 #endif
  73     SS_DEFAULT_TIMEOUT
  74 };
  75 static struct imgview_settings old_settings;
  76
  77 static struct configdata config[] =
  78 {
  79 #ifdef HAVE_LCD_COLOR
  80     { TYPE_ENUM, 0, COLOUR_NUM_MODES, { .int_p = &settings.jpeg_colour_mode },
  81         "Colour Mode", (char *[]){ "Colour", "Grayscale" } },
  82     { TYPE_ENUM, 0, DITHER_NUM_MODES, { .int_p = &settings.jpeg_dither_mode },
  83         "Dither Mode", (char *[]){ "None", "Ordered", "Diffusion" } },
  84 #endif
  85     { TYPE_INT, SS_MIN_TIMEOUT, SS_MAX_TIMEOUT,
  86         { .int_p = &settings.ss_timeout }, "Slideshow Time", NULL },
  87 };
  88
  89 /**************** begin Application ********************/
  90
  91
  92 /************************* Globals ***************************/
  93
  94 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
  95 static fb_data rgb_linebuf[LCD_WIDTH];  /* Line buffer for scrolling when
  96                                            DITHER_DIFFUSION is set        */
  97 #endif
  98
  99 /* my memory pool (from the mp3 buffer) */
 100 static char print[32]; /* use a common snprintf() buffer */
 101 /* the remaining free part of the buffer for loaded+resized images */
 102 static unsigned char* buf;
 103 static size_t buf_size;
 104
 105 static int ds, ds_min, ds_max; /* downscaling and limits */
 106 static struct image_info image_info;
 107
 108 /* the current full file name */
 109 static char np_file[MAX_PATH];
 110 static int curfile = 0, direction = DIR_NEXT, entries = 0;
 111
 112 /* list of the supported image files */
 113 static char **file_pt;
 114
 115 /************************* Implementation ***************************/
 116
 117 /* Read directory contents for scrolling. */
 118 static void get_pic_list(void)
 119 {
 120     struct tree_context *tree = rb->tree_get_context();
 121     struct entry *dircache = tree->dircache;
 122     int i;
 123     char *pname;
 124
 125     file_pt = (char **) buf;
 126
 127     /* Remove path and leave only the name.*/
 128     pname = rb->strrchr(np_file,'/');
 129     pname++;
 130
 131     for (i = 0; i < tree->filesindir && buf_size > sizeof(char**); i++)
 132     {
 133         if (!(dircache[i].attr & ATTR_DIRECTORY)
 134             && img_ext(rb->strrchr(dircache[i].name,'.')))
 135         {
 136             file_pt[entries] = dircache[i].name;
 137             /* Set Selected File. */
 138             if (!rb->strcmp(file_pt[entries], pname))
 139                 curfile = entries;
 140             entries++;
 141
 142             buf += (sizeof(char**));
 143             buf_size -= (sizeof(char**));
 144         }
 145     }
 146 }
 147
 148 static int change_filename(int direct)
 149 {
 150     bool file_erased = (file_pt[curfile] == NULL);
 151     direction = direct;
 152
 153     curfile += (direct == DIR_PREV? entries - 1: 1);
 154     if (curfile >= entries)
 155         curfile -= entries;
 156
 157     if (file_erased)
 158     {
 159         /* remove 'erased' file names from list. */
 160         int count, i;
 161         for (count = i = 0; i < entries; i++)
 162         {
 163             if (curfile == i)
 164                 curfile = count;
 165             if (file_pt[i] != NULL)
 166                 file_pt[count++] = file_pt[i];
 167         }
 168         entries = count;
 169     }
 170
 171     if (entries == 0)
 172     {
 173         rb->splash(HZ, "No supported files");
 174         return PLUGIN_ERROR;
 175     }
 176
 177     rb->strcpy(rb->strrchr(np_file, '/')+1, file_pt[curfile]);
 178
 179     return PLUGIN_OTHER;
 180 }
 181
 182 /* switch off overlay, for handling SYS_ events */
 183 static void cleanup(void *parameter)
 184 {
 185     (void)parameter;
 186 #ifdef USEGSLIB
 187     grey_show(false);
 188 #endif
 189 }
 190
 191 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
 192 static bool set_option_grayscale(void)
 193 {
 194     bool gray = settings.jpeg_colour_mode == COLOURMODE_GRAY;
 195     rb->set_bool("Grayscale", &gray);
 196     settings.jpeg_colour_mode = gray ? COLOURMODE_GRAY : COLOURMODE_COLOUR;
 197     return false;
 198 }
 199
 200 static bool set_option_dithering(void)
 201 {
 202     static const struct opt_items dithering[DITHER_NUM_MODES] = {
 203         [DITHER_NONE]      = { "Off",       -1 },
 204         [DITHER_ORDERED]   = { "Ordered",   -1 },
 205         [DITHER_DIFFUSION] = { "Diffusion", -1 },
 206     };
 207
 208     rb->set_option("Dithering", &settings.jpeg_dither_mode, INT,
 209                    dithering, DITHER_NUM_MODES, NULL);
 210     return false;
 211 }
 212
 213 MENUITEM_FUNCTION(grayscale_item, 0, "Greyscale",
 214                   set_option_grayscale, NULL, NULL, Icon_NOICON);
 215 MENUITEM_FUNCTION(dithering_item, 0, "Dithering",
 216                   set_option_dithering, NULL, NULL, Icon_NOICON);
 217 MAKE_MENU(display_menu, "Display Options", NULL, Icon_NOICON,
 218             &grayscale_item, &dithering_item);
 219
 220 static void display_options(void)
 221 {
 222     rb->do_menu(&display_menu, NULL, NULL, false);
 223 }
 224 #endif /* defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER) */
 225
 226 static int show_menu(void) /* return 1 to quit */
 227 {
 228     int result;
 229
 230     enum menu_id
 231     {
 232         MIID_RETURN = 0,
 233         MIID_TOGGLE_SS_MODE,
 234         MIID_CHANGE_SS_MODE,
 235 #ifdef USE_PLUG_BUF
 236         MIID_SHOW_PLAYBACK_MENU,
 237 #endif
 238 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
 239         MIID_DISPLAY_OPTIONS,
 240 #endif
 241         MIID_QUIT,
 242     };
 243
 244     MENUITEM_STRINGLIST(menu, MENU_TITLE, NULL,
 245                         "Return", "Toggle Slideshow Mode",
 246                         "Change Slideshow Time",
 247 #ifdef USE_PLUG_BUF
 248                         "Show Playback Menu",
 249 #endif
 250 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
 251                         "Display Options",
 252 #endif
 253                         "Quit");
 254
 255     static const struct opt_items slideshow[2] = {
 256         { "Disable", -1 },
 257         { "Enable", -1 },
 258     };
 259
 260     result=rb->do_menu(&menu, NULL, NULL, false);
 261
 262     switch (result)
 263     {
 264         case MIID_RETURN:
 265             break;
 266         case MIID_TOGGLE_SS_MODE:
 267             rb->set_option("Toggle Slideshow", &slideshow_enabled, BOOL,
 268                            slideshow , 2, NULL);
 269             break;
 270         case MIID_CHANGE_SS_MODE:
 271             rb->set_int("Slideshow Time", "s", UNIT_SEC,
 272                         &settings.ss_timeout, NULL, 1,
 273                         SS_MIN_TIMEOUT, SS_MAX_TIMEOUT, NULL);
 274             break;
 275
 276 #ifdef USE_PLUG_BUF
 277         case MIID_SHOW_PLAYBACK_MENU:
 278             if (plug_buf)
 279             {
 280                 playback_control(NULL);
 281             }
 282             else
 283             {
 284                 rb->splash(HZ, "Cannot restart playback");
 285             }
 286             break;
 287 #endif
 288 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
 289         case MIID_DISPLAY_OPTIONS:
 290             display_options();
 291             break;
 292 #endif
 293         case MIID_QUIT:
 294             return 1;
 295             break;
 296     }
 297
 298 #ifdef DISK_SPINDOWN
 299     /* change ata spindown time based on slideshow time setting */
 300     immediate_ata_off = false;
 301     rb->storage_spindown(rb->global_settings->disk_spindown);
 302
 303     if (slideshow_enabled)
 304     {
 305         if(settings.ss_timeout < 10)
 306         {
 307             /* slideshow times < 10s keep disk spinning */
 308             rb->storage_spindown(0);
 309         }
 310         else if (!rb->mp3_is_playing())
 311         {
 312             /* slideshow times > 10s and not playing: ata_off after load */
 313             immediate_ata_off = true;
 314         }
 315     }
 316 #endif
 317 #if LCD_DEPTH > 1
 318     rb->lcd_set_backdrop(NULL);
 319     rb->lcd_set_foreground(LCD_WHITE);
 320     rb->lcd_set_background(LCD_BLACK);
 321 #endif
 322     rb->lcd_clear_display();
 323     return 0;
 324 }
 325
 326 #ifdef USE_PLUG_BUF
 327 static int ask_and_get_audio_buffer(const char *filename)
 328 {
 329     rb->lcd_setfont(FONT_SYSFIXED);
 330     rb->lcd_clear_display();
 331     rb->lcd_puts(0, 0, rb->strrchr(filename,'/')+1);
 332     rb->lcd_puts(0, 1, "Not enough plugin memory!");
 333     rb->lcd_puts(0, 2, "Zoom In: Stop playback.");
 334     if(entries > 1)
 335         rb->lcd_puts(0, 3, "Left/Right: Skip File.");
 336     rb->lcd_puts(0, 4, "Show Menu: Quit.");
 337     rb->lcd_update();
 338     rb->lcd_setfont(FONT_UI);
 339
 340     rb->button_clear_queue();
 341
 342     while (1)
 343     {
 344         int button = rb->button_get(true);
 345         switch(button)
 346         {
 347             case IMGVIEW_ZOOM_IN:
 348                 plug_buf = false;
 349                 buf = rb->plugin_get_audio_buffer(&buf_size);
 350                 /*try again this file, now using the audio buffer */
 351                 return PLUGIN_OTHER;
 352 #ifdef IMGVIEW_RC_MENU
 353             case IMGVIEW_RC_MENU:
 354 #endif
 355 #ifdef IMGVIEW_QUIT
 356             case IMGVIEW_QUIT:
 357 #endif
 358             case IMGVIEW_MENU:
 359                 return PLUGIN_OK;
 360
 361             case IMGVIEW_LEFT:
 362                 if(entries>1)
 363                 {
 364                     rb->lcd_clear_display();
 365                     return change_filename(DIR_PREV);
 366                 }
 367                 break;
 368
 369             case IMGVIEW_RIGHT:
 370                 if(entries>1)
 371                 {
 372                     rb->lcd_clear_display();
 373                     return change_filename(DIR_NEXT);
 374                 }
 375                 break;
 376             default:
 377                 if(rb->default_event_handler_ex(button, cleanup, NULL)
 378                         == SYS_USB_CONNECTED)
 379                     return PLUGIN_USB_CONNECTED;
 380         }
 381     }
 382 }
 383 #endif /* USE_PLUG_BUF */
 384
 385 /* callback updating a progress meter while image decoding */
 386 void cb_progress(int current, int total)
 387 {
 388     rb->yield(); /* be nice to the other threads */
 389 #ifndef USEGSLIB
 390     /* in slideshow mode, keep gui interference to a minimum */
 391     const int size = (!running_slideshow ? 8 : 4);
 392 #else
 393     const int size = 8;
 394     if(!running_slideshow)
 395 #endif
 396     {
 397         rb->gui_scrollbar_draw(rb->screens[SCREEN_MAIN],
 398                             0, LCD_HEIGHT-size, LCD_WIDTH, size,
 399                             total, 0, current, HORIZONTAL);
 400         rb->lcd_update_rect(0, LCD_HEIGHT-size, LCD_WIDTH, size);
 401     }
 402 }
 403
 404 #define VSCROLL (LCD_HEIGHT/8)
 405 #define HSCROLL (LCD_WIDTH/10)
 406
 407 #define ZOOM_IN  100 /* return codes for below function */
 408 #define ZOOM_OUT 101
 409
 410 /* Pan the viewing window right - move image to the left and fill in
 411    the right-hand side */
 412 static void pan_view_right(struct image_info *info)
 413 {
 414     int move;
 415
 416     move = MIN(HSCROLL, info->width - info->x - LCD_WIDTH);
 417     if (move > 0)
 418     {
 419         MYXLCD(scroll_left)(move); /* scroll left */
 420         info->x += move;
 421         draw_image_rect(info, LCD_WIDTH - move, 0, move, info->height-info->y);
 422         MYLCD_UPDATE();
 423     }
 424 }
 425
 426 /* Pan the viewing window left - move image to the right and fill in
 427    the left-hand side */
 428 static void pan_view_left(struct image_info *info)
 429 {
 430     int move;
 431
 432     move = MIN(HSCROLL, info->x);
 433     if (move > 0)
 434     {
 435         MYXLCD(scroll_right)(move); /* scroll right */
 436         info->x -= move;
 437         draw_image_rect(info, 0, 0, move, info->height-info->y);
 438         MYLCD_UPDATE();
 439     }
 440 }
 441
 442 /* Pan the viewing window up - move image down and fill in
 443    the top */
 444 static void pan_view_up(struct image_info *info)
 445 {
 446     int move;
 447
 448     move = MIN(VSCROLL, info->y);
 449     if (move > 0)
 450     {
 451         MYXLCD(scroll_down)(move); /* scroll down */
 452         info->y -= move;
 453 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
 454         if (settings.jpeg_dither_mode == DITHER_DIFFUSION)
 455         {
 456             /* Draw over the band at the top of the last update
 457                caused by lack of error history on line zero. */
 458             move = MIN(move + 1, info->y + info->height);
 459         }
 460 #endif
 461         draw_image_rect(info, 0, 0, info->width-info->x, move);
 462         MYLCD_UPDATE();
 463     }
 464 }
 465
 466 /* Pan the viewing window down - move image up and fill in
 467    the bottom */
 468 static void pan_view_down(struct image_info *info)
 469 {
 470     int move;
 471
 472     move = MIN(VSCROLL, info->height - info->y - LCD_HEIGHT);
 473     if (move > 0)
 474     {
 475         MYXLCD(scroll_up)(move); /* scroll up */
 476         info->y += move;
 477 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
 478         if (settings.jpeg_dither_mode == DITHER_DIFFUSION)
 479         {
 480             /* Save the line that was on the last line of the display
 481                and draw one extra line above then recover the line with
 482                image data that had an error history when it was drawn.
 483              */
 484             move++, info->y--;
 485             rb->memcpy(rgb_linebuf,
 486                     rb->lcd_framebuffer + (LCD_HEIGHT - move)*LCD_WIDTH,
 487                     LCD_WIDTH*sizeof (fb_data));
 488         }
 489 #endif
 490
 491         draw_image_rect(info, 0, LCD_HEIGHT - move, info->width-info->x, move);
 492
 493 #if defined(HAVE_LCD_COLOR) && defined(JPEG_VIEWER)
 494         if (settings.jpeg_dither_mode == DITHER_DIFFUSION)
 495         {
 496             /* Cover the first row drawn with previous image data. */
 497             rb->memcpy(rb->lcd_framebuffer + (LCD_HEIGHT - move)*LCD_WIDTH,
 498                         rgb_linebuf, LCD_WIDTH*sizeof (fb_data));
 499             info->y++;
 500         }
 501 #endif
 502         MYLCD_UPDATE();
 503     }
 504 }
 505
 506 /* interactively scroll around the image */
 507 static int scroll_bmp(struct image_info *info)
 508 {
 509     int button;
 510     int lastbutton = BUTTON_NONE;
 511
 512     while (true)
 513     {
 514         if (slideshow_enabled)
 515             button = rb->button_get_w_tmo(settings.ss_timeout * HZ);
 516         else
 517             button = rb->button_get(true);
 518
 519         running_slideshow = false;
 520
 521         switch(button)
 522         {
 523         case IMGVIEW_LEFT:
 524             if (entries > 1 && info->width <= LCD_WIDTH
 525                             && info->height <= LCD_HEIGHT)
 526                 return change_filename(DIR_PREV);
 527         case IMGVIEW_LEFT | BUTTON_REPEAT:
 528             pan_view_left(info);
 529             break;
 530
 531         case IMGVIEW_RIGHT:
 532             if (entries > 1 && info->width <= LCD_WIDTH
 533                             && info->height <= LCD_HEIGHT)
 534                 return change_filename(DIR_NEXT);
 535         case IMGVIEW_RIGHT | BUTTON_REPEAT:
 536             pan_view_right(info);
 537             break;
 538
 539         case IMGVIEW_UP:
 540         case IMGVIEW_UP | BUTTON_REPEAT:
 541             pan_view_up(info);
 542             break;
 543
 544         case IMGVIEW_DOWN:
 545         case IMGVIEW_DOWN | BUTTON_REPEAT:
 546             pan_view_down(info);
 547             break;
 548
 549         case BUTTON_NONE:
 550             if (slideshow_enabled && entries > 1)
 551             {
 552                 running_slideshow = true;
 553                 return change_filename(DIR_NEXT);
 554             }
 555             break;
 556
 557 #ifdef IMGVIEW_SLIDE_SHOW
 558         case IMGVIEW_SLIDE_SHOW:
 559             slideshow_enabled = !slideshow_enabled;
 560             break;
 561 #endif
 562
 563 #ifdef IMGVIEW_NEXT_REPEAT
 564         case IMGVIEW_NEXT_REPEAT:
 565 #endif
 566         case IMGVIEW_NEXT:
 567             if (entries > 1)
 568                 return change_filename(DIR_NEXT);
 569             break;
 570
 571 #ifdef IMGVIEW_PREVIOUS_REPEAT
 572         case IMGVIEW_PREVIOUS_REPEAT:
 573 #endif
 574         case IMGVIEW_PREVIOUS:
 575             if (entries > 1)
 576                 return change_filename(DIR_PREV);
 577             break;
 578
 579         case IMGVIEW_ZOOM_IN:
 580 #ifdef IMGVIEW_ZOOM_PRE
 581             if (lastbutton != IMGVIEW_ZOOM_PRE)
 582                 break;
 583 #endif
 584             return ZOOM_IN;
 585             break;
 586
 587         case IMGVIEW_ZOOM_OUT:
 588 #ifdef IMGVIEW_ZOOM_PRE
 589             if (lastbutton != IMGVIEW_ZOOM_PRE)
 590                 break;
 591 #endif
 592             return ZOOM_OUT;
 593             break;
 594
 595 #ifdef IMGVIEW_RC_MENU
 596         case IMGVIEW_RC_MENU:
 597 #endif
 598         case IMGVIEW_MENU:
 599 #ifdef IMGVIEW_MENU_PRE
 600             if (lastbutton != IMGVIEW_MENU_PRE)
 601                 break;
 602 #endif
 603 #ifdef USEGSLIB
 604             grey_show(false); /* switch off greyscale overlay */
 605 #endif
 606             if (show_menu() == 1)
 607                 return PLUGIN_OK;
 608
 609 #ifdef USEGSLIB
 610             grey_show(true); /* switch on greyscale overlay */
 611 #else
 612             draw_image_rect(info, 0, 0,
 613                             info->width-info->x, info->height-info->y);
 614             MYLCD_UPDATE();
 615 #endif
 616             break;
 617
 618 #ifdef IMGVIEW_QUIT
 619             case IMGVIEW_QUIT:
 620             return PLUGIN_OK;
 621             break;
 622 #endif
 623
 624         default:
 625             if (rb->default_event_handler_ex(button, cleanup, NULL)
 626                 == SYS_USB_CONNECTED)
 627                 return PLUGIN_USB_CONNECTED;
 628             break;
 629
 630         } /* switch */
 631
 632         if (button != BUTTON_NONE)
 633             lastbutton = button;
 634     } /* while (true) */
 635 }
 636
 637 /********************* main function *************************/
 638
 639 /* how far can we zoom in without running out of memory */
 640 static int min_downscale(int bufsize)
 641 {
 642     int downscale = 8;
 643
 644     if (img_mem(8) > bufsize)
 645         return 0; /* error, too large, even 1:8 doesn't fit */
 646
 647     while (downscale > 1 && img_mem(downscale/2) <= bufsize)
 648         downscale /= 2;
 649
 650     return downscale;
 651 }
 652
 653 /* how far can we zoom out, to fit image into the LCD */
 654 static int max_downscale(struct image_info *info)
 655 {
 656     int downscale = 1;
 657
 658     while (downscale < 8 && (info->x_size/downscale > LCD_WIDTH
 659                           || info->y_size/downscale > LCD_HEIGHT))
 660     {
 661         downscale *= 2;
 662     }
 663
 664     return downscale;
 665 }
 666
 667 /* set the view to the given center point, limit if necessary */
 668 static void set_view(struct image_info *info, int cx, int cy)
 669 {
 670     int x, y;
 671
 672     /* plain center to available width/height */
 673     x = cx - MIN(LCD_WIDTH, info->width) / 2;
 674     y = cy - MIN(LCD_HEIGHT, info->height) / 2;
 675
 676     /* limit against upper image size */
 677     x = MIN(info->width - LCD_WIDTH, x);
 678     y = MIN(info->height - LCD_HEIGHT, y);
 679
 680     /* limit against negative side */
 681     x = MAX(0, x);
 682     y = MAX(0, y);
 683
 684     info->x = x; /* set the values */
 685     info->y = y;
 686 }
 687
 688 /* calculate the view center based on the bitmap position */
 689 static void get_view(struct image_info *info, int *p_cx, int *p_cy)
 690 {
 691     *p_cx = info->x + MIN(LCD_WIDTH, info->width) / 2;
 692     *p_cy = info->y + MIN(LCD_HEIGHT, info->height) / 2;
 693 }
 694
 695 /* load, decode, display the image */
 696 static int load_and_show(char* filename, struct image_info *info)
 697 {
 698     int status;
 699     int cx, cy;
 700     ssize_t remaining;
 701
 702     rb->lcd_clear_display();
 703
 704     rb->memset(info, 0, sizeof(*info));
 705     remaining = buf_size;
 706
 707     if (rb->button_get(false) == IMGVIEW_MENU)
 708         status = PLUGIN_ABORT;
 709     else
 710         status = load_image(filename, info, buf, &remaining);
 711
 712     if (status == PLUGIN_OUTOFMEM)
 713     {
 714 #ifdef USE_PLUG_BUF
 715         if(plug_buf)
 716         {
 717             return ask_and_get_audio_buffer(filename);
 718         }
 719         else
 720 #endif
 721         {
 722             rb->splash(HZ, "Out of Memory");
 723             file_pt[curfile] = NULL;
 724             return change_filename(direction);
 725         }
 726     }
 727     else if (status == PLUGIN_ERROR)
 728     {
 729         file_pt[curfile] = NULL;
 730         return change_filename(direction);
 731     }
 732     else if (status == PLUGIN_ABORT) {
 733         rb->splash(HZ, "aborted");
 734         return PLUGIN_OK;
 735     }
 736
 737     ds_max = max_downscale(info);       /* check display constraint */
 738     ds_min = min_downscale(remaining);  /* check memory constraint */
 739     if (ds_min == 0)
 740     {
 741 #if UNSCALED_IS_AVAILABLE
 742         /* Can not resize the image but original one is available, so use it. */
 743         ds_min = ds_max = 1;
 744 #else
 745         /* not enough memory to decode image. */
 746 #ifdef USE_PLUG_BUF
 747         if(plug_buf)
 748         {
 749             return ask_and_get_audio_buffer(filename);
 750         }
 751         else
 752 #endif
 753         {
 754             rb->splash(HZ, "too large");
 755             file_pt[curfile] = NULL;
 756             return change_filename(direction);
 757         }
 758 #endif
 759     }
 760     else if (ds_max < ds_min)
 761         ds_max = ds_min;
 762
 763     ds = ds_max; /* initialize setting */
 764     cx = info->x_size/ds/2; /* center the view */
 765     cy = info->y_size/ds/2;
 766
 767     do  /* loop the image prepare and decoding when zoomed */
 768     {
 769         status = get_image(info, ds); /* decode or fetch from cache */
 770         if (status == PLUGIN_ERROR)
 771         {
 772             file_pt[curfile] = NULL;
 773             return change_filename(direction);
 774         }
 775
 776         set_view(info, cx, cy);
 777
 778         if(!running_slideshow)
 779         {
 780             rb->snprintf(print, sizeof(print), "showing %dx%d",
 781                             info->width, info->height);
 782             rb->lcd_puts(0, 3, print);
 783             rb->lcd_update();
 784         }
 785
 786         MYLCD(clear_display)();
 787         draw_image_rect(info, 0, 0,
 788                         info->width-info->x, info->height-info->y);
 789         MYLCD_UPDATE();
 790
 791 #ifdef USEGSLIB
 792         grey_show(true); /* switch on greyscale overlay */
 793 #endif
 794
 795         /* drawing is now finished, play around with scrolling
 796          * until you press OFF or connect USB
 797          */
 798         while (1)
 799         {
 800             status = scroll_bmp(info);
 801             if (status == ZOOM_IN)
 802             {
 803 #if UNSCALED_IS_AVAILABLE
 804                 if (ds > 1)
 805 #else
 806                 if (ds > ds_min)
 807 #endif
 808                 {
 809 #if UNSCALED_IS_AVAILABLE
 810                     /* if 1/1 is always available, jump ds from ds_min to 1. */
 811                     int zoom = (ds == ds_min)? ds_min: 2;
 812 #else
 813                     const int zoom = 2;
 814 #endif
 815                     ds /= zoom; /* reduce downscaling to zoom in */
 816                     get_view(info, &cx, &cy);
 817                     cx *= zoom; /* prepare the position in the new image */
 818                     cy *= zoom;
 819                 }
 820                 else
 821                     continue;
 822             }
 823
 824             if (status == ZOOM_OUT)
 825             {
 826                 if (ds < ds_max)
 827                 {
 828 #if UNSCALED_IS_AVAILABLE
 829                     /* if ds is 1 and ds_min is > 1, jump ds to ds_min. */
 830                     int zoom = (ds < ds_min)? ds_min: 2;
 831 #else
 832                     const int zoom = 2;
 833 #endif
 834                     ds *= zoom; /* increase downscaling to zoom out */
 835                     get_view(info, &cx, &cy);
 836                     cx /= zoom; /* prepare the position in the new image */
 837                     cy /= zoom;
 838                 }
 839                 else
 840                     continue;
 841             }
 842             break;
 843         }
 844
 845 #ifdef USEGSLIB
 846         grey_show(false); /* switch off overlay */
 847 #endif
 848         rb->lcd_clear_display();
 849     }
 850     while (status > PLUGIN_OTHER);
 851 #ifdef USEGSLIB
 852     rb->lcd_update();
 853 #endif
 854     return status;
 855 }
 856
 857 /******************** Plugin entry point *********************/
 858
 859 enum plugin_status plugin_start(const void* parameter)
 860 {
 861     int condition;
 862 #ifdef USEGSLIB
 863     long greysize; /* helper */
 864 #endif
 865
 866     if(!parameter) return PLUGIN_ERROR;
 867
 868 #ifdef USE_PLUG_BUF
 869     buf = rb->plugin_get_buffer(&buf_size);
 870 #else
 871     buf = rb->plugin_get_audio_buffer(&buf_size);
 872 #endif
 873
 874     rb->strcpy(np_file, parameter);
 875     get_pic_list();
 876
 877     if(!entries) return PLUGIN_ERROR;
 878
 879 #ifdef USE_PLUG_BUF
 880     if(!rb->audio_status())
 881     {
 882         plug_buf = false;
 883         buf = rb->plugin_get_audio_buffer(&buf_size);
 884     }
 885 #endif
 886
 887 #ifdef USEGSLIB
 888     if (!grey_init(buf, buf_size, GREY_ON_COP,
 889                    LCD_WIDTH, LCD_HEIGHT, &greysize))
 890     {
 891         rb->splash(HZ, "grey buf error");
 892         return PLUGIN_ERROR;
 893     }
 894     buf += greysize;
 895     buf_size -= greysize;
 896 #endif
 897
 898     /* should be ok to just load settings since the plugin itself has
 899        just been loaded from disk and the drive should be spinning */
 900     configfile_load(IMGVIEW_CONFIGFILE, config,
 901                     ARRAYLEN(config), IMGVIEW_SETTINGS_MINVERSION);
 902     rb->memcpy(&old_settings, &settings, sizeof (settings));
 903
 904     /* Turn off backlight timeout */
 905     backlight_force_on(); /* backlight control in lib/helper.c */
 906
 907 #if LCD_DEPTH > 1
 908     rb->lcd_set_backdrop(NULL);
 909     rb->lcd_set_foreground(LCD_WHITE);
 910     rb->lcd_set_background(LCD_BLACK);
 911 #endif
 912
 913     do
 914     {
 915         condition = load_and_show(np_file, &image_info);
 916     } while (condition >= PLUGIN_OTHER);
 917
 918     if (rb->memcmp(&settings, &old_settings, sizeof (settings)))
 919     {
 920         /* Just in case drive has to spin, keep it from looking locked */
 921         rb->splash(0, "Saving Settings");
 922         configfile_save(IMGVIEW_CONFIGFILE, config,
 923                         ARRAYLEN(config), IMGVIEW_SETTINGS_VERSION);
 924     }
 925
 926 #ifdef DISK_SPINDOWN
 927     /* set back ata spindown time in case we changed it */
 928     rb->storage_spindown(rb->global_settings->disk_spindown);
 929 #endif
 930
 931     /* Turn on backlight timeout (revert to settings) */
 932     backlight_use_settings(); /* backlight control in lib/helper.c */
 933
 934 #ifdef USEGSLIB
 935     grey_release(); /* deinitialize */
 936 #endif
 937
 938     return condition;
 939 }