开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
SDL_fbvideo.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：43k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

SDL_fbvideo.c：源码内容
  1. /*
  2. SDL - Simple DirectMedia Layer
  3. Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002  Sam Lantinga
  5. This library is free software; you can redistribute it and/or
  6. modify it under the terms of the GNU Library General Public
  7. License as published by the Free Software Foundation; either
  8. version 2 of the License, or (at your option) any later version.
  10. This library is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13. Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free
  17. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19. Sam Lantinga
  20. slouken@libsdl.org
  21. */
  23. #ifdef SAVE_RCSID
  24. static char rcsid =
  25.  "@(#) $Id: SDL_fbvideo.c,v 1.4 2002/04/22 21:38:04 wmay Exp $";
  26. #endif
  28. /* Framebuffer console based SDL video driver implementation.
  29. */
  31. #include <stdlib.h>
  32. #include <stdio.h>
  33. #include <string.h>
  34. #include <fcntl.h>
  35. #include <unistd.h>
  36. #include <sys/ioctl.h>
  37. #include <sys/mman.h>
  38. #include <asm/page.h> /* For definition of PAGE_SIZE */
  40. #include "SDL.h"
  41. #include "SDL_error.h"
  42. #include "SDL_video.h"
  43. #include "SDL_mouse.h"
  44. #include "SDL_sysvideo.h"
  45. #include "SDL_pixels_c.h"
  46. #include "SDL_events_c.h"
  47. #include "SDL_fbvideo.h"
  48. #include "SDL_fbmouse_c.h"
  49. #include "SDL_fbevents_c.h"
  50. #include "SDL_fb3dfx.h"
  51. #include "SDL_fbmatrox.h"
  52. #include "SDL_fbriva.h"
  55. #if defined(i386) && defined(FB_TYPE_VGA_PLANES)
  56. #define VGA16_FBCON_SUPPORT
  57. #ifndef FB_AUX_VGA_PLANES_VGA4
  58. #define FB_AUX_VGA_PLANES_VGA4 0
  59. #endif
  60. static inline void outb (unsigned char value, unsigned short port)
  61. {
  62.   __asm__ __volatile__ ("outb %b0,%w1"::"a" (value), "Nd" (port));
  63. } 
  64. #endif /* FB_TYPE_VGA_PLANES */
  66. /* A list of video resolutions that we query for (sorted largest to smallest) */
  67. static const SDL_Rect checkres[] = {
  68. {  0, 0, 1600, 1200 }, /* 16 bpp: 0x11E, or 286 */
  69. {  0, 0, 1408, 1056 }, /* 16 bpp: 0x19A, or 410 */
  70. {  0, 0, 1280, 1024 }, /* 16 bpp: 0x11A, or 282 */
  71. {  0, 0, 1152,  864 }, /* 16 bpp: 0x192, or 402 */
  72. {  0, 0, 1024,  768 }, /* 16 bpp: 0x117, or 279 */
  73. {  0, 0,  960,  720 }, /* 16 bpp: 0x18A, or 394 */
  74. {  0, 0,  800,  600 }, /* 16 bpp: 0x114, or 276 */
  75. {  0, 0,  768,  576 }, /* 16 bpp: 0x182, or 386 */
  76. {  0, 0,  720,  576 }, /* PAL */
  77. {  0, 0,  720,  480 }, /* NTSC */
  78. {  0, 0,  640,  480 }, /* 16 bpp: 0x111, or 273 */
  79. {  0, 0,  640,  400 }, /*  8 bpp: 0x100, or 256 */
  80. {  0, 0,  512,  384 },
  81. {  0, 0,  320,  240 },
  82. {  0, 0,  320,  200 }
  83. };
  84. static const struct {
  85. int xres;
  86. int yres;
  87. int pixclock;
  88. int left;
  89. int right;
  90. int upper;
  91. int lower;
  92. int hslen;
  93. int vslen;
  94. int sync;
  95. int vmode;
  96. } vesa_timings[] = {
  97. #ifdef USE_VESA_TIMINGS /* Only tested on Matrox Millenium I */
  98. {  640,  400, 39771,  48, 16, 39,  8,  96, 2, 2, 0 }, /* 70 Hz */
  99. {  640,  480, 39683,  48, 16, 33, 10,  96, 2, 0, 0 }, /* 60 Hz */
  100. {  768,  576, 26101, 144, 16, 28,  6, 112, 4, 0, 0 }, /* 60 Hz */
  101. {  800,  600, 24038, 144, 24, 28,  8, 112, 6, 0, 0 }, /* 60 Hz */
  102. {  960,  720, 17686, 144, 24, 28,  8, 112, 4, 0, 0 }, /* 60 Hz */
  103. { 1024,  768, 15386, 160, 32, 30,  4, 128, 4, 0, 0 }, /* 60 Hz */
  104. { 1152,  864, 12286, 192, 32, 30,  4, 128, 4, 0, 0 }, /* 60 Hz */
  105. { 1280, 1024,  9369, 224, 32, 32,  4, 136, 4, 0, 0 }, /* 60 Hz */
  106. { 1408, 1056,  8214, 256, 40, 32,  5, 144, 5, 0, 0 }, /* 60 Hz */
  107. { 1600, 1200,/*?*/0, 272, 48, 32,  5, 152, 5, 0, 0 }, /* 60 Hz */
  108. #else
  109. /* You can generate these timings from your XF86Config file using
  110.    the 'modeline2fb' perl script included with the fbset package.
  111.    These timings were generated for Matrox Millenium I, 15" monitor.
  112. */
  113. {  320,  200, 79440,  16, 16, 20,  4,  48, 1, 0, 2 }, /* 70 Hz */
  114. {  320,  240, 63492,  16, 16, 16,  4,  48, 2, 0, 2 }, /* 72 Hz */
  115. {  512,  384, 49603,  48, 16, 16,  1,  64, 3, 0, 0 }, /* 78 Hz */
  116. {  640,  400, 31746,  96, 32, 41,  1,  64, 3, 2, 0 }, /* 85 Hz */
  117. {  640,  480, 31746, 120, 16, 16,  1,  64, 3, 0, 0 }, /* 75 Hz */
  118. {  768,  576, 26101, 144, 16, 28,  6, 112, 4, 0, 0 }, /* 60 Hz */
  119. {  800,  600, 20000,  64, 56, 23, 37, 120, 6, 3, 0 }, /* 72 Hz */
  120. {  960,  720, 17686, 144, 24, 28,  8, 112, 4, 0, 0 }, /* 60 Hz */
  121. { 1024,  768, 13333, 144, 24, 29,  3, 136, 6, 0, 0 }, /* 70 Hz */
  122. { 1152,  864, 12286, 192, 32, 30,  4, 128, 4, 0, 0 }, /* 60 Hz */
  123. { 1280, 1024,  9369, 224, 32, 32,  4, 136, 4, 0, 0 }, /* 60 Hz */
  124. { 1408, 1056,  8214, 256, 40, 32,  5, 144, 5, 0, 0 }, /* 60 Hz */
  125. { 1600, 1200,/*?*/0, 272, 48, 32,  5, 152, 5, 0, 0 }, /* 60 Hz */
  126. #endif
  127. };
  129. /* Initialization/Query functions */
  130. static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat);
  131. static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  132. static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  133. #ifdef VGA16_FBCON_SUPPORT
  134. static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  135. #endif
  136. static int FB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
  137. static void FB_VideoQuit(_THIS);
  139. /* Hardware surface functions */
  140. static int FB_InitHWSurfaces(_THIS, SDL_Surface *screen, char *base, int size);
  141. static void FB_FreeHWSurfaces(_THIS);
  142. static int FB_AllocHWSurface(_THIS, SDL_Surface *surface);
  143. static int FB_LockHWSurface(_THIS, SDL_Surface *surface);
  144. static void FB_UnlockHWSurface(_THIS, SDL_Surface *surface);
  145. static void FB_FreeHWSurface(_THIS, SDL_Surface *surface);
  146. static void FB_WaitVBL(_THIS);
  147. static void FB_WaitIdle(_THIS);
  148. static int FB_FlipHWSurface(_THIS, SDL_Surface *surface);
  150. /* Internal palette functions */
  151. static void FB_SavePalette(_THIS, struct fb_fix_screeninfo *finfo,
  152.                                   struct fb_var_screeninfo *vinfo);
  153. static void FB_RestorePalette(_THIS);
  155. /* FB driver bootstrap functions */
  157. static int FB_Available(void)
  158. {
  159. int console;
  160. const char *SDL_fbdev;
  162. SDL_fbdev = getenv("SDL_FBDEV");
  163. if ( SDL_fbdev == NULL ) {
  164. SDL_fbdev = "/dev/fb0";
  165. }
  166. console = open(SDL_fbdev, O_RDWR, 0);
  167. if ( console >= 0 ) {
  168. close(console);
  169. }
  170. return(console >= 0);
  171. }
  173. static void FB_DeleteDevice(SDL_VideoDevice *device)
  174. {
  175. free(device->hidden);
  176. free(device);
  177. }
  179. static SDL_VideoDevice *FB_CreateDevice(int devindex)
  180. {
  181. SDL_VideoDevice *this;
  183. /* Initialize all variables that we clean on shutdown */
  184. this = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
  185. if ( this ) {
  186. memset(this, 0, (sizeof *this));
  187. this->hidden = (struct SDL_PrivateVideoData *)
  188. malloc((sizeof *this->hidden));
  189. }
  190. if ( (this == NULL) || (this->hidden == NULL) ) {
  191. SDL_OutOfMemory();
  192. if ( this ) {
  193. free(this);
  194. }
  195. return(0);
  196. }
  197. memset(this->hidden, 0, (sizeof *this->hidden));
  198. wait_vbl = FB_WaitVBL;
  199. wait_idle = FB_WaitIdle;
  200. mouse_fd = -1;
  201. keyboard_fd = -1;
  203. /* Set the function pointers */
  204. this->VideoInit = FB_VideoInit;
  205. this->ListModes = FB_ListModes;
  206. this->SetVideoMode = FB_SetVideoMode;
  207. this->SetColors = FB_SetColors;
  208. this->UpdateRects = NULL;
  209. this->VideoQuit = FB_VideoQuit;
  210. this->AllocHWSurface = FB_AllocHWSurface;
  211. this->CheckHWBlit = NULL;
  212. this->FillHWRect = NULL;
  213. this->SetHWColorKey = NULL;
  214. this->SetHWAlpha = NULL;
  215. this->LockHWSurface = FB_LockHWSurface;
  216. this->UnlockHWSurface = FB_UnlockHWSurface;
  217. this->FlipHWSurface = FB_FlipHWSurface;
  218. this->FreeHWSurface = FB_FreeHWSurface;
  219. this->SetCaption = NULL;
  220. this->SetIcon = NULL;
  221. this->IconifyWindow = NULL;
  222. this->GrabInput = NULL;
  223. this->GetWMInfo = NULL;
  224. this->InitOSKeymap = FB_InitOSKeymap;
  225. this->PumpEvents = FB_PumpEvents;
  227. this->free = FB_DeleteDevice;
  229. return this;
  230. }
  232. VideoBootStrap FBCON_bootstrap = {
  233. "fbcon", "Linux Framebuffer Console",
  234. FB_Available, FB_CreateDevice
  235. };
  237. static int FB_CheckMode(_THIS, struct fb_var_screeninfo *vinfo,
  238.                         int index, unsigned int *w, unsigned int *h)
  239. {
  240. int mode_okay;
  242. mode_okay = 0;
  243. vinfo->bits_per_pixel = (index+1)*8;
  244. vinfo->xres = *w;
  245. vinfo->xres_virtual = *w;
  246. vinfo->yres = *h;
  247. vinfo->yres_virtual = *h;
  248. vinfo->activate = FB_ACTIVATE_TEST;
  249. if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, vinfo) == 0 ) {
  250. #ifdef FBCON_DEBUG
  251. fprintf(stderr, "Checked mode %dx%d at %d bpp, got mode %dx%d at %d bppn", *w, *h, (index+1)*8, vinfo->xres, vinfo->yres, vinfo->bits_per_pixel);
  252. #endif
  253. if ( (((vinfo->bits_per_pixel+7)/8)-1) == index ) {
  254. *w = vinfo->xres;
  255. *h = vinfo->yres;
  256. mode_okay = 1;
  257. }
  258. }
  259. return mode_okay;
  260. }
  262. static int FB_AddMode(_THIS, int index, unsigned int w, unsigned int h)
  263. {
  264. SDL_Rect *mode;
  265. int i;
  266. int next_mode;
  268. /* Check to see if we already have this mode */
  269. if ( SDL_nummodes[index] > 0 ) {
  270. mode = SDL_modelist[index][SDL_nummodes[index]-1];
  271. if ( (mode->w == w) && (mode->h == h) ) {
  272. #ifdef FBCON_DEBUG
  273. fprintf(stderr, "We already have mode %dx%d at %d bytes per pixeln", w, h, index+1);
  274. #endif
  275. return(0);
  276. }
  277. }
  279. /* Only allow a mode if we have a valid timing for it */
  280. next_mode = -1;
  281. for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) {
  282. if ( (w == vesa_timings[i].xres) &&
  283.      (h == vesa_timings[i].yres) && vesa_timings[i].pixclock ) {
  284. next_mode = i;
  285. break;
  286. }
  287. }
  288. if ( next_mode == -1 ) {
  289. #ifdef FBCON_DEBUG
  290. fprintf(stderr, "No valid timing line for mode %dx%dn", w, h);
  291. #endif
  292. return(0);
  293. }
  295. /* Set up the new video mode rectangle */
  296. mode = (SDL_Rect *)malloc(sizeof *mode);
  297. if ( mode == NULL ) {
  298. SDL_OutOfMemory();
  299. return(-1);
  300. }
  301. mode->x = 0;
  302. mode->y = 0;
  303. mode->w = w;
  304. mode->h = h;
  305. #ifdef FBCON_DEBUG
  306. fprintf(stderr, "Adding mode %dx%d at %d bytes per pixeln", w, h, index+1);
  307. #endif
  309. /* Allocate the new list of modes, and fill in the new mode */
  310. next_mode = SDL_nummodes[index];
  311. SDL_modelist[index] = (SDL_Rect **)
  312.        realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *));
  313. if ( SDL_modelist[index] == NULL ) {
  314. SDL_OutOfMemory();
  315. SDL_nummodes[index] = 0;
  316. free(mode);
  317. return(-1);
  318. }
  319. SDL_modelist[index][next_mode] = mode;
  320. SDL_modelist[index][next_mode+1] = NULL;
  321. SDL_nummodes[index]++;
  323. return(0);
  324. }
  326. static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat)
  327. {
  328. struct fb_fix_screeninfo finfo;
  329. struct fb_var_screeninfo vinfo;
  330. int i, j;
  331. int current_index;
  332. unsigned int current_w;
  333. unsigned int current_h;
  334. const char *SDL_fbdev;
  336. /* Initialize the library */
  337. SDL_fbdev = getenv("SDL_FBDEV");
  338. if ( SDL_fbdev == NULL ) {
  339. SDL_fbdev = "/dev/fb0";
  340. }
  341. console_fd = open(SDL_fbdev, O_RDWR, 0);
  342. if ( console_fd < 0 ) {
  343. SDL_SetError("Unable to open %s", SDL_fbdev);
  344. return(-1);
  345. }
  347. #ifndef DISABLE_THREADS
  348. /* Create the hardware surface lock mutex */
  349. hw_lock = SDL_CreateMutex();
  350. if ( hw_lock == NULL ) {
  351. SDL_SetError("Unable to create lock mutex");
  352. FB_VideoQuit(this);
  353. return(-1);
  354. }
  355. #endif
  357. /* Get the type of video hardware */
  358. if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) {
  359. SDL_SetError("Couldn't get console hardware info");
  360. FB_VideoQuit(this);
  361. return(-1);
  362. }
  363. switch (finfo.type) {
  364. case FB_TYPE_PACKED_PIXELS:
  365. /* Supported, no worries.. */
  366. break;
  367. #ifdef VGA16_FBCON_SUPPORT
  368. case FB_TYPE_VGA_PLANES:
  369. /* VGA16 is supported, but that's it */
  370. if ( finfo.type_aux == FB_AUX_VGA_PLANES_VGA4 ) {
  371. if ( ioperm(0x3b4, 0x3df - 0x3b4 + 1, 1) < 0 ) {
  372. SDL_SetError("No I/O port permissions");
  373. FB_VideoQuit(this);
  374. return(-1);
  375. }
  376. this->SetVideoMode = FB_SetVGA16Mode;
  377. break;
  378. }
  379. /* Fall through to unsupported case */
  380. #endif /* VGA16_FBCON_SUPPORT */
  381. default:
  382. SDL_SetError("Unsupported console hardware");
  383. FB_VideoQuit(this);
  384. return(-1);
  385. }
  386. switch (finfo.visual) {
  387. case FB_VISUAL_TRUECOLOR:
  388. case FB_VISUAL_PSEUDOCOLOR:
  389. case FB_VISUAL_STATIC_PSEUDOCOLOR:
  390. case FB_VISUAL_DIRECTCOLOR:
  391. break;
  392. default:
  393. SDL_SetError("Unsupported console hardware");
  394. FB_VideoQuit(this);
  395. return(-1);
  396. }
  398. /* Check if the user wants to disable hardware acceleration */
  399. { const char *fb_accel;
  400. fb_accel = getenv("SDL_FBACCEL");
  401. if ( fb_accel ) {
  402. finfo.accel = atoi(fb_accel);
  403. }
  404. }
  406. /* Memory map the device, compensating for buggy PPC mmap() */
  407. mapped_offset = (((long)finfo.smem_start) -
  408.                 (((long)finfo.smem_start)&~(PAGE_SIZE-1)));
  409. mapped_memlen = finfo.smem_len+mapped_offset;
  410. mapped_mem = mmap(NULL, mapped_memlen,
  411.                   PROT_READ|PROT_WRITE, MAP_SHARED, console_fd, 0);
  412. if ( mapped_mem == (char *)-1 ) {
  413. SDL_SetError("Unable to memory map the video hardware");
  414. mapped_mem = NULL;
  415. FB_VideoQuit(this);
  416. return(-1);
  417. }
  419. /* Determine the current screen depth */
  420. if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) {
  421. SDL_SetError("Couldn't get console pixel format");
  422. FB_VideoQuit(this);
  423. return(-1);
  424. }
  425. vformat->BitsPerPixel = vinfo.bits_per_pixel;
  426. if ( vformat->BitsPerPixel < 8 ) {
  427. /* Assuming VGA16, we handle this via a shadow framebuffer */
  428. vformat->BitsPerPixel = 8;
  429. }
  430. for ( i=0; i<vinfo.red.length; ++i ) {
  431. vformat->Rmask <<= 1;
  432. vformat->Rmask |= (0x00000001<<vinfo.red.offset);
  433. }
  434. for ( i=0; i<vinfo.green.length; ++i ) {
  435. vformat->Gmask <<= 1;
  436. vformat->Gmask |= (0x00000001<<vinfo.green.offset);
  437. }
  438. for ( i=0; i<vinfo.blue.length; ++i ) {
  439. vformat->Bmask <<= 1;
  440. vformat->Bmask |= (0x00000001<<vinfo.blue.offset);
  441. }
  442. saved_vinfo = vinfo;
  444. /* Save hardware palette, if needed */
  445. FB_SavePalette(this, &finfo, &vinfo);
  447. /* If the I/O registers are available, memory map them so we
  448.    can take advantage of any supported hardware acceleration.
  449.  */
  450. vinfo.accel_flags = 0; /* Temporarily reserve registers */
  451. ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo);
  452. if ( finfo.accel && finfo.mmio_len ) {
  453. mapped_iolen = finfo.mmio_len;
  454. mapped_io = mmap(NULL, mapped_iolen, PROT_READ|PROT_WRITE,
  455.                  MAP_SHARED, console_fd, mapped_memlen);
  456. if ( mapped_io == (char *)-1 ) {
  457. /* Hmm, failed to memory map I/O registers */
  458. mapped_io = NULL;
  459. }
  460. }
  462. /* Query for the list of available video modes */
  463. current_w = vinfo.xres;
  464. current_h = vinfo.yres;
  465. current_index = ((vinfo.bits_per_pixel+7)/8)-1;
  466. for ( i=0; i<NUM_MODELISTS; ++i ) {
  467. SDL_nummodes[i] = 0;
  468. SDL_modelist[i] = NULL;
  469. for ( j=0; j<(sizeof(checkres)/sizeof(checkres[0])); ++j ) {
  470. unsigned int w, h;
  472. /* See if we are querying for the current mode */
  473. w = checkres[j].w;
  474. h = checkres[j].h;
  475. if ( i == current_index ) {
  476. if ( (current_w > w) || (current_h > h) ) {
  477. /* Only check once */
  478. FB_AddMode(this, i,current_w,current_h);
  479. current_index = -1;
  480. }
  481. }
  482. if ( FB_CheckMode(this, &vinfo, i, &w, &h) ) {
  483. FB_AddMode(this, i, w, h);
  484. }
  485. }
  486. }
  488. /* Fill in our hardware acceleration capabilities */
  489. this->info.wm_available = 0;
  490. this->info.hw_available = 1;
  491. this->info.video_mem = finfo.smem_len/1024;
  492. if ( mapped_io ) {
  493. switch (finfo.accel) {
  494.     case FB_ACCEL_MATROX_MGA2064W:
  495.     case FB_ACCEL_MATROX_MGA1064SG:
  496.     case FB_ACCEL_MATROX_MGA2164W:
  497.     case FB_ACCEL_MATROX_MGA2164W_AGP:
  498.     case FB_ACCEL_MATROX_MGAG100:
  499.     /*case FB_ACCEL_MATROX_MGAG200: G200 acceleration broken! */
  500.     case FB_ACCEL_MATROX_MGAG400:
  501. #ifdef FBACCEL_DEBUG
  502. printf("Matrox hardware accelerator!n");
  503. #endif
  504. FB_MatroxAccel(this, finfo.accel);
  505. break;
  506.     case FB_ACCEL_3DFX_BANSHEE:
  507. #ifdef FBACCEL_DEBUG
  508. printf("3DFX hardware accelerator!n");
  509. #endif
  510. FB_3DfxAccel(this, finfo.accel);
  511. break;
  512.     case FB_ACCEL_NV3:
  513.     case FB_ACCEL_NV4:
  514. #ifdef FBACCEL_DEBUG
  515. printf("NVidia hardware accelerator!n");
  516. #endif
  517. FB_RivaAccel(this, finfo.accel);
  518. break;
  519.     default:
  520. #ifdef FBACCEL_DEBUG
  521. printf("Unknown hardware accelerator.n");
  522. #endif
  523. break;
  524. }
  525. }
  527. /* Enable mouse and keyboard support */
  528. if ( FB_OpenKeyboard(this) < 0 ) {
  529. FB_VideoQuit(this);
  530. return(-1);
  531. }
  532. if ( FB_OpenMouse(this) < 0 ) {
  533. const char *sdl_nomouse;
  535. sdl_nomouse = getenv("SDL_NOMOUSE");
  536. if ( ! sdl_nomouse ) {
  537. SDL_SetError("Unable to open mouse");
  538. FB_VideoQuit(this);
  539. return(-1);
  540. }
  541. }
  543. /* We're done! */
  544. return(0);
  545. }
  547. static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
  548. {
  549. return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]);
  550. }
  552. /* Various screen update functions available */
  553. static void FB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
  554. #ifdef VGA16_FBCON_SUPPORT
  555. static void FB_VGA16Update(_THIS, int numrects, SDL_Rect *rects);
  556. #endif
  558. #ifdef FBCON_DEBUG
  559. static void print_vinfo(struct fb_var_screeninfo *vinfo)
  560. {
  561. fprintf(stderr, "Printing vinfo:n");
  562. fprintf(stderr, "txres: %dn", vinfo->xres);
  563. fprintf(stderr, "tyres: %dn", vinfo->yres);
  564. fprintf(stderr, "txres_virtual: %dn", vinfo->xres_virtual);
  565. fprintf(stderr, "tyres_virtual: %dn", vinfo->yres_virtual);
  566. fprintf(stderr, "txoffset: %dn", vinfo->xoffset);
  567. fprintf(stderr, "tyoffset: %dn", vinfo->yoffset);
  568. fprintf(stderr, "tbits_per_pixel: %dn", vinfo->bits_per_pixel);
  569. fprintf(stderr, "tgrayscale: %dn", vinfo->grayscale);
  570. fprintf(stderr, "tnonstd: %dn", vinfo->nonstd);
  571. fprintf(stderr, "tactivate: %dn", vinfo->activate);
  572. fprintf(stderr, "theight: %dn", vinfo->height);
  573. fprintf(stderr, "twidth: %dn", vinfo->width);
  574. fprintf(stderr, "taccel_flags: %dn", vinfo->accel_flags);
  575. fprintf(stderr, "tpixclock: %dn", vinfo->pixclock);
  576. fprintf(stderr, "tleft_margin: %dn", vinfo->left_margin);
  577. fprintf(stderr, "tright_margin: %dn", vinfo->right_margin);
  578. fprintf(stderr, "tupper_margin: %dn", vinfo->upper_margin);
  579. fprintf(stderr, "tlower_margin: %dn", vinfo->lower_margin);
  580. fprintf(stderr, "thsync_len: %dn", vinfo->hsync_len);
  581. fprintf(stderr, "tvsync_len: %dn", vinfo->vsync_len);
  582. fprintf(stderr, "tsync: %dn", vinfo->sync);
  583. fprintf(stderr, "tvmode: %dn", vinfo->vmode);
  584. fprintf(stderr, "tred: %d/%dn", vinfo->red.length, vinfo->red.offset);
  585. fprintf(stderr, "tgreen: %d/%dn", vinfo->green.length, vinfo->green.offset);
  586. fprintf(stderr, "tblue: %d/%dn", vinfo->blue.length, vinfo->blue.offset);
  587. fprintf(stderr, "talpha: %d/%dn", vinfo->transp.length, vinfo->transp.offset);
  588. }
  589. static void print_finfo(struct fb_fix_screeninfo *finfo)
  590. {
  591. fprintf(stderr, "Printing finfo:n");
  592. fprintf(stderr, "tsmem_start = %pn", (char *)finfo->smem_start);
  593. fprintf(stderr, "tsmem_len = %dn", finfo->smem_len);
  594. fprintf(stderr, "ttype = %dn", finfo->type);
  595. fprintf(stderr, "ttype_aux = %dn", finfo->type_aux);
  596. fprintf(stderr, "tvisual = %dn", finfo->visual);
  597. fprintf(stderr, "txpanstep = %dn", finfo->xpanstep);
  598. fprintf(stderr, "typanstep = %dn", finfo->ypanstep);
  599. fprintf(stderr, "tywrapstep = %dn", finfo->ywrapstep);
  600. fprintf(stderr, "tline_length = %dn", finfo->line_length);
  601. fprintf(stderr, "tmmio_start = %pn", (char *)finfo->mmio_start);
  602. fprintf(stderr, "tmmio_len = %dn", finfo->mmio_len);
  603. fprintf(stderr, "taccel = %dn", finfo->accel);
  604. }
  605. #endif
  607. static int choose_fbmodes_mode(struct fb_var_screeninfo *vinfo)
  608. {
  609. int matched;
  610. FILE *fbmodes;
  612. matched = 0;
  613. fbmodes = fopen("/etc/fb.modes", "r");
  614. if ( fbmodes ) {
  615. /* FIXME: Parse the mode definition file */
  616. fclose(fbmodes);
  617. }
  618. return(matched);
  619. }
  621. static int choose_vesa_mode(struct fb_var_screeninfo *vinfo)
  622. {
  623. int matched;
  624. int i;
  626. /* Check for VESA timings */
  627. matched = 0;
  628. for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) {
  629. if ( (vinfo->xres == vesa_timings[i].xres) &&
  630.      (vinfo->yres == vesa_timings[i].yres) ) {
  631. #ifdef FBCON_DEBUG
  632. fprintf(stderr, "Using VESA timings for %dx%dn",
  633. vinfo->xres, vinfo->yres);
  634. #endif
  635. if ( vesa_timings[i].pixclock ) {
  636. vinfo->pixclock = vesa_timings[i].pixclock;
  637. }
  638. vinfo->left_margin = vesa_timings[i].left;
  639. vinfo->right_margin = vesa_timings[i].right;
  640. vinfo->upper_margin = vesa_timings[i].upper;
  641. vinfo->lower_margin = vesa_timings[i].lower;
  642. vinfo->hsync_len = vesa_timings[i].hslen;
  643. vinfo->vsync_len = vesa_timings[i].vslen;
  644. vinfo->sync = vesa_timings[i].sync;
  645. vinfo->vmode = vesa_timings[i].vmode;
  646. matched = 1;
  647. break;
  648. }
  649. }
  650. return(matched);
  651. }
  653. #ifdef VGA16_FBCON_SUPPORT
  654. static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current,
  655. int width, int height, int bpp, Uint32 flags)
  656. {
  657. struct fb_fix_screeninfo finfo;
  658. struct fb_var_screeninfo vinfo;
  660. /* Set the terminal into graphics mode */
  661. if ( FB_EnterGraphicsMode(this) < 0 ) {
  662. return(NULL);
  663. }
  665. /* Restore the original palette */
  666. FB_RestorePalette(this);
  668. /* Set the video mode and get the final screen format */
  669. if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) {
  670. SDL_SetError("Couldn't get console screen info");
  671. return(NULL);
  672. }
  673. cache_vinfo = vinfo;
  674. #ifdef FBCON_DEBUG
  675. fprintf(stderr, "Printing actual vinfo:n");
  676. print_vinfo(&vinfo);
  677. #endif
  678. if ( ! SDL_ReallocFormat(current, bpp, 0, 0, 0, 0) ) {
  679. return(NULL);
  680. }
  681. current->format->palette->ncolors = 16;
  683. /* Get the fixed information about the console hardware.
  684.    This is necessary since finfo.line_length changes.
  685.  */
  686. if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) {
  687. SDL_SetError("Couldn't get console hardware info");
  688. return(NULL);
  689. }
  690. #ifdef FBCON_DEBUG
  691. fprintf(stderr, "Printing actual finfo:n");
  692. print_finfo(&finfo);
  693. #endif
  695. /* Save hardware palette, if needed */
  696. FB_SavePalette(this, &finfo, &vinfo);
  698. /* Set up the new mode framebuffer */
  699. current->flags = SDL_FULLSCREEN;
  700. current->w = vinfo.xres;
  701. current->h = vinfo.yres;
  702. current->pitch = current->w;
  703. current->pixels = malloc(current->h*current->pitch);
  705. /* Set the update rectangle function */
  706. this->UpdateRects = FB_VGA16Update;
  708. /* We're done */
  709. return(current);
  710. }
  711. #endif /* VGA16_FBCON_SUPPORT */
  713. static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current,
  714. int width, int height, int bpp, Uint32 flags)
  715. {
  716. struct fb_fix_screeninfo finfo;
  717. struct fb_var_screeninfo vinfo;
  718. int i;
  719. Uint32 Rmask;
  720. Uint32 Gmask;
  721. Uint32 Bmask;
  722. char *surfaces_mem;
  723. int surfaces_len;
  725. /* Set the terminal into graphics mode */
  726. if ( FB_EnterGraphicsMode(this) < 0 ) {
  727. return(NULL);
  728. }
  730. /* Restore the original palette */
  731. FB_RestorePalette(this);
  733. /* Set the video mode and get the final screen format */
  734. if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) {
  735. SDL_SetError("Couldn't get console screen info");
  736. return(NULL);
  737. }
  738. #ifdef FBCON_DEBUG
  739. fprintf(stderr, "Printing original vinfo:n");
  740. print_vinfo(&vinfo);
  741. #endif
  742. if ( (vinfo.xres != width) || (vinfo.yres != height) ||
  743.      (vinfo.bits_per_pixel != bpp) || (flags & SDL_DOUBLEBUF) ) {
  744. vinfo.activate = FB_ACTIVATE_NOW;
  745. vinfo.accel_flags = 0;
  746. vinfo.bits_per_pixel = bpp;
  747. vinfo.xres = width;
  748. vinfo.xres_virtual = width;
  749. vinfo.yres = height;
  750. if ( flags & SDL_DOUBLEBUF ) {
  751. vinfo.yres_virtual = height*2;
  752. } else {
  753. vinfo.yres_virtual = height;
  754. }
  755. vinfo.xoffset = 0;
  756. vinfo.yoffset = 0;
  757. vinfo.red.length = vinfo.red.offset = 0;
  758. vinfo.green.length = vinfo.green.offset = 0;
  759. vinfo.blue.length = vinfo.blue.offset = 0;
  760. vinfo.transp.length = vinfo.transp.offset = 0;
  761. if ( ! choose_fbmodes_mode(&vinfo) ) {
  762. choose_vesa_mode(&vinfo);
  763. }
  764. #ifdef FBCON_DEBUG
  765. fprintf(stderr, "Printing wanted vinfo:n");
  766. print_vinfo(&vinfo);
  767. #endif
  768. if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0 ) {
  769. vinfo.yres_virtual = height;
  770. if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0 ) {
  771. SDL_SetError("Couldn't set console screen info");
  772. return(NULL);
  773. }
  774. }
  775. } else {
  776. int maxheight;
  778. /* Figure out how much video memory is available */
  779. if ( flags & SDL_DOUBLEBUF ) {
  780. maxheight = height*2;
  781. } else {
  782. maxheight = height;
  783. }
  784. if ( vinfo.yres_virtual > maxheight ) {
  785. vinfo.yres_virtual = maxheight;
  786. }
  787. }
  788. cache_vinfo = vinfo;
  789. #ifdef FBCON_DEBUG
  790. fprintf(stderr, "Printing actual vinfo:n");
  791. print_vinfo(&vinfo);
  792. #endif
  793. Rmask = 0;
  794. for ( i=0; i<vinfo.red.length; ++i ) {
  795. Rmask <<= 1;
  796. Rmask |= (0x00000001<<vinfo.red.offset);
  797. }
  798. Gmask = 0;
  799. for ( i=0; i<vinfo.green.length; ++i ) {
  800. Gmask <<= 1;
  801. Gmask |= (0x00000001<<vinfo.green.offset);
  802. }
  803. Bmask = 0;
  804. for ( i=0; i<vinfo.blue.length; ++i ) {
  805. Bmask <<= 1;
  806. Bmask |= (0x00000001<<vinfo.blue.offset);
  807. }
  808. if ( ! SDL_ReallocFormat(current, vinfo.bits_per_pixel,
  809.                                   Rmask, Gmask, Bmask, 0) ) {
  810. return(NULL);
  811. }
  813. /* Get the fixed information about the console hardware.
  814.    This is necessary since finfo.line_length changes.
  815.  */
  816. if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) {
  817. SDL_SetError("Couldn't get console hardware info");
  818. return(NULL);
  819. }
  821. /* Save hardware palette, if needed */
  822. FB_SavePalette(this, &finfo, &vinfo);
  824. /* Set up the new mode framebuffer */
  825. current->flags = (SDL_FULLSCREEN|SDL_HWSURFACE);
  826. current->w = vinfo.xres;
  827. current->h = vinfo.yres;
  828. current->pitch = finfo.line_length;
  829. current->pixels = mapped_mem+mapped_offset;
  831. /* Set up the information for hardware surfaces */
  832. surfaces_mem = (char *)current->pixels +
  833.                         vinfo.yres_virtual*current->pitch;
  834. surfaces_len = (mapped_memlen-(surfaces_mem-mapped_mem));
  835. FB_FreeHWSurfaces(this);
  836. FB_InitHWSurfaces(this, current, surfaces_mem, surfaces_len);
  838. /* Let the application know we have a hardware palette */
  839. switch (finfo.visual) {
  840.     case FB_VISUAL_PSEUDOCOLOR:
  841. current->flags |= SDL_HWPALETTE;
  842. break;
  843.     default:
  844. break;
  845. }
  847. /* Update for double-buffering, if we can */
  848. if ( flags & SDL_DOUBLEBUF ) {
  849. if ( vinfo.yres_virtual == (height*2) ) {
  850. current->flags |= SDL_DOUBLEBUF;
  851. flip_page = 0;
  852. flip_address[0] = (char *)current->pixels;
  853. flip_address[1] = (char *)current->pixels+
  854.                           current->h*current->pitch;
  855. this->screen = current;
  856. FB_FlipHWSurface(this, current);
  857. this->screen = NULL;
  858. }
  859. }
  861. /* Set the update rectangle function */
  862. this->UpdateRects = FB_DirectUpdate;
  864. /* We're done */
  865. return(current);
  866. }
  868. #ifdef FBCON_DEBUG
  869. void FB_DumpHWSurfaces(_THIS)
  870. {
  871. vidmem_bucket *bucket;
  873. printf("Memory left: %d (%d total)n", surfaces_memleft, surfaces_memtotal);
  874. printf("n");
  875. printf("         Base  Sizen");
  876. for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
  877. printf("Bucket:  %p, %d (%s)n", bucket->base, bucket->size, bucket->used ? "used" : "free");
  878. if ( bucket->prev ) {
  879. if ( bucket->base != bucket->prev->base+bucket->prev->size ) {
  880. printf("Warning, corrupt bucket list! (prev)n");
  881. }
  882. } else {
  883. if ( bucket != &surfaces ) {
  884. printf("Warning, corrupt bucket list! (!prev)n");
  885. }
  886. }
  887. if ( bucket->next ) {
  888. if ( bucket->next->base != bucket->base+bucket->size ) {
  889. printf("Warning, corrupt bucket list! (next)n");
  890. }
  891. }
  892. }
  893. printf("n");
  894. }
  895. #endif
  897. static int FB_InitHWSurfaces(_THIS, SDL_Surface *screen, char *base, int size)
  898. {
  899. vidmem_bucket *bucket;
  901. surfaces_memtotal = size;
  902. surfaces_memleft = size;
  904. if ( surfaces_memleft > 0 ) {
  905. bucket = (vidmem_bucket *)malloc(sizeof(*bucket));
  906. if ( bucket == NULL ) {
  907. SDL_OutOfMemory();
  908. return(-1);
  909. }
  910. bucket->prev = &surfaces;
  911. bucket->used = 0;
  912. bucket->dirty = 0;
  913. bucket->base = base;
  914. bucket->size = size;
  915. bucket->next = NULL;
  916. } else {
  917. bucket = NULL;
  918. }
  920. surfaces.prev = NULL;
  921. surfaces.used = 1;
  922. surfaces.dirty = 0;
  923. surfaces.base = screen->pixels;
  924. surfaces.size = (unsigned int)((long)base - (long)surfaces.base);
  925. surfaces.next = bucket;
  926. screen->hwdata = (struct private_hwdata *)&surfaces;
  927. return(0);
  928. }
  929. static void FB_FreeHWSurfaces(_THIS)
  930. {
  931. vidmem_bucket *bucket, *freeable;
  933. bucket = surfaces.next;
  934. while ( bucket ) {
  935. freeable = bucket;
  936. bucket = bucket->next;
  937. free(freeable);
  938. }
  939. surfaces.next = NULL;
  940. }
  942. static int FB_AllocHWSurface(_THIS, SDL_Surface *surface)
  943. {
  944. vidmem_bucket *bucket;
  945. int size;
  946. int extra;
  948. /* Temporarily, we only allow surfaces the same width as display.
  949.    Some blitters require the pitch between two hardware surfaces
  950.    to be the same.  Others have interesting alignment restrictions.
  951.    Until someone who knows these details looks at the code...
  952. */
  953. if ( surface->pitch > SDL_VideoSurface->pitch ) {
  954. SDL_SetError("Surface requested wider than screen");
  955. return(-1);
  956. }
  957. surface->pitch = SDL_VideoSurface->pitch;
  958. size = surface->h * surface->pitch;
  959. #ifdef FBCON_DEBUG
  960. fprintf(stderr, "Allocating bucket of %d bytesn", size);
  961. #endif
  963. /* Quick check for available mem */
  964. if ( size > surfaces_memleft ) {
  965. SDL_SetError("Not enough video memory");
  966. return(-1);
  967. }
  969. /* Search for an empty bucket big enough */
  970. for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
  971. if ( ! bucket->used && (size <= bucket->size) ) {
  972. break;
  973. }
  974. }
  975. if ( bucket == NULL ) {
  976. SDL_SetError("Video memory too fragmented");
  977. return(-1);
  978. }
  980. /* Create a new bucket for left-over memory */
  981. extra = (bucket->size - size);
  982. if ( extra ) {
  983. vidmem_bucket *newbucket;
  985. #ifdef FBCON_DEBUG
  986. fprintf(stderr, "Adding new free bucket of %d bytesn", extra);
  987. #endif
  988. newbucket = (vidmem_bucket *)malloc(sizeof(*newbucket));
  989. if ( newbucket == NULL ) {
  990. SDL_OutOfMemory();
  991. return(-1);
  992. }
  993. newbucket->prev = bucket;
  994. newbucket->used = 0;
  995. newbucket->base = bucket->base+size;
  996. newbucket->size = extra;
  997. newbucket->next = bucket->next;
  998. if ( bucket->next ) {
  999. bucket->next->prev = newbucket;
  1000. }
  1001. bucket->next = newbucket;
  1002. }
  1004. /* Set the current bucket values and return it! */
  1005. bucket->used = 1;
  1006. bucket->size = size;
  1007. bucket->dirty = 0;
  1008. #ifdef FBCON_DEBUG
  1009. fprintf(stderr, "Allocated %d bytes at %pn", bucket->size, bucket->base);
  1010. #endif
  1011. surfaces_memleft -= size;
  1012. surface->flags |= SDL_HWSURFACE;
  1013. surface->pixels = bucket->base;
  1014. surface->hwdata = (struct private_hwdata *)bucket;
  1015. return(0);
  1016. }
  1017. static void FB_FreeHWSurface(_THIS, SDL_Surface *surface)
  1018. {
  1019. vidmem_bucket *bucket, *freeable;
  1021. /* Look for the bucket in the current list */
  1022. for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
  1023. if ( bucket == (vidmem_bucket *)surface->hwdata ) {
  1024. break;
  1025. }
  1026. }
  1027. if ( bucket && bucket->used ) {
  1028. /* Add the memory back to the total */
  1029. #ifdef DGA_DEBUG
  1030. printf("Freeing bucket of %d bytesn", bucket->size);
  1031. #endif
  1032. surfaces_memleft += bucket->size;
  1034. /* Can we merge the space with surrounding buckets? */
  1035. bucket->used = 0;
  1036. if ( bucket->next && ! bucket->next->used ) {
  1037. #ifdef DGA_DEBUG
  1038. printf("Merging with next bucket, for %d total bytesn", bucket->size+bucket->next->size);
  1039. #endif
  1040. freeable = bucket->next;
  1041. bucket->size += bucket->next->size;
  1042. bucket->next = bucket->next->next;
  1043. if ( bucket->next ) {
  1044. bucket->next->prev = bucket;
  1045. }
  1046. free(freeable);
  1047. }
  1048. if ( bucket->prev && ! bucket->prev->used ) {
  1049. #ifdef DGA_DEBUG
  1050. printf("Merging with previous bucket, for %d total bytesn", bucket->prev->size+bucket->size);
  1051. #endif
  1052. freeable = bucket;
  1053. bucket->prev->size += bucket->size;
  1054. bucket->prev->next = bucket->next;
  1055. if ( bucket->next ) {
  1056. bucket->next->prev = bucket->prev;
  1057. }
  1058. free(freeable);
  1059. }
  1060. }
  1061. surface->pixels = NULL;
  1062. surface->hwdata = NULL;
  1063. }
  1064. static int FB_LockHWSurface(_THIS, SDL_Surface *surface)
  1065. {
  1066. if ( surface == this->screen ) {
  1067. SDL_mutexP(hw_lock);
  1068. if ( FB_IsSurfaceBusy(surface) ) {
  1069. FB_WaitBusySurfaces(this);
  1070. }
  1071. } else {
  1072. if ( FB_IsSurfaceBusy(surface) ) {
  1073. FB_WaitBusySurfaces(this);
  1074. }
  1075. }
  1076. return(0);
  1077. }
  1078. static void FB_UnlockHWSurface(_THIS, SDL_Surface *surface)
  1079. {
  1080. if ( surface == this->screen ) {
  1081. SDL_mutexV(hw_lock);
  1082. }
  1083. }
  1085. static void FB_WaitVBL(_THIS)
  1086. {
  1087. #ifdef FBIOWAITRETRACE /* Heheh, this didn't make it into the main kernel */
  1088. ioctl(console_fd, FBIOWAITRETRACE, 0);
  1089. #endif
  1090. return;
  1091. }
  1093. static void FB_WaitIdle(_THIS)
  1094. {
  1095. return;
  1096. }
  1098. static int FB_FlipHWSurface(_THIS, SDL_Surface *surface)
  1099. {
  1100. /* Wait for vertical retrace and then flip display */
  1101. cache_vinfo.yoffset = flip_page*surface->h;
  1102. if ( FB_IsSurfaceBusy(this->screen) ) {
  1103. FB_WaitBusySurfaces(this);
  1104. }
  1105. wait_vbl(this);
  1106. if ( ioctl(console_fd, FBIOPAN_DISPLAY, &cache_vinfo) < 0 ) {
  1107. SDL_SetError("ioctl(FBIOPAN_DISPLAY) failed");
  1108. return(-1);
  1109. }
  1110. flip_page = !flip_page;
  1112. surface->pixels = flip_address[flip_page];
  1113. return(0);
  1114. }
  1116. static void FB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
  1117. {
  1118. /* The application is already updating the visible video memory */
  1119. return;
  1120. }
  1122. #ifdef VGA16_FBCON_SUPPORT
  1123. /* Code adapted with thanks from the XFree86 VGA16 driver! :) */
  1124. #define writeGr(index, value) 
  1125. outb(index, 0x3CE);           
  1126. outb(value, 0x3CF);
  1127. #define writeSeq(index, value) 
  1128. outb(index, 0x3C4);            
  1129. outb(value, 0x3C5);
  1131. static void FB_VGA16Update(_THIS, int numrects, SDL_Rect *rects)
  1132. {
  1133.     SDL_Surface *screen;
  1134.     int width, height, FBPitch, left, i, j, SRCPitch, phase;
  1135.     register Uint32 m;
  1136.     Uint8  s1, s2, s3, s4;
  1137.     Uint32 *src, *srcPtr;
  1138.     Uint8  *dst, *dstPtr;
  1140.     screen = this->screen;
  1141.     FBPitch = screen->w >> 3;
  1142.     SRCPitch = screen->pitch >> 2;
  1144.     writeGr(0x03, 0x00);
  1145.     writeGr(0x05, 0x00);
  1146.     writeGr(0x01, 0x00);
  1147.     writeGr(0x08, 0xFF);
  1149.     while(numrects--) {
  1150. left = rects->x & ~7;
  1151.         width = (rects->w + 7) >> 3;
  1152.         height = rects->h;
  1153.         src = (Uint32*)screen->pixels + (rects->y * SRCPitch) + (left >> 2); 
  1154.         dst = (Uint8*)mapped_mem + (rects->y * FBPitch) + (left >> 3);
  1156. if((phase = (long)dst & 3L)) {
  1157.     phase = 4 - phase;
  1158.     if(phase > width) phase = width;
  1159.     width -= phase;
  1160. }
  1162.         while(height--) {
  1163.     writeSeq(0x02, 1 << 0);
  1164.     dstPtr = dst;
  1165.     srcPtr = src;
  1166.     i = width;
  1167.     j = phase;
  1168.     while(j--) {
  1169. m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4);
  1170.   *dstPtr++ = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3);
  1171. srcPtr += 2;
  1172.     }
  1173.     while(i >= 4) {
  1174. m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4);
  1175.   s1 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3);
  1176. m = (srcPtr[3] & 0x01010101) | ((srcPtr[2] & 0x01010101) << 4);
  1177.   s2 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3);
  1178. m = (srcPtr[5] & 0x01010101) | ((srcPtr[4] & 0x01010101) << 4);
  1179.   s3 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3);
  1180. m = (srcPtr[7] & 0x01010101) | ((srcPtr[6] & 0x01010101) << 4);
  1181.   s4 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3);
  1182. *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24);
  1183. srcPtr += 8;
  1184. dstPtr += 4;
  1185. i -= 4;
  1186.     }
  1187.     while(i--) {
  1188. m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4);
  1189.   *dstPtr++ = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3);
  1190. srcPtr += 2;
  1191.     }
  1193.     writeSeq(0x02, 1 << 1);
  1194.     dstPtr = dst;
  1195.     srcPtr = src;
  1196.     i = width;
  1197.     j = phase;
  1198.     while(j--) {
  1199. m = (srcPtr[1] & 0x02020202) | ((srcPtr[0] & 0x02020202) << 4);
  1200.   *dstPtr++ = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2);
  1201. srcPtr += 2;
  1202.     }
  1203.     while(i >= 4) {
  1204. m = (srcPtr[1] & 0x02020202) | ((srcPtr[0] & 0x02020202) << 4);
  1205.   s1 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2);
  1206. m = (srcPtr[3] & 0x02020202) | ((srcPtr[2] & 0x02020202) << 4);
  1207.   s2 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2);
  1208. m = (srcPtr[5] & 0x02020202) | ((srcPtr[4] & 0x02020202) << 4);
  1209.   s3 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2);
  1210. m = (srcPtr[7] & 0x02020202) | ((srcPtr[6] & 0x02020202) << 4);
  1211.   s4 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2);
  1212. *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24);
  1213. srcPtr += 8;
  1214. dstPtr += 4;
  1215. i -= 4;
  1216.     }
  1217.     while(i--) {
  1218. m = (srcPtr[1] & 0x02020202) | ((srcPtr[0] & 0x02020202) << 4);
  1219.   *dstPtr++ = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2);
  1220. srcPtr += 2;
  1221.     }
  1223.     writeSeq(0x02, 1 << 2);
  1224.     dstPtr = dst;
  1225.     srcPtr = src;
  1226.     i = width;
  1227.     j = phase;
  1228.     while(j--) {
  1229. m = (srcPtr[1] & 0x04040404) | ((srcPtr[0] & 0x04040404) << 4);
  1230.   *dstPtr++ = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1);
  1231. srcPtr += 2;
  1232.     }
  1233.     while(i >= 4) {
  1234. m = (srcPtr[1] & 0x04040404) | ((srcPtr[0] & 0x04040404) << 4);
  1235.   s1 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1);
  1236. m = (srcPtr[3] & 0x04040404) | ((srcPtr[2] & 0x04040404) << 4);
  1237.   s2 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1);
  1238. m = (srcPtr[5] & 0x04040404) | ((srcPtr[4] & 0x04040404) << 4);
  1239.   s3 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1);
  1240. m = (srcPtr[7] & 0x04040404) | ((srcPtr[6] & 0x04040404) << 4);
  1241.   s4 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1);
  1242. *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24);
  1243. srcPtr += 8;
  1244. dstPtr += 4;
  1245. i -= 4;
  1246.     }
  1247.     while(i--) {
  1248. m = (srcPtr[1] & 0x04040404) | ((srcPtr[0] & 0x04040404) << 4);
  1249.   *dstPtr++ = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1);
  1250. srcPtr += 2;
  1251.     }
  1252.     
  1253.     writeSeq(0x02, 1 << 3);
  1254.     dstPtr = dst;
  1255.     srcPtr = src;
  1256.     i = width;
  1257.     j = phase;
  1258.     while(j--) {
  1259. m = (srcPtr[1] & 0x08080808) | ((srcPtr[0] & 0x08080808) << 4);
  1260.   *dstPtr++ = (m >> 27) | (m >> 18) | (m >> 9) | m;
  1261. srcPtr += 2;
  1262.     }
  1263.     while(i >= 4) {
  1264. m = (srcPtr[1] & 0x08080808) | ((srcPtr[0] & 0x08080808) << 4);
  1265.   s1 = (m >> 27) | (m >> 18) | (m >> 9) | m;
  1266. m = (srcPtr[3] & 0x08080808) | ((srcPtr[2] & 0x08080808) << 4);
  1267.   s2 = (m >> 27) | (m >> 18) | (m >> 9) | m;
  1268. m = (srcPtr[5] & 0x08080808) | ((srcPtr[4] & 0x08080808) << 4);
  1269.   s3 = (m >> 27) | (m >> 18) | (m >> 9) | m;
  1270. m = (srcPtr[7] & 0x08080808) | ((srcPtr[6] & 0x08080808) << 4);
  1271.   s4 = (m >> 27) | (m >> 18) | (m >> 9) | m;
  1272. *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24);
  1273. srcPtr += 8;
  1274. dstPtr += 4;
  1275. i -= 4;
  1276.     }
  1277.     while(i--) {
  1278. m = (srcPtr[1] & 0x08080808) | ((srcPtr[0] & 0x08080808) << 4);
  1279.   *dstPtr++ = (m >> 27) | (m >> 18) | (m >> 9) | m;
  1280. srcPtr += 2;
  1281.     }
  1283.             dst += FBPitch;
  1284.             src += SRCPitch;
  1285.         }
  1286.         rects++;
  1287.     }
  1288. }
  1289. #endif /* VGA16_FBCON_SUPPORT */
  1291. void FB_SavePaletteTo(_THIS, int palette_len, __u16 *area)
  1292. {
  1293. struct fb_cmap cmap;
  1295. cmap.start = 0;
  1296. cmap.len = palette_len;
  1297. cmap.red = &area[0*palette_len];
  1298. cmap.green = &area[1*palette_len];
  1299. cmap.blue = &area[2*palette_len];
  1300. cmap.transp = NULL;
  1301. ioctl(console_fd, FBIOGETCMAP, &cmap);
  1302. }
  1304. void FB_RestorePaletteFrom(_THIS, int palette_len, __u16 *area)
  1305. {
  1306. struct fb_cmap cmap;
  1308. cmap.start = 0;
  1309. cmap.len = palette_len;
  1310. cmap.red = &area[0*palette_len];
  1311. cmap.green = &area[1*palette_len];
  1312. cmap.blue = &area[2*palette_len];
  1313. cmap.transp = NULL;
  1314. ioctl(console_fd, FBIOPUTCMAP, &cmap);
  1315. }
  1317. static void FB_SavePalette(_THIS, struct fb_fix_screeninfo *finfo,
  1318.                                   struct fb_var_screeninfo *vinfo)
  1319. {
  1320. int i;
  1322. /* Save hardware palette, if needed */
  1323. if ( finfo->visual == FB_VISUAL_PSEUDOCOLOR ) {
  1324. saved_cmaplen = 1<<vinfo->bits_per_pixel;
  1325. saved_cmap=(__u16 *)malloc(3*saved_cmaplen*sizeof(*saved_cmap));
  1326. if ( saved_cmap != NULL ) {
  1327. FB_SavePaletteTo(this, saved_cmaplen, saved_cmap);
  1328. }
  1329. }
  1331. /* Added support for FB_VISUAL_DIRECTCOLOR.
  1332.    With this mode pixel information is passed through the palette...
  1333.    Neat fading and gamma correction effects can be had by simply
  1334.    fooling around with the palette instead of changing the pixel
  1335.    values themselves... Very neat!
  1337.    Adam Meyerowitz 1/19/2000
  1338.    ameyerow@optonline.com
  1339. */
  1340. if ( finfo->visual == FB_VISUAL_DIRECTCOLOR ) {
  1341. __u16 new_entries[3*256];
  1343. /* Save the colormap */
  1344. saved_cmaplen = 256;
  1345. saved_cmap=(__u16 *)malloc(3*saved_cmaplen*sizeof(*saved_cmap));
  1346. if ( saved_cmap != NULL ) {
  1347. FB_SavePaletteTo(this, saved_cmaplen, saved_cmap);
  1348. }
  1350. /* Allocate new identity colormap */
  1351. for ( i=0; i<256; ++i ) {
  1352.        new_entries[(0*256)+i] =
  1353. new_entries[(1*256)+i] =
  1354. new_entries[(2*256)+i] = (i<<8)|i;
  1355. }
  1356. FB_RestorePaletteFrom(this, 256, new_entries);
  1357. }
  1358. }
  1360. static void FB_RestorePalette(_THIS)
  1361. {
  1362. /* Restore the original palette */
  1363. if ( saved_cmap ) {
  1364. FB_RestorePaletteFrom(this, saved_cmaplen, saved_cmap);
  1365. free(saved_cmap);
  1366. saved_cmap = NULL;
  1367. }
  1368. }
  1370. static int FB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
  1371. {
  1372. int i;
  1373. __u16 r[256];
  1374. __u16 g[256];
  1375. __u16 b[256];
  1376. struct fb_cmap cmap;
  1378. /* Set up the colormap */
  1379. for (i = 0; i < ncolors; i++) {
  1380. r[i] = colors[i].r << 8;
  1381. g[i] = colors[i].g << 8;
  1382. b[i] = colors[i].b << 8;
  1383. }
  1384. cmap.start = firstcolor;
  1385. cmap.len = ncolors;
  1386. cmap.red = r;
  1387. cmap.green = g;
  1388. cmap.blue = b;
  1389. cmap.transp = NULL;
  1391. if( (ioctl(console_fd, FBIOPUTCMAP, &cmap) < 0) ||
  1392.     !(this->screen->flags & SDL_HWPALETTE) ) {
  1393.         colors = this->screen->format->palette->colors;
  1394. ncolors = this->screen->format->palette->ncolors;
  1395. cmap.start = 0;
  1396. cmap.len = ncolors;
  1397. memset(r, 0, sizeof(r));
  1398. memset(g, 0, sizeof(g));
  1399. memset(b, 0, sizeof(b));
  1400. if ( ioctl(console_fd, FBIOGETCMAP, &cmap) == 0 ) {
  1401. for ( i=ncolors-1; i>=0; --i ) {
  1402. colors[i].r = (r[i]>>8);
  1403. colors[i].g = (g[i]>>8);
  1404. colors[i].b = (b[i]>>8);
  1405. }
  1406. }
  1407. return(0);
  1408. }
  1409. return(1);
  1410. }
  1412. /* Note:  If we are terminated, this could be called in the middle of
  1413.    another SDL video routine -- notably UpdateRects.
  1414. */
  1415. static void FB_VideoQuit(_THIS)
  1416. {
  1417. int i, j;
  1419. if ( this->screen ) {
  1420. /* Clear screen and tell SDL not to free the pixels */
  1421. if ( this->screen->pixels && FB_InGraphicsMode(this) ) {
  1422. #ifdef __powerpc__ /* SIGBUS when using memset() ?? */
  1423. Uint8 *rowp = (Uint8 *)this->screen->pixels;
  1424. int left = this->screen->pitch*this->screen->h;
  1425. while ( left-- ) { *rowp++ = 0; }
  1426. #else
  1427. memset(this->screen->pixels,0,this->screen->h*this->screen->pitch);
  1428. #endif
  1429. }
  1430. /* This test fails when using the VGA16 shadow memory */
  1431. if ( ((char *)this->screen->pixels >= mapped_mem) &&
  1432.      ((char *)this->screen->pixels < (mapped_mem+mapped_memlen)) ) {
  1433. this->screen->pixels = NULL;
  1434. }
  1435. }
  1437. /* Clear the lock mutex */
  1438. if ( hw_lock ) {
  1439. SDL_DestroyMutex(hw_lock);
  1440. hw_lock = NULL;
  1441. }
  1443. /* Clean up defined video modes */
  1444. for ( i=0; i<NUM_MODELISTS; ++i ) {
  1445. if ( SDL_modelist[i] != NULL ) {
  1446. for ( j=0; SDL_modelist[i][j]; ++j ) {
  1447. free(SDL_modelist[i][j]);
  1448. }
  1449. free(SDL_modelist[i]);
  1450. SDL_modelist[i] = NULL;
  1451. }
  1452. }
  1454. /* Clean up the memory bucket list */
  1455. FB_FreeHWSurfaces(this);
  1457. /* Close console and input file descriptors */
  1458. if ( console_fd > 0 ) {
  1459. /* Unmap the video framebuffer and I/O registers */
  1460. if ( mapped_mem ) {
  1461. munmap(mapped_mem, mapped_memlen);
  1462. mapped_mem = NULL;
  1463. }
  1464. if ( mapped_io ) {
  1465. munmap(mapped_io, mapped_iolen);
  1466. mapped_io = NULL;
  1467. }
  1469. /* Restore the original video mode and palette */
  1470. if ( FB_InGraphicsMode(this) ) {
  1471. FB_RestorePalette(this);
  1472. ioctl(console_fd, FBIOPUT_VSCREENINFO, &saved_vinfo);
  1473. }
  1475. /* We're all done with the framebuffer */
  1476. close(console_fd);
  1477. console_fd = -1;
  1478. }
  1479. FB_CloseMouse(this);
  1480. FB_CloseKeyboard(this);
  1481. }