Mercurial > sdl-ios-xcode
comparison src/video/dga/SDL_dgavideo.c @ 292:eadc0746dfaf
Added SDL_LockRect() and SDL_UnlockRect()
Incorporated XFree86 extension libraries into the source
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Tue, 05 Mar 2002 19:55:32 +0000 |
parents | e8157fcb3114 |
children | f6ffac90895c |
comparison
equal
deleted
inserted
replaced
291:68a8a8237c09 | 292:eadc0746dfaf |
---|---|
29 */ | 29 */ |
30 | 30 |
31 #include <stdlib.h> | 31 #include <stdlib.h> |
32 #include <string.h> | 32 #include <string.h> |
33 #include <X11/Xlib.h> | 33 #include <X11/Xlib.h> |
34 #include <X11/extensions/xf86dga.h> | 34 #include <XFree86/extensions/xf86dga.h> |
35 | 35 |
36 #ifdef HAVE_ALLOCA_H | 36 #ifdef HAVE_ALLOCA_H |
37 #include <alloca.h> | 37 #include <alloca.h> |
38 #endif | 38 #endif |
39 | 39 |
85 (strncmp(XDisplayName(display), "unix:", 5) == 0) ) { | 85 (strncmp(XDisplayName(display), "unix:", 5) == 0) ) { |
86 dpy = XOpenDisplay(display); | 86 dpy = XOpenDisplay(display); |
87 if ( dpy ) { | 87 if ( dpy ) { |
88 int events, errors, major, minor; | 88 int events, errors, major, minor; |
89 | 89 |
90 if ( XDGAQueryExtension(dpy, &events, &errors) && | 90 if ( SDL_NAME(XDGAQueryExtension)(dpy, &events, &errors) && |
91 XDGAQueryVersion(dpy, &major, &minor) ) { | 91 SDL_NAME(XDGAQueryVersion)(dpy, &major, &minor) ) { |
92 int screen; | 92 int screen; |
93 | 93 |
94 screen = DefaultScreen(dpy); | 94 screen = DefaultScreen(dpy); |
95 if ( (major >= 2) && | 95 if ( (major >= 2) && |
96 XDGAOpenFramebuffer(dpy, screen) ) { | 96 SDL_NAME(XDGAOpenFramebuffer)(dpy, screen) ) { |
97 available = 1; | 97 available = 1; |
98 XDGACloseFramebuffer(dpy, screen); | 98 SDL_NAME(XDGACloseFramebuffer)(dpy, screen); |
99 } | 99 } |
100 } | 100 } |
101 XCloseDisplay(dpy); | 101 XCloseDisplay(dpy); |
102 } | 102 } |
103 } | 103 } |
214 | 214 |
215 /* This whole function is a hack. :) */ | 215 /* This whole function is a hack. :) */ |
216 static Uint32 get_video_size(_THIS) | 216 static Uint32 get_video_size(_THIS) |
217 { | 217 { |
218 /* This is a non-exported function from libXxf86dga.a */ | 218 /* This is a non-exported function from libXxf86dga.a */ |
219 extern unsigned char *XDGAGetMappedMemory(int screen); | 219 extern unsigned char *SDL_NAME(XDGAGetMappedMemory)(int screen); |
220 FILE *proc; | 220 FILE *proc; |
221 unsigned long mem; | 221 unsigned long mem; |
222 unsigned start, stop; | 222 unsigned start, stop; |
223 char line[BUFSIZ]; | 223 char line[BUFSIZ]; |
224 Uint32 size; | 224 Uint32 size; |
225 | 225 |
226 mem = (unsigned long)XDGAGetMappedMemory(DGA_Screen); | 226 mem = (unsigned long)SDL_NAME(XDGAGetMappedMemory)(DGA_Screen); |
227 size = 0; | 227 size = 0; |
228 proc = fopen("/proc/self/maps", "r"); | 228 proc = fopen("/proc/self/maps", "r"); |
229 if ( proc ) { | 229 if ( proc ) { |
230 while ( fgets(line, sizeof(line)-1, proc) ) { | 230 while ( fgets(line, sizeof(line)-1, proc) ) { |
231 sscanf(line, "%x-%x", &start, &stop); | 231 sscanf(line, "%x-%x", &start, &stop); |
238 } | 238 } |
239 return(size); | 239 return(size); |
240 } | 240 } |
241 | 241 |
242 #ifdef DGA_DEBUG | 242 #ifdef DGA_DEBUG |
243 static void PrintMode(XDGAMode *mode) | 243 static void PrintMode(SDL_NAME(XDGAMode) *mode) |
244 { | 244 { |
245 printf("Mode: %s (%dx%d) at %d bpp (%f refresh, %d pitch) num: %d\n", | 245 printf("Mode: %s (%dx%d) at %d bpp (%f refresh, %d pitch) num: %d\n", |
246 mode->name, | 246 mode->name, |
247 mode->viewportWidth, mode->viewportHeight, | 247 mode->viewportWidth, mode->viewportHeight, |
248 mode->depth == 24 ? mode->bitsPerPixel : mode->depth, | 248 mode->depth == 24 ? mode->bitsPerPixel : mode->depth, |
276 } | 276 } |
277 #endif /* DGA_DEBUG */ | 277 #endif /* DGA_DEBUG */ |
278 | 278 |
279 static int cmpmodes(const void *va, const void *vb) | 279 static int cmpmodes(const void *va, const void *vb) |
280 { | 280 { |
281 const XDGAMode *a = (const XDGAMode *)va; | 281 const SDL_NAME(XDGAMode) *a = (const SDL_NAME(XDGAMode) *)va; |
282 const XDGAMode *b = (const XDGAMode *)vb; | 282 const SDL_NAME(XDGAMode) *b = (const SDL_NAME(XDGAMode) *)vb; |
283 | 283 |
284 /* Prefer DirectColor visuals for otherwise equal modes */ | 284 /* Prefer DirectColor visuals for otherwise equal modes */ |
285 if ( (a->viewportWidth == b->viewportWidth) && | 285 if ( (a->viewportWidth == b->viewportWidth) && |
286 (b->viewportHeight == a->viewportHeight) ) { | 286 (b->viewportHeight == a->viewportHeight) ) { |
287 if ( a->visualClass == DirectColor ) | 287 if ( a->visualClass == DirectColor ) |
293 if(a->viewportWidth > b->viewportWidth) | 293 if(a->viewportWidth > b->viewportWidth) |
294 return -1; | 294 return -1; |
295 return b->viewportHeight - a->viewportHeight; | 295 return b->viewportHeight - a->viewportHeight; |
296 } | 296 } |
297 } | 297 } |
298 static void UpdateHWInfo(_THIS, XDGAMode *mode) | 298 static void UpdateHWInfo(_THIS, SDL_NAME(XDGAMode) *mode) |
299 { | 299 { |
300 this->info.wm_available = 0; | 300 this->info.wm_available = 0; |
301 this->info.hw_available = 1; | 301 this->info.hw_available = 1; |
302 if ( mode->flags & XDGABlitRect ) { | 302 if ( mode->flags & XDGABlitRect ) { |
303 this->info.blit_hw = 1; | 303 this->info.blit_hw = 1; |
321 { | 321 { |
322 const char *display; | 322 const char *display; |
323 int event_base, error_base; | 323 int event_base, error_base; |
324 int major_version, minor_version; | 324 int major_version, minor_version; |
325 Visual *visual; | 325 Visual *visual; |
326 XDGAMode *modes; | 326 SDL_NAME(XDGAMode) *modes; |
327 int i, num_modes; | 327 int i, num_modes; |
328 | 328 |
329 /* Open the X11 display */ | 329 /* Open the X11 display */ |
330 display = NULL; /* Get it from DISPLAY environment variable */ | 330 display = NULL; /* Get it from DISPLAY environment variable */ |
331 | 331 |
334 SDL_SetError("Couldn't open X11 display"); | 334 SDL_SetError("Couldn't open X11 display"); |
335 return(-1); | 335 return(-1); |
336 } | 336 } |
337 | 337 |
338 /* Check for the DGA extension */ | 338 /* Check for the DGA extension */ |
339 if ( ! XDGAQueryExtension(DGA_Display, &event_base, &error_base) || | 339 if ( ! SDL_NAME(XDGAQueryExtension)(DGA_Display, &event_base, &error_base) || |
340 ! XDGAQueryVersion(DGA_Display, &major_version, &minor_version) ) { | 340 ! SDL_NAME(XDGAQueryVersion)(DGA_Display, &major_version, &minor_version) ) { |
341 SDL_SetError("DGA extension not available"); | 341 SDL_SetError("DGA extension not available"); |
342 XCloseDisplay(DGA_Display); | 342 XCloseDisplay(DGA_Display); |
343 return(-1); | 343 return(-1); |
344 } | 344 } |
345 if ( major_version < 2 ) { | 345 if ( major_version < 2 ) { |
375 vformat->Gmask = visual->green_mask; | 375 vformat->Gmask = visual->green_mask; |
376 vformat->Bmask = visual->blue_mask; | 376 vformat->Bmask = visual->blue_mask; |
377 } | 377 } |
378 | 378 |
379 /* Open access to the framebuffer */ | 379 /* Open access to the framebuffer */ |
380 if ( ! XDGAOpenFramebuffer(DGA_Display, DGA_Screen) ) { | 380 if ( ! SDL_NAME(XDGAOpenFramebuffer)(DGA_Display, DGA_Screen) ) { |
381 SDL_SetError("Unable to map the video memory"); | 381 SDL_SetError("Unable to map the video memory"); |
382 XCloseDisplay(DGA_Display); | 382 XCloseDisplay(DGA_Display); |
383 return(-1); | 383 return(-1); |
384 } | 384 } |
385 | 385 |
386 /* Query for the list of available video modes */ | 386 /* Query for the list of available video modes */ |
387 modes = XDGAQueryModes(DGA_Display, DGA_Screen, &num_modes); | 387 modes = SDL_NAME(XDGAQueryModes)(DGA_Display, DGA_Screen, &num_modes); |
388 qsort(modes, num_modes, sizeof *modes, cmpmodes); | 388 qsort(modes, num_modes, sizeof *modes, cmpmodes); |
389 for ( i=0; i<num_modes; ++i ) { | 389 for ( i=0; i<num_modes; ++i ) { |
390 #ifdef DGA_DEBUG | 390 #ifdef DGA_DEBUG |
391 PrintMode(&modes[i]); | 391 PrintMode(&modes[i]); |
392 #endif | 392 #endif |
427 static void DGA_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); | 427 static void DGA_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); |
428 | 428 |
429 SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current, | 429 SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current, |
430 int width, int height, int bpp, Uint32 flags) | 430 int width, int height, int bpp, Uint32 flags) |
431 { | 431 { |
432 XDGAMode *modes; | 432 SDL_NAME(XDGAMode) *modes; |
433 int i, num_modes; | 433 int i, num_modes; |
434 XDGADevice *mode; | 434 SDL_NAME(XDGADevice) *mode; |
435 int screen_len; | 435 int screen_len; |
436 Uint8 *surfaces_mem; | 436 Uint8 *surfaces_mem; |
437 int surfaces_len; | 437 int surfaces_len; |
438 | 438 |
439 /* Free any previous colormap */ | 439 /* Free any previous colormap */ |
441 XFreeColormap(DGA_Display, DGA_colormap); | 441 XFreeColormap(DGA_Display, DGA_colormap); |
442 DGA_colormap = 0; | 442 DGA_colormap = 0; |
443 } | 443 } |
444 | 444 |
445 /* Search for a matching video mode */ | 445 /* Search for a matching video mode */ |
446 modes = XDGAQueryModes(DGA_Display, DGA_Screen, &num_modes); | 446 modes = SDL_NAME(XDGAQueryModes)(DGA_Display, DGA_Screen, &num_modes); |
447 qsort(modes, num_modes, sizeof *modes, cmpmodes); | 447 qsort(modes, num_modes, sizeof *modes, cmpmodes); |
448 for ( i=0; i<num_modes; ++i ) { | 448 for ( i=0; i<num_modes; ++i ) { |
449 int depth; | 449 int depth; |
450 | 450 |
451 | 451 |
466 SDL_SetError("No matching video mode found"); | 466 SDL_SetError("No matching video mode found"); |
467 return(NULL); | 467 return(NULL); |
468 } | 468 } |
469 | 469 |
470 /* Set the video mode */ | 470 /* Set the video mode */ |
471 mode = XDGASetMode(DGA_Display, DGA_Screen, modes[i].num); | 471 mode = SDL_NAME(XDGASetMode)(DGA_Display, DGA_Screen, modes[i].num); |
472 XFree(modes); | 472 XFree(modes); |
473 if ( mode == NULL ) { | 473 if ( mode == NULL ) { |
474 SDL_SetError("Unable to switch to requested mode"); | 474 SDL_SetError("Unable to switch to requested mode"); |
475 return(NULL); | 475 return(NULL); |
476 } | 476 } |
493 screen_len = current->h*current->pitch; | 493 screen_len = current->h*current->pitch; |
494 | 494 |
495 /* Create a colormap if necessary */ | 495 /* Create a colormap if necessary */ |
496 if ( (DGA_visualClass == PseudoColor) || | 496 if ( (DGA_visualClass == PseudoColor) || |
497 (DGA_visualClass == DirectColor) ) { | 497 (DGA_visualClass == DirectColor) ) { |
498 DGA_colormap = XDGACreateColormap(DGA_Display, DGA_Screen, | 498 DGA_colormap = SDL_NAME(XDGACreateColormap)(DGA_Display, DGA_Screen, |
499 mode, AllocAll); | 499 mode, AllocAll); |
500 if ( DGA_visualClass == PseudoColor ) { | 500 if ( DGA_visualClass == PseudoColor ) { |
501 current->flags |= SDL_HWPALETTE; | 501 current->flags |= SDL_HWPALETTE; |
502 } else { | 502 } else { |
503 /* Initialize the colormap to the identity mapping */ | 503 /* Initialize the colormap to the identity mapping */ |
505 this->screen = current; | 505 this->screen = current; |
506 DGA_SetGammaRamp(this, this->gamma); | 506 DGA_SetGammaRamp(this, this->gamma); |
507 this->screen = NULL; | 507 this->screen = NULL; |
508 } | 508 } |
509 } else { | 509 } else { |
510 DGA_colormap = XDGACreateColormap(DGA_Display, DGA_Screen, | 510 DGA_colormap = SDL_NAME(XDGACreateColormap)(DGA_Display, DGA_Screen, |
511 mode, AllocNone); | 511 mode, AllocNone); |
512 } | 512 } |
513 XDGAInstallColormap(DGA_Display, DGA_Screen, DGA_colormap); | 513 SDL_NAME(XDGAInstallColormap)(DGA_Display, DGA_Screen, DGA_colormap); |
514 | 514 |
515 /* Update the hardware capabilities */ | 515 /* Update the hardware capabilities */ |
516 UpdateHWInfo(this, &mode->mode); | 516 UpdateHWInfo(this, &mode->mode); |
517 | 517 |
518 /* Set up the information for hardware surfaces */ | 518 /* Set up the information for hardware surfaces */ |
519 surfaces_mem = (Uint8 *)current->pixels + screen_len; | 519 surfaces_mem = (Uint8 *)current->pixels + screen_len; |
520 surfaces_len = (mode->mode.imageHeight*current->pitch - screen_len); | 520 surfaces_len = (mode->mode.imageHeight*current->pitch - screen_len); |
521 | 521 |
522 /* Update for double-buffering, if we can */ | 522 /* Update for double-buffering, if we can */ |
523 XDGASetViewport(DGA_Display, DGA_Screen, 0, 0, XDGAFlipRetrace); | 523 SDL_NAME(XDGASetViewport)(DGA_Display, DGA_Screen, 0, 0, XDGAFlipRetrace); |
524 if ( flags & SDL_DOUBLEBUF ) { | 524 if ( flags & SDL_DOUBLEBUF ) { |
525 if ( mode->mode.imageHeight >= (current->h*2) ) { | 525 if ( mode->mode.imageHeight >= (current->h*2) ) { |
526 current->flags |= SDL_DOUBLEBUF; | 526 current->flags |= SDL_DOUBLEBUF; |
527 flip_page = 0; | 527 flip_page = 0; |
528 flip_yoffset[0] = 0; | 528 flip_yoffset[0] = 0; |
554 /* Enable mouse and keyboard support */ | 554 /* Enable mouse and keyboard support */ |
555 { long input_mask; | 555 { long input_mask; |
556 input_mask = (KeyPressMask | KeyReleaseMask); | 556 input_mask = (KeyPressMask | KeyReleaseMask); |
557 input_mask |= (ButtonPressMask | ButtonReleaseMask); | 557 input_mask |= (ButtonPressMask | ButtonReleaseMask); |
558 input_mask |= PointerMotionMask; | 558 input_mask |= PointerMotionMask; |
559 XDGASelectInput(DGA_Display, DGA_Screen, input_mask); | 559 SDL_NAME(XDGASelectInput)(DGA_Display, DGA_Screen, input_mask); |
560 } | 560 } |
561 | 561 |
562 /* We're done */ | 562 /* We're done */ |
563 return(current); | 563 return(current); |
564 } | 564 } |
650 static __inline__ void DGA_WaitBusySurfaces(_THIS) | 650 static __inline__ void DGA_WaitBusySurfaces(_THIS) |
651 { | 651 { |
652 vidmem_bucket *bucket; | 652 vidmem_bucket *bucket; |
653 | 653 |
654 /* Wait for graphic operations to complete */ | 654 /* Wait for graphic operations to complete */ |
655 XDGASync(DGA_Display, DGA_Screen); | 655 SDL_NAME(XDGASync)(DGA_Display, DGA_Screen); |
656 | 656 |
657 /* Clear all surface dirty bits */ | 657 /* Clear all surface dirty bits */ |
658 for ( bucket=&surfaces; bucket; bucket=bucket->next ) { | 658 for ( bucket=&surfaces; bucket; bucket=bucket->next ) { |
659 bucket->dirty = 0; | 659 bucket->dirty = 0; |
660 } | 660 } |
805 unsigned int w, h; | 805 unsigned int w, h; |
806 | 806 |
807 /* Don't fill the visible part of the screen, wait until flipped */ | 807 /* Don't fill the visible part of the screen, wait until flipped */ |
808 LOCK_DISPLAY(); | 808 LOCK_DISPLAY(); |
809 if ( was_flipped && (dst == this->screen) ) { | 809 if ( was_flipped && (dst == this->screen) ) { |
810 while ( XDGAGetViewportStatus(DGA_Display, DGA_Screen) ) | 810 while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) ) |
811 /* Keep waiting for the hardware ... */ ; | 811 /* Keep waiting for the hardware ... */ ; |
812 was_flipped = 0; | 812 was_flipped = 0; |
813 } | 813 } |
814 DGA_dst_to_xy(this, dst, &x, &y); | 814 DGA_dst_to_xy(this, dst, &x, &y); |
815 x += rect->x; | 815 x += rect->x; |
817 w = rect->w; | 817 w = rect->w; |
818 h = rect->h; | 818 h = rect->h; |
819 #if 0 | 819 #if 0 |
820 printf("Hardware accelerated rectangle fill: %dx%d at %d,%d\n", w, h, x, y); | 820 printf("Hardware accelerated rectangle fill: %dx%d at %d,%d\n", w, h, x, y); |
821 #endif | 821 #endif |
822 XDGAFillRectangle(DGA_Display, DGA_Screen, x, y, w, h, color); | 822 SDL_NAME(XDGAFillRectangle)(DGA_Display, DGA_Screen, x, y, w, h, color); |
823 XFlush(DGA_Display); | 823 XFlush(DGA_Display); |
824 DGA_AddBusySurface(dst); | 824 DGA_AddBusySurface(dst); |
825 UNLOCK_DISPLAY(); | 825 UNLOCK_DISPLAY(); |
826 return(0); | 826 return(0); |
827 } | 827 } |
836 | 836 |
837 this = current_video; | 837 this = current_video; |
838 /* Don't blit to the visible part of the screen, wait until flipped */ | 838 /* Don't blit to the visible part of the screen, wait until flipped */ |
839 LOCK_DISPLAY(); | 839 LOCK_DISPLAY(); |
840 if ( was_flipped && (dst == this->screen) ) { | 840 if ( was_flipped && (dst == this->screen) ) { |
841 while ( XDGAGetViewportStatus(DGA_Display, DGA_Screen) ) | 841 while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) ) |
842 /* Keep waiting for the hardware ... */ ; | 842 /* Keep waiting for the hardware ... */ ; |
843 was_flipped = 0; | 843 was_flipped = 0; |
844 } | 844 } |
845 DGA_dst_to_xy(this, src, &srcx, &srcy); | 845 DGA_dst_to_xy(this, src, &srcx, &srcy); |
846 srcx += srcrect->x; | 846 srcx += srcrect->x; |
852 h = srcrect->h; | 852 h = srcrect->h; |
853 #if 0 | 853 #if 0 |
854 printf("Blitting %dx%d from %d,%d to %d,%d\n", w, h, srcx, srcy, dstx, dsty); | 854 printf("Blitting %dx%d from %d,%d to %d,%d\n", w, h, srcx, srcy, dstx, dsty); |
855 #endif | 855 #endif |
856 if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | 856 if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { |
857 XDGACopyTransparentArea(DGA_Display, DGA_Screen, | 857 SDL_NAME(XDGACopyTransparentArea)(DGA_Display, DGA_Screen, |
858 srcx, srcy, w, h, dstx, dsty, src->format->colorkey); | 858 srcx, srcy, w, h, dstx, dsty, src->format->colorkey); |
859 } else { | 859 } else { |
860 XDGACopyArea(DGA_Display, DGA_Screen, | 860 SDL_NAME(XDGACopyArea)(DGA_Display, DGA_Screen, |
861 srcx, srcy, w, h, dstx, dsty); | 861 srcx, srcy, w, h, dstx, dsty); |
862 } | 862 } |
863 XFlush(DGA_Display); | 863 XFlush(DGA_Display); |
864 DGA_AddBusySurface(src); | 864 DGA_AddBusySurface(src); |
865 DGA_AddBusySurface(dst); | 865 DGA_AddBusySurface(dst); |
895 } | 895 } |
896 | 896 |
897 static __inline__ void DGA_WaitFlip(_THIS) | 897 static __inline__ void DGA_WaitFlip(_THIS) |
898 { | 898 { |
899 if ( was_flipped ) { | 899 if ( was_flipped ) { |
900 while ( XDGAGetViewportStatus(DGA_Display, DGA_Screen) ) | 900 while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) ) |
901 /* Keep waiting for the hardware ... */ ; | 901 /* Keep waiting for the hardware ... */ ; |
902 was_flipped = 0; | 902 was_flipped = 0; |
903 } | 903 } |
904 } | 904 } |
905 | 905 |
935 LOCK_DISPLAY(); | 935 LOCK_DISPLAY(); |
936 if ( DGA_IsSurfaceBusy(this->screen) ) { | 936 if ( DGA_IsSurfaceBusy(this->screen) ) { |
937 DGA_WaitBusySurfaces(this); | 937 DGA_WaitBusySurfaces(this); |
938 } | 938 } |
939 DGA_WaitFlip(this); | 939 DGA_WaitFlip(this); |
940 XDGASetViewport(DGA_Display, DGA_Screen, | 940 SDL_NAME(XDGASetViewport)(DGA_Display, DGA_Screen, |
941 0, flip_yoffset[flip_page], XDGAFlipRetrace); | 941 0, flip_yoffset[flip_page], XDGAFlipRetrace); |
942 XFlush(DGA_Display); | 942 XFlush(DGA_Display); |
943 UNLOCK_DISPLAY(); | 943 UNLOCK_DISPLAY(); |
944 was_flipped = 1; | 944 was_flipped = 1; |
945 flip_page = !flip_page; | 945 flip_page = !flip_page; |
1022 XFreeColormap(DGA_Display, DGA_colormap); | 1022 XFreeColormap(DGA_Display, DGA_colormap); |
1023 DGA_colormap = 0; | 1023 DGA_colormap = 0; |
1024 } | 1024 } |
1025 | 1025 |
1026 /* Unmap memory and reset video mode */ | 1026 /* Unmap memory and reset video mode */ |
1027 XDGACloseFramebuffer(DGA_Display, DGA_Screen); | 1027 SDL_NAME(XDGACloseFramebuffer)(DGA_Display, DGA_Screen); |
1028 if ( this->screen ) { | 1028 if ( this->screen ) { |
1029 /* Tell SDL not to free the pixels */ | 1029 /* Tell SDL not to free the pixels */ |
1030 this->screen->pixels = NULL; | 1030 this->screen->pixels = NULL; |
1031 } | 1031 } |
1032 XDGASetMode(DGA_Display, DGA_Screen, 0); | 1032 SDL_NAME(XDGASetMode)(DGA_Display, DGA_Screen, 0); |
1033 | 1033 |
1034 /* Clear the lock mutex */ | 1034 /* Clear the lock mutex */ |
1035 if ( hw_lock != NULL ) { | 1035 if ( hw_lock != NULL ) { |
1036 SDL_DestroyMutex(hw_lock); | 1036 SDL_DestroyMutex(hw_lock); |
1037 hw_lock = NULL; | 1037 hw_lock = NULL; |