l4/pkg/libsdl/contrib/src/video/vgl/SDL_vglvideo.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2012 Sam Lantinga
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Lesser General Public
   7     License as published by the Free Software Foundation; either
   8     version 2.1 of the License, or (at your option) any later version.
   9
  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     Lesser General Public License for more details.
  14
  15     You should have received a copy of the GNU Lesser General Public
  16     License along with this library; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19     Sam Lantinga
  20     slouken@libsdl.org
  21 */
  22 #include "SDL_config.h"
  23
  24 /* libvga based SDL video driver implementation.
  25 */
  26
  27 #include <err.h>
  28 #include <osreldate.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31
  32 #include <sys/fbio.h>
  33 #include <sys/consio.h>
  34 #include <sys/kbio.h>
  35 #include <vgl.h>
  36
  37 #include "SDL_video.h"
  38 #include "SDL_mouse.h"
  39 #include "../SDL_sysvideo.h"
  40 #include "../SDL_pixels_c.h"
  41 #include "../../events/SDL_events_c.h"
  42 #include "SDL_vglvideo.h"
  43 #include "SDL_vglevents_c.h"
  44 #include "SDL_vglmouse_c.h"
  45
  46
  47 /* Initialization/Query functions */
  48 static int VGL_VideoInit(_THIS, SDL_PixelFormat *vformat);
  49 static SDL_Rect **VGL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  50 static SDL_Surface *VGL_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  51 static int VGL_SetColors(_THIS, int firstcolor, int ncolors,
  52                           SDL_Color *colors);
  53 static void VGL_VideoQuit(_THIS);
  54
  55 /* Hardware surface functions */
  56 static int VGL_AllocHWSurface(_THIS, SDL_Surface *surface);
  57 static int VGL_LockHWSurface(_THIS, SDL_Surface *surface);
  58 static int VGL_FlipHWSurface(_THIS, SDL_Surface *surface);
  59 static void VGL_UnlockHWSurface(_THIS, SDL_Surface *surface);
  60 static void VGL_FreeHWSurface(_THIS, SDL_Surface *surface);
  61
  62 /* Misc function */
  63 static VGLMode ** VGLListModes(int depth, int mem_model);
  64
  65 /* VGL driver bootstrap functions */
  66
  67 static int VGL_Available(void)
  68 {
  69         /*
  70          * Check to see if we are root and stdin is a
  71          * virtual console. Also try to ensure that
  72          * modes other than 320x200 are available
  73          */
  74         int console, hires_available, i;
  75         VGLMode **modes;
  76
  77         console = STDIN_FILENO;
  78         if ( console >= 0 ) {
  79                 struct stat sb;
  80                 struct vt_mode dummy;
  81
  82                 if ( (fstat(console, &sb) < 0) ||
  83                      (ioctl(console, VT_GETMODE, &dummy) < 0) ) {
  84                         console = -1;
  85                 }
  86         }
  87         if (geteuid() != 0 && console == -1)
  88                 return 0;
  89
  90         modes = VGLListModes(8, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
  91         hires_available = 0;
  92         for (i = 0; modes[i] != NULL; i++) {
  93                 if ((modes[i]->ModeInfo.Xsize > 320) &&
  94                     (modes[i]->ModeInfo.Ysize > 200) &&
  95                     ((modes[i]->ModeInfo.Type == VIDBUF8) ||
  96                      (modes[i]->ModeInfo.Type == VIDBUF16) ||
  97                      (modes[i]->ModeInfo.Type == VIDBUF32))) {
  98                         hires_available = 1;
  99                         break;
 100                 }
 101         }
 102         return hires_available;
 103 }
 104
 105 static void VGL_DeleteDevice(SDL_VideoDevice *device)
 106 {
 107         SDL_free(device->hidden);
 108         SDL_free(device);
 109 }
 110
 111 static SDL_VideoDevice *VGL_CreateDevice(int devindex)
 112 {
 113         SDL_VideoDevice *device;
 114
 115         /* Initialize all variables that we clean on shutdown */
 116         device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
 117         if ( device ) {
 118                 SDL_memset(device, 0, (sizeof *device));
 119                 device->hidden = (struct SDL_PrivateVideoData *)
 120                                   SDL_malloc((sizeof *device->hidden));
 121         }
 122         if ( (device == NULL) || (device->hidden == NULL) ) {
 123                 SDL_OutOfMemory();
 124                 if ( device ) {
 125                         SDL_free(device);
 126                 }
 127                 return(0);
 128         }
 129         SDL_memset(device->hidden, 0, (sizeof *device->hidden));
 130
 131         /* Set the function pointers */
 132         device->VideoInit = VGL_VideoInit;
 133         device->ListModes = VGL_ListModes;
 134         device->SetVideoMode = VGL_SetVideoMode;
 135         device->SetColors = VGL_SetColors;
 136         device->UpdateRects = NULL;
 137         device->VideoQuit = VGL_VideoQuit;
 138         device->AllocHWSurface = VGL_AllocHWSurface;
 139         device->CheckHWBlit = NULL;
 140         device->FillHWRect = NULL;
 141         device->SetHWColorKey = NULL;
 142         device->SetHWAlpha = NULL;
 143         device->LockHWSurface = VGL_LockHWSurface;
 144         device->UnlockHWSurface = VGL_UnlockHWSurface;
 145         device->FlipHWSurface = VGL_FlipHWSurface;
 146         device->FreeHWSurface = VGL_FreeHWSurface;
 147         device->SetIcon = NULL;
 148         device->SetCaption = NULL;
 149         device->GetWMInfo = NULL;
 150         device->FreeWMCursor = VGL_FreeWMCursor;
 151         device->CreateWMCursor = VGL_CreateWMCursor;
 152         device->ShowWMCursor = VGL_ShowWMCursor;
 153         device->WarpWMCursor = VGL_WarpWMCursor;
 154         device->InitOSKeymap = VGL_InitOSKeymap;
 155         device->PumpEvents = VGL_PumpEvents;
 156
 157         device->free = VGL_DeleteDevice;
 158
 159         return device;
 160 }
 161
 162 VideoBootStrap VGL_bootstrap = {
 163         "vgl", "FreeBSD libVGL",
 164         VGL_Available, VGL_CreateDevice
 165 };
 166
 167 static int VGL_AddMode(_THIS, VGLMode *inmode)
 168 {
 169         SDL_Rect *mode;
 170
 171         int i, index;
 172         int next_mode;
 173
 174         /* Check to see if we already have this mode */
 175         if (inmode->Depth < 8) {  /* Not supported */
 176                 return 0;
 177         }
 178         index = ((inmode->Depth + 7) / 8) - 1;
 179         for (i=0; i<SDL_nummodes[index]; ++i) {
 180                 mode = SDL_modelist[index][i];
 181                 if ((mode->w == inmode->ModeInfo.Xsize) &&
 182                     (mode->h == inmode->ModeInfo.Ysize))
 183                         return 0;
 184         }
 185
 186         /* Set up the new video mode rectangle */
 187         mode = (SDL_Rect *)SDL_malloc(sizeof *mode);
 188         if (mode == NULL) {
 189                 SDL_OutOfMemory();
 190                 return -1;
 191         }
 192         mode->x = 0;
 193         mode->y = 0;
 194         mode->w = inmode->ModeInfo.Xsize;
 195         mode->h = inmode->ModeInfo.Ysize;
 196
 197         /* Allocate the new list of modes, and fill in the new mode */
 198         next_mode = SDL_nummodes[index];
 199         SDL_modelist[index] = (SDL_Rect **)
 200                 SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *));
 201         if (SDL_modelist[index] == NULL) {
 202                 SDL_OutOfMemory();
 203                 SDL_nummodes[index] = 0;
 204                 SDL_free(mode);
 205                 return -1;
 206         }
 207         SDL_modelist[index][next_mode] = mode;
 208         SDL_modelist[index][next_mode+1] = NULL;
 209         SDL_nummodes[index]++;
 210
 211         return 0;
 212 }
 213
 214 static void VGL_UpdateVideoInfo(_THIS)
 215 {
 216         this->info.wm_available = 0;
 217         this->info.hw_available = 1;
 218         this->info.video_mem = 0;
 219         if (VGLCurMode == NULL) {
 220                 return;
 221         }
 222         if (VGLCurMode->ModeInfo.PixelBytes > 0) {
 223                 this->info.video_mem = VGLCurMode->ModeInfo.PixelBytes *
 224                                        VGLCurMode->ModeInfo.Xsize *
 225                                        VGLCurMode->ModeInfo.Ysize;
 226         }
 227 }
 228
 229 int VGL_VideoInit(_THIS, SDL_PixelFormat *vformat)
 230 {
 231         int i;
 232         int total_modes;
 233         VGLMode **modes;
 234
 235         /* Initialize all variables that we clean on shutdown */
 236         for ( i=0; i<NUM_MODELISTS; ++i ) {
 237                 SDL_nummodes[i] = 0;
 238                 SDL_modelist[i] = NULL;
 239         }
 240
 241         /* Enable mouse and keyboard support */
 242         if (SDL_getenv("SDL_NO_RAWKBD") == NULL) {
 243                 if (VGLKeyboardInit(VGL_CODEKEYS) != 0) {
 244                         SDL_SetError("Unable to initialize keyboard");
 245                         return -1;
 246                 }
 247         } else {
 248                 warnx("Requiest to put keyboard into a raw mode ignored");
 249         }
 250         if (VGL_initkeymaps(STDIN_FILENO) != 0) {
 251                 SDL_SetError("Unable to initialize keymap");
 252                 return -1;
 253         }
 254         if (VGL_initmouse(STDIN_FILENO) != 0) {
 255                 SDL_SetError("Unable to initialize mouse");
 256                 return -1;
 257         }
 258
 259         /* Determine the current screen size */
 260         if (VGLCurMode != NULL) {
 261                 this->info.current_w = VGLCurMode->ModeInfo.Xsize;
 262                 this->info.current_h = VGLCurMode->ModeInfo.Ysize;
 263         }
 264
 265         /* Determine the screen depth */
 266         if (VGLCurMode != NULL)
 267                 vformat->BitsPerPixel = VGLCurMode->Depth;
 268         else
 269                 vformat->BitsPerPixel = 16;     /* Good default */
 270
 271         /* Query for the list of available video modes */
 272         total_modes = 0;
 273         modes = VGLListModes(-1, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
 274         for (i = 0; modes[i] != NULL; i++) {
 275                 if ((modes[i]->ModeInfo.Type == VIDBUF8) ||
 276                     (modes[i]->ModeInfo.Type == VIDBUF16) ||
 277                     (modes[i]->ModeInfo.Type == VIDBUF32)) {
 278                         VGL_AddMode(this, modes[i]);
 279                         total_modes++;
 280                 }
 281         }
 282         if (total_modes == 0) {
 283                 SDL_SetError("No linear video modes available");
 284                 return -1;
 285         }
 286
 287         /* Fill in our hardware acceleration capabilities */
 288         VGL_UpdateVideoInfo(this);
 289
 290         /* Create the hardware surface lock mutex */
 291         hw_lock = SDL_CreateMutex();
 292         if (hw_lock == NULL) {
 293                 SDL_SetError("Unable to create lock mutex");
 294                 VGL_VideoQuit(this);
 295                 return -1;
 296         }
 297
 298         /* We're done! */
 299         return 0;
 300 }
 301
 302 SDL_Rect **VGL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
 303 {
 304         return SDL_modelist[((format->BitsPerPixel+7)/8)-1];
 305 }
 306
 307 /* Various screen update functions available */
 308 static void VGL_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
 309
 310 SDL_Surface *VGL_SetVideoMode(_THIS, SDL_Surface *current,
 311                               int width, int height, int bpp, Uint32 flags)
 312 {
 313         int mode_found;
 314         int i;
 315         VGLMode **modes;
 316
 317         modes = VGLListModes(bpp, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
 318         mode_found = 0;
 319         for (i = 0; modes[i] != NULL; i++) {
 320                 if ((modes[i]->ModeInfo.Xsize == width) &&
 321                     (modes[i]->ModeInfo.Ysize == height) &&
 322                     ((modes[i]->ModeInfo.Type == VIDBUF8) ||
 323                      (modes[i]->ModeInfo.Type == VIDBUF16) ||
 324                      (modes[i]->ModeInfo.Type == VIDBUF32))) {
 325                         mode_found = 1;
 326                         break;
 327                 }
 328         }
 329         if (mode_found == 0) {
 330                 SDL_SetError("No matching video mode found");
 331                 return NULL;
 332         }
 333
 334         /* Shutdown previous videomode (if any) */
 335         if (VGLCurMode != NULL)
 336                 VGLEnd();
 337
 338         /* Try to set the requested linear video mode */
 339         if (VGLInit(modes[i]->ModeId) != 0) {
 340                 SDL_SetError("Unable to switch to requested mode");
 341                 return NULL;
 342         }
 343
 344         VGLCurMode = SDL_realloc(VGLCurMode, sizeof(VGLMode));
 345         VGLCurMode->ModeInfo = *VGLDisplay;
 346         VGLCurMode->Depth = modes[i]->Depth;
 347         VGLCurMode->ModeId = modes[i]->ModeId;
 348         VGLCurMode->Rmask = modes[i]->Rmask;
 349         VGLCurMode->Gmask = modes[i]->Gmask;
 350         VGLCurMode->Bmask = modes[i]->Bmask;
 351
 352         /* Workaround a bug in libvgl */
 353         if (VGLCurMode->ModeInfo.PixelBytes == 0)
 354                 (VGLCurMode->ModeInfo.PixelBytes = 1);
 355
 356         current->w = VGLCurMode->ModeInfo.Xsize;
 357         current->h = VGLCurMode->ModeInfo.Ysize;
 358         current->pixels = VGLCurMode->ModeInfo.Bitmap;
 359         current->pitch = VGLCurMode->ModeInfo.Xsize *
 360                          VGLCurMode->ModeInfo.PixelBytes;
 361         current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE);
 362
 363         /* Check if we are in a pseudo-color mode */
 364         if (VGLCurMode->ModeInfo.Type == VIDBUF8)
 365                 current->flags |= SDL_HWPALETTE;
 366
 367         /* Check if we can do doublebuffering */
 368         if (flags & SDL_DOUBLEBUF) {
 369                 if (VGLCurMode->ModeInfo.Xsize * 2 <=
 370                     VGLCurMode->ModeInfo.VYsize) {
 371                         current->flags |= SDL_DOUBLEBUF;
 372                         flip_page = 0;
 373                         flip_address[0] = (byte *)current->pixels;
 374                         flip_address[1] = (byte *)current->pixels +
 375                                           current->h * current->pitch;
 376                         VGL_FlipHWSurface(this, current);
 377                 }
 378         }
 379
 380         if (! SDL_ReallocFormat(current, modes[i]->Depth, VGLCurMode->Rmask,
 381                                 VGLCurMode->Gmask, VGLCurMode->Bmask, 0)) {
 382                 return NULL;
 383         }
 384
 385         /* Update hardware acceleration info */
 386         VGL_UpdateVideoInfo(this);
 387
 388         /* Set the blit function */
 389         this->UpdateRects = VGL_DirectUpdate;
 390
 391         /* We're done */
 392         return current;
 393 }
 394
 395 /* We don't actually allow hardware surfaces other than the main one */
 396 static int VGL_AllocHWSurface(_THIS, SDL_Surface *surface)
 397 {
 398         return -1;
 399 }
 400 static void VGL_FreeHWSurface(_THIS, SDL_Surface *surface)
 401 {
 402         return;
 403 }
 404
 405 /* We need to wait for vertical retrace on page flipped displays */
 406 static int VGL_LockHWSurface(_THIS, SDL_Surface *surface)
 407 {
 408         if (surface == SDL_VideoSurface) {
 409                 SDL_mutexP(hw_lock);
 410         }
 411         return 0;
 412 }
 413 static void VGL_UnlockHWSurface(_THIS, SDL_Surface *surface)
 414 {
 415         if (surface == SDL_VideoSurface) {
 416                 SDL_mutexV(hw_lock);
 417         }
 418 }
 419
 420 static int VGL_FlipHWSurface(_THIS, SDL_Surface *surface)
 421 {
 422         if (VGLPanScreen(VGLDisplay, 0, flip_page * surface->h) < 0) {
 423                 SDL_SetError("VGLPanSreen() failed");
 424                 return -1;
 425         }
 426
 427         flip_page = !flip_page;
 428         surface->pixels = flip_address[flip_page];
 429
 430         return 0;
 431 }
 432
 433 static void VGL_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
 434 {
 435         return;
 436 }
 437
 438 int VGL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 439 {
 440         int i;
 441
 442         for(i = 0; i < ncolors; i++) {
 443                 VGLSetPaletteIndex(firstcolor + i,
 444                                colors[i].r>>2,
 445                                colors[i].g>>2,
 446                                colors[i].b>>2);
 447         }
 448         return 1;
 449 }
 450
 451 /* Note:  If we are terminated, this could be called in the middle of
 452    another SDL video routine -- notably UpdateRects.
 453 */
 454 void VGL_VideoQuit(_THIS)
 455 {
 456         int i, j;
 457
 458         /* Return the keyboard to the normal state */
 459         VGLKeyboardEnd();
 460
 461         /* Reset the console video mode if we actually initialised one */
 462         if (VGLCurMode != NULL) {
 463                 VGLEnd();
 464                 SDL_free(VGLCurMode);
 465                 VGLCurMode = NULL;
 466         }
 467
 468         /* Clear the lock mutex */
 469         if (hw_lock != NULL) {
 470                 SDL_DestroyMutex(hw_lock);
 471                 hw_lock = NULL;
 472         }
 473
 474         /* Free video mode lists */
 475         for (i = 0; i < NUM_MODELISTS; i++) {
 476                 if (SDL_modelist[i] != NULL) {
 477                         for (j = 0; SDL_modelist[i][j] != NULL; ++j) {
 478                                 SDL_free(SDL_modelist[i][j]);
 479                         }
 480                         SDL_free(SDL_modelist[i]);
 481                         SDL_modelist[i] = NULL;
 482                 }
 483         }
 484
 485         if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) {
 486         /* Direct screen access, not a memory buffer */
 487                 this->screen->pixels = NULL;
 488         }
 489 }
 490
 491 #define VGL_RED_INDEX   0
 492 #define VGL_GREEN_INDEX 1
 493 #define VGL_BLUE_INDEX  2
 494
 495 static VGLMode **
 496 VGLListModes(int depth, int mem_model)
 497 {
 498   static VGLMode **modes = NULL;
 499
 500   VGLBitmap *vminfop;
 501   VGLMode **modesp, *modescp;
 502   video_info_t minfo;
 503   int adptype, i, modenum;
 504
 505   if (modes == NULL) {
 506     modes = SDL_malloc(sizeof(VGLMode *) * M_VESA_MODE_MAX);
 507     bzero(modes, sizeof(VGLMode *) * M_VESA_MODE_MAX);
 508   }
 509   modesp = modes;
 510
 511   for (modenum = 0; modenum < M_VESA_MODE_MAX; modenum++) {
 512     minfo.vi_mode = modenum;
 513     if (ioctl(0, CONS_MODEINFO, &minfo) || ioctl(0, CONS_CURRENT, &adptype))
 514       continue;
 515     if (minfo.vi_mode != modenum)
 516       continue;
 517     if ((minfo.vi_flags & V_INFO_GRAPHICS) == 0)
 518       continue;
 519     if ((mem_model != -1) && ((minfo.vi_mem_model & mem_model) == 0))
 520       continue;
 521     if ((depth > 1) && (minfo.vi_depth != depth))
 522       continue;
 523
 524     /* reallocf can fail */
 525     if ((*modesp = reallocf(*modesp, sizeof(VGLMode))) == NULL)
 526       return NULL;
 527     modescp = *modesp;
 528
 529     vminfop = &(modescp->ModeInfo);
 530     bzero(vminfop, sizeof(VGLBitmap));
 531
 532     vminfop->Type = NOBUF;
 533
 534     vminfop->PixelBytes = 1;    /* Good default value */
 535     switch (minfo.vi_mem_model) {
 536     case V_INFO_MM_PLANAR:
 537       /* we can handle EGA/VGA planar modes only */
 538       if (!(minfo.vi_depth != 4 || minfo.vi_planes != 4
 539             || (adptype != KD_EGA && adptype != KD_VGA)))
 540         vminfop->Type = VIDBUF4;
 541       break;
 542     case V_INFO_MM_PACKED:
 543       /* we can do only 256 color packed modes */
 544       if (minfo.vi_depth == 8)
 545         vminfop->Type = VIDBUF8;
 546       break;
 547     case V_INFO_MM_VGAX:
 548       vminfop->Type = VIDBUF8X;
 549       break;
 550 #if defined(__FREEBSD__) && (defined(__DragonFly__) || __FreeBSD_version >= 500000)
 551     case V_INFO_MM_DIRECT:
 552       vminfop->PixelBytes = minfo.vi_pixel_size;
 553       switch (vminfop->PixelBytes) {
 554       case 2:
 555         vminfop->Type = VIDBUF16;
 556         break;
 557 #if notyet
 558       case 3:
 559         vminfop->Type = VIDBUF24;
 560         break;
 561 #endif
 562       case 4:
 563         vminfop->Type = VIDBUF32;
 564         break;
 565       default:
 566         break;
 567       }
 568 #endif
 569     default:
 570       break;
 571     }
 572     if (vminfop->Type == NOBUF)
 573       continue;
 574
 575     switch (vminfop->Type) {
 576     case VIDBUF16:
 577     case VIDBUF32:
 578       modescp->Rmask = ((1 << minfo.vi_pixel_fsizes[VGL_RED_INDEX]) - 1) <<
 579                        minfo.vi_pixel_fields[VGL_RED_INDEX];
 580       modescp->Gmask = ((1 << minfo.vi_pixel_fsizes[VGL_GREEN_INDEX]) - 1) <<
 581                        minfo.vi_pixel_fields[VGL_GREEN_INDEX];
 582       modescp->Bmask = ((1 << minfo.vi_pixel_fsizes[VGL_BLUE_INDEX]) - 1) <<
 583                        minfo.vi_pixel_fields[VGL_BLUE_INDEX];
 584       break;
 585
 586     default:
 587       break;
 588     }
 589
 590     vminfop->Xsize = minfo.vi_width;
 591     vminfop->Ysize = minfo.vi_height;
 592     modescp->Depth = minfo.vi_depth;
 593
 594     /* XXX */
 595     if (minfo.vi_mode >= M_VESA_BASE)
 596       modescp->ModeId = _IO('V', minfo.vi_mode - M_VESA_BASE);
 597     else
 598       modescp->ModeId = _IO('S', minfo.vi_mode);
 599
 600     /* Sort list */
 601     for (i = 0; modes + i < modesp ; i++) {
 602       if (modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize >
 603           vminfop->Xsize * modes[i]->ModeInfo.Ysize)
 604         continue;
 605       if ((modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize ==
 606            vminfop->Xsize * vminfop->Ysize) &&
 607           (modes[i]->Depth >= modescp->Depth))
 608         continue;
 609       *modesp = modes[i];
 610       modes[i] = modescp;
 611       modescp = *modesp;
 612       vminfop = &(modescp->ModeInfo);
 613     }
 614
 615     modesp++;
 616   }
 617
 618   if (*modesp != NULL) {
 619     SDL_free(*modesp);
 620     *modesp = NULL;
 621   }
 622
 623   return modes;
 624 }