Mercurial > sdl-ios-xcode

comparison src/video/windib/SDL_dibvideo.c @ 1336:3692456e7b0f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Use SDL_ prefixed versions of C library functions. FIXME: Change #include <stdlib.h> to #include "SDL_stdlib.h" Change #include <string.h> to #include "SDL_string.h" Make sure nothing else broke because of this...
author Sam Lantinga <slouken@libsdl.org>
date Tue, 07 Feb 2006 06:59:48 +0000
parents 450721ad5436
children 604d73db6802
comparison
equal deleted inserted replaced
1335:c39265384763 1336:3692456e7b0f
103 103
104 static void DIB_DeleteDevice(SDL_VideoDevice *device) 104 static void DIB_DeleteDevice(SDL_VideoDevice *device)
105 { 105 {
106 if ( device ) { 106 if ( device ) {
107 if ( device->hidden ) { 107 if ( device->hidden ) {
108 free(device->hidden); 108 SDL_free(device->hidden);
109 } 109 }
110 if ( device->gl_data ) { 110 if ( device->gl_data ) {
111 free(device->gl_data); 111 SDL_free(device->gl_data);
112 } 112 }
113 free(device); 113 SDL_free(device);
114 } 114 }
115 } 115 }
116 116
117 static SDL_VideoDevice *DIB_CreateDevice(int devindex) 117 static SDL_VideoDevice *DIB_CreateDevice(int devindex)
118 { 118 {
119 SDL_VideoDevice *device; 119 SDL_VideoDevice *device;
120 120
121 /* Initialize all variables that we clean on shutdown */ 121 /* Initialize all variables that we clean on shutdown */
122 device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); 122 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
123 if ( device ) { 123 if ( device ) {
124 memset(device, 0, (sizeof *device)); 124 SDL_memset(device, 0, (sizeof *device));
125 device->hidden = (struct SDL_PrivateVideoData *) 125 device->hidden = (struct SDL_PrivateVideoData *)
126 malloc((sizeof *device->hidden)); 126 SDL_malloc((sizeof *device->hidden));
127 device->gl_data = (struct SDL_PrivateGLData *) 127 device->gl_data = (struct SDL_PrivateGLData *)
128 malloc((sizeof *device->gl_data)); 128 SDL_malloc((sizeof *device->gl_data));
129 } 129 }
130 if ( (device == NULL) || (device->hidden == NULL) || 130 if ( (device == NULL) || (device->hidden == NULL) ||
131 (device->gl_data == NULL) ) { 131 (device->gl_data == NULL) ) {
132 SDL_OutOfMemory(); 132 SDL_OutOfMemory();
133 DIB_DeleteDevice(device); 133 DIB_DeleteDevice(device);
134 return(NULL); 134 return(NULL);
135 } 135 }
136 memset(device->hidden, 0, (sizeof *device->hidden)); 136 SDL_memset(device->hidden, 0, (sizeof *device->hidden));
137 memset(device->gl_data, 0, (sizeof *device->gl_data)); 137 SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
138 138
139 /* Set the function pointers */ 139 /* Set the function pointers */
140 device->VideoInit = DIB_VideoInit; 140 device->VideoInit = DIB_VideoInit;
141 device->ListModes = DIB_ListModes; 141 device->ListModes = DIB_ListModes;
142 device->SetVideoMode = DIB_SetVideoMode; 142 device->SetVideoMode = DIB_SetVideoMode;
221 return(0); 221 return(0);
222 } 222 }
223 } 223 }
224 224
225 /* Set up the new video mode rectangle */ 225 /* Set up the new video mode rectangle */
226 mode = (SDL_Rect *)malloc(sizeof *mode); 226 mode = (SDL_Rect *)SDL_malloc(sizeof *mode);
227 if ( mode == NULL ) { 227 if ( mode == NULL ) {
228 SDL_OutOfMemory(); 228 SDL_OutOfMemory();
229 return(-1); 229 return(-1);
230 } 230 }
231 mode->x = 0; 231 mode->x = 0;
234 mode->h = h; 234 mode->h = h;
235 235
236 /* Allocate the new list of modes, and fill in the new mode */ 236 /* Allocate the new list of modes, and fill in the new mode */
237 next_mode = SDL_nummodes[index]; 237 next_mode = SDL_nummodes[index];
238 SDL_modelist[index] = (SDL_Rect **) 238 SDL_modelist[index] = (SDL_Rect **)
239 realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); 239 SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *));
240 if ( SDL_modelist[index] == NULL ) { 240 if ( SDL_modelist[index] == NULL ) {
241 SDL_OutOfMemory(); 241 SDL_OutOfMemory();
242 SDL_nummodes[index] = 0; 242 SDL_nummodes[index] = 0;
243 free(mode); 243 SDL_free(mode);
244 return(-1); 244 return(-1);
245 } 245 }
246 SDL_modelist[index][next_mode] = mode; 246 SDL_modelist[index][next_mode] = mode;
247 SDL_modelist[index][next_mode+1] = NULL; 247 SDL_modelist[index][next_mode+1] = NULL;
248 SDL_nummodes[index]++; 248 SDL_nummodes[index]++;
268 268
269 ncolors = 1; 269 ncolors = 1;
270 for ( i=0; i<bpp; ++i ) { 270 for ( i=0; i<bpp; ++i ) {
271 ncolors *= 2; 271 ncolors *= 2;
272 } 272 }
273 palette = (LOGPALETTE *)malloc(sizeof(*palette)+ 273 palette = (LOGPALETTE *)SDL_malloc(sizeof(*palette)+
274 ncolors*sizeof(PALETTEENTRY)); 274 ncolors*sizeof(PALETTEENTRY));
275 palette->palVersion = 0x300; 275 palette->palVersion = 0x300;
276 palette->palNumEntries = ncolors; 276 palette->palNumEntries = ncolors;
277 hdc = GetDC(SDL_Window); 277 hdc = GetDC(SDL_Window);
278 GetSystemPaletteEntries(hdc, 0, ncolors, palette->palPalEntry); 278 GetSystemPaletteEntries(hdc, 0, ncolors, palette->palPalEntry);
279 ReleaseDC(SDL_Window, hdc); 279 ReleaseDC(SDL_Window, hdc);
280 handle = CreatePalette(palette); 280 handle = CreatePalette(palette);
281 free(palette); 281 SDL_free(palette);
282 } 282 }
283 283
284 return handle; 284 return handle;
285 } 285 }
286 286
337 settings.dmPelsWidth, settings.dmPelsHeight); 337 settings.dmPelsWidth, settings.dmPelsHeight);
338 } 338 }
339 /* Sort the mode lists */ 339 /* Sort the mode lists */
340 for ( i=0; i<NUM_MODELISTS; ++i ) { 340 for ( i=0; i<NUM_MODELISTS; ++i ) {
341 if ( SDL_nummodes[i] > 0 ) { 341 if ( SDL_nummodes[i] > 0 ) {
342 qsort(SDL_modelist[i], SDL_nummodes[i], sizeof *SDL_modelist[i], cmpmodes); 342 SDL_qsort(SDL_modelist[i], SDL_nummodes[i], sizeof *SDL_modelist[i], cmpmodes);
343 } 343 }
344 } 344 }
345 #endif /* !NO_CHANGEDISPLAYSETTINGS */ 345 #endif /* !NO_CHANGEDISPLAYSETTINGS */
346 346
347 /* Grab an identity palette if we are in a palettized mode */ 347 /* Grab an identity palette if we are in a palettized mode */
398 398
399 /* Allocate enough space for a DIB header plus palette (for 399 /* Allocate enough space for a DIB header plus palette (for
400 * 8-bit modes) or bitfields (for 16- and 32-bit modes) 400 * 8-bit modes) or bitfields (for 16- and 32-bit modes)
401 */ 401 */
402 dib_size = sizeof(BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD); 402 dib_size = sizeof(BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD);
403 dib_hdr = (LPBITMAPINFOHEADER) malloc(dib_size); 403 dib_hdr = (LPBITMAPINFOHEADER) SDL_malloc(dib_size);
404 memset(dib_hdr, 0, dib_size); 404 SDL_memset(dib_hdr, 0, dib_size);
405 dib_hdr->biSize = sizeof(BITMAPINFOHEADER); 405 dib_hdr->biSize = sizeof(BITMAPINFOHEADER);
406 406
407 /* Get a device-dependent bitmap that's compatible with the 407 /* Get a device-dependent bitmap that's compatible with the
408 screen. 408 screen.
409 */ 409 */
529 /* Set fullscreen mode if appropriate */ 529 /* Set fullscreen mode if appropriate */
530 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 530 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
531 DEVMODE settings; 531 DEVMODE settings;
532 BOOL changed; 532 BOOL changed;
533 533
534 memset(&settings, 0, sizeof(DEVMODE)); 534 SDL_memset(&settings, 0, sizeof(DEVMODE));
535 settings.dmSize = sizeof(DEVMODE); 535 settings.dmSize = sizeof(DEVMODE);
536 settings.dmBitsPerPel = video->format->BitsPerPixel; 536 settings.dmBitsPerPel = video->format->BitsPerPixel;
537 settings.dmPelsWidth = width; 537 settings.dmPelsWidth = width;
538 settings.dmPelsHeight = height; 538 settings.dmPelsHeight = height;
539 settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL; 539 settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
614 binfo_size += 3*sizeof(DWORD); 614 binfo_size += 3*sizeof(DWORD);
615 } else if ( video->format->palette ) { 615 } else if ( video->format->palette ) {
616 binfo_size += video->format->palette->ncolors * 616 binfo_size += video->format->palette->ncolors *
617 sizeof(RGBQUAD); 617 sizeof(RGBQUAD);
618 } 618 }
619 binfo = (BITMAPINFO *)malloc(binfo_size); 619 binfo = (BITMAPINFO *)SDL_malloc(binfo_size);
620 if ( ! binfo ) { 620 if ( ! binfo ) {
621 if ( video != current ) { 621 if ( video != current ) {
622 SDL_FreeSurface(video); 622 SDL_FreeSurface(video);
623 } 623 }
624 SDL_OutOfMemory(); 624 SDL_OutOfMemory();
643 ((Uint32*)binfo->bmiColors)[1] = video->format->Gmask; 643 ((Uint32*)binfo->bmiColors)[1] = video->format->Gmask;
644 ((Uint32*)binfo->bmiColors)[2] = video->format->Bmask; 644 ((Uint32*)binfo->bmiColors)[2] = video->format->Bmask;
645 } else { 645 } else {
646 binfo->bmiHeader.biCompression = BI_RGB; /* BI_BITFIELDS for 565 vs 555 */ 646 binfo->bmiHeader.biCompression = BI_RGB; /* BI_BITFIELDS for 565 vs 555 */
647 if ( video->format->palette ) { 647 if ( video->format->palette ) {
648 memset(binfo->bmiColors, 0, 648 SDL_memset(binfo->bmiColors, 0,
649 video->format->palette->ncolors*sizeof(RGBQUAD)); 649 video->format->palette->ncolors*sizeof(RGBQUAD));
650 } 650 }
651 } 651 }
652 652
653 /* Create the offscreen bitmap buffer */ 653 /* Create the offscreen bitmap buffer */
654 hdc = GetDC(SDL_Window); 654 hdc = GetDC(SDL_Window);
655 screen_bmp = CreateDIBSection(hdc, binfo, DIB_RGB_COLORS, 655 screen_bmp = CreateDIBSection(hdc, binfo, DIB_RGB_COLORS,
656 (void **)(&video->pixels), NULL, 0); 656 (void **)(&video->pixels), NULL, 0);
657 ReleaseDC(SDL_Window, hdc); 657 ReleaseDC(SDL_Window, hdc);
658 free(binfo); 658 SDL_free(binfo);
659 if ( screen_bmp == NULL ) { 659 if ( screen_bmp == NULL ) {
660 if ( video != current ) { 660 if ( video != current ) {
661 SDL_FreeSurface(video); 661 SDL_FreeSurface(video);
662 } 662 }
663 SDL_SetError("Couldn't create DIB section"); 663 SDL_SetError("Couldn't create DIB section");
678 UINT swp_flags; 678 UINT swp_flags;
679 const char *window = NULL; 679 const char *window = NULL;
680 const char *center = NULL; 680 const char *center = NULL;
681 681
682 if ( !SDL_windowX && !SDL_windowY ) { 682 if ( !SDL_windowX && !SDL_windowY ) {
683 window = getenv("SDL_VIDEO_WINDOW_POS"); 683 window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
684 center = getenv("SDL_VIDEO_CENTERED"); 684 center = SDL_getenv("SDL_VIDEO_CENTERED");
685 if ( window ) { 685 if ( window ) {
686 if ( sscanf(window, "%d,%d", &x, &y) == 2 ) { 686 if ( SDL_sscanf(window, "%d,%d", &x, &y) == 2 ) {
687 SDL_windowX = x; 687 SDL_windowX = x;
688 SDL_windowY = y; 688 SDL_windowY = y;
689 } 689 }
690 if ( strcmp(window, "center") == 0 ) { 690 if ( SDL_strcmp(window, "center") == 0 ) {
691 center = window; 691 center = window;
692 } 692 }
693 } 693 }
694 } 694 }
695 swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW); 695 swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW);
876 SetDeviceGammaRamp(hdc, gamma_saved); 876 SetDeviceGammaRamp(hdc, gamma_saved);
877 ReleaseDC(SDL_Window, hdc); 877 ReleaseDC(SDL_Window, hdc);
878 } 878 }
879 879
880 /* Free the saved gamma memory */ 880 /* Free the saved gamma memory */
881 free(gamma_saved); 881 SDL_free(gamma_saved);
882 gamma_saved = 0; 882 gamma_saved = 0;
883 } 883 }
884 #endif /* !NO_GAMMA_SUPPORT */ 884 #endif /* !NO_GAMMA_SUPPORT */
885 } 885 }
886 886
893 HDC hdc; 893 HDC hdc;
894 BOOL succeeded; 894 BOOL succeeded;
895 895
896 /* Set the ramp for the display */ 896 /* Set the ramp for the display */
897 if ( ! gamma_saved ) { 897 if ( ! gamma_saved ) {
898 gamma_saved = (WORD *)malloc(3*256*sizeof(*gamma_saved)); 898 gamma_saved = (WORD *)SDL_malloc(3*256*sizeof(*gamma_saved));
899 if ( ! gamma_saved ) { 899 if ( ! gamma_saved ) {
900 SDL_OutOfMemory(); 900 SDL_OutOfMemory();
901 return -1; 901 return -1;
902 } 902 }
903 hdc = GetDC(SDL_Window); 903 hdc = GetDC(SDL_Window);