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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

SDL_gsvideo.c：源码内容
  1. /*
  2. SDL - Simple DirectMedia Layer
  3. Copyright (C) 1997, 1998, 1999, 2000  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_gsvideo.c,v 1.3 2002/04/22 21:38:05 wmay Exp $";
  26. #endif
  28. /* Framebuffer console based SDL video driver implementation.
  29. */
  31. #include <stdlib.h>
  32. #include <stdio.h>
  33. #include <fcntl.h>
  34. #include <unistd.h>
  35. #include <sys/ioctl.h>
  36. #include <sys/mman.h>
  38. #include "SDL.h"
  39. #include "SDL_error.h"
  40. #include "SDL_video.h"
  41. #include "SDL_mouse.h"
  42. #include "SDL_sysvideo.h"
  43. #include "SDL_pixels_c.h"
  44. #include "SDL_events_c.h"
  45. #include "SDL_cursor_c.h"
  46. #include "SDL_gsvideo.h"
  47. #include "SDL_gsmouse_c.h"
  48. #include "SDL_gsevents_c.h"
  49. #include "SDL_gsyuv_c.h"
  52. /* Initialization/Query functions */
  53. static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat);
  54. static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  55. static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  56. static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
  57. static void GS_VideoQuit(_THIS);
  59. /* Hardware surface functions */
  60. static int GS_AllocHWSurface(_THIS, SDL_Surface *surface);
  61. static int GS_LockHWSurface(_THIS, SDL_Surface *surface);
  62. static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface);
  63. static void GS_FreeHWSurface(_THIS, SDL_Surface *surface);
  65. /* GS driver bootstrap functions */
  67. static int GS_Available(void)
  68. {
  69. int console, memory;
  71. console = open(PS2_DEV_GS, O_RDWR, 0);
  72. if ( console >= 0 ) {
  73. close(console);
  74. }
  75. memory = open(PS2_DEV_MEM, O_RDWR, 0);
  76. if ( memory >= 0 ) {
  77. close(memory);
  78. }
  79. return((console >= 0) && (memory >= 0));
  80. }
  82. static void GS_DeleteDevice(SDL_VideoDevice *device)
  83. {
  84. free(device->hidden);
  85. free(device);
  86. }
  88. static SDL_VideoDevice *GS_CreateDevice(int devindex)
  89. {
  90. SDL_VideoDevice *this;
  92. /* Initialize all variables that we clean on shutdown */
  93. this = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
  94. if ( this ) {
  95. memset(this, 0, (sizeof *this));
  96. this->hidden = (struct SDL_PrivateVideoData *)
  97. malloc((sizeof *this->hidden));
  98. }
  99. if ( (this == NULL) || (this->hidden == NULL) ) {
  100. SDL_OutOfMemory();
  101. if ( this ) {
  102. free(this);
  103. }
  104. return(0);
  105. }
  106. memset(this->hidden, 0, (sizeof *this->hidden));
  107. mouse_fd = -1;
  108. keyboard_fd = -1;
  110. /* Set the function pointers */
  111. this->VideoInit = GS_VideoInit;
  112. this->ListModes = GS_ListModes;
  113. this->SetVideoMode = GS_SetVideoMode;
  114. this->CreateYUVOverlay = GS_CreateYUVOverlay;
  115. this->SetColors = GS_SetColors;
  116. this->UpdateRects = NULL;
  117. this->VideoQuit = GS_VideoQuit;
  118. this->AllocHWSurface = GS_AllocHWSurface;
  119. this->CheckHWBlit = NULL;
  120. this->FillHWRect = NULL;
  121. this->SetHWColorKey = NULL;
  122. this->SetHWAlpha = NULL;
  123. this->LockHWSurface = GS_LockHWSurface;
  124. this->UnlockHWSurface = GS_UnlockHWSurface;
  125. this->FlipHWSurface = NULL;
  126. this->FreeHWSurface = GS_FreeHWSurface;
  127. this->SetIcon = NULL;
  128. this->SetCaption = NULL;
  129. this->GetWMInfo = NULL;
  130. this->FreeWMCursor = GS_FreeWMCursor;
  131. this->CreateWMCursor = GS_CreateWMCursor;
  132. this->ShowWMCursor = GS_ShowWMCursor;
  133. this->MoveWMCursor = GS_MoveWMCursor;
  134. this->InitOSKeymap = GS_InitOSKeymap;
  135. this->PumpEvents = GS_PumpEvents;
  137. this->free = GS_DeleteDevice;
  139. return this;
  140. }
  142. VideoBootStrap PS2GS_bootstrap = {
  143. "ps2gs", "PlayStation 2 Graphics Synthesizer",
  144. GS_Available, GS_CreateDevice
  145. };
  147. /* These are the pixel formats for the 32, 24, and 16 bit video modes */
  148. static struct {
  149. int bpp;
  150. Uint32 r;
  151. Uint32 g;
  152. Uint32 b;
  153. } GS_pixelmasks[] = {
  154. { 32, 0x000000FF, /* RGB little-endian */
  155.       0x0000FF00,
  156.       0x00FF0000 },
  157. { 24, 0x000000FF, /* RGB little-endian */
  158.       0x0000FF00,
  159.       0x00FF0000 },
  160. { 16, 0x0000001f, /* RGB little-endian */
  161.       0x000003e0,
  162.       0x00007c00 },
  163. };
  164. /* This is a mapping from SDL bytes-per-pixel to GS pixel format */
  165. static int GS_formatmap[] = {
  166. -1, /* 0 bpp, not a legal value */
  167. -1, /* 8 bpp, not supported (yet?) */
  168. PS2_GS_PSMCT16, /* 16 bpp */
  169. PS2_GS_PSMCT24, /* 24 bpp */
  170. PS2_GS_PSMCT32 /* 32 bpp */
  171. };
  173. static unsigned long long head_tags[] __attribute__((aligned(16))) = {
  174. 4 | (1LL << 60), /* GIFtag */
  175. 0x0e, /* A+D */
  176. 0, /* 2 */
  177. PS2_GS_BITBLTBUF,
  178. 0, /* 4 */
  179. PS2_GS_TRXPOS,
  180. 0, /* 6 */
  181. PS2_GS_TRXREG,
  182. 0, /* 8 */
  183. PS2_GS_TRXDIR
  184. };
  186. #define MAXIMG (32767 * 16)
  187. #define MAXTAGS 8
  189. static inline int loadimage_nonblock(int fd, struct ps2_image *image, int size,
  190.                                      unsigned long long *hm,
  191.                                      unsigned long long *im)
  192. {
  193. struct ps2_plist plist;
  194. struct ps2_packet packet[1 + MAXTAGS * 2];
  195. int isize;
  196. int pnum, it, eop;
  197. char *data;
  199. /* initialize the variables */
  200. data = (char *)image->ptr;
  201. pnum = it = eop = 0;
  202. plist.packet = packet;
  204. /* make BITBLT packet */
  205. packet[pnum].ptr = hm;
  206. packet[pnum].len = sizeof(head_tags);
  207. pnum++;
  208. hm[2] = ((unsigned long long)image->fbp << 32) |
  209.         ((unsigned long long)image->fbw << 48) |
  210.         ((unsigned long long)image->psm << 56);
  211. hm[4] = ((unsigned long long)image->x << 32) |
  212.         ((unsigned long long)image->y << 48);
  213. hm[6] = (unsigned long long)image->w |
  214.         ((unsigned long long)image->h << 32);
  216. /* make image mode tags */
  217. while (!eop) {
  218. isize = size > MAXIMG ? MAXIMG : size;
  219. size -= isize;
  220. eop = (size == 0);
  222. packet[pnum].ptr = &im[it];
  223. packet[pnum].len = sizeof(unsigned long long) * 2;
  224. pnum++;
  225. im[it++] = (isize >> 4) | (eop ? (1 << 15) : 0) | (2LL << 58);
  226. im[it++] = 0;
  228. packet[pnum].ptr = (void *)data;
  229. packet[pnum].len = isize;
  230. pnum++;
  231. data += isize;
  232. }
  233. plist.num = pnum;
  235. return ioctl(fd, PS2IOC_SENDL, &plist);
  236. }
  238. static unsigned long long tex_tags[] __attribute__((aligned(16))) = {
  239. 3 | (1LL << 60), /* GIFtag */
  240. 0x0e, /* A+D */
  241. 0, /* 2 */
  242. PS2_GS_TEX0_1,
  243. (1 << 5) + (1 << 6),
  244. PS2_GS_TEX1_1,
  245. 0,
  246. PS2_GS_TEXFLUSH
  247. };
  248. static unsigned long long scale_tags[] __attribute__((aligned(16))) = {
  249. 5 | (1LL << 60), /* GIFtag */
  250. 0x0e, /* A+D */
  251. 6 + (1 << 4) + (1 << 8),
  252. PS2_GS_PRIM,
  253. ((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
  254. PS2_GS_UV,
  255. ((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
  256. PS2_GS_XYZ2,
  257. 0, /* 8 */
  258. PS2_GS_UV,
  259. 0, /* 10 */
  260. PS2_GS_XYZ2
  261. };
  264. int scaleimage_nonblock(int fd, unsigned long long *tm, unsigned long long *sm)
  265. {
  266. struct ps2_plist plist;
  267. struct ps2_packet packet[2];
  269. /* initialize the variables */
  270. plist.num = 2;
  271. plist.packet = packet;
  273. packet[0].ptr = tm;
  274. packet[0].len = sizeof(tex_tags);
  275. packet[1].ptr = sm;
  276. packet[1].len = sizeof(scale_tags);
  278. return ioctl(fd, PS2IOC_SENDL, &plist);
  279. }
  281. static int power_of_2(int value)
  282. {
  283. int shift;
  285. for ( shift = 0; (1<<shift) < value; ++shift ) {
  286. /* Keep looking */ ;
  287. }
  288. return(shift);
  289. }
  291. static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat)
  292. {
  293. struct ps2_screeninfo vinfo;
  295. /* Initialize the library */
  296. console_fd = open(PS2_DEV_GS, O_RDWR, 0);
  297. if ( console_fd < 0 ) {
  298. SDL_SetError("Unable to open %s", PS2_DEV_GS);
  299. return(-1);
  300. }
  301. memory_fd = open(PS2_DEV_MEM, O_RDWR, 0);
  302. if ( memory_fd < 0 ) {
  303. close(console_fd);
  304. console_fd = -1;
  305. SDL_SetError("Unable to open %s", PS2_DEV_MEM);
  306. return(-1);
  307. }
  309. /* Determine the current screen depth */
  310. if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
  311. close(memory_fd);
  312. close(console_fd);
  313. console_fd = -1;
  314. SDL_SetError("Couldn't get console pixel format");
  315. return(-1);
  316. }
  317. switch (vinfo.psm) {
  318.     /* Supported pixel formats */
  319.     case PS2_GS_PSMCT32:
  320.     case PS2_GS_PSMCT24:
  321.     case PS2_GS_PSMCT16:
  322. break;
  323.     default:
  324. GS_VideoQuit(this);
  325. SDL_SetError("Unknown console pixel format: %d", vinfo.psm);
  326. return(-1);
  327. }
  328. vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp;
  329. vformat->Rmask = GS_pixelmasks[vinfo.psm].r;
  330. vformat->Gmask = GS_pixelmasks[vinfo.psm].g;
  331. vformat->Bmask = GS_pixelmasks[vinfo.psm].b;
  332. saved_vinfo = vinfo;
  334. /* Enable mouse and keyboard support */
  335. if ( GS_OpenKeyboard(this) < 0 ) {
  336. GS_VideoQuit(this);
  337. SDL_SetError("Unable to open keyboard");
  338. return(-1);
  339. }
  340. if ( GS_OpenMouse(this) < 0 ) {
  341. const char *sdl_nomouse;
  343. sdl_nomouse = getenv("SDL_NOMOUSE");
  344. if ( ! sdl_nomouse ) {
  345. GS_VideoQuit(this);
  346. SDL_SetError("Unable to open mouse");
  347. return(-1);
  348. }
  349. }
  351. /* We're done! */
  352. return(0);
  353. }
  355. static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
  356. {
  357. static SDL_Rect GS_vesa_mode_list[] = {
  358. { 0, 0, 1280, 1024 },
  359. { 0, 0, 1024, 768 },
  360. { 0, 0, 800, 600 },
  361. { 0, 0, 640, 480 }
  362. };
  363. static SDL_Rect *GS_vesa_modes[] = {
  364. &GS_vesa_mode_list[0],
  365. &GS_vesa_mode_list[1],
  366. &GS_vesa_mode_list[2],
  367. &GS_vesa_mode_list[3],
  368. NULL
  369. };
  370. static SDL_Rect GS_tvout_stretch;
  371. static SDL_Rect GS_tvout_mode;
  372. static SDL_Rect *GS_tvout_modes[3];
  373. SDL_Rect **modes = NULL;
  375. switch (format->BitsPerPixel) {
  376.     case 16:
  377.     case 24:
  378.     case 32:
  379. if ( saved_vinfo.mode == PS2_GS_VESA ) {
  380. modes = GS_vesa_modes;
  381. } else {
  382. int i, j = 0;
  384. // FIXME - what's wrong with the stretch code at 16 bpp?
  385. if ( format->BitsPerPixel != 32 ) break;
  386. /* Add a mode that we could possibly stretch to */
  387. for ( i=0; GS_vesa_modes[i]; ++i ) {
  388. if ( (GS_vesa_modes[i]->w == saved_vinfo.w) &&
  389.      (GS_vesa_modes[i]->h != saved_vinfo.h) ) {
  390. GS_tvout_stretch.w=GS_vesa_modes[i]->w;
  391. GS_tvout_stretch.h=GS_vesa_modes[i]->h;
  392. GS_tvout_modes[j++] = &GS_tvout_stretch;
  393. break;
  394. }
  395. }
  396. /* Add the current TV video mode */
  397. GS_tvout_mode.w = saved_vinfo.w;
  398. GS_tvout_mode.h = saved_vinfo.h;
  399. GS_tvout_modes[j++] = &GS_tvout_mode;
  400. GS_tvout_modes[j++] = NULL;
  402. /* Return the created list of modes */
  403. modes = GS_tvout_modes;
  404. }
  405. break;
  406.     default:
  407. break;
  408. }
  409. return(modes);
  410. }
  412. /* Various screen update functions available */
  413. static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects);
  415. static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current,
  416. int width, int height, int bpp, Uint32 flags)
  417. {
  418. struct ps2_screeninfo vinfo;
  420. /* Set the terminal into graphics mode */
  421. if ( GS_EnterGraphicsMode(this) < 0 ) {
  422. return(NULL);
  423. }
  425. /* Set the video mode and get the final screen format */
  426. if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
  427. SDL_SetError("Couldn't get console screen info");
  428. return(NULL);
  429. }
  430. if ( (vinfo.w != width) || (vinfo.h != height) ||
  431.      (GS_pixelmasks[vinfo.psm].bpp != bpp) ) {
  432. /* If we're not in VESA mode, we have to scale resolution */
  433. if ( saved_vinfo.mode == PS2_GS_VESA ) {
  434. switch (width) {
  435.     case 640:
  436. vinfo.res = PS2_GS_640x480;
  437. break;
  438.     case 800:
  439. vinfo.res = PS2_GS_800x600;
  440. break;
  441.     case 1024:
  442. vinfo.res = PS2_GS_1024x768;
  443. break;
  444.     case 1280:
  445. vinfo.res = PS2_GS_1280x1024;
  446. break;
  447.     default:
  448. SDL_SetError("Unsupported resolution: %dx%dn",
  449.      width, height);
  450. return(NULL);
  451. }
  452. vinfo.res |= (PS2_GS_75Hz << 8);
  453. vinfo.w = width;
  454. vinfo.h = height;
  455. }
  456. vinfo.fbp = 0;
  457. vinfo.psm = GS_formatmap[bpp/8];
  458. if ( vinfo.psm < 0 ) {
  459. SDL_SetError("Unsupported depth: %d bppn", bpp);
  460. return(NULL);
  461. }
  462. if ( ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0 ) {
  463. SDL_SetError("Couldn't set console screen info");
  464. return(NULL);
  465. }
  467. /* Unmap the previous DMA buffer */
  468. if ( mapped_mem ) {
  469. munmap(mapped_mem, mapped_len);
  470. mapped_mem = NULL;
  471. }
  472. }
  473. if ( ! SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp,
  474.                                   GS_pixelmasks[vinfo.psm].r,
  475.                                   GS_pixelmasks[vinfo.psm].g,
  476.                                   GS_pixelmasks[vinfo.psm].b, 0) ) {
  477. return(NULL);
  478. }
  480. /* Set up the new mode framebuffer */
  481. current->flags = SDL_FULLSCREEN;
  482. current->w = width;
  483. current->h = height;
  484. current->pitch = SDL_CalculatePitch(current);
  486. /* Memory map the DMA area for block memory transfer */
  487. if ( ! mapped_mem ) {
  488. pixels_len = height * current->pitch;
  489. mapped_len = pixels_len +
  490.              /* Screen update DMA command area */
  491.              sizeof(head_tags) + ((2 * MAXTAGS) * 16);
  492. if ( saved_vinfo.mode != PS2_GS_VESA ) {
  493. mapped_len += sizeof(tex_tags) + sizeof(scale_tags);
  494. }
  495. mapped_mem = mmap(0, mapped_len, PROT_READ|PROT_WRITE,
  496.                   MAP_SHARED, memory_fd, 0);
  497. if ( mapped_mem == MAP_FAILED ) {
  498. SDL_SetError("Unable to map %d bytes for DMA",
  499.              mapped_len);
  500. mapped_mem = NULL;
  501. return(NULL);
  502. }
  504. /* Set up the entire screen for DMA transfer */
  505. screen_image.ptr = mapped_mem;
  506. screen_image.fbp = 0;
  507. screen_image.fbw = (vinfo.w + 63) / 64;
  508. screen_image.psm = vinfo.psm;
  509. screen_image.x = 0;
  510. if ( vinfo.h == height ) {
  511. screen_image.y = 0;
  512. } else {
  513. /* Put image offscreen and scale to screen height */
  514. screen_image.y = vinfo.h;
  515. }
  516. screen_image.w = current->w;
  517. screen_image.h = current->h;
  519. /* get screen image data size (qword aligned) */
  520. screen_image_size = (screen_image.w * screen_image.h);
  521. switch (screen_image.psm) {
  522.     case PS2_GS_PSMCT32:
  523. screen_image_size *= 4;
  524. break;
  525.     case PS2_GS_PSMCT24:
  526. screen_image_size *= 3;
  527. break;
  528.     case PS2_GS_PSMCT16:
  529. screen_image_size *= 2;
  530. break;
  531. }
  532. screen_image_size = (screen_image_size + 15) & ~15;
  534. /* Set up the memory for screen update DMA commands */
  535. head_tags_mem = (unsigned long long *)
  536.                 (mapped_mem + pixels_len);
  537. image_tags_mem = (unsigned long long *)
  538.                  ((caddr_t)head_tags_mem + sizeof(head_tags));
  539. memcpy(head_tags_mem, head_tags, sizeof(head_tags));
  540. if ( saved_vinfo.mode != PS2_GS_VESA ) {
  541. tex_tags_mem = (unsigned long long *)
  542.                  ((caddr_t)image_tags_mem + ((2*MAXTAGS)*16));
  543. scale_tags_mem = (unsigned long long *)
  544.                  ((caddr_t)tex_tags_mem + sizeof(tex_tags));
  545. memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags));
  546. tex_tags_mem[2] = 
  547. (vinfo.h * vinfo.w) / 64 +
  548.            ((unsigned long long)screen_image.fbw << 14) +
  549.            ((unsigned long long)screen_image.psm << 20) +
  550.            ((unsigned long long)power_of_2(screen_image.w) << 26) +
  551.            ((unsigned long long)power_of_2(screen_image.h) << 30) +
  552.            ((unsigned long long)1 << 34) +
  553.            ((unsigned long long)1 << 35);
  554. memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags));
  555. scale_tags_mem[8] =
  556. ((unsigned long long)screen_image.w * 16) +
  557.          (((unsigned long long)screen_image.h * 16) << 16);
  558. scale_tags_mem[10] =
  559. ((unsigned long long)vinfo.w * 16) +
  560.          (((unsigned long long)vinfo.h * 16) << 16);
  561. }
  562. }
  563. current->pixels = NULL;
  564. if ( getenv("SDL_FULLSCREEN_UPDATE") ) {
  565. /* Correct semantics */
  566. current->flags |= SDL_ASYNCBLIT;
  567. } else {
  568. /* We lie here - the screen memory isn't really the visible
  569.    display memory and still requires an update, but this
  570.    has the desired effect for most applications.
  571.  */
  572. current->flags |= SDL_HWSURFACE;
  573. }
  575. /* Set the update rectangle function */
  576. this->UpdateRects = GS_DMAFullUpdate;
  578. /* We're done */
  579. return(current);
  580. }
  582. /* We don't support hardware surfaces yet */
  583. static int GS_AllocHWSurface(_THIS, SDL_Surface *surface)
  584. {
  585. return(-1);
  586. }
  587. static void GS_FreeHWSurface(_THIS, SDL_Surface *surface)
  588. {
  589. return;
  590. }
  591. static int GS_LockHWSurface(_THIS, SDL_Surface *surface)
  592. {
  593. if ( surface == this->screen ) {
  594. /* Since mouse motion affects 'pixels', lock it */
  595. SDL_LockCursor();
  597. /* Make sure any pending DMA has completed */
  598. if ( dma_pending ) {
  599. ioctl(console_fd, PS2IOC_SENDQCT, 1);
  600. dma_pending = 0;
  601. }
  603. /* If the cursor is drawn on the DMA area, remove it */
  604. if ( cursor_drawn ) {
  605. surface->pixels = mapped_mem + surface->offset;
  606. SDL_EraseCursorNoLock(this->screen);
  607. cursor_drawn = 0;
  608. }
  610. /* Set the surface pixels to the base of the DMA area */
  611. surface->pixels = mapped_mem;
  613. /* We're finished! */
  614. SDL_UnlockCursor();
  615. }
  616. return(0);
  617. }
  618. static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface)
  619. {
  620. if ( surface == this->screen ) {
  621. /* Since mouse motion affects 'pixels', lock it */
  622. SDL_LockCursor();
  623. surface->pixels = NULL;
  624. SDL_UnlockCursor();
  625. }
  626. }
  628. static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects)
  629. {
  630. /* Lock so we aren't interrupted by a mouse update */
  631. SDL_LockCursor();
  633. /* Make sure any pending DMA has completed */
  634. if ( dma_pending ) {
  635. ioctl(console_fd, PS2IOC_SENDQCT, 1);
  636. dma_pending = 0;
  637. }
  639. /* If the mouse is visible, draw it on the DMA area */
  640. if ( (SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn ) {
  641. this->screen->pixels = mapped_mem + this->screen->offset;
  642. SDL_DrawCursorNoLock(this->screen);
  643. this->screen->pixels = NULL;
  644. cursor_drawn = 1;
  645. }
  647. /* Put the image onto the screen */
  648. loadimage_nonblock(console_fd,
  649.                    &screen_image, screen_image_size,
  650.                    head_tags_mem, image_tags_mem);
  651. if ( screen_image.y > 0 ) {
  652. /* Need to scale offscreen image to TV output */
  653. ioctl(console_fd, PS2IOC_SENDQCT, 1);
  654. dma_pending = 0;
  655. scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem);
  656. } else {
  657. dma_pending = 1;
  658. }
  660. /* We're finished! */
  661. SDL_UnlockCursor();
  662. }
  664. static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
  665. {
  666. return(0);
  667. }
  669. static void GS_VideoQuit(_THIS)
  670. {
  671. /* Close console and input file descriptors */
  672. if ( console_fd > 0 ) {
  673. /* Unmap the video framebuffer */
  674. if ( mapped_mem ) {
  675. /* Unmap the video framebuffer */
  676. munmap(mapped_mem, mapped_len);
  677. mapped_mem = NULL;
  678. }
  679. close(memory_fd);
  681. /* Restore the original video mode */
  682. if ( GS_InGraphicsMode(this) ) {
  683. ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo);
  684. }
  686. /* We're all done with the graphics device */
  687. close(console_fd);
  688. console_fd = -1;
  689. }
  690. GS_CloseMouse(this);
  691. GS_CloseKeyboard(this);
  692. }