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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

SDL_gemvideo.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_gemvideo.c,v 1.1 2002/04/22 21:38:05 wmay Exp $";
  26. #endif
  28. /*
  29.  * GEM SDL video driver implementation
  30.  * inspired from the Dummy SDL driver
  31.  * 
  32.  * Patrice Mandin
  33.  * and work from
  34.  * Olivier Landemarre, Johan Klockars, Xavier Joubert, Claude Attard
  35.  */
  37. #include <stdio.h>
  38. #include <stdlib.h>
  39. #include <string.h>
  41. /* Mint includes */
  42. #include <gem.h>
  43. #include <gemx.h>
  44. #include <mint/osbind.h>
  45. #include <sys/cookie.h>
  47. #include "SDL.h"
  48. #include "SDL_error.h"
  49. #include "SDL_video.h"
  50. #include "SDL_mouse.h"
  51. #include "SDL_sysvideo.h"
  52. #include "SDL_pixels_c.h"
  53. #include "SDL_events_c.h"
  54. #include "SDL_cursor_c.h"
  56. #include "SDL_ataric2p_s.h"
  57. #include "SDL_ataric2p060_c.h"
  58. #include "SDL_atarieddi_s.h"
  59. #include "SDL_atarimxalloc_c.h"
  60. #include "SDL_gemvideo.h"
  61. #include "SDL_gemevents_c.h"
  62. #include "SDL_gemmouse_c.h"
  63. #include "SDL_gemwm_c.h"
  64. #include "SDL_xbiosevents_c.h"
  66. /* Defines */
  68. #define GEM_VID_DRIVER_NAME "gem"
  70. /* Variables */
  72. static unsigned char vdi_index[256] = {
  73. 0,  2,  3,  6,  4,  7,  5,   8,
  74. 9, 10, 11, 14, 12, 15, 13, 255
  75. };
  77. static const unsigned char empty_name[]="";
  79. /* Initialization/Query functions */
  80. static int GEM_VideoInit(_THIS, SDL_PixelFormat *vformat);
  81. static SDL_Rect **GEM_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  82. static SDL_Surface *GEM_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  83. static int GEM_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
  84. static void GEM_VideoQuit(_THIS);
  86. /* Hardware surface functions */
  87. static int GEM_AllocHWSurface(_THIS, SDL_Surface *surface);
  88. static int GEM_LockHWSurface(_THIS, SDL_Surface *surface);
  89. static int GEM_FlipHWSurface(_THIS, SDL_Surface *surface);
  90. static void GEM_UnlockHWSurface(_THIS, SDL_Surface *surface);
  91. static void GEM_FreeHWSurface(_THIS, SDL_Surface *surface);
  92. static void GEM_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
  93. #if 0
  94. static int GEM_ToggleFullScreen(_THIS, int on);
  95. #endif
  97. /* Internal functions */
  98. static void GEM_FreeBuffers(_THIS);
  99. static void GEM_ClearScreen(_THIS);
  100. static void GEM_LockScreen(_THIS);
  101. static void GEM_UnlockScreen(_THIS);
  102. static void refresh_window(_THIS, int winhandle, short *rect);
  104. /* GEM driver bootstrap functions */
  106. static int GEM_Available(void)
  107. {
  108. short ap_id;
  109. const char *envr = getenv("SDL_VIDEODRIVER");
  111. /* Check if user asked a different video driver */
  112. if ((envr) && (strcmp(envr, GEM_VID_DRIVER_NAME)!=0)) {
  113. return 0;
  114. }
  116. /* Test if AES available */
  117. ap_id = appl_init();
  118. if (ap_id == -1)
  119. return 0;
  121. appl_exit();
  122. return 1;
  123. }
  125. static void GEM_DeleteDevice(SDL_VideoDevice *device)
  126. {
  127. free(device->hidden);
  128. free(device);
  129. }
  131. static SDL_VideoDevice *GEM_CreateDevice(int devindex)
  132. {
  133. SDL_VideoDevice *device;
  135. /* Initialize all variables that we clean on shutdown */
  136. device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
  137. if ( device ) {
  138. memset(device, 0, (sizeof *device));
  139. device->hidden = (struct SDL_PrivateVideoData *)
  140. malloc((sizeof *device->hidden));
  141. }
  142. if ( (device == NULL) || (device->hidden == NULL) ) {
  143. SDL_OutOfMemory();
  144. if ( device ) {
  145. free(device);
  146. }
  147. return(0);
  148. }
  149. memset(device->hidden, 0, (sizeof *device->hidden));
  151. atari_test_cpu060_present();
  153. /* Set the function pointers */
  154. device->VideoInit = GEM_VideoInit;
  155. device->ListModes = GEM_ListModes;
  156. device->SetVideoMode = GEM_SetVideoMode;
  157. device->SetColors = GEM_SetColors;
  158. device->UpdateRects = NULL /*GEM_UpdateRects*/;
  159. device->VideoQuit = GEM_VideoQuit;
  160. device->AllocHWSurface = GEM_AllocHWSurface;
  161. device->LockHWSurface = GEM_LockHWSurface;
  162. device->UnlockHWSurface = GEM_UnlockHWSurface;
  163. device->FlipHWSurface = GEM_FlipHWSurface;
  164. device->FreeHWSurface = GEM_FreeHWSurface;
  165. device->ToggleFullScreen = NULL /*GEM_ToggleFullScreen*/;
  167. /* Window manager */
  168. device->SetCaption = GEM_SetCaption;
  169. device->SetIcon = NULL /*GEM_SetIcon*/;
  170. device->IconifyWindow = GEM_IconifyWindow;
  171. device->GrabInput = GEM_GrabInput;
  173. /* Events */
  174. device->InitOSKeymap = GEM_InitOSKeymap;
  175. device->PumpEvents = GEM_PumpEvents;
  177. /* Mouse */
  178. device->FreeWMCursor = GEM_FreeWMCursor;
  179. device->CreateWMCursor = GEM_CreateWMCursor;
  180. device->ShowWMCursor = GEM_ShowWMCursor;
  181. device->WarpWMCursor = NULL /*GEM_WarpWMCursor*/;
  182. device->CheckMouseMode = GEM_CheckMouseMode;
  184. /* Joystick + Mouse relative motion */
  185. SDL_AtariXbios_InstallVectors(ATARI_XBIOS_MOUSEEVENTS|ATARI_XBIOS_JOYSTICKEVENTS);
  187. device->free = GEM_DeleteDevice;
  189. return device;
  190. }
  192. VideoBootStrap GEM_bootstrap = {
  193. GEM_VID_DRIVER_NAME, "Atari GEM video driver",
  194. GEM_Available, GEM_CreateDevice
  195. };
  197. static void VDI_ReadExtInfo(_THIS, short *work_out)
  198. {
  199. unsigned long EdDI_version;
  200. unsigned long cookie_EdDI;
  201. Uint32 num_colours;
  202. Uint16 clut_type, num_bits;
  204. /* Read EdDI informations */
  205. if  (Getcookie(C_EdDI, &cookie_EdDI) == C_NOTFOUND) {
  206. return;
  207. }
  209. EdDI_version = Atari_get_EdDI_version( (void *)cookie_EdDI);
  211. vq_scrninfo(VDI_handle, work_out);
  213. VDI_format = work_out[0];
  214. clut_type = work_out[1];
  215. num_bits = work_out[2];
  216. num_colours = *((Uint32 *) &work_out[3]);
  218. /* With EdDI>=1.1, we can have screen pitch, address and format
  219.  * so we can directly write to screen without using vro_cpyfm
  220.  */
  221. if (EdDI_version >= EDDI_11) {
  222. VDI_pitch = work_out[5];
  223. VDI_screen = (void *) *((unsigned long *) &work_out[6]);
  225. switch(num_colours) {
  226. case 32768UL:
  227. if (work_out[14] & (1<<7)) {
  228. /* Little endian */
  229. if (work_out[14] & (1<<1)) {
  230. /* Falcon */
  231. VDI_alphamask = 1 << 13;
  232. VDI_redmask = 31 << 3;
  233. VDI_greenmask = (3 << 14) | 7;
  234. VDI_bluemask = 31 << 8;
  235. } else {
  236. /* Others */
  237. VDI_alphamask = 1 << 7;
  238. VDI_redmask = 31 << 2;
  239. VDI_greenmask = (7 << 13) | 3;
  240. VDI_bluemask = 31 << 8;
  241. }
  242. } else {
  243. /* Big endian */
  244. if (work_out[14] & (1<<1)) {
  245. /* Falcon */
  246. VDI_alphamask = 1 << 5;
  247. VDI_redmask = 31 << 11;
  248. VDI_greenmask = 31 << 6;
  249. VDI_bluemask = 31;
  250. } else {
  251. /* Others */
  252. VDI_alphamask = 1 << 15;
  253. VDI_redmask = 31 << 10;
  254. VDI_greenmask = 31 << 5;
  255. VDI_bluemask = 31;
  256. }
  257. }
  258. break;
  259. case 65536UL:
  260. if (work_out[14] & (1<<7)) {
  261. /* Little endian */
  262. VDI_alphamask = 0;
  263. VDI_redmask = 31 << 3;
  264. VDI_greenmask = (7 << 13) | 7;
  265. VDI_bluemask = 31 << 8;
  266. } else {
  267. /* Big endian */
  268. VDI_alphamask = 0;
  269. VDI_redmask = 31 << 11;
  270. VDI_greenmask = 63 << 5;
  271. VDI_bluemask = 31;
  272. }
  273. break;
  274. case 16777216UL:
  275. if (work_out[14] & (1<<7)) {
  276. /* Little endian */
  277. switch(num_bits) {
  278. case 24:
  279. VDI_alphamask = 0;
  280. VDI_redmask = 255;
  281. VDI_greenmask = 255 << 8;
  282. VDI_bluemask = 255 << 16;
  283. break;
  284. case 32:
  285. VDI_alphamask = 255;
  286. VDI_redmask = 255 << 8;
  287. VDI_greenmask = 255 << 16;
  288. VDI_bluemask = 255 << 24;
  289. break;
  290. }
  291. } else {
  292. /* Big endian */
  293. switch(num_bits) {
  294. case 24:
  295. VDI_alphamask = 0;
  296. VDI_redmask = 255 << 16;
  297. VDI_greenmask = 255 << 8;
  298. VDI_bluemask = 255;
  299. break;
  300. case 32:
  301. VDI_alphamask = 255 << 24;
  302. VDI_redmask = 255 << 16;
  303. VDI_greenmask = 255 << 8;
  304. VDI_bluemask = 255;
  305. break;
  306. }
  307. }
  308. break;
  309. }
  310. }
  312. switch(clut_type) {
  313. case VDI_CLUT_HARDWARE:
  314. {
  315. int i;
  316. Uint16 *tmp_p;
  318. tmp_p = (Uint16 *)&work_out[16];
  320. for (i=0;i<256;i++) {
  321. vdi_index[*tmp_p++] = i;
  322. }
  323. }
  324. break;
  325. case VDI_CLUT_SOFTWARE:
  326. if (EdDI_version < EDDI_11) {
  327. int component; /* red, green, blue, alpha, overlay */
  328. int num_bit;
  329. unsigned short *tmp_p;
  331. /* We can build masks with info here */
  332. tmp_p = (unsigned short *) &work_out[16];
  333. for (component=0;component<5;component++) {
  334. for (num_bit=0;num_bit<16;num_bit++) {
  335. unsigned short valeur;
  337. valeur = *tmp_p++;
  339. if (valeur == 0xffff) {
  340. continue;
  341. }
  343. switch(component) {
  344. case 0:
  345. VDI_redmask |= 1<< valeur;
  346. break;
  347. case 1:
  348. VDI_greenmask |= 1<< valeur;
  349. break;
  350. case 2:
  351. VDI_bluemask |= 1<< valeur;
  352. break;
  353. case 3:
  354. VDI_alphamask |= 1<< valeur;
  355. break;
  356. }
  357. }
  358. }
  359. }
  361. /* Remove lower green bits for Intel endian screen */
  362. if ((VDI_greenmask == ((7<<13)|3)) || (VDI_greenmask == ((7<<13)|7))) {
  363. VDI_greenmask &= ~(7<<13);
  364. }
  365. break;
  366. case VDI_CLUT_NONE:
  367. break;
  368. }
  369. }
  371. int GEM_VideoInit(_THIS, SDL_PixelFormat *vformat)
  372. {
  373. int i;
  374. short work_in[12], work_out[272], dummy;
  376. /* Open AES (Application Environment Services) */
  377. GEM_ap_id = appl_init();
  378. if (GEM_ap_id == -1) {
  379. fprintf(stderr,"Can not open AESn");
  380. return 1;
  381. }
  383. /* Read version and features */
  384. GEM_version = aes_global[0];
  385. if (GEM_version >= 0x0400) {
  386. short ap_gout[4];
  388. GEM_wfeatures=0;
  389. if (appl_getinfo(AES_WINDOW, &ap_gout[0], &ap_gout[1], &ap_gout[2], &ap_gout[3])==0) {
  390. GEM_wfeatures=ap_gout[0];
  391. }
  392. }
  394. /* Ask VDI physical workstation handle opened by AES */
  395. VDI_handle = graf_handle(&dummy, &dummy, &dummy, &dummy);
  396. if (VDI_handle<1) {
  397. fprintf(stderr,"Wrong VDI handle %d returned by AESn",VDI_handle);
  398. return 1;
  399. }
  401. /* Open virtual VDI workstation */
  402. work_in[0]=Getrez()+2;
  403. for(i = 1; i < 10; i++)
  404. work_in[i] = 1;
  405. work_in[10] = 2;
  407. v_opnvwk(work_in, &VDI_handle, work_out);
  408. if (VDI_handle == 0) {
  409. fprintf(stderr,"Can not open VDI virtual workstationn");
  410. return 1;
  411. }
  413. /* Read fullscreen size */
  414. VDI_w = work_out[0] + 1;
  415. VDI_h = work_out[1] + 1;
  417. /* Read desktop size and position */
  418. if (!wind_get(DESKTOP_HANDLE, WF_WORKXYWH, &GEM_desk_x, &GEM_desk_y, &GEM_desk_w, &GEM_desk_h)) {
  419. fprintf(stderr,"Can not read desktop propertiesn");
  420. return 1;
  421. }
  423. /* Read bit depth */
  424. vq_extnd(VDI_handle, 1, work_out);
  425. VDI_bpp = work_out[4];
  426. VDI_oldnumcolors=0;
  428. switch(VDI_bpp) {
  429. case 8:
  430. VDI_pixelsize=1;
  431. break;
  432. case 15:
  433. case 16:
  434. VDI_pixelsize=2;
  435. break;
  436. case 24:
  437. VDI_pixelsize=3;
  438. break;
  439. case 32:
  440. VDI_pixelsize=4;
  441. break;
  442. default:
  443. fprintf(stderr,"%d bits colour depth not supportedn",VDI_bpp);
  444. return 1;
  445. }
  447. /* Setup hardware -> VDI palette mapping */
  448. for(i = 16; i < 255; i++) {
  449. vdi_index[i] = i;
  450. }
  451. vdi_index[255] = 1;
  453. /* Save current palette */
  454. if (VDI_bpp>8) {
  455. VDI_oldnumcolors=1<<8;
  456. } else {
  457. VDI_oldnumcolors=1<<VDI_bpp;
  458. }
  460. for(i = 0; i < VDI_oldnumcolors; i++) {
  461. short rgb[3];
  463. vq_color(VDI_handle, i, 0, rgb);
  465. VDI_oldpalette[i][0] = rgb[0];
  466. VDI_oldpalette[i][1] = rgb[1];
  467. VDI_oldpalette[i][2] = rgb[2];
  468. }
  470. /* Setup screen info */
  471. GEM_title_name = empty_name;
  472. GEM_icon_name = empty_name;
  474. GEM_handle = -1;
  475. GEM_locked = SDL_FALSE;
  476. GEM_win_fulled = SDL_FALSE;
  478. VDI_screen = NULL;
  479. VDI_ReadExtInfo(this, work_out);
  480. if (VDI_screen == NULL) {
  481. VDI_pitch = VDI_w * VDI_pixelsize;
  482. VDI_format = VDI_FORMAT_UNKNOWN;
  483. VDI_redmask = VDI_greenmask = VDI_bluemask = VDI_alphamask = 0;
  484. }
  486. /* Setup destination mfdb */
  487. VDI_dst_mfdb.fd_addr = NULL;
  489. /* Update hardware info */
  490. this->info.hw_available = 0;
  491. this->info.video_mem = 0;
  493. /* TC, screen : no shadow (direct)
  494.      *  8P, screen: no shadow (direct)
  495.      *  8I, screen: shadow, c2p (shadow -> c2p)
  496.  *  TC, no screen: shadow (vro_cpyfm)
  497.  *  8P, no screen: shadow (vro_cpyfm)
  498.  *  8I/U, no screen: shadow, shadow_c2p, c2p (shadow -> c2p -> vro_cpyfm)
  499.  */
  501. /* Determine the screen depth */
  502. /* we change this during the SDL_SetVideoMode implementation... */
  503. vformat->BitsPerPixel = VDI_bpp;
  505. /* Set mouse cursor to arrow */
  506. graf_mouse(ARROW, NULL);
  508. /* Init chunky to planar routine */
  509. Atari_C2pInit = Atari_C2pInit8;
  510. if (atari_cpu060_avail) {
  511. Atari_C2pConvert = Atari_C2pConvert8_060;
  512. } else {
  513. Atari_C2pConvert = Atari_C2pConvert8;
  514. }
  515. Atari_C2pInit();
  517. /* We're done! */
  518. return(0);
  519. }
  521. SDL_Rect **GEM_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
  522. {
  523. if (format->BitsPerPixel == VDI_bpp) {
  524. return((SDL_Rect **)-1);
  525. } else {
  526. return ((SDL_Rect **)NULL);
  527. }
  528. }
  530. static void GEM_FreeBuffers(_THIS)
  531. {
  532. /* Release buffer */
  533. if ( GEM_buffer ) {
  534. free( GEM_buffer );
  535. GEM_buffer=NULL;
  536. }
  538. /* Destroy window */
  539. if (GEM_handle>=0) {
  540. wind_close(GEM_handle);
  541. wind_delete(GEM_handle);
  542. GEM_handle=-1;
  543. }
  544. }
  546. static void GEM_ClearScreen(_THIS)
  547. {
  548. short rgb[3]={0,0,0};
  549. short oldrgb[3];
  550. short pxy[4];
  552. v_hide_c(VDI_handle);
  554. vq_color(VDI_handle, vdi_index[0], 0, oldrgb);
  555. vs_color(VDI_handle, vdi_index[0], rgb);
  557. pxy[0] = pxy[1] = 0;
  558. pxy[2] = VDI_w - 1;
  559. pxy[3] = VDI_h - 1;
  560. vsf_color(VDI_handle,0);
  561. vsf_interior(VDI_handle,1);
  562. vsf_perimeter(VDI_handle,0);
  563. v_bar(VDI_handle,pxy);
  565. vs_color(VDI_handle, vdi_index[0], oldrgb);
  567. v_show_c(VDI_handle, 1);
  568. }
  570. static void GEM_LockScreen(_THIS)
  571. {
  572. if (!GEM_locked) {
  573. /* Reserve memory space, used to be sure of compatibility */
  574. form_dial( FMD_START, 0,0,0,0, 0,0,VDI_w,VDI_h);
  575. /* Lock AES */
  576. wind_update(BEG_UPDATE);
  577. wind_update(BEG_MCTRL);
  579. GEM_locked=SDL_TRUE;
  580. }
  581. }
  583. static void GEM_UnlockScreen(_THIS)
  584. {
  585. if (GEM_locked) {
  586. /* Restore screen memory, and send REDRAW to all apps */
  587. form_dial( FMD_FINISH, 0,0,0,0, 0,0,VDI_w,VDI_h);
  588. /* Unlock AES */
  589. wind_update(END_MCTRL);
  590. wind_update(END_UPDATE);
  592. GEM_locked=SDL_FALSE;
  593. }
  594. }
  596. SDL_Surface *GEM_SetVideoMode(_THIS, SDL_Surface *current,
  597. int width, int height, int bpp, Uint32 flags)
  598. {
  599. int maxwidth, maxheight;
  600. Uint32 modeflags, screensize;
  601. SDL_bool use_shadow;
  603. modeflags = SDL_HWPALETTE;
  604. GEM_FreeBuffers(this);
  606. /*--- Verify if asked mode can be used ---*/
  607. if (flags & SDL_FULLSCREEN) {
  608. maxwidth=VDI_w;
  609. maxheight=VDI_h;
  610. } else {
  611. /* Windowed mode */
  612. maxwidth=GEM_desk_w;
  613. maxheight=GEM_desk_h;
  614. }
  616. if ((maxwidth < width) || (maxheight < height) || (VDI_bpp != bpp)) {
  617. SDL_SetError("Couldn't find requested mode in list");
  618. return(NULL);
  619. }
  621. /*--- Allocate the new pixel format for the screen ---*/
  622. if ( ! SDL_ReallocFormat(current, VDI_bpp, VDI_redmask, VDI_greenmask, VDI_bluemask, VDI_alphamask) ) {
  623. SDL_SetError("Couldn't allocate new pixel format for requested mode");
  624. return(NULL);
  625. }
  627. /*--- Allocate shadow buffer if needed ---*/
  628. use_shadow=SDL_FALSE;
  629. if (flags & SDL_FULLSCREEN) {
  630. if (!VDI_screen) {
  631. /* No access to real framebuffer, use shadow surface */
  632. use_shadow=SDL_TRUE;
  633. } else {
  634. if (VDI_format==VDI_FORMAT_INTER) {
  635. /* Real framebuffer, interleaved bitplanes,
  636.   use shadow surface */
  637. use_shadow=SDL_TRUE;
  638. } else if (flags & SDL_DOUBLEBUF) {
  639. /* Real framebuffer, double-buffered,
  640.   use shadow surface */
  641. use_shadow=SDL_TRUE;
  642. modeflags |= SDL_DOUBLEBUF;
  643. }
  644. }
  645. } else {
  646. /* Windowed mode, always with shadow surface */
  647. use_shadow=SDL_TRUE;
  648. }
  650. if (use_shadow) {
  651. screensize = width * height * VDI_pixelsize;
  653. GEM_buffer = Atari_SysMalloc(screensize, MX_PREFTTRAM);
  654. if (GEM_buffer==NULL) {
  655. fprintf(stderr,"Unable to allocate shadow buffern");
  656. return NULL;
  657. }
  658. memset(GEM_buffer, 0, screensize);
  659. }
  661. /*--- Initialize screen ---*/
  662. if (flags & SDL_FULLSCREEN) {
  663. GEM_LockScreen(this);
  665. GEM_ClearScreen(this);
  667. modeflags |= SDL_FULLSCREEN;
  668. if (VDI_screen && (VDI_format==VDI_FORMAT_PACK) && !use_shadow) {
  669. modeflags |= SDL_HWSURFACE;
  670. } else {
  671. modeflags |= SDL_SWSURFACE;
  672. }
  673. } else {
  674. int posx,posy;
  675. short x2,y2,w2,h2;
  677. GEM_UnlockScreen(this);
  679. /* Center our window */
  680. posx = GEM_desk_x;
  681. posy = GEM_desk_y;
  682. if (width<GEM_desk_w)
  683. posx += (GEM_desk_w - width) >> 1;
  684. if (height<GEM_desk_h)
  685. posy += (GEM_desk_h - height) >> 1;
  687. /* Calculate our window size and position */
  688. if (!(flags & SDL_NOFRAME)) {
  689. GEM_win_type=NAME|MOVER|CLOSER|SMALLER;
  690. if (flags & SDL_RESIZABLE) {
  691. GEM_win_type |= FULLER|SIZER;
  692. modeflags |= SDL_RESIZABLE;
  693. }
  694. } else {
  695. GEM_win_type=0;
  696. modeflags |= SDL_NOFRAME;
  697. }
  699. if (!wind_calc(0, GEM_win_type, posx, posy, width, height, &x2, &y2, &w2, &h2)) {
  700. GEM_FreeBuffers(this);
  701. fprintf(stderr,"Can not calculate window attributesn");
  702. return NULL;
  703. }
  705. /* Create window */
  706. GEM_handle=wind_create(GEM_win_type, x2, y2, w2, h2);
  707. if (GEM_handle<0) {
  708. GEM_FreeBuffers(this);
  709. fprintf(stderr,"Can not create windown");
  710. return NULL;
  711. }
  713. /* Setup window name */
  714. wind_set(GEM_handle,WF_NAME,(short)(((unsigned long)GEM_title_name)>>16),(short)(((unsigned long)GEM_title_name) & 0xffff),0,0);
  716. /* Open the window */
  717. wind_open(GEM_handle,x2,y2,w2,h2);
  719. modeflags |= SDL_SWSURFACE;
  720. }
  722. /* Set up the new mode framebuffer */
  723. current->flags = modeflags;
  724. current->w = width;
  725. current->h = height;
  726. if (use_shadow) {
  727. current->pixels = GEM_buffer;
  728. current->pitch = width * (VDI_bpp >> 3);
  729. } else {
  730. current->pixels = VDI_screen;
  731. current->pixels += VDI_pitch * ((VDI_h - height) >> 1);
  732. current->pixels += VDI_pixelsize * ((VDI_w - width) >> 1);
  733. current->pitch = VDI_pitch;
  734. }
  736. this->UpdateRects = GEM_UpdateRects;
  738. /* We're done */
  739. return(current);
  740. }
  742. /* We don't actually allow hardware surfaces other than the main one */
  743. static int GEM_AllocHWSurface(_THIS, SDL_Surface *surface)
  744. {
  745. return -1;
  746. }
  747. static void GEM_FreeHWSurface(_THIS, SDL_Surface *surface)
  748. {
  749. return;
  750. }
  752. /* We need to wait for vertical retrace on page flipped displays */
  753. static int GEM_LockHWSurface(_THIS, SDL_Surface *surface)
  754. {
  755. return(0);
  756. }
  758. static void GEM_UnlockHWSurface(_THIS, SDL_Surface *surface)
  759. {
  760. return;
  761. }
  763. static void GEM_UpdateRectsFullscreen(_THIS, int numrects, SDL_Rect *rects)
  764. {
  765. SDL_Surface *surface;
  766. MFDB mfdb_src;
  767. short blitcoords[8];
  768. int i;
  770. surface = this->screen;
  772. if (VDI_screen) {
  773. if (VDI_format==VDI_FORMAT_INTER) {
  774. void *destscr;
  775. int destx;
  777. destscr = VDI_screen;
  778. destscr += VDI_pitch * ((VDI_h - surface->h) >> 1);
  779. destx = (VDI_w - surface->w) >> 1;
  780. destx &= ~15;
  781. destscr += destx;
  783. for (i=0;i<numrects;i++) {
  784. void *source,*destination;
  785. int x1,x2;
  787. x1 = rects[i].x & ~15;
  788. x2 = rects[i].x+rects[i].w;
  789. if (x2 & 15) {
  790. x2 = (x2 | 15) +1;
  791. }
  793. source = surface->pixels;
  794. source += surface->pitch * rects[i].y;
  795. source += x1;
  797. destination = destscr;
  798. destination += VDI_pitch * rects[i].y;
  799. destination += x1;
  801. /* Convert chunky to planar screen */
  802. Atari_C2pConvert(
  803. source,
  804. destination,
  805. x2-x1,
  806. rects[i].h,
  807. SDL_FALSE,
  808. surface->pitch,
  809. VDI_pitch
  810. );
  812. }
  814. return;
  815. }
  817. if (!(surface->flags & SDL_DOUBLEBUF)) {
  818. return;
  819. }
  820. }
  822. mfdb_src.fd_addr=surface->pixels;
  823. mfdb_src.fd_w=surface->w;
  824. mfdb_src.fd_h=surface->h;
  825. mfdb_src.fd_wdwidth=(surface->w) >> 4;
  826. mfdb_src.fd_stand=0;
  827. mfdb_src.fd_nplanes=surface->format->BitsPerPixel;
  828. mfdb_src.fd_r1=0;
  829. mfdb_src.fd_r2=0;
  830. mfdb_src.fd_r3=0;
  832. for ( i=0; i<numrects; ++i ) {
  833. blitcoords[0] = rects[i].x;
  834. blitcoords[1] = rects[i].y;
  835. blitcoords[2] = blitcoords[0] + rects[i].w - 1;
  836. blitcoords[3] = blitcoords[1] + rects[i].h - 1;
  838. blitcoords[4] = rects[i].x + ((VDI_w - surface->w) >> 1);
  839. blitcoords[5] = rects[i].y + ((VDI_h - surface->h) >> 1);
  840. blitcoords[6] = blitcoords[4] + rects[i].w - 1;
  841. blitcoords[7] = blitcoords[5] + rects[i].h - 1;
  843. vro_cpyfm(VDI_handle, S_ONLY, blitcoords, &mfdb_src, &VDI_dst_mfdb);
  844. }
  845. }
  847. static void GEM_UpdateRectsWindowed(_THIS, int numrects, SDL_Rect *rects)
  848. {
  849. short pxy[8], wind_pxy[8];
  850. int i;
  852. wind_get(GEM_handle, WF_WORKXYWH, &wind_pxy[0], &wind_pxy[1], &wind_pxy[2], &wind_pxy[3]);
  854. for ( i=0; i<numrects; ++i ) {
  855. pxy[0] = wind_pxy[0] + rects[i].x;
  856. pxy[1] = wind_pxy[1] + rects[i].y;
  857. pxy[2] = rects[i].w;
  858. pxy[3] = rects[i].h;
  860. GEM_wind_redraw(this, GEM_handle, pxy);
  861. }
  862. }
  864. static void GEM_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
  865. {
  866. SDL_Surface *surface;
  868. surface = this->screen;
  870. if (surface->flags & SDL_FULLSCREEN) {
  871. GEM_UpdateRectsFullscreen(this, numrects, rects);
  872. } else {
  873. GEM_UpdateRectsWindowed(this, numrects, rects);
  874. }
  875. }
  877. static int GEM_FlipHWSurfaceFullscreen(_THIS, SDL_Surface *surface)
  878. {
  879. MFDB mfdb_src;
  880. short blitcoords[8];
  882. if (VDI_screen) {
  883. if (VDI_format==VDI_FORMAT_INTER) {
  884. void *destscr;
  885. int destx;
  887. /* Center on destination screen */
  888. destscr = VDI_screen;
  889. destscr += VDI_pitch * ((VDI_h - surface->h) >> 1);
  890. destx = (VDI_w - surface->w) >> 1;
  891. destx &= ~15;
  892. destscr += destx;
  894. /* Convert chunky to planar screen */
  895. Atari_C2pConvert(
  896. surface->pixels,
  897. destscr,
  898. surface->w,
  899. surface->h,
  900. SDL_FALSE,
  901. surface->pitch,
  902. VDI_pitch
  903. );
  905. return(0);
  906. }
  908. if (!(surface->flags & SDL_DOUBLEBUF)) {
  909. return(0);
  910. }
  911. }
  913. mfdb_src.fd_addr=surface->pixels;
  914. mfdb_src.fd_w=surface->w;
  915. mfdb_src.fd_h=surface->h;
  916. mfdb_src.fd_wdwidth=(surface->w) >> 4;
  917. mfdb_src.fd_stand=0;
  918. mfdb_src.fd_nplanes=surface->format->BitsPerPixel;
  919. mfdb_src.fd_r1=0;
  920. mfdb_src.fd_r2=0;
  921. mfdb_src.fd_r3=0;
  923. blitcoords[0] = 0;
  924. blitcoords[1] = 0;
  925. blitcoords[2] = surface->w - 1;
  926. blitcoords[3] = surface->h - 1;
  927. blitcoords[4] = (VDI_w - surface->w) >> 1;
  928. blitcoords[5] = (VDI_h - surface->h) >> 1;
  929. blitcoords[6] = blitcoords[4] + surface->w - 1;
  930. blitcoords[7] = blitcoords[5] + surface->h - 1;
  932. vro_cpyfm(VDI_handle, S_ONLY, blitcoords, &mfdb_src, &VDI_dst_mfdb);
  934. return(0);
  935. }
  937. static int GEM_FlipHWSurfaceWindowed(_THIS, SDL_Surface *surface)
  938. {
  939. short pxy[8];
  941. /* Update the whole window */
  942. wind_get(GEM_handle, WF_WORKXYWH, &pxy[0], &pxy[1], &pxy[2], &pxy[3]);
  944. GEM_wind_redraw(this, GEM_handle, pxy);
  946. return(0);
  947. }
  949. static int GEM_FlipHWSurface(_THIS, SDL_Surface *surface)
  950. {
  951. if (surface->flags & SDL_FULLSCREEN) {
  952. return GEM_FlipHWSurfaceFullscreen(this, surface);
  953. } else {
  954. return GEM_FlipHWSurfaceWindowed(this, surface);
  955. }
  956. }
  958. static int GEM_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
  959. {
  960. int i;
  961. SDL_Surface *surface;
  963. /* Do not change palette in True Colour */
  964. surface = this->screen;
  965. if (surface->format->BitsPerPixel > 8) {
  966. return 1;
  967. }
  969. for(i = 0; i < ncolors; i++)
  970. {
  971. int r, g, b;
  972. short rgb[3];
  974. r = colors[i].r;
  975. g = colors[i].g;
  976. b = colors[i].b;
  978. rgb[0] = (1000 * r) / 255;
  979. rgb[1] = (1000 * g) / 255;
  980. rgb[2] = (1000 * b) / 255;
  982. vs_color(VDI_handle, vdi_index[firstcolor+i], rgb);
  983. }
  985. return(1);
  986. }
  988. #if 0
  989. static int GEM_ToggleFullScreen(_THIS, int on)
  990. {
  991. if (on) {
  992. GEM_LockScreen(this);
  993. } else {
  994. GEM_UnlockScreen(this);
  995. }
  997. return(1);
  998. }
  999. #endif
  1001. /* Note:  If we are terminated, this could be called in the middle of
  1002.    another SDL video routine -- notably UpdateRects.
  1003. */
  1004. void GEM_VideoQuit(_THIS)
  1005. {
  1006. SDL_AtariXbios_RestoreVectors();
  1008. GEM_FreeBuffers(this);
  1010. GEM_UnlockScreen(this);
  1012. appl_exit();
  1014. /* Restore palette */
  1015. if (VDI_oldnumcolors) {
  1016. int i;
  1018. for(i = 0; i < VDI_oldnumcolors; i++) {
  1019. short rgb[3];
  1021. rgb[0] = VDI_oldpalette[i][0];
  1022. rgb[1] = VDI_oldpalette[i][1];
  1023. rgb[2] = VDI_oldpalette[i][2];
  1025. vs_color(VDI_handle, i, rgb);
  1026. }
  1027. }
  1029. /* Close VDI workstation */
  1030. if (VDI_handle) {
  1031. v_clsvwk(VDI_handle);
  1032. }
  1034. /* Free mode list */
  1035. if (SDL_modelist[0]) {
  1036. free(SDL_modelist[0]);
  1037. SDL_modelist[0]=NULL;
  1038. }
  1040. this->screen->pixels = NULL;
  1041. }
  1043. void GEM_wind_redraw(_THIS, int winhandle, short *inside)
  1044. {
  1045. short todo[4];
  1047. /* Tell AES we are going to update */
  1048. wind_update(BEG_UPDATE);
  1050. v_hide_c(VDI_handle);
  1052. /* Browse the rectangle list to redraw */
  1053. wind_get(winhandle, WF_FIRSTXYWH, &todo[0], &todo[1], &todo[2], &todo[3]);
  1055. while (todo[2] && todo[3]) {
  1057. if (rc_intersect((GRECT *)inside,(GRECT *)todo)) {
  1058. todo[2] += todo[0]-1;
  1059. todo[3] += todo[1]-1;
  1060. refresh_window(this, winhandle, todo);
  1061. }
  1063. wind_get(winhandle, WF_NEXTXYWH, &todo[0], &todo[1], &todo[2], &todo[3]);
  1064. }
  1066. /* Update finished */
  1067. wind_update(END_UPDATE);
  1069. v_show_c(VDI_handle,1);
  1070. }
  1072. static void refresh_window(_THIS, int winhandle, short *rect)
  1073. {
  1074. MFDB mfdb_src;
  1075. short pxy[8], wind_pxy[8];
  1076. int iconified;
  1077. SDL_Surface *surface;
  1079. surface=this->screen;
  1081. /* Is window iconified ? */
  1082. iconified = 0;
  1083. if (GEM_wfeatures & (1<<WF_ICONIFY)) {
  1084. wind_get(winhandle, WF_ICONIFY, &wind_pxy[0], &wind_pxy[1], &wind_pxy[2], &wind_pxy[3]);
  1085. iconified = pxy[0];
  1086. }
  1088. wind_get(winhandle, WF_WORKXYWH, &wind_pxy[0], &wind_pxy[1], &wind_pxy[2], &wind_pxy[3]);
  1090. if (iconified) {
  1091. /* Refresh icon */
  1092. mfdb_src.fd_addr=surface->pixels; /* Should be icon image */
  1093. mfdb_src.fd_w=surface->w;
  1094. mfdb_src.fd_h=surface->h;
  1095. mfdb_src.fd_wdwidth=mfdb_src.fd_w>>4;
  1096.    mfdb_src.fd_stand=0;
  1097.    mfdb_src.fd_nplanes=surface->format->BitsPerPixel;
  1098. mfdb_src.fd_r1=0;
  1099.    mfdb_src.fd_r2=0;
  1100.    mfdb_src.fd_r3=0;
  1101. } else {
  1102. /* Refresh window */
  1103. mfdb_src.fd_addr=surface->pixels;
  1104. mfdb_src.fd_w=surface->w;
  1105. mfdb_src.fd_h=surface->h;
  1106. mfdb_src.fd_wdwidth=mfdb_src.fd_w>>4;
  1107.    mfdb_src.fd_stand=0;
  1108.    mfdb_src.fd_nplanes=surface->format->BitsPerPixel;
  1109. mfdb_src.fd_r1=0;
  1110.    mfdb_src.fd_r2=0;
  1111.    mfdb_src.fd_r3=0;
  1112. }
  1114. pxy[0] = rect[0] - wind_pxy[0];
  1115. pxy[1] = rect[1] - wind_pxy[1];
  1116.   pxy[2] = pxy[0] + rect[2] - rect[0];   
  1117.   pxy[3] = pxy[1] + rect[3] - rect[1];  
  1119. pxy[4] = rect[0];
  1120. pxy[5] = rect[1];
  1121. pxy[6] = rect[2];  
  1122. pxy[7] = rect[3];
  1124. vro_cpyfm( VDI_handle, S_ONLY, pxy, &mfdb_src, &VDI_dst_mfdb);
  1125. }