SDL_cgxvideo.c
上传用户:sun1608
上传日期:2007-02-02
资源大小:6116k
文件大小:35k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

Visual C++

  1. /*
  2.     SDL - Simple DirectMedia Layer
  3.     Copyright (C) 1997, 1998, 1999, 2000  Sam Lantinga
  4.     This library is free software; you can redistribute it and/or
  5.     modify it under the terms of the GNU Library General Public
  6.     License as published by the Free Software Foundation; either
  7.     version 2 of the License, or (at your option) any later version.
  8.     This library is distributed in the hope that it will be useful,
  9.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.     Library General Public License for more details.
  12.     You should have received a copy of the GNU Library General Public
  13.     License along with this library; if not, write to the Free
  14.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15.     Sam Lantinga
  16.     slouken@libsdl.org
  17. */
  18. #ifdef SAVE_RCSID
  19. static char rcsid =
  20.  "@(#) $Id: SDL_cgxvideo.c,v 1.4 2002/04/22 21:38:04 wmay Exp $";
  21. #endif
  22. /*
  23.  * CGX based SDL video driver implementation by Gabriele Greco
  24.  * gabriele.greco@aruba.it
  25.  */
  26. /*
  27. #include <stdlib.h>
  28. #include <stdio.h>
  29. #include <unistd.h>
  30. #include <string.h>
  31. #include <sys/ioctl.h>
  32. #ifdef MTRR_SUPPORT
  33. #include <asm/mtrr.h>
  34. #include <sys/fcntl.h>
  35. #endif
  36. */
  37. #include "SDL.h"
  38. #include "SDL_error.h"
  39. #include "SDL_timer.h"
  40. #include "SDL_thread.h"
  41. #include "SDL_video.h"
  42. #include "SDL_mouse.h"
  43. #include "SDL_endian.h"
  44. #include "SDL_sysvideo.h"
  45. #include "SDL_pixels_c.h"
  46. #include "SDL_events_c.h"
  47. #include "SDL_cgxgl_c.h"
  48. #include "SDL_cgxvideo.h"
  49. #include "SDL_cgxwm_c.h"
  50. #include "SDL_amigamouse_c.h"
  51. #include "SDL_amigaevents_c.h"
  52. #include "SDL_cgxmodes_c.h"
  53. #include "SDL_cgximage_c.h"
  54. #include "SDL_cgxyuv_c.h"
  55. /* Initialization/Query functions */
  56. static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat);
  57. static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  58. static int CGX_ToggleFullScreen(_THIS, int on);
  59. static void CGX_UpdateMouse(_THIS);
  60. static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
  61. static void CGX_VideoQuit(_THIS);
  62. /* CGX driver bootstrap functions */
  63. struct Library *CyberGfxBase=NULL;
  64. struct IntuitionBase *IntuitionBase=NULL;
  65. struct GfxBase *GfxBase=NULL;
  66. int CGX_SetGamma(_THIS, float red, float green, float blue)
  67. {
  68.     SDL_SetError("Gamma correction not supported");
  69.     return -1;
  70. }
  71. int CGX_GetGamma(_THIS, float red, float green, float blue)
  72. {
  73.     SDL_SetError("Gamma correction not supported");
  74.     return -1;
  75. }
  76. int CGX_SetGammaRamp(_THIS, Uint16 *ramp)
  77. {
  78. #if 0
  79. Int i, ncolors;
  80. XColor xcmap[256];
  81. /* See if actually setting the gamma is supported */
  82. if ( SDL_Visual->class != DirectColor ) {
  83.     SDL_SetError("Gamma correction not supported on this visual");
  84.     return(-1);
  85. }
  86. /* Calculate the appropriate palette for the given gamma ramp */
  87. ncolors = SDL_Visual->map_entries;
  88. for ( i=0; i<ncolors; ++i ) {
  89. Uint8 c = (256 * i / ncolors);
  90. xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c);
  91. xcmap[i].red   = ramp[0*256+c];
  92. xcmap[i].green = ramp[1*256+c];
  93. xcmap[i].blue  = ramp[2*256+c];
  94. xcmap[i].flags = (DoRed|DoGreen|DoBlue);
  95. }
  96. XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
  97. XSync(GFX_Display, False);
  98. return(0);
  99. #else
  100.     SDL_SetError("Gamma correction not supported on this visual");
  101.     return(-1);
  102. #endif
  103. }
  104. static void DestroyScreen(_THIS)
  105. {
  106.    if(currently_fullscreen)
  107. {
  108. if(this->hidden->dbuffer)
  109. {
  110. extern struct MsgPort *safeport,*dispport;
  111. this->hidden->dbuffer=0;
  112. if(safeport)
  113. {
  114. while(GetMsg(safeport)!=NULL);
  115. DeleteMsgPort(safeport);
  116. }
  117. if(dispport)
  118. {
  119. while(GetMsg(dispport)!=NULL);
  120. DeleteMsgPort(dispport);
  121. }
  122. this->hidden->SB[0]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=this->hidden->SB[0]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=NULL;
  123. this->hidden->SB[1]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=this->hidden->SB[1]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=NULL;
  124. if(this->hidden->SB[1])
  125. FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
  126. if(this->hidden->SB[0])
  127. FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);
  128. this->hidden->SB[0]=this->hidden->SB[1]=NULL;
  129. if(SDL_RastPort && SDL_RastPort != &SDL_Display->RastPort)
  130. free(SDL_RastPort);
  131. SDL_RastPort=NULL;
  132. }
  133. CloseScreen(GFX_Display);
  134. currently_fullscreen=0;
  135. }
  136. else if(GFX_Display)
  137. UnlockPubScreen(NULL,GFX_Display);
  138. GFX_Display = NULL;
  139. }
  140. static int CGX_Available(void)
  141. {
  142. struct Library *l;
  143. l = OpenLibrary("cybergraphics.library",0L);
  144. if ( l != NULL ) {
  145. D(bug("CGX video device AVAILABLEn"));
  146. CloseLibrary(l);
  147. }
  148. D(else bug("**CGX video device UNAVAILABLEn"));
  149. return(l != NULL);
  150. }
  151. static void CGX_DeleteDevice(SDL_VideoDevice *device)
  152. {
  153. if ( device ) {
  154. if ( device->hidden ) {
  155. free(device->hidden);
  156. }
  157. if ( device->gl_data ) {
  158. free(device->gl_data);
  159. }
  160. free(device);
  161. }
  162. }
  163. static SDL_VideoDevice *CGX_CreateDevice(int devindex)
  164. {
  165. SDL_VideoDevice *device;
  166. /* Initialize all variables that we clean on shutdown */
  167. device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
  168. if ( device ) {
  169. memset(device, 0, (sizeof *device));
  170. device->hidden = (struct SDL_PrivateVideoData *)
  171. malloc((sizeof *device->hidden));
  172. device->gl_data = (struct SDL_PrivateGLData *)
  173. malloc((sizeof *device->gl_data));
  174. }
  175. if ( (device == NULL) || (device->hidden == NULL) ||
  176.                          (device->gl_data == NULL) ) {
  177. D(bug("Unable to create video device!n"));
  178. SDL_OutOfMemory();
  179. CGX_DeleteDevice(device);
  180. return(0);
  181. }
  182. memset(device->hidden, 0, sizeof(*device->hidden));
  183. memset(device->gl_data, 0, sizeof(*device->gl_data));
  184. /* Set the driver flags */
  185. device->handles_any_size = 1;
  186. /* Set the function pointers */
  187. device->VideoInit = CGX_VideoInit;
  188. device->ListModes = CGX_ListModes;
  189. device->SetVideoMode = CGX_SetVideoMode;
  190. device->ToggleFullScreen = CGX_ToggleFullScreen;
  191. device->UpdateMouse = CGX_UpdateMouse;
  192. #ifdef XFREE86_XV
  193. device->CreateYUVOverlay = X11_CreateYUVOverlay;
  194. #endif
  195. device->SetColors = CGX_SetColors;
  196. device->UpdateRects = NULL;
  197. device->VideoQuit = CGX_VideoQuit;
  198. device->AllocHWSurface = CGX_AllocHWSurface;
  199. device->CheckHWBlit = CGX_CheckHWBlit;
  200. device->FillHWRect = CGX_FillHWRect;
  201. device->SetHWColorKey = CGX_SetHWColorKey;
  202. device->SetHWAlpha = NULL;
  203. device->LockHWSurface = CGX_LockHWSurface;
  204. device->UnlockHWSurface = CGX_UnlockHWSurface;
  205. device->FlipHWSurface = CGX_FlipHWSurface;
  206. device->FreeHWSurface = CGX_FreeHWSurface;
  207. device->SetGamma = CGX_SetGamma;
  208. device->GetGamma = CGX_GetGamma;
  209. device->SetGammaRamp = CGX_SetGammaRamp;
  210. device->GetGammaRamp = NULL;
  211. #ifdef HAVE_OPENGL
  212. device->GL_LoadLibrary = CGX_GL_LoadLibrary;
  213. device->GL_GetProcAddress = CGX_GL_GetProcAddress;
  214. device->GL_GetAttribute = CGX_GL_GetAttribute;
  215. device->GL_MakeCurrent = CGX_GL_MakeCurrent;
  216. device->GL_SwapBuffers = CGX_GL_SwapBuffers;
  217. #endif
  218. device->SetIcon = CGX_SetIcon;
  219. device->SetCaption = CGX_SetCaption;
  220. device->IconifyWindow = NULL; /* CGX_IconifyWindow; */
  221. device->GrabInput = NULL /* CGX_GrabInput*/;
  222. device->GetWMInfo = CGX_GetWMInfo;
  223. device->FreeWMCursor = amiga_FreeWMCursor;
  224. device->CreateWMCursor = amiga_CreateWMCursor;
  225. device->ShowWMCursor = amiga_ShowWMCursor;
  226. device->WarpWMCursor = amiga_WarpWMCursor;
  227. device->CheckMouseMode = amiga_CheckMouseMode;
  228. device->InitOSKeymap = amiga_InitOSKeymap;
  229. device->PumpEvents = amiga_PumpEvents;
  230. device->free = CGX_DeleteDevice;
  231. return device;
  232. }
  233. VideoBootStrap CGX_bootstrap = {
  234. "CGX", "AmigaOS CyberGraphics", CGX_Available, CGX_CreateDevice
  235. };
  236. Uint32 MakeBitMask(_THIS,int type,int format,int *bpp)
  237. {
  238. D(if(type==0)bug("REAL pixel format: "));
  239. if(this->hidden->depth==*bpp)
  240. {
  241. switch(format)
  242.      {
  243. case PIXFMT_LUT8:
  244. D(if(type==0)bug("LUT8n"));
  245. return 0;
  246. case PIXFMT_BGR15:
  247. case PIXFMT_RGB15PC:
  248. switch(type)
  249. {
  250. case 0:
  251. D(bug("RGB15PC/BGR15n"));
  252. return 31;
  253. case 1:
  254. return 992;
  255. case 2:
  256. return 31744;
  257. }
  258. case PIXFMT_RGB15:
  259. case PIXFMT_BGR15PC:
  260. switch(type)
  261. {
  262. case 0:
  263. D(bug("RGB15/BGR15PCn"));
  264. return 31744;
  265. case 1:
  266. return 992;
  267. case 2:
  268. return 31;
  269. }
  270. case PIXFMT_BGR16PC:
  271. case PIXFMT_RGB16:
  272. switch(type)
  273. {
  274. case 0:
  275. D(bug("RGB16PCn"));
  276. return 63488;
  277. case 1:
  278. return 2016;
  279. case 2:
  280. return 31;
  281. }
  282. case PIXFMT_BGR16:
  283. case PIXFMT_RGB16PC:
  284. switch(type)
  285. {
  286. case 0:
  287. D(bug("RGB16PC/BGR16n"));
  288. return 31;
  289. case 1:
  290. return 2016;
  291. case 2:
  292. return 63488;
  293. }
  294. case PIXFMT_RGB24:
  295. switch(type)
  296. {
  297. case 0:
  298. D(bug("RGB24/BGR24n"));
  299. return 0xff0000;
  300. case 1:
  301. return 0xff00;
  302. case 2:
  303. return 0xff;
  304. }
  305. case PIXFMT_BGR24:
  306. switch(type)
  307. {
  308. case 0:
  309. D(bug("BGR24n"));
  310. return 0xff;
  311. case 1:
  312. return 0xff00;
  313. case 2:
  314. return 0xff0000;
  315. }
  316. case PIXFMT_ARGB32:
  317. switch(type)
  318. {
  319. case 0:
  320. D(bug("ARGB32n"));
  321. return 0xff0000;
  322. case 1:
  323. return 0xff00;
  324. case 2:
  325. return 0xff;
  326. }
  327. case PIXFMT_BGRA32:
  328. switch(type)
  329. {
  330. case 0:
  331. D(bug("BGRA32n"));
  332. return 0xff00;
  333. case 1:
  334. return 0xff0000;
  335. case 2:
  336. return 0xff000000;
  337. }
  338. case PIXFMT_RGBA32:
  339. switch(type)
  340. {
  341. case 0:
  342. D(bug("RGBA32n"));
  343. return 0xff000000;
  344. case 1:
  345. return 0xff0000;
  346. case 2:
  347. return 0xff00;
  348. }
  349. default:
  350. D(bug("Unknown pixel format! Default to 24bitn"));
  351. return (Uint32) (255<<(type*8));
  352. }
  353. }
  354. else
  355. {
  356. D(if(type==0)bug("DIFFERENT from screen.nAllocated screen format: "));
  357. switch(*bpp)
  358. {
  359. case 32:
  360. D(if(type==0) bug("RGBA32n"));
  361. switch(type)
  362. {
  363. case 0:
  364. return 0xff000000;
  365. case 1:
  366. return 0xff0000;
  367. case 2:
  368. return 0xff00;
  369. }
  370. break;
  371. case 24:
  372. use_truecolor:
  373. switch(type)
  374. {
  375. case 0:
  376. D(bug("RGB24n"));
  377. return 0xff0000;
  378. case 1:
  379. return 0xff00;
  380. case 2:
  381. return 0xff;
  382. }
  383. case 16:
  384. case 15:
  385. D(if(type==0) bug("Not supported, switching to 24bit!n"));
  386. *bpp=24;
  387. goto use_truecolor;
  388. break;
  389. default:
  390. D(if(type==0)bug("This is a chunky displayn"));
  391. // For chunky display mask is always 0;
  392. return 0;
  393. }
  394. }
  395. return 0;
  396. }
  397. static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
  398. {
  399. int i;
  400. struct Library *RTGBase;
  401. D(bug("VideoInit... Opening librariesn"));
  402. if(!IntuitionBase) {
  403. if( !(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",39L))) {
  404. SDL_SetError("Couldn't open intuition V39+");
  405. return -1;
  406. }
  407. }
  408. if(!GfxBase) {
  409. if( !(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",39L))) {
  410. SDL_SetError("Couldn't open graphics V39+");
  411. return -1;
  412. }
  413. }
  414. if(!CyberGfxBase) {
  415. if( !(CyberGfxBase=OpenLibrary("cybergraphics.library",40L))) {
  416. SDL_SetError("Couldn't open cybergraphics.");
  417. return(-1);
  418. }
  419. }
  420. if(RTGBase=OpenLibrary("libs:picasso96/rtg.library",0L)) {
  421. extern int use_picasso96;
  422. CloseLibrary(RTGBase);
  423. use_picasso96=1;
  424. }
  425. D(bug("Library intialized, locking screen...n"));
  426. SDL_Display = LockPubScreen(NULL);
  427. if ( SDL_Display == NULL ) {
  428. D(bug("Cannot lock display...n"));
  429. SDL_SetError("Couldn't lock the display");
  430. return(-1);
  431. }
  432. D(bug("Checking if we are using a CGX native display...n"));
  433. if(!IsCyberModeID(GetVPModeID(&SDL_Display->ViewPort)))
  434. {
  435. Uint32 okid=BestCModeIDTags(CYBRBIDTG_NominalWidth,SDL_Display->Width,
  436. CYBRBIDTG_NominalHeight,SDL_Display->Height,
  437. CYBRBIDTG_Depth,8,
  438. TAG_DONE);
  439. D(bug("Default visual is not CGX native!n"));
  440. UnlockPubScreen(NULL,SDL_Display);
  441. GFX_Display=NULL;
  442. if(okid!=INVALID_ID)
  443. {
  444. GFX_Display=OpenScreenTags(NULL,
  445. SA_Width,SDL_Display->Width,
  446. SA_Height,SDL_Display->Height,
  447. SA_Depth,8,SA_Quiet,TRUE,
  448. SA_ShowTitle,FALSE,
  449. SA_DisplayID,okid,
  450. TAG_DONE);
  451. }
  452. if(!GFX_Display)
  453. {
  454. SDL_SetError("Unable to open a suited CGX display");
  455. return -1;
  456. }
  457. else SDL_Display=GFX_Display;
  458. }
  459. else GFX_Display = SDL_Display;
  460. /* See whether or not we need to swap pixels */
  461. swap_pixels = 0;
  462. // Non e' detto che sia cosi' pero', alcune schede potrebbero gestire i modi in modo differente
  463. if ( SDL_BYTEORDER == SDL_LIL_ENDIAN ) {
  464. swap_pixels = 1;
  465. }
  466. D(bug("Before GetVideoModes....n"));
  467. /* Get the available video modes */
  468. if(CGX_GetVideoModes(this) < 0)
  469.     return -1;
  470. /* Determine the default screen depth:
  471.    Use the default visual (or at least one with the same depth) */
  472. for(i = 0; i < this->hidden->nvisuals; i++)
  473.     if(this->hidden->visuals[i].depth == GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH))
  474. break;
  475. if(i == this->hidden->nvisuals) {
  476.     /* default visual was useless, take the deepest one instead */
  477.     i = 0;
  478. }
  479. SDL_Visual = this->hidden->visuals[i].visual;
  480. // SDL_XColorMap = SDL_DisplayColormap;
  481. this->hidden->depth = this->hidden->visuals[i].depth;
  482. D(bug("Init: Setting screen depth to: %ldn",this->hidden->depth));
  483. vformat->BitsPerPixel = this->hidden->visuals[i].depth; /* this->hidden->visuals[i].bpp; */
  484. {
  485. int form;
  486. APTR handle;
  487. struct DisplayInfo info;
  488. if(!(handle=FindDisplayInfo(this->hidden->visuals[i].visual)))
  489. {
  490. D(bug("Unable to get visual info...n"));
  491. return -1;
  492. }
  493. if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL)) {
  494. D(bug("Unable to get visual info data...n"));
  495. return -1;
  496. }
  497. form=GetCyberIDAttr(CYBRIDATTR_PIXFMT,SDL_Visual);
  498. // In this case I use makebitmask in a way that I'm sure I'll get PIXFMT pixel mask
  499. if ( vformat->BitsPerPixel > 8 )
  500. {
  501. vformat->Rmask = MakeBitMask(this,0,form,&this->hidden->depth);
  502.    vformat->Gmask = MakeBitMask(this,1,form,&this->hidden->depth);
  503.    vformat->Bmask = MakeBitMask(this,2,form,&this->hidden->depth);
  504. }
  505. }
  506. /* See if we have been passed a window to use */
  507. /* SDL_windowid = getenv("SDL_WINDOWID"); */
  508. SDL_windowid=NULL;
  509. /* Create the blank cursor */
  510. SDL_BlankCursor = AllocMem(16,MEMF_CHIP|MEMF_CLEAR);
  511. /* Fill in some window manager capabilities */
  512. this->info.wm_available = 1;
  513. this->info.blit_hw = 1;
  514. this->info.blit_hw_CC = 1;
  515. this->info.blit_sw = 1;
  516. this->info.blit_fill = 1;
  517. this->info.video_mem=2000000; // Not always true but almost any Amiga card has this memory!
  518. this->hidden->same_format=0;
  519. SDL_RastPort=&SDL_Display->RastPort;
  520. /* We're done! */
  521. D(bug("End of CGX_VideoInitn"));
  522. return(0);
  523. }
  524. void CGX_DestroyWindow(_THIS, SDL_Surface *screen)
  525. {
  526. D(bug("Destroy Window...n"));
  527. if ( ! SDL_windowid ) {
  528. /* Hide the managed window */
  529. int was_fullscreen=0;
  530. /* Clean up OpenGL */
  531. if ( screen ) {
  532. screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT);
  533. }
  534. if ( screen && (screen->flags & SDL_FULLSCREEN) ) {
  535. was_fullscreen=1;
  536. screen->flags &= ~SDL_FULLSCREEN;
  537. // CGX_LeaveFullScreen(this); tolto x crash
  538. }
  539. /* Destroy the output window */
  540. if ( SDL_Window ) {
  541. CloseWindow(SDL_Window);
  542. SDL_Window=NULL;
  543. }
  544. /* Free the colormap entries */
  545. if ( SDL_XPixels ) {
  546. int numcolors;
  547. unsigned long pixel;
  548. if(this->screen->format&&this->hidden->depth==8&&!was_fullscreen)
  549. {
  550. numcolors = 1<<this->screen->format->BitsPerPixel;
  551. if(numcolors>256)
  552. numcolors=256;
  553. if(!was_fullscreen&&this->hidden->depth==8)
  554. {
  555. for ( pixel=0; pixel<numcolors; pixel++ )
  556. {
  557. if(SDL_XPixels[pixel]>=0)
  558. ReleasePen(GFX_Display->ViewPort.ColorMap,SDL_XPixels[pixel]);
  559. }
  560. }
  561. }
  562. free(SDL_XPixels);
  563. SDL_XPixels = NULL;
  564. }
  565. }
  566. }
  567. static void CGX_SetSizeHints(_THIS, int w, int h, Uint32 flags)
  568. {
  569. if ( flags & SDL_RESIZABLE ) {
  570. WindowLimits(SDL_Window, 32, 32,4096,4096);
  571. } else {
  572. WindowLimits(SDL_Window, w,h,w,h);
  573. }
  574. if ( flags & SDL_FULLSCREEN ) {
  575. flags&=~SDL_RESIZABLE;
  576. } else if ( getenv("SDL_VIDEO_CENTERED") ) {
  577. int display_w, display_h;
  578. display_w = SDL_Display->Width;
  579. display_h = SDL_Display->Height;
  580. ChangeWindowBox(SDL_Window,(display_w - w - SDL_Window->BorderLeft-SDL_Window->BorderRight)/2,
  581. (display_h - h - SDL_Window->BorderTop-SDL_Window->BorderBottom)/2,
  582. w+SDL_Window->BorderLeft+SDL_Window->BorderRight,
  583. h+SDL_Window->BorderTop+SDL_Window->BorderBottom);
  584. }
  585. }
  586. int CGX_CreateWindow(_THIS, SDL_Surface *screen,
  587.     int w, int h, int bpp, Uint32 flags)
  588. {
  589. #if 0
  590. int i, depth;
  591. Uint32 vis;
  592. #endif
  593. D(bug("CGX_CreateWindown"));
  594. /* If a window is already present, destroy it and start fresh */
  595. if ( SDL_Window ) {
  596. CGX_DestroyWindow(this, screen);
  597. }
  598. /* See if we have been given a window id */
  599. if ( SDL_windowid ) {
  600. SDL_Window = (struct Window *)atol(SDL_windowid);
  601. } else {
  602. SDL_Window = 0;
  603. }
  604. /* find out which visual we are going to use */
  605. #if 0
  606. /* questo l'ho spostato nell'apertura dello schermo, in quanto su Amiga le finestre
  607.    hanno il pixel mode degli schermi.
  608.  */
  609. /*if ( flags & SDL_OPENGL ) {
  610. SDL_SetError("OpenGL not supported by the Amiga SDL!");
  611. return -1;
  612. }
  613. else {*/
  614. for ( i = 0; i < this->hidden->nvisuals; i++ ) {
  615. if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
  616. break;
  617. }
  618. if ( i == this->hidden->nvisuals ) {
  619. SDL_SetError("No matching visual for requested depth");
  620. return -1; /* should never happen */
  621. }
  622. vis = this->hidden->visuals[i].visual;
  623. depth = this->hidden->visuals[i].depth;
  624. // }
  625. SDL_Visual = vis;
  626. this->hidden->depth = depth;
  627. D(bug("Setting screen depth to: %ldn",this->hidden->depth));
  628. #endif
  629. /* Allocate the new pixel format for this video mode */
  630. {
  631. Uint32 form;
  632. APTR handle;
  633. struct DisplayInfo info;
  634. if(!(handle=FindDisplayInfo(SDL_Visual)))
  635. return -1;
  636. if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL))
  637. return -1;
  638. form=GetCyberIDAttr(CYBRIDATTR_PIXFMT,SDL_Visual);
  639. if(flags&SDL_HWSURFACE)
  640. {
  641. if(bpp!=this->hidden->depth)
  642. {
  643. bpp=this->hidden->depth;
  644. D(bug("Accel forces bpp to be equal (%ld)n",bpp));
  645. }
  646. }
  647. D(bug("BEFORE screen allocation: bpp:%ld (real:%ld)n",bpp,this->hidden->depth));
  648. /* With this call if needed I'll revert the wanted bpp to a bpp best suited for the display, actually occurs
  649.    only with requested format 15/16bit and display format != 15/16bit
  650.  */
  651. if ( ! SDL_ReallocFormat(screen, bpp,
  652. MakeBitMask(this,0,form,&bpp), MakeBitMask(this,1,form,&bpp), MakeBitMask(this,2,form,&bpp), 0) )
  653. return -1;
  654. D(bug("AFTER screen allocation: bpp:%ld (real:%ld)n",bpp,this->hidden->depth));
  655. }
  656. /* Create the appropriate colormap */
  657. /*
  658. if ( SDL_XColorMap != SDL_DisplayColormap ) {
  659. XFreeColormap(SDL_Display, SDL_XColorMap);
  660. }
  661. */
  662. if ( GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_PIXFMT)==PIXFMT_LUT8 || bpp==8 ) {
  663.     int ncolors,i;
  664.     D(bug("XPixels palette allocation...n"));
  665.     /* Allocate the pixel flags */
  666.     if(bpp==8)
  667. ncolors=256;
  668.     else
  669. ncolors = 1 << screen->format->BitsPerPixel;
  670.     SDL_XPixels = (Sint32 *)malloc(ncolors * sizeof(Sint32));
  671.     if(SDL_XPixels == NULL) {
  672. SDL_OutOfMemory();
  673. return -1;
  674.     }
  675.     for(i=0;i<ncolors;i++)
  676.     SDL_XPixels[i]=-1;
  677.     /* always allocate a private colormap on non-default visuals */
  678.     if(bpp==8)
  679. flags |= SDL_HWPALETTE;
  680.     if ( flags & SDL_HWPALETTE )
  681. screen->flags |= SDL_HWPALETTE;
  682. /* resize the (possibly new) window manager window */
  683. /* Create (or use) the X11 display window */
  684. if ( !SDL_windowid ) {
  685. if( flags & SDL_FULLSCREEN )
  686. {
  687. SDL_Window = OpenWindowTags(NULL,WA_Width,w,WA_Height,h,
  688. WA_Flags,WFLG_ACTIVATE|WFLG_RMBTRAP|WFLG_BORDERLESS|WFLG_BACKDROP|WFLG_REPORTMOUSE,
  689. WA_IDCMP,IDCMP_RAWKEY|IDCMP_MOUSEBUTTONS|IDCMP_MOUSEMOVE,
  690. WA_CustomScreen,(ULONG)SDL_Display,
  691. TAG_DONE);
  692. D(bug("Opening backdrop window %ldx%ld on display %lx!n",w,h,SDL_Display));
  693. }
  694. else
  695. {
  696. /* Create GimmeZeroZero window when OpenGL is used */
  697. unsigned long gzz = FALSE;
  698. if( flags & SDL_OPENGL ) {
  699. gzz = TRUE;
  700. }
  701. SDL_Window = OpenWindowTags(NULL,WA_InnerWidth,w,WA_InnerHeight,h,
  702. WA_Flags,WFLG_REPORTMOUSE|WFLG_ACTIVATE|WFLG_RMBTRAP | ((flags&SDL_NOFRAME) ? 0 : (WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_DRAGBAR | ((flags&SDL_RESIZABLE) ? WFLG_SIZEGADGET|WFLG_SIZEBBOTTOM : 0))),
  703. WA_IDCMP,IDCMP_RAWKEY|IDCMP_CLOSEWINDOW|IDCMP_MOUSEBUTTONS|IDCMP_NEWSIZE|IDCMP_MOUSEMOVE,
  704. WA_PubScreen,(ULONG)SDL_Display,
  705. WA_GimmeZeroZero, gzz,
  706. TAG_DONE);
  707. D(bug("Opening WB window of size: %ldx%ld!n",w,h));
  708. }
  709. if(!SDL_Window)
  710. return -1;
  711. }
  712. this->hidden->BytesPerPixel=GetCyberMapAttr(SDL_Window->RPort->BitMap,CYBRMATTR_BPPIX);
  713. if(screen->flags & SDL_DOUBLEBUF)
  714. {
  715. if(SDL_RastPort=malloc(sizeof(struct RastPort)))
  716. {
  717. InitRastPort(SDL_RastPort);
  718. SDL_RastPort->BitMap=this->hidden->SB[1]->sb_BitMap;
  719. }
  720. else
  721. return -1;
  722. }
  723. else SDL_RastPort=SDL_Window->RPort;
  724. if(flags&SDL_HWSURFACE)
  725. screen->flags|=SDL_HWSURFACE;
  726. if( !SDL_windowid ) {
  727.     CGX_SetSizeHints(this, w, h, flags);
  728. current_w = w;
  729. current_h = h;
  730. }
  731. /* Set our colormaps when not setting a GL mode */
  732. /*
  733. if ( ! (flags & SDL_OPENGL) ) {
  734. XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap);
  735. }
  736. */
  737. /* Map them both and go fullscreen, if requested */
  738. if ( ! SDL_windowid ) {
  739. if ( flags & SDL_FULLSCREEN ) {
  740. screen->flags |= SDL_FULLSCREEN;
  741. currently_fullscreen=1;
  742. // CGX_EnterFullScreen(this); Ci siamo gia'!
  743. } else {
  744. screen->flags &= ~SDL_FULLSCREEN;
  745. }
  746. }
  747. screen->w = w;
  748. screen->h = h;
  749. screen->pitch = SDL_CalculatePitch(screen);
  750. CGX_ResizeImage(this, screen, flags);
  751. /* Make OpenGL Context if needed*/
  752. if(flags & SDL_OPENGL) {
  753. if(this->gl_data->gl_active == 0) {
  754. if(CGX_GL_Init(this) < 0)
  755. return -1;
  756. else
  757. screen->flags |= SDL_OPENGL;
  758. }
  759. else {
  760. if(CGX_GL_Update(this) < 0)
  761. return -1;
  762. else
  763. screen->flags |= SDL_OPENGL;
  764. }
  765. }
  766. }
  767. int CGX_ResizeWindow(_THIS,
  768. SDL_Surface *screen, int w, int h, Uint32 flags)
  769. {
  770. D(bug("CGX_ResizeWindown"));
  771. if ( ! SDL_windowid ) {
  772. /* Resize the window manager window */
  773. CGX_SetSizeHints(this, w, h, flags);
  774. current_w = w;
  775. current_h = h;
  776. ChangeWindowBox(SDL_Window,SDL_Window->LeftEdge,SDL_Window->TopEdge, w+SDL_Window->BorderLeft+SDL_Window->BorderRight,
  777. h+SDL_Window->BorderTop+SDL_Window->BorderBottom);
  778. screen->w = w;
  779. screen->h = h;
  780. screen->pitch = SDL_CalculatePitch(screen);
  781. CGX_ResizeImage(this, screen, flags);
  782. }
  783. return(0);
  784. }
  785. static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current,
  786. int width, int height, int bpp, Uint32 flags)
  787. {
  788. Uint32 saved_flags;
  789. int needcreate=0;
  790. D(bug("CGX_SetVideoMode current:%lxn",current));
  791. /* Lock the event thread, in multi-threading environments */
  792. SDL_Lock_EventThread();
  793. // Check if the window needs to be closed or can be resized
  794. if( (flags&SDL_FULLSCREEN) || (current && current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)))
  795. needcreate=1;
  796. // Check if we need to close an already existing videomode...
  797. if(current && current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)) {
  798. unsigned long i;
  799. D(bug("Destroying image, window & screen!n"));
  800. CGX_DestroyImage(this,current);
  801. CGX_DestroyWindow(this,current);
  802. DestroyScreen(this);
  803. GFX_Display=SDL_Display=LockPubScreen(NULL);
  804. bpp=this->hidden->depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);
  805. for ( i = 0; i < this->hidden->nvisuals; i++ ) {
  806. if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
  807. break;
  808. }
  809. if ( i == this->hidden->nvisuals ) {
  810. SDL_SetError("No matching visual for requested depth");
  811. return NULL; /* should never happen */
  812. }
  813. SDL_Visual = this->hidden->visuals[i].visual;
  814. D(bug("Setting screen depth to: %ldn",this->hidden->depth));
  815. }
  816. /* Check the combination of flags we were passed */
  817. if ( flags & SDL_FULLSCREEN ) {
  818. int i;
  819. /* Clear fullscreen flag if not supported */
  820. if ( SDL_windowid ) {
  821. flags &= ~SDL_FULLSCREEN;
  822. }
  823. else if(current && current->flags&SDL_FULLSCREEN ) {
  824. if(current->w!=width ||
  825. current->h!=height ||
  826. (this->hidden && this->hidden->depth!=bpp))
  827. {
  828. D(bug("Deleting previous window...n"));
  829. CGX_DestroyImage(this,current);
  830. CGX_DestroyWindow(this,current);
  831. DestroyScreen(this);
  832. goto buildnewscreen;
  833. }
  834. }
  835. else
  836. buildnewscreen:
  837. {
  838. Uint32 okid=BestCModeIDTags(CYBRBIDTG_NominalWidth,width,
  839. CYBRBIDTG_NominalHeight,height,
  840. CYBRBIDTG_Depth,bpp,
  841. TAG_DONE);
  842. GFX_Display=NULL;
  843. D(bug("Opening screen...n"));
  844. if(okid!=INVALID_ID)
  845. GFX_Display=OpenScreenTags(NULL,
  846. SA_Width,width,
  847. SA_Height,height,
  848. SA_Quiet,TRUE,SA_ShowTitle,FALSE,
  849. SA_Depth,bpp,
  850. SA_DisplayID,okid,
  851. TAG_DONE);
  852. if(!GFX_Display) {
  853. GFX_Display=SDL_Display;
  854. flags &= ~SDL_FULLSCREEN;
  855. flags &= ~SDL_DOUBLEBUF;
  856. }
  857. else {
  858. UnlockPubScreen(NULL,SDL_Display);
  859. SDL_Display=GFX_Display;
  860. D(bug("Screen opened.n"));
  861. if(flags&SDL_DOUBLEBUF) {
  862. int ok=0;
  863. D(bug("Start of DBuffering allocations...n"));
  864. if(this->hidden->SB[0]=AllocScreenBuffer(SDL_Display,NULL,SB_SCREEN_BITMAP)) {
  865. if(this->hidden->SB[1]=AllocScreenBuffer(SDL_Display,NULL,0L)) {
  866. extern struct MsgPort *safeport,*dispport;
  867. safeport=CreateMsgPort();
  868. dispport=CreateMsgPort();
  869. if(!safeport || !dispport) {
  870. if(safeport) {
  871. DeleteMsgPort(safeport);
  872. safeport=NULL;
  873. }
  874. if(dispport) {
  875. DeleteMsgPort(dispport);
  876. dispport=NULL;
  877. }
  878. FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);
  879. FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
  880. }
  881. else {
  882. extern ULONG safe_sigbit,disp_sigbit;
  883. int i;
  884. safe_sigbit=1L<< safeport->mp_SigBit;
  885. disp_sigbit=1L<< dispport->mp_SigBit;
  886. for(i=0;i<2;i++) {
  887. this->hidden->SB[i]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=safeport;
  888. this->hidden->SB[i]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=dispport;
  889. }
  890. ok=1;
  891. D(bug("Dbuffering enabled!n"));
  892. this->hidden->dbuffer=1;
  893. current->flags|=SDL_DOUBLEBUF;
  894. }
  895. }
  896. else {
  897. FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
  898. this->hidden->SB[0]=NULL;
  899. }
  900. }
  901. if(!ok)
  902. flags&=~SDL_DOUBLEBUF;
  903. }
  904. }
  905. if(GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH)==bpp)
  906. this->hidden->same_format=1;
  907. }
  908. bpp=this->hidden->depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);
  909. D(bug("Setting screen depth to: %ldn",this->hidden->depth));
  910. for ( i = 0; i < this->hidden->nvisuals; i++ )
  911. if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
  912. break;
  913. if ( i == this->hidden->nvisuals ) {
  914. SDL_SetError("No matching visual for requested depth");
  915. return NULL; /* should never happen */
  916. }
  917. SDL_Visual = this->hidden->visuals[i].visual;
  918. }
  919. /* Set up the X11 window */
  920. saved_flags = current->flags;
  921. if (SDL_Window && (saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL)
  922.     && bpp == current->format->BitsPerPixel && !needcreate) {
  923. if (CGX_ResizeWindow(this, current, width, height, flags) < 0) {
  924. current = NULL;
  925. goto done;
  926. }
  927. } else {
  928. if (CGX_CreateWindow(this,current,width,height,bpp,flags) < 0) {
  929. current = NULL;
  930. goto done;
  931. }
  932. }
  933. #if 0
  934. /* Set up the new mode framebuffer */
  935. if ( ((current->w != width) || (current->h != height)) ||
  936.              ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) {
  937. current->w = width;
  938. current->h = height;
  939. current->pitch = SDL_CalculatePitch(current);
  940. CGX_ResizeImage(this, current, flags);
  941. }
  942. #endif
  943. current->flags |= (flags&SDL_RESIZABLE); // Resizable only if the user asked it
  944.   done:
  945. /* Release the event thread */
  946. SDL_Unlock_EventThread();
  947. /* We're done! */
  948. return(current);
  949. }
  950. static int CGX_ToggleFullScreen(_THIS, int on)
  951. {
  952. Uint32 event_thread;
  953. /* Don't switch if we don't own the window */
  954. if ( SDL_windowid ) {
  955. return(0);
  956. }
  957. /* Don't lock if we are the event thread */
  958. event_thread = SDL_EventThreadID();
  959. if ( event_thread && (SDL_ThreadID() == event_thread) ) {
  960. event_thread = 0;
  961. }
  962. if ( event_thread ) {
  963. SDL_Lock_EventThread();
  964. }
  965. if ( on ) {
  966. this->screen->flags |= SDL_FULLSCREEN;
  967. CGX_EnterFullScreen(this);
  968. } else {
  969. this->screen->flags &= ~SDL_FULLSCREEN;
  970. CGX_LeaveFullScreen(this);
  971. }
  972. CGX_RefreshDisplay(this);
  973. if ( event_thread ) {
  974. SDL_Unlock_EventThread();
  975. }
  976. SDL_ResetKeyboard();
  977. return(1);
  978. }
  979. static void SetSingleColor(Uint32 fmt, unsigned char r, unsigned char g, unsigned char b, unsigned char *c)
  980. {
  981. switch(fmt)
  982. {
  983. case PIXFMT_BGR15:
  984. case PIXFMT_RGB15PC:
  985. {
  986. Uint16 *t=(Uint16 *)c;
  987. *t=(r>>3) | ((g>>3)<<5) | ((b>>3)<<10) ;
  988. }
  989. break;
  990. case PIXFMT_RGB15:
  991. case PIXFMT_BGR15PC:
  992. {
  993. Uint16 *t=(Uint16 *)c;
  994. *t=(b>>3) | ((g>>3)<<5) | ((r>>3)<<10) ;
  995. }
  996. break;
  997. case PIXFMT_BGR16PC:
  998. case PIXFMT_RGB16:
  999. {
  1000. Uint16 *t=(Uint16 *)c;
  1001. *t=(b>>3) | ((g>>2)<<5) | ((r>>3)<<11) ;
  1002. }
  1003. break;
  1004. case PIXFMT_BGR16:
  1005. case PIXFMT_RGB16PC:
  1006. {
  1007. Uint16 *t=(Uint16 *)c;
  1008. *t=(r>>3) | ((g>>2)<<5) | ((b>>3)<<11) ;
  1009. }
  1010. break;
  1011. case PIXFMT_RGB24:
  1012. c[0]=r;
  1013. c[1]=g;
  1014. c[2]=b;
  1015. c[3]=0;
  1016. break;
  1017. case PIXFMT_BGR24:
  1018. c[0]=b;
  1019. c[1]=g;
  1020. c[2]=r;
  1021. c[3]=0;
  1022. break;
  1023. case PIXFMT_ARGB32:
  1024. c[0]=0;
  1025. c[1]=r;
  1026. c[2]=g;
  1027. c[3]=b;
  1028. break;
  1029. case PIXFMT_BGRA32:
  1030. c[0]=b;
  1031. c[1]=g;
  1032. c[2]=r;
  1033. c[3]=0;
  1034. break;
  1035. case PIXFMT_RGBA32:
  1036. c[0]=r;
  1037. c[1]=g;
  1038. c[2]=b;
  1039. c[3]=0;
  1040. break;
  1041. default:
  1042. D(bug("Error, SetSingleColor with PIXFMT %ld!n",fmt));
  1043. }
  1044. }
  1045. /* Update the current mouse state and position */
  1046. static void CGX_UpdateMouse(_THIS)
  1047. {
  1048. /* Lock the event thread, in multi-threading environments */
  1049. SDL_Lock_EventThread();
  1050. if(currently_fullscreen)
  1051. {
  1052. SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
  1053. SDL_PrivateMouseMotion(0, 0, SDL_Display->MouseX, SDL_Display->MouseY);
  1054. }
  1055. else
  1056. {
  1057. if( SDL_Display->MouseX>=(SDL_Window->LeftEdge+SDL_Window->BorderLeft) && SDL_Display->MouseX<(SDL_Window->LeftEdge+SDL_Window->Width-SDL_Window->BorderRight) &&
  1058. SDL_Display->MouseY>=(SDL_Window->TopEdge+SDL_Window->BorderLeft) && SDL_Display->MouseY<(SDL_Window->TopEdge+SDL_Window->Height-SDL_Window->BorderBottom)
  1059. )
  1060. {
  1061. SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
  1062. SDL_PrivateMouseMotion(0, 0, SDL_Display->MouseX-SDL_Window->LeftEdge-SDL_Window->BorderLeft,
  1063. SDL_Display->MouseY-SDL_Window->TopEdge-SDL_Window->BorderTop);
  1064. }
  1065. else
  1066. {
  1067. SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
  1068. }
  1069. }
  1070. SDL_Unlock_EventThread();
  1071. }
  1072. static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
  1073. {
  1074. int      i;
  1075. /* Check to make sure we have a colormap allocated */
  1076. /* It's easy if we have a hidden colormap */
  1077. if ( (this->screen->flags & SDL_HWPALETTE) && currently_fullscreen )
  1078. {
  1079. ULONG  xcmap[256*3+2];
  1080. xcmap[0]=(ncolors<<16);
  1081. xcmap[0]+=firstcolor;
  1082. // D(bug("Setting %ld colors on an HWPALETTE screenn",ncolors));
  1083. for ( i=0; i<ncolors; i++ ) {
  1084. xcmap[i*3+1] = colors[i+firstcolor].r<<24;
  1085. xcmap[i*3+2] = colors[i+firstcolor].g<<24;
  1086. xcmap[i*3+3] = colors[i+firstcolor].b<<24;
  1087. }
  1088. xcmap[ncolors*3+1]=0;
  1089. LoadRGB32(&GFX_Display->ViewPort,xcmap);
  1090. } else {
  1091. // XPixels are not needed on 8bit screen with hwpalette
  1092. unsigned long pixel;
  1093. if ( SDL_XPixels == NULL ) {
  1094. D(bug("SetColors without colormap!"));
  1095. return(0);
  1096. }
  1097. if(this->hidden->depth==8)
  1098. {
  1099. // In this case I have to unalloc and realloc the full palette
  1100. D(bug("Obtaining %ld colors on the screenn",ncolors));
  1101. /* Free existing allocated colors */
  1102. for ( pixel=0; pixel<this->screen->format->palette->ncolors; ++pixel ) {
  1103. if(SDL_XPixels[pixel]>=0)
  1104. ReleasePen(GFX_Display->ViewPort.ColorMap,SDL_XPixels[pixel]);
  1105. }
  1106. /* Try to allocate all the colors */
  1107. for ( i=0; i<this->screen->format->palette->ncolors; ++i ) {
  1108. SDL_XPixels[i]=ObtainBestPenA(GFX_Display->ViewPort.ColorMap,colors[i].r<<24,colors[i].g<<24,colors[i].b<<24,NULL);
  1109. }
  1110. }
  1111. else
  1112. {
  1113. #ifndef USE_CGX_WRITELUTPIXEL
  1114. Uint32 fmt;
  1115. D(bug("Preparing a conversion pixel table...n"));
  1116. fmt=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_PIXFMT);
  1117. for(i=0;i<ncolors;i++)
  1118. {
  1119. SetSingleColor(fmt,colors[firstcolor+i].r,colors[firstcolor+i].g,colors[firstcolor+i].b,(unsigned char *)&SDL_XPixels[firstcolor+i]);
  1120. }
  1121. #else
  1122. // D(bug("Executing XPixel(%lx) remapping: (from %ld, %ld colors) first: r%ld g%ld b%ldn",SDL_XPixels,firstcolor,ncolors,colors[firstcolor].r,colors[firstcolor].g,colors[firstcolor].b));
  1123. for(i=0;i<ncolors;i++)
  1124. SDL_XPixels[i+firstcolor]=(colors[firstcolor+i].r<<16)+(colors[firstcolor+i].g<<8)+colors[firstcolor+i].b;
  1125. #endif
  1126. }
  1127. }
  1128. // Actually it cannot fail!
  1129. return 1;
  1130. }
  1131. /* Note:  If we are terminated, this could be called in the middle of
  1132.    another SDL video routine -- notably UpdateRects.
  1133. */
  1134. static void CGX_VideoQuit(_THIS)
  1135. {
  1136. /* Shutdown everything that's still up */
  1137. /* The event thread should be done, so we can touch SDL_Display */
  1138. D(bug("CGX_VideoQuitn"));
  1139. if ( SDL_Display != NULL ) {
  1140. /* Clean up OpenGL */
  1141. if(this->gl_data->gl_active == 1) {
  1142. CGX_GL_Quit(this);
  1143. }
  1144. /* Start shutting down the windows */
  1145. D(bug("Destroying image...n"));
  1146. CGX_DestroyImage(this, this->screen);
  1147. D(bug("Destroying window...n"));
  1148. CGX_DestroyWindow(this, this->screen);
  1149. // Otherwise SDL_VideoQuit will try to free it!
  1150. SDL_VideoSurface=NULL;
  1151. CGX_FreeVideoModes(this);
  1152. /* Free that blank cursor */
  1153. if ( SDL_BlankCursor != NULL ) {
  1154. FreeMem(SDL_BlankCursor,16);
  1155. SDL_BlankCursor = NULL;
  1156. }
  1157. /* Close the X11 graphics connection */
  1158. this->hidden->same_format=0;
  1159. D(bug("Destroying screen...n"));
  1160. if ( GFX_Display != NULL )
  1161. DestroyScreen(this);
  1162. /* Close the X11 display connection */
  1163. SDL_Display = NULL;
  1164. /* Unload GL library after X11 shuts down */
  1165. }
  1166. D(bug("Closing libraries...n"));
  1167. if( CyberGfxBase) {
  1168. CloseLibrary(CyberGfxBase);
  1169. CyberGfxBase=NULL;
  1170. }
  1171. if (IntuitionBase) {
  1172. CloseLibrary((struct Library *)IntuitionBase);
  1173. IntuitionBase=NULL;
  1174. }
  1175. if (GfxBase) {
  1176. CloseLibrary((struct Library *)GfxBase);
  1177. GfxBase=NULL;
  1178. }
  1179. if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) {
  1180. /* Direct screen access, no memory buffer */
  1181. this->screen->pixels = NULL;
  1182. }
  1183. D(bug("End of CGX_VideoQuit.n"));
  1184. }