uisimulator/x11/lcd-x11.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Daniel Stenberg <daniel@haxx.se>
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdarg.h>
  23 #include <stdlib.h>
  24 #include <ctype.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28
  29 #include <errno.h>
  30 #include <ctype.h>
  31 #include <time.h>
  32
  33 #include "screenhack.h"
  34 #include "config.h"
  35 #include "debug.h"
  36
  37 /*
  38  * Specific implementations for X11, using the generic LCD API and data.
  39  */
  40
  41 #include "lcd-x11.h"
  42 #include "lcd-playersim.h"
  43
  44 #if LCD_DEPTH == 2
  45 #define YBLOCK 4
  46 #define ANDBIT 3 /* AND with this to get the color number */
  47 #else
  48 #define YBLOCK 8
  49 #define ANDBIT 1
  50 #endif
  51
  52 extern void screen_resized(int width, int height);
  53 extern bool lcd_display_redraw;
  54
  55 #ifdef HAVE_LCD_BITMAP
  56 #if LCD_DEPTH==16
  57 fb_data lcd_framebuffer_copy[LCD_HEIGHT][LCD_WIDTH*2];
  58 #else
  59 fb_data lcd_framebuffer_copy[LCD_HEIGHT/YBLOCK][LCD_WIDTH];
  60 #endif
  61
  62 void lcd_update (void)
  63 {
  64     /* update a full screen rect */
  65     lcd_update_rect(0, 0, LCD_WIDTH, LCD_HEIGHT);
  66 }
  67
  68 void lcd_update_rect(int x_start, int y_start,
  69                      int width, int height)
  70 {
  71     int x;
  72     int yline=y_start;
  73     int y;
  74     int p=0;
  75     int bit;
  76     int xmax;
  77     int ymax;
  78     int colors[LCD_WIDTH * LCD_HEIGHT];
  79     struct coordinate points[LCD_WIDTH * LCD_HEIGHT];
  80     unsigned force_mask = lcd_display_redraw ? 0xFF : 0;
  81
  82 #if 0
  83     fprintf(stderr, "%04d: lcd_update_rect(%d, %d, %d, %d)\n",
  84             counter++, x_start, y_start, width, height);
  85 #endif
  86     /* The Y coordinates have to work on even YBLOCK pixel rows */
  87     ymax = (yline + height)/YBLOCK;
  88     yline /= YBLOCK;
  89
  90     xmax = x_start + width;
  91
  92     if(xmax > LCD_WIDTH)
  93         xmax = LCD_WIDTH;
  94     if(ymax >= LCD_HEIGHT/YBLOCK)
  95         ymax = LCD_HEIGHT/YBLOCK-1;
  96
  97     for(; yline <= ymax; yline++) {
  98         y = yline * YBLOCK;
  99         for(x = x_start; x < xmax; x++) {
 100             unsigned char diff = (lcd_framebuffer[yline][x]
 101                                   ^ lcd_framebuffer_copy[yline][x])
 102                                  | force_mask;
 103             if(diff) {
 104                 /* one or more bits/pixels are changed */
 105                 unsigned char mask = ANDBIT;
 106                 for(bit = 0; bit < YBLOCK; bit++) {
 107                     if(diff & mask) {
 108                         /* pixel has changed */
 109                         unsigned int col = lcd_framebuffer[yline][x] & mask;
 110 #if LCD_DEPTH == 2
 111                         colors[p] = col >> (bit * LCD_DEPTH);
 112 #else
 113                         colors[p] = col ? 3 : 0;
 114 #endif
 115                         points[p].x = x + MARGIN_X;
 116                         points[p].y = y + bit + MARGIN_Y;
 117                         p++; /* increase the point counter */
 118                     }
 119                     mask <<= LCD_DEPTH;
 120                 }
 121
 122                 /* update the copy */
 123                 lcd_framebuffer_copy[yline][x] = lcd_framebuffer[yline][x];
 124             }
 125         }
 126     }
 127
 128     dots(colors, &points[0], p);
 129     /* printf("lcd_update_rect: Draws %d pixels, clears %d pixels\n", p, cp);*/
 130     XtAppLock(app);
 131     XSync(dpy,False);
 132     XtAppUnlock(app);
 133     lcd_display_redraw=false;
 134 }
 135
 136 #ifdef LCD_REMOTE_HEIGHT
 137 extern unsigned char lcd_remote_framebuffer[LCD_REMOTE_HEIGHT/8][LCD_REMOTE_WIDTH];
 138 unsigned char lcd_remote_framebuffer_copy[LCD_REMOTE_HEIGHT/8][LCD_REMOTE_WIDTH];
 139
 140 #define REMOTE_START_Y (LCD_HEIGHT + 2*MARGIN_Y)
 141
 142 void lcd_remote_update (void)
 143 {
 144     lcd_remote_update_rect(0, 0, LCD_REMOTE_WIDTH, LCD_REMOTE_HEIGHT);
 145 }
 146
 147 void lcd_remote_update_rect(int x_start, int y_start,
 148                             int width, int height)
 149 {
 150     int x;
 151     int yline=y_start;
 152     int y;
 153     int p=0;
 154     int bit;
 155     int xmax;
 156     int ymax;
 157     struct coordinate points[LCD_REMOTE_WIDTH * LCD_REMOTE_HEIGHT];
 158     int colors[LCD_REMOTE_WIDTH * LCD_REMOTE_HEIGHT];
 159     unsigned force_mask = lcd_display_redraw ? 0xFF : 0;
 160
 161 #if 0
 162     fprintf(stderr, "%04d: lcd_update_rect(%d, %d, %d, %d)\n",
 163             counter++, x_start, y_start, width, height);
 164 #endif
 165     /* The Y coordinates have to work on even 8 pixel rows */
 166     ymax = (yline + height)/8;
 167     yline /= 8;
 168
 169     xmax = x_start + width;
 170
 171     if(xmax > LCD_REMOTE_WIDTH)
 172         xmax = LCD_REMOTE_WIDTH;
 173     if(ymax >= LCD_REMOTE_HEIGHT/8)
 174         ymax = LCD_REMOTE_HEIGHT/8-1;
 175
 176     for(; yline <= ymax; yline++) {
 177         y = yline * 8;
 178         for(x = x_start; x < xmax; x++) {
 179             unsigned char diff = (lcd_remote_framebuffer[yline][x]
 180                                   ^ lcd_remote_framebuffer_copy[yline][x])
 181                                  | force_mask;
 182             if(diff) {
 183                 unsigned char mask = 1;
 184                 for(bit = 0; bit < 8; bit++) {
 185                     if(diff & mask) {
 186                         unsigned int col = lcd_remote_framebuffer[yline][x] & mask;
 187                         colors[p] = col ? 3 : 0;
 188                         points[p].x = x + MARGIN_X;
 189                         points[p].y = y + bit + (REMOTE_START_Y + MARGIN_Y);
 190                         p++; /* increase the point counter */
 191                     }
 192                     mask <<= 1;
 193                 }
 194
 195                 /* update the copy */
 196                 lcd_remote_framebuffer_copy[yline][x] =
 197                     lcd_remote_framebuffer[yline][x];
 198             }
 199         }
 200     }
 201
 202     dots(colors, &points[0], p);
 203     /* printf("lcd_update_rect: Draws %d pixels, clears %d pixels\n", p, cp);*/
 204     XtAppLock(app);
 205     XSync(dpy,False);
 206     XtAppUnlock(app);
 207     lcd_display_redraw=false;
 208 }
 209
 210
 211 #endif
 212
 213 #endif
 214 #ifdef HAVE_LCD_CHARCELLS
 215
 216 /* Defined in lcd-playersim.c */
 217 extern void lcd_print_char(int x, int y);
 218 extern unsigned char lcd_buffer[2][11];
 219 extern void drawrect(int color, int x1, int y1, int x2, int y2);
 220
 221 extern unsigned char hardware_buffer_lcd[11][2];
 222 static unsigned char lcd_buffer_copy[11][2];
 223
 224 void lcd_update (void)
 225 {
 226     bool changed=false;
 227     int x, y;
 228     for (y=0; y<2; y++) {
 229         for (x=0; x<11; x++) {
 230             if (lcd_display_redraw ||
 231                 lcd_buffer_copy[x][y] != hardware_buffer_lcd[x][y]) {
 232                 lcd_buffer_copy[x][y] = hardware_buffer_lcd[x][y];
 233                 lcd_print_char(x, y);
 234                 changed=true;
 235             }
 236         }
 237     }
 238     if (changed)
 239     {
 240         XtAppLock(app);
 241         XSync(dpy,False);
 242         XtAppUnlock(app);
 243     }
 244     lcd_display_redraw=false;
 245 }
 246
 247 #endif
 248
 249 #ifdef CONFIG_BACKLIGHT
 250 void sim_backlight(int value)
 251 {
 252     DEBUGF("backlight: %s\n", (value > 0) ? "on" : "off");
 253 }
 254 #endif
 255
 256 #ifdef HAVE_REMOTE_LCD
 257 void sim_remote_backlight(int value)
 258 {
 259     DEBUGF("remote backlight: %s\n", (value > 0) ? "on" : "off");
 260 }
 261 #endif
 262