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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

SDL_xbios.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_xbios.c,v 1.1 2002/04/22 21:38:06 wmay Exp $";
  26. #endif
  28. /*
  29.  * Xbios SDL video driver
  30.  * 
  31.  * Patrice Mandin
  32.  */
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <string.h>
  37. #include <sys/stat.h>
  38. #include <unistd.h>
  40. /* Mint includes */
  41. #include <sys/cookie.h>
  42. #include <mint/osbind.h>
  43. #include <mint/falcon.h>
  45. #include "SDL.h"
  46. #include "SDL_error.h"
  47. #include "SDL_video.h"
  48. #include "SDL_mouse.h"
  49. #include "SDL_sysvideo.h"
  50. #include "SDL_pixels_c.h"
  51. #include "SDL_events_c.h"
  53. #include "SDL_ataric2p_s.h"
  54. #include "SDL_ataric2p060_c.h"
  55. #include "SDL_atarievents_c.h"
  56. #include "SDL_atarimxalloc_c.h"
  57. #include "SDL_xbios.h"
  59. #define XBIOS_VID_DRIVER_NAME "xbios"
  61. /* Initialization/Query functions */
  62. static int XBIOS_VideoInit(_THIS, SDL_PixelFormat *vformat);
  63. static SDL_Rect **XBIOS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  64. static SDL_Surface *XBIOS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  65. static int XBIOS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
  66. static void XBIOS_VideoQuit(_THIS);
  68. /* Hardware surface functions */
  69. static int XBIOS_AllocHWSurface(_THIS, SDL_Surface *surface);
  70. static int XBIOS_LockHWSurface(_THIS, SDL_Surface *surface);
  71. static int XBIOS_FlipHWSurface(_THIS, SDL_Surface *surface);
  72. static void XBIOS_UnlockHWSurface(_THIS, SDL_Surface *surface);
  73. static void XBIOS_FreeHWSurface(_THIS, SDL_Surface *surface);
  74. static void XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
  76. /* List of video modes */
  78. /* ST modes */
  79. static int xbiosnummodes_st=1;
  80. static xbiosmode_t xbiosmodelist_st[]={
  81. {ST_LOW>>8,320,200,4,SDL_FALSE}
  82. };
  84. /* TT modes */
  85. static int xbiosnummodes_tt=2;
  86. static xbiosmode_t xbiosmodelist_tt[]={
  87. {TT_LOW,320,480,8,SDL_FALSE},
  88. {TT_LOW,320,240,8,SDL_TRUE} /* Software double-lined mode */
  89. };
  91. /* Falcon RVB modes */
  92. static int xbiosnummodes_f30rvb=16;
  93. static xbiosmode_t xbiosmodelist_f30rvb[]={
  94. {BPS16|COL80|OVERSCAN|VERTFLAG,768,480,16,SDL_FALSE},
  95. {BPS16|COL80|OVERSCAN,768,240,16,SDL_FALSE},
  96. {BPS16|COL80|VERTFLAG,640,400,16,SDL_FALSE},
  97. {BPS16|COL80,640,200,16,SDL_FALSE},
  98. {BPS16|OVERSCAN|VERTFLAG,384,480,16,SDL_FALSE},
  99. {BPS16|OVERSCAN,384,240,16,SDL_FALSE},
  100. {BPS16|VERTFLAG,320,400,16,SDL_FALSE},
  101. {BPS16,320,200,16,SDL_FALSE},
  103. {BPS8|COL80|OVERSCAN|VERTFLAG,768,480,8,SDL_FALSE},
  104. {BPS8|COL80|OVERSCAN,768,240,8,SDL_FALSE},
  105. {BPS8|COL80|VERTFLAG,640,400,8,SDL_FALSE},
  106. {BPS8|COL80,640,200,8,SDL_FALSE},
  107. {BPS8|OVERSCAN|VERTFLAG,384,480,8,SDL_FALSE},
  108. {BPS8|OVERSCAN,384,240,8,SDL_FALSE},
  109. {BPS8|VERTFLAG,320,400,8,SDL_FALSE},
  110. {BPS8,320,200,8,SDL_FALSE}
  111. };
  113. /* Falcon VGA modes */
  114. static int xbiosnummodes_f30vga=6;
  115. static xbiosmode_t xbiosmodelist_f30vga[]={
  116. {BPS16,320,480,16,SDL_FALSE},
  117. {BPS16|VERTFLAG,320,240,16,SDL_FALSE},
  119. {BPS8|COL80,640,480,8,SDL_FALSE},
  120. {BPS8|COL80|VERTFLAG,640,240,8,SDL_FALSE},
  121. {BPS8,320,480,8,SDL_FALSE},
  122. {BPS8|VERTFLAG,320,240,8,SDL_FALSE}
  123. };
  125. /* To setup palette */
  127. static unsigned short TT_palette[256];
  128. static unsigned long F30_palette[256];
  130. /* Xbios driver bootstrap functions */
  132. static int XBIOS_Available(void)
  133. {
  134. const char *envr = getenv("SDL_VIDEODRIVER");
  135. unsigned long cookie_vdo;
  137. /* Check if user asked a different video driver */
  138. if ((envr) && (strcmp(envr, XBIOS_VID_DRIVER_NAME)!=0)) {
  139. return 0;
  140. }
  142. /* Cookie _VDO present ? if not, assume ST machine */
  143. if (Getcookie(C__VDO, &cookie_vdo) != C_FOUND) {
  144. cookie_vdo = VDO_ST << 16;
  145. }
  147. /* Test if we have a monochrome monitor plugged in */
  148. switch( cookie_vdo >>16) {
  149. case VDO_ST:
  150. case VDO_STE:
  151. if ( Getrez() == (ST_HIGH>>8) )
  152. return 0;
  153. break;
  154. case VDO_TT:
  155. if ( (EgetShift() & ES_MODE) == TT_HIGH)
  156. return 0;
  157. break;
  158. case VDO_F30:
  159. if ( Montype() == MONITOR_MONO)
  160. return 0;
  161. break;
  162. default:
  163. return 0;
  164. }
  166. return 1;
  167. }
  169. static void XBIOS_DeleteDevice(SDL_VideoDevice *device)
  170. {
  171. free(device->hidden);
  172. free(device);
  173. }
  175. static SDL_VideoDevice *XBIOS_CreateDevice(int devindex)
  176. {
  177. SDL_VideoDevice *device;
  179. /* Initialize all variables that we clean on shutdown */
  180. device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
  181. if ( device ) {
  182. memset(device, 0, (sizeof *device));
  183. device->hidden = (struct SDL_PrivateVideoData *)
  184. malloc((sizeof *device->hidden));
  185. }
  186. if ( (device == NULL) || (device->hidden == NULL) ) {
  187. SDL_OutOfMemory();
  188. if ( device ) {
  189. free(device);
  190. }
  191. return(0);
  192. }
  193. memset(device->hidden, 0, (sizeof *device->hidden));
  195. atari_test_cpu060_present();
  197. /* Video functions */
  198. device->VideoInit = XBIOS_VideoInit;
  199. device->ListModes = XBIOS_ListModes;
  200. device->SetVideoMode = XBIOS_SetVideoMode;
  201. device->SetColors = XBIOS_SetColors;
  202. device->UpdateRects = NULL;
  203. device->VideoQuit = XBIOS_VideoQuit;
  204. device->AllocHWSurface = XBIOS_AllocHWSurface;
  205. device->LockHWSurface = XBIOS_LockHWSurface;
  206. device->UnlockHWSurface = XBIOS_UnlockHWSurface;
  207. device->FlipHWSurface = XBIOS_FlipHWSurface;
  208. device->FreeHWSurface = XBIOS_FreeHWSurface;
  210. /* Events */
  211. device->InitOSKeymap = Atari_InitOSKeymap;
  212. device->PumpEvents = Atari_PumpEvents;
  214. device->free = XBIOS_DeleteDevice;
  216. return device;
  217. }
  219. VideoBootStrap XBIOS_bootstrap = {
  220. XBIOS_VID_DRIVER_NAME, "Atari Xbios driver",
  221. XBIOS_Available, XBIOS_CreateDevice
  222. };
  224. static int XBIOS_VideoInit(_THIS, SDL_PixelFormat *vformat)
  225. {
  226. int i,j8,j16;
  227. xbiosmode_t *current_mode;
  229. /* Initialize all variables that we clean on shutdown */
  230. memset (SDL_modelist, 0, sizeof(SDL_modelist));
  232. /* Cookie _VDO present ? if not, assume ST machine */
  233. if (Getcookie(C__VDO, &XBIOS_cvdo) != C_FOUND) {
  234. XBIOS_cvdo = VDO_ST << 16;
  235. }
  237. /* Allocate memory for old palette */
  238. XBIOS_oldpalette = (void *)malloc(256*sizeof(long));
  239. if ( !XBIOS_oldpalette ) {
  240. SDL_SetError("Unable to allocate memory for old paletten");
  241. return(-1);
  242. }
  244. /* Initialize video mode list */
  245. /* and save current screen status (palette, screen address, video mode) */
  247. switch (XBIOS_cvdo >>16) {
  248. case VDO_ST:
  249. case VDO_STE:
  250. {
  251. short *oldpalette;
  253. XBIOS_nummodes=xbiosnummodes_st;
  254. XBIOS_modelist=xbiosmodelist_st;
  256. XBIOS_oldvbase=Physbase();
  257. XBIOS_oldvmode=Getrez();
  258. switch(XBIOS_oldvmode << 8) {
  259. case ST_LOW:
  260. XBIOS_oldnumcol=16;
  261. break;
  262. case ST_MED:
  263. XBIOS_oldnumcol=4;
  264. break;
  265. case ST_HIGH:
  266. XBIOS_oldnumcol=2;
  267. break;
  268. default:
  269. XBIOS_oldnumcol=0;
  270. break;
  271. }
  273. oldpalette= (short *) XBIOS_oldpalette;
  274. for (i=0;i<XBIOS_oldnumcol;i++) {
  275. *oldpalette++=Setcolor(i,-1);
  276. }
  278. vformat->BitsPerPixel = 8;
  279. }
  280. break;
  281. case VDO_TT:
  282. XBIOS_nummodes=xbiosnummodes_tt;
  283. XBIOS_modelist=xbiosmodelist_tt;
  285. XBIOS_oldvbase=Logbase();
  286. XBIOS_oldvmode=EgetShift();
  288. switch(XBIOS_oldvmode & ES_MODE) {
  289. case TT_LOW:
  290. XBIOS_oldnumcol=256;
  291. break;
  292. case ST_LOW:
  293. case TT_MED:
  294. XBIOS_oldnumcol=16;
  295. break;
  296. case ST_MED:
  297. XBIOS_oldnumcol=4;
  298. break;
  299. case ST_HIGH:
  300. case TT_HIGH:
  301. XBIOS_oldnumcol=2;
  302. break;
  303. default:
  304. XBIOS_oldnumcol=0;
  305. break;
  306. }
  307. if (XBIOS_oldnumcol) {
  308. EgetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
  309. }
  311. vformat->BitsPerPixel = 8;
  312. break;
  313. case VDO_F30:
  314. switch (Montype())
  315. {
  316. case MONITOR_MONO:
  317. /* Not usable */
  318. break;
  319. case MONITOR_RGB:
  320. case MONITOR_TV:
  321. XBIOS_nummodes = xbiosnummodes_f30rvb;
  322. XBIOS_modelist = xbiosmodelist_f30rvb;
  323. break;
  324. case MONITOR_VGA:
  325. XBIOS_nummodes = xbiosnummodes_f30vga;
  326. XBIOS_modelist = xbiosmodelist_f30vga;
  327. break;
  328. }
  329. XBIOS_oldvbase=Logbase();
  330. XBIOS_oldvmode=Vsetmode(-1);
  332. XBIOS_oldnumcol= 1<< (1 << (XBIOS_oldvmode & NUMCOLS));
  333. if (XBIOS_oldnumcol > 256) {
  334. XBIOS_oldnumcol = 0;
  335. }
  336. if (XBIOS_oldnumcol) {
  337. VgetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
  338. }
  340. vformat->BitsPerPixel = 16;
  342. /* Keep vga/rvb, and pal/ntsc bits */
  343. current_mode = XBIOS_modelist;
  344. for (i=0;i<XBIOS_nummodes;i++) {
  345. Uint16 newvmode;
  347. newvmode = current_mode->number;
  348. newvmode &= ~(VGA|PAL);
  349. newvmode |= XBIOS_oldvmode & (VGA|PAL);
  350. current_mode->number = newvmode;
  352. current_mode++;
  353. }
  355. break;
  356. }
  358. current_mode = XBIOS_modelist;
  359. j8 = j16 = 0;
  360. for (i=0;i<XBIOS_nummodes;i++) {
  361. switch (current_mode->depth) {
  362. case 4:
  363. case 8:
  364. SDL_modelist[0][j8] = malloc(sizeof(SDL_Rect));
  365. SDL_modelist[0][j8]->x = SDL_modelist[0][j8]->y = 0;
  366. SDL_modelist[0][j8]->w = current_mode->width;
  367. SDL_modelist[0][j8]->h = current_mode->height;
  368. XBIOS_videomodes[0][j8]=current_mode;
  369. current_mode++;
  370. j8++;
  371. break;
  372. case 16:
  373. SDL_modelist[1][j16] = malloc(sizeof(SDL_Rect));
  374. SDL_modelist[1][j16]->x = SDL_modelist[1][j16]->y = 0;
  375. SDL_modelist[1][j16]->w = current_mode->width;
  376. SDL_modelist[1][j16]->h = current_mode->height;
  377. XBIOS_videomodes[1][j16]=current_mode;
  378. current_mode++;
  379. j16++;
  380. break;
  381. }
  382. }
  383. SDL_modelist[0][j8] = NULL;
  384. SDL_modelist[1][j16] = NULL;
  386. XBIOS_screens[0]=NULL;
  387. XBIOS_screens[1]=NULL;
  388. XBIOS_shadowscreen=NULL;
  390. /* Update hardware info */
  391. this->info.hw_available = 1;
  392. this->info.video_mem = (Uint32) Atari_SysMalloc(-1L, MX_STRAM);
  394. /* Init chunky to planar routine */
  395. Atari_C2pInit = Atari_C2pInit8;
  396. if (atari_cpu060_avail) {
  397. Atari_C2pConvert = Atari_C2pConvert8_060;
  398. } else {
  399. Atari_C2pConvert = Atari_C2pConvert8;
  400. }
  401. Atari_C2pInit();
  403. /* We're done! */
  404. return(0);
  405. }
  407. static SDL_Rect **XBIOS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
  408. {
  409. /* 8 bits -> list 0 */
  410. /* 16 bits -> list 1 */
  411. return(SDL_modelist[(format->BitsPerPixel)>>4]);
  412. }
  414. static void XBIOS_FreeBuffers(_THIS)
  415. {
  416. int i;
  418. for (i=0;i<2;i++) {
  419. if (XBIOS_screensmem[i]!=NULL) {
  420. Mfree(XBIOS_screensmem[i]);
  421. XBIOS_screensmem[i]=NULL;
  422. }
  423. }
  425. if (XBIOS_shadowscreen!=NULL) {
  426. Mfree(XBIOS_shadowscreen);
  427. XBIOS_shadowscreen=NULL;
  428. }
  429. }
  431. static SDL_Surface *XBIOS_SetVideoMode(_THIS, SDL_Surface *current,
  432. int width, int height, int bpp, Uint32 flags)
  433. {
  434. int mode, new_depth;
  435. int i;
  436. xbiosmode_t *new_video_mode;
  437. Uint32 new_screen_size;
  438. Uint32 modeflags;
  440. /* Free current buffers */
  441. XBIOS_FreeBuffers(this);
  443. /* Search if the mode exists (width, height, bpp) */
  444. bpp >>= 4;
  445. for ( mode=0; SDL_modelist[bpp][mode]; ++mode ) {
  446. if ( (SDL_modelist[bpp][mode]->w == width) &&
  447.      (SDL_modelist[bpp][mode]->h == height) ) {
  449. break;
  450. }
  451. }
  452. if ( SDL_modelist[bpp][mode] == NULL ) {
  453. SDL_SetError("Couldn't find requested mode in list");
  454. return(NULL);
  455. }
  457. modeflags = (SDL_FULLSCREEN|SDL_HWPALETTE);
  459. /* Allocate needed buffers: simple/double buffer and shadow surface */
  460. new_video_mode = XBIOS_videomodes[bpp][mode];
  461. new_depth = new_video_mode->depth;
  462. if (new_depth == 4) {
  463. Atari_C2pInit = Atari_C2pInit4;
  464. if (atari_cpu060_avail) {
  465. Atari_C2pConvert = Atari_C2pConvert4_060;
  466. } else {
  467. Atari_C2pConvert = Atari_C2pConvert4;
  468. }
  469. new_depth=8;
  470. modeflags |= SDL_SWSURFACE;
  471. } else if (new_depth == 8) {
  472. Atari_C2pInit = Atari_C2pInit8;
  473. if (atari_cpu060_avail) {
  474. Atari_C2pConvert = Atari_C2pConvert8_060;
  475. } else {
  476. Atari_C2pConvert = Atari_C2pConvert8;
  477. }
  478. modeflags |= SDL_SWSURFACE;
  479. } else {
  480. modeflags |= SDL_HWSURFACE;
  481. }
  483. new_screen_size = width * height * ((new_depth)>>3);
  484. new_screen_size += 256; /* To align on a 256 byte adress */
  486. if (new_depth == 8) {
  487. XBIOS_shadowscreen = Atari_SysMalloc(new_screen_size, MX_PREFTTRAM);
  489. if (XBIOS_shadowscreen == NULL) {
  490. SDL_SetError("XBIOS_SetVideoMode: Not enough memory for shadow surface");
  491. return (NULL);
  492. }
  493. memset(XBIOS_shadowscreen, 0, new_screen_size);
  494. }
  496. /* Output buffer needs to be twice in size for the software double-line mode */
  497. XBIOS_doubleline = SDL_FALSE;
  498. if (new_video_mode->doubleline) {
  499. new_screen_size <<= 1;
  500. XBIOS_doubleline = SDL_TRUE;
  501. }
  503. XBIOS_screensmem[0] = Atari_SysMalloc(new_screen_size, MX_STRAM);
  505. if (XBIOS_screensmem[0]==NULL) {
  506. XBIOS_FreeBuffers(this);
  507. SDL_SetError("XBIOS_SetVideoMode: Not enough memory for video buffer");
  508. return (NULL);
  509. }
  510. memset(XBIOS_screensmem[0], 0, new_screen_size);
  512. XBIOS_screens[0]=(void *) (( (long) XBIOS_screensmem[0]+256) & 0xFFFFFF00UL);
  514. /* Double buffer ? */
  515. if (flags & SDL_DOUBLEBUF) {
  516. XBIOS_screensmem[1] = Atari_SysMalloc(new_screen_size, MX_STRAM);
  518. if (XBIOS_screensmem[1]==NULL) {
  519. XBIOS_FreeBuffers(this);
  520. SDL_SetError("XBIOS_SetVideoMode: Not enough memory for double buffer");
  521. return (NULL);
  522. }
  523. memset(XBIOS_screensmem[1], 0, new_screen_size);
  525. XBIOS_screens[1]=(void *) (( (long) XBIOS_screensmem[1]+256) & 0xFFFFFF00UL);
  526. modeflags |= SDL_DOUBLEBUF;
  527. }
  529. /* Allocate the new pixel format for the screen */
  530. if ( ! SDL_ReallocFormat(current, new_depth, 0, 0, 0, 0) ) {
  531. XBIOS_FreeBuffers(this);
  532. SDL_SetError("Couldn't allocate new pixel format for requested mode");
  533. return(NULL);
  534. }
  536. current->flags = modeflags;
  537. current->w = XBIOS_width = width;
  538. current->h = XBIOS_height = height;
  539. current->pitch = (width * new_depth)>>3;
  541. /* this is for C2P conversion */
  542. XBIOS_pitch = (new_video_mode->width * new_video_mode->depth)>>3;
  544. if (new_depth == 8)
  545. current->pixels = XBIOS_shadowscreen;
  546. else
  547. current->pixels = XBIOS_screens[0];
  549. XBIOS_fbnum = 0;
  551. /* Now set the video mode */
  552. Setscreen(-1,XBIOS_screens[0],-1);
  554. switch(XBIOS_cvdo >> 16) {
  555. case VDO_ST:
  556. Setscreen(-1,-1,new_video_mode->number);
  557. /* Reset palette */
  558. for (i=0;i<16;i++) {
  559. int c;
  561. c = ((i>>1)<<8) | ((i>>1)<<4) | (i>>1);
  562. if ((i & 1) && (i<15))
  563. c += (1<<4);
  564. if (i==14)
  565. c -= 1<<8;
  567. TT_palette[i]= c;
  568. }
  569. Setpalette(TT_palette);
  570. break;
  571. case VDO_STE:
  572. Setscreen(-1,-1,new_video_mode->number);
  573. /* Reset palette */
  574. for (i=0;i<16;i++)
  575. {
  576. int c;
  578. c=((i&1)<<3)|((i>>1)&7);
  579. TT_palette[i]=(c<<8)|(c<<4)|c;
  580. }
  581. Setpalette(TT_palette);
  582. break;
  583. case VDO_TT:
  584. EsetShift(new_video_mode->number);
  585. break;
  586. case VDO_F30:
  587. Vsetmode(new_video_mode->number);
  588. break;
  589. }
  591. Vsync();
  593. this->UpdateRects = XBIOS_UpdateRects;
  595. return (current);
  596. }
  598. /* We don't actually allow hardware surfaces other than the main one */
  599. static int XBIOS_AllocHWSurface(_THIS, SDL_Surface *surface)
  600. {
  601. return(-1);
  602. }
  604. static void XBIOS_FreeHWSurface(_THIS, SDL_Surface *surface)
  605. {
  606. return;
  607. }
  609. static int XBIOS_LockHWSurface(_THIS, SDL_Surface *surface)
  610. {
  611. return(0);
  612. }
  614. static void XBIOS_UnlockHWSurface(_THIS, SDL_Surface *surface)
  615. {
  616. return;
  617. }
  619. static void XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
  620. {
  621. SDL_Surface *surface;
  623. surface = this->screen;
  625. if ((surface->format->BitsPerPixel) == 8) {
  626. void *destscr;
  627. int destx;
  628. int i;
  630. /* Center on destination screen */
  631. destscr = XBIOS_screens[XBIOS_fbnum];
  632. destscr += XBIOS_pitch * ((XBIOS_height - surface->h) >> 1);
  633. destx = (XBIOS_width - surface->w) >> 1;
  634. destx &= ~15;
  635. destscr += destx;
  637. for (i=0;i<numrects;i++) {
  638. void *source,*destination;
  639. int x1,x2;
  641. x1 = rects[i].x & ~15;
  642. x2 = rects[i].x+rects[i].w;
  643. if (x2 & 15) {
  644. x2 = (x2 | 15) +1;
  645. }
  647. source = surface->pixels;
  648. source += surface->pitch * rects[i].y;
  649. source += x1;
  651. destination = destscr;
  652. destination += XBIOS_pitch * rects[i].y;
  653. destination += x1;
  655. /* Convert chunky to planar screen */
  656. Atari_C2pConvert(
  657. source,
  658. destination,
  659. x2-x1,
  660. rects[i].h,
  661. XBIOS_doubleline,
  662. surface->pitch,
  663. XBIOS_pitch
  664. );
  665. }
  666. }
  668. Setscreen(-1,XBIOS_screens[XBIOS_fbnum],-1);
  669. Vsync();
  671. if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
  672. XBIOS_fbnum ^= 1;
  673. if ((surface->format->BitsPerPixel) > 8) {
  674. surface->pixels=XBIOS_screens[XBIOS_fbnum];
  675. }
  676. }
  677. }
  679. static int XBIOS_FlipHWSurface(_THIS, SDL_Surface *surface)
  680. {
  681. if ((surface->format->BitsPerPixel) == 8) {
  682. void *destscr;
  683. int destx;
  685. /* Center on destination screen */
  686. destscr = XBIOS_screens[XBIOS_fbnum];
  687. destscr += XBIOS_pitch * ((XBIOS_height - surface->h) >> 1);
  688. destx = (XBIOS_width - surface->w) >> 1;
  689. destx &= ~15;
  690. destscr += destx;
  692. /* Convert chunky to planar screen */
  693. Atari_C2pConvert(
  694. surface->pixels,
  695. destscr,
  696. surface->w,
  697. surface->h,
  698. XBIOS_doubleline,
  699. surface->pitch,
  700. XBIOS_pitch
  701. );
  702. }
  704. Setscreen(-1,XBIOS_screens[XBIOS_fbnum],-1);
  705. Vsync();
  707. if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
  708. XBIOS_fbnum ^= 1;
  709. if ((surface->format->BitsPerPixel) > 8) {
  710. surface->pixels=XBIOS_screens[XBIOS_fbnum];
  711. }
  712. }
  714. return(0);
  715. }
  717. static int XBIOS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
  718. {
  719. int i;
  720. int r,v,b;
  722. switch( XBIOS_cvdo >> 16) {
  723. case VDO_ST:
  724. case VDO_STE:
  725.   for (i=0;i<ncolors;i++)
  726. {
  727. r = colors[i].r;
  728. v = colors[i].g;
  729. b = colors[i].b;
  731. TT_palette[firstcolor+i]=((r*30)+(v*59)+(b*11))/100;
  732. }
  733. Atari_C2pConvert4_pal(TT_palette); /* convert the lighting */
  734. break;
  735. case VDO_TT:
  736. for(i = 0; i < ncolors; i++)
  737. {
  738. r = colors[i].r;
  739. v = colors[i].g;
  740. b = colors[i].b;
  742. TT_palette[i]=((r>>4)<<8)|((v>>4)<<4)|(b>>4);
  743. }
  744. EsetPalette(firstcolor,ncolors,TT_palette);
  745. break;
  746. case VDO_F30:
  747. for(i = 0; i < ncolors; i++)
  748. {
  749. r = colors[i].r;
  750. v = colors[i].g;
  751. b = colors[i].b;
  753. F30_palette[i]=(r<<16)|(v<<8)|b;
  754. }
  755. VsetRGB(firstcolor,ncolors,F30_palette);
  756. break;
  757. }
  759. return(1);
  760. }
  762. /* Note:  If we are terminated, this could be called in the middle of
  763.    another SDL video routine -- notably UpdateRects.
  764. */
  765. static void XBIOS_VideoQuit(_THIS)
  766. {
  767. int i,j;
  769. Atari_ShutdownEvents();
  771. /* Restore video mode and palette */
  772. switch(XBIOS_cvdo >> 16) {
  773. case VDO_ST:
  774. case VDO_STE:
  775. Setscreen(-1,XBIOS_oldvbase,XBIOS_oldvmode);
  776. if (XBIOS_oldnumcol) {
  777. Setpalette(XBIOS_oldpalette);
  778. }
  779. break;
  780. case VDO_TT:
  781. Setscreen(-1,XBIOS_oldvbase,-1);
  782. EsetShift(XBIOS_oldvmode);
  783. if (XBIOS_oldnumcol) {
  784. EsetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
  785. }
  786. break;
  787. case VDO_F30:
  788. Setscreen(-1, XBIOS_oldvbase, -1);
  789. Vsetmode(XBIOS_oldvmode);
  790. if (XBIOS_oldnumcol) {
  791. VsetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
  792. }
  793. break;
  794. }
  795. Vsync();
  797. if (XBIOS_oldpalette) {
  798. free(XBIOS_oldpalette);
  799. XBIOS_oldpalette=NULL;
  800. }
  801. XBIOS_FreeBuffers(this);
  803. /* Free mode list */
  804. for (j=0;j<NUM_MODELISTS;j++) {
  805. for (i=0;i<SDL_NUMMODES;i++) {
  806. if (SDL_modelist[j][i]!=NULL) {
  807. free(SDL_modelist[j][i]);
  808. SDL_modelist[j][i]=NULL;
  809. }
  810. }
  811. }
  813. this->screen->pixels = NULL;
  814. }