URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [devs/] [framebuf/] [synth/] [current/] [host/] [framebuf.c] - Rev 810
Go to most recent revision | Compare with Previous | Blame | View Log
//============================================================================ // // framebuf.c // // A utility program to perform low-level ethernet operations // //============================================================================ // ####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 2008 Free Software Foundation, Inc. // // eCos is free software; you can redistribute it and/or modify it under // the terms of the GNU General Public License as published by the Free // Software Foundation; either version 2 or (at your option) any later // version. // // eCos is distributed in the hope that it will be useful, but WITHOUT // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License // along with eCos; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // As a special exception, if other files instantiate templates or use // macros or inline functions from this file, or you compile this file // and link it with other works to produce a work based on this file, // this file does not by itself cause the resulting work to be covered by // the GNU General Public License. However the source code for this file // must still be made available in accordance with section (3) of the GNU // General Public License v2. // // This exception does not invalidate any other reasons why a work based // on this file might be covered by the GNU General Public License. // ------------------------------------------- // ####ECOSGPLCOPYRIGHTEND#### //============================================================================ //#####DESCRIPTIONBEGIN#### // // Author(s): bartv // Contact(s): bartv // Date: 2005/10/28 // Version: 0.01 // Description: // Implementation of a framebuffer device. This script should only ever // be run from inside the ecosynth auxiliary. // // This program is fork'ed by the framebuf.tcl script running inside // the synthetic target auxiliary. It is responsible for performing the // low-level framebuffer accesses. // //####DESCRIPTIONEND#### //============================================================================ // We want to instantiate multiple conversion routines for the different // graphics formats, with extensive use of macros for efficiences. Multiple // C #include's are used for this. #ifndef RENDERFN # include <stdio.h> # include <stdarg.h> # include <stdlib.h> # include <string.h> # include <time.h> # include <signal.h> # include <limits.h> # include <unistd.h> # include <fcntl.h> # include <errno.h> # include <sys/param.h> # include <sys/types.h> # include <sys/stat.h> # include <sys/socket.h> # include <sys/ioctl.h> # include <sys/mman.h> # include <X11/Xlib.h> // The protocol between host and target is defined by a private // target-side header. # include "../src/protocol.h" // ---------------------------------------------------------------------------- // Globals // First the variables needed for X operations. The window is created by // Tcl/Tk code and its id is supplied as an argument. static Display* host_display; static Window host_win = 0; static GC host_gc; static XImage* host_image; // R, G & B shifts for the host-side. Used for palette conversion. static int host_r_shift; static int host_g_shift; static int host_b_shift; // The image data. Only 32bpp is supported. // NOTE: this is not 64-bit clean. static unsigned int* img_fb; // This is used for display depths up to and including 16bpp - // 256K of static data is irrelevant for a Linux host-side app. // 32bpp will have to be handled differently. static unsigned int host_palette[65536]; // The current function for rendering target-side data static void (*render_fn)(int, int, int, int); // And palette init and update functions. static void (*palette_init_fn)(void); static void (*palette_update_fn)(void); // Positions. With target-side viewports, magnification, and the // possibility of windows being resized, this can // get very messy. // // The target-side framebuffer consists of n pages, each of // width*height pixels, plus possibly padding at the end of each // scanline. // // img_fb consists of viewport_width*viewport_height pixels. // At magnification 1 each pixel is a 32-bit unsigned int, but // at higher magnification each pixel takes up mag^2 unsigned // ints. // // win_width and win_height determine the current window dimensions in // target pixel units, i.e. ignoring magnification. x_win_width // and x_win_height are the same dimensions in X pixels, so // mag*win_width. These dimensions are provided by X configure events. // They may be smaller, the same size, or larger than the viewport. // // A coordinate (target_x,target_y) within the current page // corresponds to (target_x - viewport_x, target_y - viewport_y). // within host_image and within the window. // // For an X expose event we get X windows coordinates. // The actually visible window dimensions. If the Tk window gets // resized then only part of the image data may be visible. These // variables change in response to X configure events. static int win_width; static int win_height; static int x_win_width; static int x_win_height; // Target-side framebuffer. // // The synth_fb_data structure at the start of the shared memory region. static synth_fb_data* shared_fb_data; // The target-side framebuffer starts at shared_fb_data->framebuf[0]. // However that is not necessarily where the visible data starts // because of page flipping and viewport support. This always points // at the top-left corner of visible data. static void* target_fb; // Parameters supplied by the target. static int target_id; static int target_depth; static int target_le; static int target_width; static int target_height; static int target_viewport_width; static int target_viewport_height; static int target_stride; static int target_number_pages; static char* target_format; // Parameters supplied by a host-side configuration file static int config_magnification; // Communication between host and target happens partially through the // shared memory region and partially through a fifo, the latter // allowing for select(). shared_fb_data already points at the shared // memory region. static char shm_name[L_tmpnam]; static int shm_created; static int shm_fd; static char fifo_t2h_name[L_tmpnam]; static int fifo_t2h_created; static int fifo_t2h_fd; static char fifo_h2t_name[L_tmpnam]; static int fifo_h2t_created; static int fifo_h2t_fd; // An atexit() handler for cleaning up the fifos and shared memory. static void atexit_handler(void) { if (shm_created) { unlink(shm_name); } if (fifo_t2h_created) { unlink(fifo_t2h_name); } if (fifo_h2t_created) { unlink(fifo_h2t_name); } } // ---------------------------------------------------------------------------- // Diagnostics. Warnings and errors are sent up to the I/O auxiliary for // display there. Debug output goes straight to stderr // Set the DEBUG_LEVEL to 0 for no debugging, 3 for maximum debugging. #define DEBUG_LEVEL 0 #define DEBUG(_level_, _str_, ...) \ if (_level_ <= DEBUG_LEVEL) { \ fprintf(stderr, "%d: " _str_, target_id, ## __VA_ARGS__); \ } #if 0 static void warn(char* fmt, ...) { char buf[512]; va_list args; va_start(args, fmt); sprintf(buf, "Warning (fb%d) : ", target_id); vsnprintf(buf + strlen(buf), 512 - strlen(buf), fmt, args); buf[511] = '\0'; (void) write(1, buf, strlen(buf)); } #endif static void error(char* fmt, ...) { char buf[512]; va_list args; va_start(args, fmt); sprintf(buf, "Error (fb%d) : ", target_id); vsnprintf(buf + strlen(buf), 512 - strlen(buf), fmt, args); buf[511] = '\0'; (void) write(1, buf, strlen(buf)); exit(1); } // ---------------------------------------------------------------------------- // Host-side. // // The main redraw routines. schedule_redraw() can get called as a result of: // // 1) an X expose event. // 2) a message from the Tk code affecting the on/off setting of // the framebuffer. // 3) a message from the target-side code indicating some of the // target-side data has changed, or some other event such as // viewport repositioning or page flipping. // // It just maintains a bounding box. do_redraw() does the real work and // is called from inside the main loop. static int redraw_pending = 0; static int x_redraw_x, x_redraw_y, x_redraw_width, x_redraw_height; static void do_redraw(void) { while (redraw_pending) { redraw_pending = 0; DEBUG(3, "do_redraw: win_x %d, win_y %d, width %d, height %d\n", x_redraw_x, x_redraw_y, x_redraw_width, x_redraw_height); XPutImage(host_display, host_win, host_gc, host_image, x_redraw_x, x_redraw_y, x_redraw_x, x_redraw_y, x_redraw_width, x_redraw_height); XFlush(host_display); } } static void schedule_redraw(int x_new_x, int x_new_y, int x_new_width, int x_new_height) { if (! redraw_pending) { redraw_pending = 1; x_redraw_x = x_new_x; x_redraw_y = x_new_y; x_redraw_width = x_new_width; x_redraw_height = x_new_height; } else { if (x_redraw_x > x_new_x) { x_redraw_x = x_new_x; } else { x_new_width += (x_new_x - x_redraw_x); } if (x_redraw_y > x_new_y) { x_redraw_y = x_new_y; } else { x_new_height += (x_new_y - x_redraw_y); } if (x_new_width > x_redraw_width) { x_redraw_width = x_new_width; } if (x_new_height > x_redraw_height) { x_redraw_height = x_new_height; } } } // ---------------------------------------------------------------------------- // Utility for blanking the screen static void blackout(void) { memset(img_fb, 0, target_viewport_width * target_viewport_height * sizeof(int) * config_magnification * config_magnification); if (0 != host_win) { schedule_redraw(0, 0, x_win_width, x_win_height); } } // ---------------------------------------------------------------------------- // This function gets called when the main select() indicates the // X server is trying to send some data. static void handle_X_event(void) { XEvent event; XNextEvent(host_display, &event); switch(event.type) { case Expose: { // In theory this code should be able to do partial redraws for every // expose event, but that does not seem to work reliably. Instead do a // full redraw, but only for the final event in a sequence. if (0 == event.xexpose.count) { DEBUG(3, "X expose event, x %d, y %d, width %d, height %d\n", event.xexpose.x, event.xexpose.y, event.xexpose.width, event.xexpose.height); schedule_redraw(0, 0, x_win_width, x_win_height); } break; } case ConfigureNotify: { DEBUG(2, "X configure notify event, width %d, height %d\n", event.xconfigure.width, event.xconfigure.height); x_win_width = event.xconfigure.width; x_win_height = event.xconfigure.height; win_width = (x_win_width + config_magnification - 1) / config_magnification; win_height = (x_win_height + config_magnification - 1) / config_magnification; if (shared_fb_data->display_on && shared_fb_data->blank_on) { (*render_fn)(0 + shared_fb_data->viewport_x, 0 + shared_fb_data->viewport_y, win_width, win_height); } else { blackout(); } break; } } } // ---------------------------------------------------------------------------- // Conversion routines // This dummy function is installed to handle draw requests before the // window is mapped - until that time the exact render function is unknown. static void dummy_render_fn(int target_x, int target_y, int width, int height) { DEBUG(2, "rendering: target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); DEBUG(2, " : window has not been mapped on to the display yet\n"); } #else // RENDERFN // These functions get instantiated N times for the N different // graphics formats. We need to take the target-side region defined by // x/y/width/height, render it into the image data, and then redraw // the relevant part of the image data. There is no point rendering more // data than is visible. static void RENDERFN(1, TARGET_FORMAT)(int target_x, int target_y, int width, int height) { int x, y; int win_x, win_y; unsigned int* img_data; unsigned int colour; TARGET_DATA; DEBUG(2, "rendering: target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); if ((0 == host_win) || !shared_fb_data->display_on || !shared_fb_data->blank_on) { DEBUG(2, " : no-op, host_win %d, display_on %d, blank_on %d\n", (int)host_win, shared_fb_data->display_on, shared_fb_data->blank_on); return; } DEBUG(2, " : current viewport x %d, y %d\n", shared_fb_data->viewport_x, shared_fb_data->viewport_y); win_x = target_x - shared_fb_data->viewport_x; win_y = target_y - shared_fb_data->viewport_y; if (win_x < 0) { width += win_x; win_x = 0; } if (win_y < 0) { height += win_y; win_y = 0; } if ((win_x + width) > win_width) { width = win_width - win_x; } if ((win_y + height) > win_height) { height = win_height - win_y; } DEBUG(2, " : after clipping, win_x %d, win_y %d, width %d, height %d\n", win_x, win_y, width, height); if ((width < 0) || (height < 0)) { return; } img_data = img_fb + (win_y * target_viewport_width) + win_x; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { colour = TARGET_NEXT_COLOUR(); *img_data++ = colour; } img_data += (target_viewport_width - width); TARGET_NEXT_LINE(); } schedule_redraw(win_x, win_y, width, height); } static void RENDERFN(2, TARGET_FORMAT)(int target_x, int target_y, int width, int height) { int x, y; int win_x, win_y; unsigned int* img_data0; unsigned int* img_data1; unsigned int colour; TARGET_DATA; DEBUG(2, "rendering: target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); if ((0 == host_win) || !shared_fb_data->display_on || !shared_fb_data->blank_on) { DEBUG(2, " : no-op, host_win %d, display_on %d, blank_on %d\n", (int)host_win, shared_fb_data->display_on, shared_fb_data->blank_on); return; } DEBUG(2, " : current viewport x %d, y %d\n", shared_fb_data->viewport_x, shared_fb_data->viewport_y); win_x = target_x - shared_fb_data->viewport_x; win_y = target_y - shared_fb_data->viewport_y; if (win_x < 0) { width += win_x; win_x = 0; } if (win_y < 0) { height += win_y; win_y = 0; } if ((win_x + width) > win_width) { width = win_width - win_x; } if ((win_y + height) > win_height) { height = win_height - win_y; } DEBUG(2, " : after clipping, target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); if ((width < 0) || (height < 0)) { return; } for (y = 0; y < height; y++) { img_data0 = img_fb + (2 * (win_y + y) * (2 * target_viewport_width)) + (2 * win_x); img_data1 = img_data0 + (2 * target_viewport_width); for (x = 0; x < width; x++) { colour = TARGET_NEXT_COLOUR(); *img_data0++ = colour; *img_data0++ = colour; *img_data1++ = colour; *img_data1++ = colour; } TARGET_NEXT_LINE(); } schedule_redraw(2 * win_x, 2 * win_y, 2 * width, 2 * height); } static void RENDERFN(3, TARGET_FORMAT)(int target_x, int target_y, int width, int height) { int x, y; int win_x, win_y; unsigned int* img_data0; unsigned int* img_data1; unsigned int* img_data2; unsigned int colour; TARGET_DATA; DEBUG(2, "rendering: target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); if ((0 == host_win) || !shared_fb_data->display_on || !shared_fb_data->blank_on) { DEBUG(2, " : no-op, host_win %d, display_on %d, blank_on %d\n", (int)host_win, shared_fb_data->display_on, shared_fb_data->blank_on); return; } DEBUG(2, " : current viewport x %d, y %d\n", shared_fb_data->viewport_x, shared_fb_data->viewport_y); win_x = target_x - shared_fb_data->viewport_x; win_y = target_y - shared_fb_data->viewport_y; if (win_x < 0) { width += win_x; win_x = 0; } if (win_y < 0) { height += win_y; win_y = 0; } if ((win_x + width) > win_width) { width = win_width - win_x; } if ((win_y + height) > win_height) { height = win_height - win_y; } DEBUG(2, " : after clipping, target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); if ((width < 0) || (height < 0)) { return; } for (y = 0; y < height; y++) { img_data0 = img_fb + (3 * (win_y + y) * (3 * target_viewport_width)) + (3 * win_x); img_data1 = img_data0 + (3 * target_viewport_width); img_data2 = img_data1 + (3 * target_viewport_width); for (x = 0; x < width; x++) { colour = TARGET_NEXT_COLOUR(); *img_data0++ = colour; *img_data0++ = colour; *img_data0++ = colour; *img_data1++ = colour; *img_data1++ = colour; *img_data1++ = colour; *img_data2++ = colour; *img_data2++ = colour; *img_data2++ = colour; } TARGET_NEXT_LINE(); } schedule_redraw(3 * win_x, 3 * win_y, 3 * width, 3 * height); } static void RENDERFN(4, TARGET_FORMAT)(int target_x, int target_y, int width, int height) { int x, y; int win_x, win_y; unsigned int* img_data0; unsigned int* img_data1; unsigned int* img_data2; unsigned int* img_data3; unsigned int colour; TARGET_DATA; DEBUG(2, "rendering: target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); if ((0 == host_win) || !shared_fb_data->display_on || !shared_fb_data->blank_on) { DEBUG(2, " : no-op, host_win %d, display_on %d, blank_on %d\n", (int)host_win, shared_fb_data->display_on, shared_fb_data->blank_on); return; } DEBUG(2, " : current viewport x %d, y %d\n", shared_fb_data->viewport_x, shared_fb_data->viewport_y); win_x = target_x - shared_fb_data->viewport_x; win_y = target_y - shared_fb_data->viewport_y; if (win_x < 0) { width += win_x; win_x = 0; } if (win_y < 0) { height += win_y; win_y = 0; } if ((win_x + width) > win_width) { width = win_width - win_x; } if ((win_y + height) > win_height) { height = win_height - win_y; } DEBUG(2, " : after clipping, target_x %d, target_y %d, width %d, height %d\n", target_x, target_y, width, height); if ((width < 0) || (height < 0)) { return; } for (y = 0; y < height; y++) { img_data0 = img_fb + (4 * (win_y + y) * (4 * target_viewport_width)) + (4 * win_x); img_data1 = img_data0 + (4 * target_viewport_width); img_data2 = img_data1 + (4 * target_viewport_width); img_data3 = img_data2 + (4 * target_viewport_width); for (x = 0; x < width; x++) { colour = TARGET_NEXT_COLOUR(); *img_data0++ = colour; *img_data0++ = colour; *img_data0++ = colour; *img_data0++ = colour; *img_data1++ = colour; *img_data1++ = colour; *img_data1++ = colour; *img_data1++ = colour; *img_data2++ = colour; *img_data2++ = colour; *img_data2++ = colour; *img_data2++ = colour; *img_data3++ = colour; *img_data3++ = colour; *img_data3++ = colour; *img_data3++ = colour; } TARGET_NEXT_LINE(); } schedule_redraw(4 * win_x, 4 * win_y, 4 * width, 4 * height); } #endif #ifndef RENDERFN # define RENDERFN_AUX(_magnification_, _format_) render_ ## _magnification_ ## _ ## _format_ # define RENDERFN(_magnification_, _format_) RENDERFN_AUX(_magnification_, _format_) // ---------------------------------------------------------------------------- // 1bpp, BE. It is convenient to always render in byte-multiples # define TARGET_FORMAT 1BPP_BE # define TARGET_DATA \ unsigned char* target_fb_current; \ unsigned int mask; \ width += target_x & 0x07; \ target_x &= ~0x07; \ width = (width + 7) & ~0x07; \ target_fb_current = ((unsigned char*)target_fb) + \ (target_y * target_stride) + (target_x >> 3); \ mask = 0x0080 # define TARGET_NEXT_COLOUR() \ ({ \ unsigned int next_colour; \ next_colour = host_palette[*target_fb_current & mask]; \ mask >>= 1; \ if (0 == mask) { \ target_fb_current += 1; \ mask = 0x0080; \ } \ next_colour; \ }) # define TARGET_NEXT_LINE() \ target_fb_current += target_stride - (width >> 3) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 1bpp, LE # define TARGET_FORMAT 1BPP_LE # define TARGET_DATA \ unsigned char* target_fb_current; \ unsigned int mask; \ width += target_x & 0x07; \ target_x &= ~0x07; \ width = (width + 7) & ~0x07; \ target_fb_current = ((unsigned char*)target_fb) + \ (target_y * target_stride) + (target_x >> 3); \ mask = 0x0001 # define TARGET_NEXT_COLOUR() \ ({ \ unsigned int next_colour; \ next_colour = host_palette[*target_fb_current & mask]; \ mask <<= 1; \ if (0x0100 == mask) { \ target_fb_current += 1; \ mask = 0x0001; \ } \ next_colour; \ }) # define TARGET_NEXT_LINE() \ target_fb_current += target_stride - (width >> 3) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 2bpp, BE # define TARGET_FORMAT 2BPP_BE # define TARGET_DATA \ unsigned char* target_fb_current; \ unsigned int mask; \ width += target_x & 0x03; \ target_x &= ~0x03; \ width = (width + 3) & ~0x03; \ target_fb_current = ((unsigned char*)target_fb) + \ (target_y * target_stride) + (target_x >> 2); \ mask = 0x00C0 # define TARGET_NEXT_COLOUR() \ ({ \ unsigned int next_colour; \ next_colour = host_palette[*target_fb_current & mask]; \ mask >>= 2; \ if (0x00 == mask) { \ target_fb_current += 1; \ mask = 0x00C0; \ } \ next_colour; \ }) # define TARGET_NEXT_LINE() \ target_fb_current += target_stride - (width >> 2) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 2bpp, LE # define TARGET_FORMAT 2BPP_LE # define TARGET_DATA \ unsigned char* target_fb_current; \ unsigned int mask; \ width += target_x & 0x03; \ target_x &= ~0x03; \ width = (width + 3) & ~0x03; \ target_fb_current = ((unsigned char*)target_fb) + \ (target_y * target_stride) + (target_x >> 2); \ mask = 0x0003 # define TARGET_NEXT_COLOUR() \ ({ \ unsigned int next_colour; \ next_colour = host_palette[*target_fb_current & mask]; \ mask <<= 2; \ if (0x0300 == mask) { \ target_fb_current += 1; \ mask = 0x0003; \ } \ next_colour; \ }) # define TARGET_NEXT_LINE() \ target_fb_current += target_stride - (width >> 2) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 4bpp, BE # define TARGET_FORMAT 4BPP_BE # define TARGET_DATA \ unsigned char* target_fb_current; \ unsigned int mask; \ width += target_x & 0x01; \ target_x &= ~0x01; \ width = (width + 1) & ~0x01; \ target_fb_current = ((unsigned char*)target_fb) + \ (target_y * target_stride) + (target_x >> 1); \ mask = 0x00F0 # define TARGET_NEXT_COLOUR() \ ({ \ unsigned int next_colour; \ next_colour = host_palette[*target_fb_current & mask]; \ mask >>= 4; \ if (0 == mask) { \ target_fb_current += 1; \ mask = 0x00F0; \ } \ next_colour; \ }) # define TARGET_NEXT_LINE() \ target_fb_current += target_stride - (width >> 1) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 4bpp, LE # define TARGET_FORMAT 4BPP_LE # define TARGET_DATA \ unsigned char* target_fb_current; \ unsigned int mask; \ width += target_x & 0x01; \ target_x &= ~0x01; \ width = (width + 1) & ~0x01; \ target_fb_current = ((unsigned char*)target_fb) + \ (target_y * target_stride) + (target_x >> 1); \ mask = 0x000F # define TARGET_NEXT_COLOUR() \ ({ \ unsigned int next_colour; \ next_colour = host_palette[*target_fb_current & mask]; \ mask <<= 4; \ if (0x0F00 == mask) { \ target_fb_current += 1; \ mask = 0x000F; \ } \ next_colour; \ }) # define TARGET_NEXT_LINE() \ target_fb_current += target_stride - (width >> 2) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 8bpp, paletted or true colour. In the case of a true colour display the // host_palette array will have been filled in appropriately for 332 so // conversion to 32-bit true colour again just involves indirecting through // the palette, rather than the more expensive bit masking and shifting. # define TARGET_FORMAT 8BPP # define TARGET_DATA \ unsigned char* target_fb_current; \ target_fb_current = ((unsigned char*)target_fb) + \ (target_y * target_stride) + target_x # define TARGET_NEXT_COLOUR() host_palette[*target_fb_current++] # define TARGET_NEXT_LINE() \ target_fb_current += (target_stride - width) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 16bpp. Again this is handled via the host_palette array, suitably // initialized for either 555 or 565 # define TARGET_FORMAT 16BPP # define TARGET_DATA \ unsigned short* target_fb_current; \ target_fb_current = ((unsigned short*)target_fb) + \ (target_y * (target_stride >> 1)) + target_x # define TARGET_NEXT_COLOUR() host_palette[*target_fb_current++] # define TARGET_NEXT_LINE() \ target_fb_current += ((target_stride >> 1) - width) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 32bpp, 0888, no swapping # define TARGET_FORMAT 32BPP # define TARGET_DATA \ unsigned int* target_fb_current; \ target_fb_current = ((unsigned int*)target_fb) + \ (target_y * (target_stride >> 2)) + target_x # define TARGET_NEXT_COLOUR() *target_fb_current++ & 0x00FFFFFF # define TARGET_NEXT_LINE() \ target_fb_current += ((target_stride >> 2) - width) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // 32bpp, 0888, but the host uses 8880. # define TARGET_FORMAT 32BPP_SWAPPED # define TARGET_DATA \ unsigned int* target_fb_current; \ target_fb_current = ((unsigned int*)target_fb) + \ (target_y * (target_stride >> 2)) + target_x # define TARGET_NEXT_COLOUR() \ ({ \ unsigned int _colour_ = *target_fb_current++; \ _colour_ = \ ((_colour_ & 0x000000FF) << 24) | \ ((_colour_ & 0x0000FF00) << 16) | \ ((_colour_ & 0x00FF0000) << 8); \ _colour_; \ }) # define TARGET_NEXT_LINE() \ target_fb_current += ((target_stride >> 2) - width) # include "framebuf.c" # undef TARGET_FORMAT # undef TARGET_DATA # undef TARGET_NEXT_COLOUR # undef TARGET_NEXT_LINE // ---------------------------------------------------------------------------- // Palette management. 8bpp and 16bpp true colour can be initialized // statically. 32bpp does not involve the host_palette array at all. // Other formats involve dynamic palette updating. static void palette_initialize_8bpp_332(void) { static const unsigned char expand2[4] = { 0x00, 0x55, 0xAA, 0xFF }; static const unsigned char expand3[8] = { 0x00, 0x20 + 4, 0x40 + 9, 0x60 + 13, 0x80 + 18, 0xA0 + 22, 0xC0 + 27, 0xE0 + 31 }; int i; for (i = 0; i < 256; i++) { int r = (i & 0x00E0) >> 5; int g = (i & 0x001C) >> 2; int b = (i & 0x0003) >> 0; host_palette[i] = (expand3[r] << host_r_shift) | (expand3[g] << host_g_shift) | (expand2[b] << host_b_shift); } } static void palette_initialize_16bpp_555(void) { static const unsigned char expand5[32] = { 0x00 + 0, 0x08 + 0, 0x10 + 0, 0x18 + 0, 0x20 + 1, 0x28 + 1, 0x30 + 1, 0x38 + 1, 0x40 + 2, 0x48 + 2, 0x50 + 2, 0x58 + 2, 0x60 + 3, 0x68 + 3, 0x70 + 3, 0x78 + 3, 0x80 + 4, 0x88 + 4, 0x90 + 4, 0x98 + 4, 0xA0 + 5, 0xA8 + 5, 0xB0 + 5, 0xB8 + 5, 0xC0 + 6, 0xC8 + 6, 0xD0 + 6, 0xD8 + 6, 0xE0 + 7, 0xE8 + 7, 0xF0 + 7, 0xF8 + 7, }; int i; for (i = 0; i < 65536; i++) { int r = (i & 0x00007C00) >> 10; int g = (i & 0x000003E0) >> 5; int b = (i & 0x0000001F) >> 0; host_palette[i] = (expand5[r] << host_r_shift) | (expand5[g] << host_g_shift) | (expand5[b] << host_b_shift); } } static void palette_initialize_16bpp_565(void) { static const unsigned char expand5[32] = { 0x00 + 0, 0x08 + 0, 0x10 + 0, 0x18 + 0, 0x20 + 1, 0x28 + 1, 0x30 + 1, 0x38 + 1, 0x40 + 2, 0x48 + 2, 0x50 + 2, 0x58 + 2, 0x60 + 3, 0x68 + 3, 0x70 + 3, 0x78 + 3, 0x80 + 4, 0x88 + 4, 0x90 + 4, 0x98 + 4, 0xA0 + 5, 0xA8 + 5, 0xB0 + 5, 0xB8 + 5, 0xC0 + 6, 0xC8 + 6, 0xD0 + 6, 0xD8 + 6, 0xE0 + 7, 0xE8 + 7, 0xF0 + 7, 0xF8 + 7, }; static const unsigned char expand6[64] = { 0x00 + 0, 0x04 + 0, 0x08 + 0, 0x0C + 0, 0x10 + 0, 0x14 + 0, 0x18 + 0, 0x1C + 0, 0x20 + 0, 0x24 + 0, 0x28 + 0, 0x2C + 0, 0x30 + 0, 0x34 + 0, 0x38 + 0, 0x3C + 0, 0x40 + 1, 0x44 + 1, 0x48 + 1, 0x4C + 1, 0x50 + 1, 0x54 + 1, 0x58 + 1, 0x5C + 1, 0x60 + 1, 0x64 + 1, 0x68 + 1, 0x6C + 1, 0x70 + 1, 0x74 + 1, 0x78 + 1, 0x7C + 1, 0x80 + 2, 0x84 + 2, 0x88 + 2, 0x8C + 2, 0x90 + 2, 0x94 + 2, 0x98 + 2, 0x9C + 2, 0xA0 + 2, 0xA4 + 2, 0xA8 + 2, 0xAC + 2, 0xB0 + 2, 0xB4 + 2, 0xB8 + 2, 0xBC + 2, 0xC0 + 3, 0xC4 + 3, 0xC8 + 3, 0xCC + 3, 0xD0 + 3, 0xD4 + 3, 0xD8 + 3, 0xDC + 3, 0xE0 + 3, 0xE4 + 3, 0xE8 + 3, 0xEC + 3, 0xF0 + 3, 0xF4 + 3, 0xF8 + 3, 0xFC + 3, }; int i; for (i = 0; i < 65536; i++) { int r = (i & 0x0000F800) >> 11; int g = (i & 0x000007E0) >> 5; int b = (i & 0x0000001F) >> 0; host_palette[i] = (expand5[r] << host_r_shift) | (expand6[g] << host_g_shift) | (expand5[b] << host_b_shift); } } static void palette_update(void) { int i, j; unsigned char* target_palette; int r, g, b; target_palette = shared_fb_data->palette; for (i = 0; i < (0x01 << target_depth); i++) { r = *target_palette++; g = *target_palette++; b = *target_palette++; host_palette[i] = (r << host_r_shift) | (g << host_g_shift) | (b << host_b_shift); } // Make sure the palette is replicated throughout the first 256 // entries. That way when rendering <8bpp data we can just mask // the target-side bytes without having to shift. for (j = 0; i < 256; i++, j++) { host_palette[i] = host_palette[j]; } } // ---------------------------------------------------------------------------- // This array is used to map the various display formats etc. on to // render functions. static struct _render_details { char* rd_format; unsigned int rd_endianness_matters; unsigned int rd_le; void (*rd_palette_init)(void); void (*rd_palette_update)(void); void (*rd_render_fns[4])(int, int, int, int); } render_array[] = { // 32BPP must come first { "32BPP_TRUE_0888", 0, 0, NULL, NULL, { &render_1_32BPP, &render_2_32BPP, &render_3_32BPP, &render_4_32BPP } }, { "16BPP_TRUE_555", 0, 0, &palette_initialize_16bpp_555, NULL, { &render_1_16BPP, &render_2_16BPP, &render_3_16BPP, &render_4_16BPP } }, { "16BPP_TRUE_565", 0, 0, &palette_initialize_16bpp_565, NULL, { &render_1_16BPP, &render_2_16BPP, &render_3_16BPP, &render_4_16BPP } }, { "8BPP_TRUE_332", 0, 0, &palette_initialize_8bpp_332, NULL, { &render_1_8BPP, &render_2_8BPP, &render_3_8BPP, &render_4_8BPP } }, { "8BPP_PAL888", 0, 0, NULL, &palette_update, { &render_1_8BPP, &render_2_8BPP, &render_3_8BPP, &render_4_8BPP } }, { "4BPP_PAL888", 1, 1, NULL, &palette_update, { &render_1_4BPP_LE, &render_2_4BPP_LE, &render_3_4BPP_LE, &render_4_4BPP_LE } }, { "4BPP_PAL888", 1, 0, NULL, &palette_update, { &render_1_4BPP_BE, &render_2_4BPP_BE, &render_3_4BPP_BE, &render_4_4BPP_BE } }, { "2BPP_PAL888", 1, 1, NULL, &palette_update, { &render_1_2BPP_LE, &render_2_2BPP_LE, &render_3_2BPP_LE, &render_4_2BPP_LE } }, { "2BPP_PAL888", 1, 0, NULL, &palette_update, { &render_1_2BPP_BE, &render_2_2BPP_BE, &render_3_2BPP_BE, &render_4_2BPP_BE } }, { "1BPP_PAL888", 1, 1, NULL, &palette_update, { &render_1_1BPP_LE, &render_2_1BPP_LE, &render_3_1BPP_LE, &render_4_1BPP_LE } }, { "1BPP_PAL888", 1, 0, NULL, &palette_update, { &render_1_1BPP_BE, &render_2_1BPP_BE, &render_3_1BPP_BE, &render_4_1BPP_BE } }, { NULL } }; // ---------------------------------------------------------------------------- // Communication between host and target // // When the target wants to wake up the host it sends a single byte down // a fifo, typically after having filled in appropriate fields in the // shared memory region. static void handle_target_request(void) { unsigned char buf[1]; int result; result = read(fifo_t2h_fd, buf, 1); if (-1 == result) { if (EINTR == errno) { return; } error("unexpected error %d (%s) reading fifo command from target-side code", errno, strerror(errno)); } if (0 == result) { // The target-side must have exited. Do not follow suit yet. Instead // exit only when the I/O auxiliary exits. DEBUG(1, "eCos application has exited\n"); close(fifo_t2h_fd); fifo_t2h_fd = -1; return; } switch(buf[0]) { case SYNTH_FB_OK: { // The target has finished initializing. This may have // involved filling in the palette DEBUG(1, "target request SYNTH_FB_OK, eCos application has connected.\n"); if (palette_update_fn) { (*palette_update_fn)(); } break; } case SYNTH_FB_SYNC: { // The target has updated part of the display. DEBUG(2, "target request SYNC, x0 %d, y0 %d, x1 %d, y1 %d\n", shared_fb_data->sync_x0, shared_fb_data->sync_y0, shared_fb_data->sync_x1, shared_fb_data->sync_y1); (*render_fn)(shared_fb_data->sync_x0, shared_fb_data->sync_y0, (shared_fb_data->sync_x1 - shared_fb_data->sync_x0), (shared_fb_data->sync_y1 - shared_fb_data->sync_y0)); break; } case SYNTH_FB_WRITE_PALETTE: { // The target-side palette has been updated. Adjust the // host-side palette and then render the whole window with // the curent colours (unless blanked). DEBUG(1, "target request WRITE_PALETTE\n"); if (palette_update_fn) { (*palette_update_fn)(); } (*render_fn)(shared_fb_data->viewport_x, shared_fb_data->viewport_y, win_width, win_height); } case SYNTH_FB_BLANK: { DEBUG(1, "target request blank, display should be %s\n", shared_fb_data->blank_on ? "on" : "off"); if (shared_fb_data->blank_on) { (*render_fn)(shared_fb_data->viewport_x, shared_fb_data->viewport_y, win_width, win_height); } else { blackout(); } break; } case SYNTH_FB_VIEWPORT: { // Just rerender the whole display as per the new viewport position. DEBUG(1, "target request move viewport to x %d, y %d\n", shared_fb_data->viewport_x, shared_fb_data->viewport_y); (*render_fn)(shared_fb_data->viewport_x, shared_fb_data->viewport_y, win_width, win_height); break; } case SYNTH_FB_PAGE_FLIP: { int page_size = target_height * target_stride; DEBUG(1, "target request page flip to page %d\n", shared_fb_data->page_visible); target_fb = (void*)(((char*)&(shared_fb_data->framebuf[0])) + (page_size * shared_fb_data->page_visible)); (*render_fn)(shared_fb_data->viewport_x, shared_fb_data->viewport_y, win_width, win_height); break; } } // Send a single-byte response back to the target DEBUG(2, "target request handled\n"); buf[0] = SYNTH_FB_OK; do { result = write(fifo_h2t_fd, buf, 1); } while ((result < 0) && (errno == EINTR)); if (result < 0) { error("unexpected error %d (%s) writing fifo status to target-side code", errno, strerror(errno)); } } // ---------------------------------------------------------------------------- // Communication from the Tcl/Tk script static void handle_mapped(int winid) { Status result; XWindowAttributes attr; XGCValues gc_values; Visual* visual; int i; DEBUG(1, "X window %d has been mapped\n", winid); if (0 != (int)host_win) { error(" window has already been mapped.\n"); } host_win = (Window)winid; result = XGetWindowAttributes(host_display, host_win, &attr); if (0 == result) { error("failed to get window attributes."); } gc_values.graphics_exposures = False; host_gc = XCreateGC(host_display, host_win, GCGraphicsExposures, &gc_values); result = XSelectInput(host_display, host_win, ExposureMask | StructureNotifyMask); // The Tcl script has already checked that we are on a 24/32 bit display. // We need to know the colour shifts and possibly adjust the render array. visual = attr.visual; DEBUG(1, " red_mask 0x%08lx, green_mask 0x%08lx, blue_mask 0x%08lx\n", visual->red_mask, visual->green_mask, visual->blue_mask); if ((0x00FF0000 == visual->red_mask) && (0x0000FF00 == visual->green_mask) && (0x000000FF == visual->blue_mask)) { // 0888, nothing special needed host_r_shift = 16; host_g_shift = 8; host_b_shift = 0; } else if ((0x0000FF00 == visual->red_mask) && (0x00FF0000 == visual->green_mask) && (0xFF000000 == visual->blue_mask)) { // 8880 host_r_shift = 8; host_g_shift = 16; host_b_shift = 24; render_array[0].rd_render_fns[0] = &render_1_32BPP_SWAPPED; render_array[0].rd_render_fns[1] = &render_2_32BPP_SWAPPED; render_array[0].rd_render_fns[2] = &render_3_32BPP_SWAPPED; render_array[0].rd_render_fns[3] = &render_4_32BPP_SWAPPED; } // Time to figure out which render function etc. to use. render_fn = (void (*)(int, int, int, int)) NULL; for (i = 0; render_array[i].rd_format; i++) { if ((0 == strcmp(render_array[i].rd_format, target_format)) && (!render_array[i].rd_endianness_matters || (render_array[i].rd_le == target_le))) { render_fn = render_array[i].rd_render_fns[config_magnification - 1]; palette_init_fn = render_array[i].rd_palette_init; palette_update_fn = render_array[i].rd_palette_update; break; } } if (NULL == render_fn) { error("Target format not supported."); } // Now it is possible to create the XImage structure, the fifos, // and the shared memory region for interaction with the target. // The XImage needs to be large enough for the viewport. That may // be larger than the actually visible window, but the window may // get resized. host_image = XCreateImage(host_display, visual, 24, // image depth. 24 bits of colour info. ZPixmap, 0, // offset NULL, // data, filled in later target_viewport_width * config_magnification, target_viewport_height * config_magnification, 32, // bitmap_pad 0 // bytes_per_line, calculated by X ); if (NULL == host_image) { error("Failed to allocate XImage structure."); } host_image->data = (void*)img_fb; x_win_width = attr.width; x_win_height = attr.height; win_width = (x_win_width + config_magnification - 1) / config_magnification; win_height = (x_win_height + config_magnification - 1) / config_magnification; DEBUG(1, " mapped window, X width %d, X height %d, win width %d, win height %d, blank on %d, display on %d\n", x_win_width, x_win_height, win_width, win_height, shared_fb_data->blank_on, shared_fb_data->display_on); // The palette may get initialized locally or by the target, depending // on the mode. if (palette_init_fn) { (*palette_init_fn)(); } if (palette_update_fn) { (*palette_update_fn)(); } if (shared_fb_data->display_on && shared_fb_data->blank_on) { (*render_fn)(shared_fb_data->viewport_x, shared_fb_data->viewport_y, win_width, win_height); } else { // Just draw the initial blank screen. blackout(); } } static void handle_auxiliary_request(void) { synth_fb_auxiliary_request req; int result; result = read(0, &req, sizeof(synth_fb_auxiliary_request)); if (result <= 0) { // The I/O auxiliary has terminated, so assume the window has gone as well. exit(0); } DEBUG(2, "handle_auxiliary request %d\n", req.command); switch (req.command) { case SYNTH_FB_AUX_MAPPED: { handle_mapped(req.arg1); break; } case SYNTH_FB_AUX_ON: { // This is used when the target-side switches the display // off and back on, rather than just blanking it. Treat it // the same as blanking. DEBUG(1, "Target has switched the display on\n"); shared_fb_data->display_on = 1; (*render_fn)(shared_fb_data->viewport_x, shared_fb_data->viewport_y, win_width, win_height); break; } case SYNTH_FB_AUX_OFF: { DEBUG(1, "Target has switched the display off\n"); shared_fb_data->display_on = 0; blackout(); break; } case SYNTH_FB_AUX_REDRAW: { DEBUG(1, "Auxiliary has requested a redraw\n"); schedule_redraw(0, 0, x_win_width, x_win_height); } } DEBUG(2, "handle_auxiliary request done\n"); } // Report an error to ecosynth during initialization. This means a // single byte 0, followed by a string. static void report_init_error(char* msg) { write(1, "0", 1); write(1, msg, strlen(msg)); close(1); exit(0); } // ---------------------------------------------------------------------------- int main(int argc, char** argv) { int size; fd_set read_fds; int max_fd; atexit(&atexit_handler); signal(SIGPIPE, SIG_IGN); if (12 != argc) { report_init_error("Incorrect number of arguments."); } target_id = (int) strtoul(argv[1], NULL, 0); target_depth = (int) strtoul(argv[2], NULL, 0); target_le = (int) strtoul(argv[3], NULL, 0); target_width = (int) strtoul(argv[4], NULL, 0); target_height = (int) strtoul(argv[5], NULL, 0); target_viewport_width = (int) strtoul(argv[6], NULL, 0); target_viewport_height = (int) strtoul(argv[7], NULL, 0); target_stride = (int) strtoul(argv[8], NULL, 0); target_number_pages = (int) strtoul(argv[9], NULL, 0); target_format = argv[10]; config_magnification = (int) strtoul(argv[11], NULL, 0); if ((target_depth != 1) && (target_depth != 2) && (target_depth != 4) && (target_depth != 8) && (target_depth != 16) && (target_depth != 32)) { report_init_error("Invalid target depth."); } if ((target_width < 16) || (target_width > 4096)) { report_init_error("Invalid target width."); } if ((target_height < 16) || (target_height > 4096)) { report_init_error("Invalid target height."); } if ((target_viewport_width < 16) || (target_viewport_width > target_width)) { report_init_error("Invalid target viewport width."); } if ((target_viewport_height < 16) || (target_viewport_height > target_height)) { report_init_error("Invalid target viewport height."); } if ((target_number_pages < 1) || (target_number_pages > 4)) { report_init_error("Invalid target number of pages."); } if ((config_magnification < 1) || (config_magnification > 4)) { report_init_error("Invalid config magnification."); } host_display = XOpenDisplay(NULL); if (NULL == host_display) { report_init_error("Failed to open X display."); } img_fb = (unsigned int*) malloc(target_viewport_width * target_viewport_height * sizeof(int) * config_magnification * config_magnification); if (NULL == img_fb) { report_init_error("Failed to allocate XImage data."); } blackout(); // Use of tmpnam() is generally discouraged and generates a linker // warning, but only three temporary file names are needed and // there are no root privileges involved so security is not a big // issue. mkstemp() cannot easily be used with fifos. if (NULL == tmpnam(fifo_t2h_name)) { report_init_error("Failed to create unique file name for target->host fifo."); } if (0 != mkfifo(fifo_t2h_name, S_IRUSR | S_IWUSR)) { report_init_error("Failed to create target->host fifo."); } // Opening O_RDONLY or O_WRONLY will result in blocking until the // other end is open as well, which is not what is wanted here. // Instead we use the Linux feature of opening with O_RDWR which // gives non-blocking behaviour. fifo_t2h_created = 1; fifo_t2h_fd = open(fifo_t2h_name, O_RDWR); if (-1 == fifo_t2h_fd) { report_init_error("Failed to open target->host fifo."); } if (NULL == tmpnam(fifo_h2t_name)) { report_init_error("Failed to create unique file name for host->target fifo."); } if (0 != mkfifo(fifo_h2t_name, S_IRUSR | S_IWUSR)) { report_init_error("Failed to create host->target fifo."); } fifo_h2t_created = 1; fifo_h2t_fd = open(fifo_h2t_name, O_RDWR); if (-1 == fifo_h2t_fd) { report_init_error("Failed to open target->host fifo."); } size = sizeof(synth_fb_data) + (target_height * target_stride * target_number_pages); if (NULL == tmpnam(shm_name)) { report_init_error("Failed to create unique file name for shared memory."); } shm_fd = open(shm_name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR); if (shm_fd < 0) { report_init_error("Failed to open file for shared memory region."); } shm_created = 1; if (ftruncate(shm_fd, size) < 0) { report_init_error("Failed to set shared memory file size."); } shared_fb_data = (synth_fb_data*)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0); if (shared_fb_data == (synth_fb_data*)MAP_FAILED) { report_init_error("Failed to mmap shared memory file."); } target_fb = &(shared_fb_data->framebuf[0]); shared_fb_data->connected = 0; shared_fb_data->fifo_to_framebuf = -1; shared_fb_data->fifo_from_framebuf = -1; shared_fb_data->devid = target_id; shared_fb_data->sync_x0 = 0; shared_fb_data->sync_y0 = 0; shared_fb_data->sync_x1 = target_viewport_width; shared_fb_data->sync_y1 = target_viewport_height; shared_fb_data->display_on = 0; shared_fb_data->blank_on = 1; shared_fb_data->viewport_x = 0; shared_fb_data->viewport_y = 0; shared_fb_data->page_visible = 0; render_fn = &dummy_render_fn; msync(shared_fb_data, size, MS_SYNC); // Everything seems to be in order. Report back to the auxiliary. { char buf[513]; if ((strlen(shm_name) + strlen(fifo_t2h_name) + strlen(fifo_h2t_name) + 3) > 512) { report_init_error("Temporary path names too long."); } buf[0] = '1'; strcpy(&(buf[1]), shm_name); strcat(&(buf[1]), ";"); strcat(&(buf[1]), fifo_t2h_name); strcat(&(buf[1]), ";"); strcat(&(buf[1]), fifo_h2t_name); strcat(&(buf[1]), ";"); write(1, buf, 2 + strlen(&(buf[1]))); } // Now we just loop, processing events. We want to select on file descriptor // 0 from the auxiliary, the X file descriptor, and the fifo t2h descriptor. // The latter may go away. X should never go away, and if the auxiliary goes // away we exit immediately. max_fd = MAX(ConnectionNumber(host_display), fifo_t2h_fd); while ( 1 ) { while (XPending(host_display) > 0) { handle_X_event(); } FD_ZERO(&read_fds); FD_SET(0, &read_fds); FD_SET(ConnectionNumber(host_display), &read_fds); if (-1 != fifo_t2h_fd) { FD_SET(fifo_t2h_fd, &read_fds); } DEBUG(3, "framebuf main loop: selecting on 0x%08x\n", *(int*)&read_fds); do_redraw(); if (select(max_fd + 1, &read_fds, NULL, NULL, NULL) >= 0) { if (FD_ISSET(0, &read_fds)) { DEBUG(2, "framebuf main loop: auxiliary request\n"); handle_auxiliary_request(); } if ((-1 != fifo_t2h_fd) && FD_ISSET(fifo_t2h_fd, &read_fds)) { DEBUG(2, "framebuf main loop: target request\n"); handle_target_request(); } if (FD_ISSET(ConnectionNumber(host_display), &read_fds)) { DEBUG(3, "framebuf main loop: X request\n"); (void)XEventsQueued(host_display, QueuedAfterReading); } } } exit(EXIT_SUCCESS); } #endif // INSTANTIATE_CONVERTER
Go to most recent revision | Compare with Previous | Blame | View Log