static int ANDROID_LockHWSurface(_THIS, SDL_Surface *surface) { if( !SDL_ANDROID_InsideVideoThread() ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Error: calling %s not from the main thread!", __PRETTY_FUNCTION__); return -1; } if( surface == SDL_CurrentVideoSurface ) { // Copy pixels from pixelbuffer to video surface - this is slow! Uint16 * row = NULL; int fakeH = SDL_ANDROID_sFakeWindowHeight, fakeW = SDL_ANDROID_sFakeWindowWidth; int realH = SDL_ANDROID_sWindowHeight, realW = SDL_ANDROID_sWindowWidth; int x, y; if( ! SDL_CurrentVideoSurface->pixels ) { glPixelStorei(GL_PACK_ALIGNMENT, 1); SDL_CurrentVideoSurface->pixels = SDL_malloc(SDL_ANDROID_sFakeWindowWidth * SDL_ANDROID_sFakeWindowHeight * ANDROID_BYTESPERPIXEL); if ( ! SDL_CurrentVideoSurface->pixels ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Couldn't allocate buffer for SDL_CurrentVideoSurface"); SDL_SetError("Couldn't allocate buffer for SDL_CurrentVideoSurface"); return(-1); } } if( ! SDL_CurrentVideoSurface->hwdata ) { SDL_CurrentVideoSurface->hwdata = (struct private_hwdata *)SDL_CreateTexture(SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, SDL_ANDROID_sFakeWindowWidth, SDL_ANDROID_sFakeWindowHeight); if( !SDL_CurrentVideoSurface->hwdata ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Couldn't allocate texture for SDL_CurrentVideoSurface"); SDL_OutOfMemory(); return(-1); } if( SDL_ANDROID_SmoothVideo ) SDL_SetTextureScaleMode((SDL_Texture *)SDL_CurrentVideoSurface->hwdata, SDL_SCALEMODE_SLOW); // Register main video texture to be recreated when needed HwSurfaceCount++; HwSurfaceList = SDL_realloc( HwSurfaceList, HwSurfaceCount * sizeof(SDL_Surface *) ); HwSurfaceList[HwSurfaceCount-1] = SDL_CurrentVideoSurface; DEBUGOUT("ANDROID_SetVideoMode() HwSurfaceCount %d HwSurfaceList %p", HwSurfaceCount, HwSurfaceList); } row = SDL_stack_alloc(Uint16, SDL_ANDROID_sWindowWidth); for(y=0; y<fakeH; y++) { glReadPixels(0, realH - 1 - (realH * y / fakeH), realW, 1, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, row); for(x=0; x<fakeW; x++) ((Uint16 *)SDL_CurrentVideoSurface->pixels)[ fakeW * y + x ] = row[ x * fakeW / realW ]; } SDL_stack_free(row); } if( !surface->hwdata ) return(-1); // Extra check not necessary /* if( SDL_CurrentVideoSurface->format->BitsPerPixel == surface->format->BitsPerPixel && SDL_CurrentVideoSurface->format->Rmask == surface->format->Rmask && SDL_CurrentVideoSurface->format->Gmask == surface->format->Gmask && SDL_CurrentVideoSurface->format->Bmask == surface->format->Bmask && SDL_CurrentVideoSurface->format->Amask == surface->format->Amask ) return(0); if( this->displayformatalphapixel->BitsPerPixel == surface->format->BitsPerPixel && this->displayformatalphapixel->Rmask == surface->format->Rmask && this->displayformatalphapixel->Gmask == surface->format->Gmask && this->displayformatalphapixel->Bmask == surface->format->Bmask && this->displayformatalphapixel->Amask == surface->format->Amask ) return(0); return(-1); */ return(0); }
SDL_Surface *ANDROID_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags) { SDL_PixelFormat format; int bpp1; __android_log_print(ANDROID_LOG_INFO, "libSDL", "SDL_SetVideoMode(): application requested mode %dx%d OpenGL %d HW %d", width, height, flags & SDL_OPENGL, flags & SDL_HWSURFACE); if( ! SDL_ANDROID_InsideVideoThread() ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Error: calling %s not from the main thread!", __PRETTY_FUNCTION__); return NULL; } sdl_opengl = (flags & SDL_OPENGL) ? 1 : 0; SDL_ANDROID_sFakeWindowWidth = width; SDL_ANDROID_sFakeWindowHeight = height; current->flags = (flags & SDL_FULLSCREEN) | (flags & SDL_OPENGL) | SDL_DOUBLEBUF | ( flags & SDL_HWSURFACE ); current->w = width; current->h = height; current->pitch = SDL_ANDROID_sFakeWindowWidth * ANDROID_BYTESPERPIXEL; current->pixels = NULL; current->hwdata = NULL; HwSurfaceCount = 0; HwSurfaceList = NULL; DEBUGOUT("ANDROID_SetVideoMode() HwSurfaceCount %d HwSurfaceList %p", HwSurfaceCount, HwSurfaceList); if( ! sdl_opengl ) { SDL_DisplayMode mode; SDL_RendererInfo SDL_VideoRendererInfo; SDL_SelectVideoDisplay(0); SDL_VideoWindow = SDL_CreateWindow("", 0, 0, width, height, SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS | SDL_WINDOW_OPENGL); SDL_memset(&mode, 0, sizeof(mode)); mode.format = SDL_PIXELFORMAT_RGB565; SDL_SetWindowDisplayMode(SDL_VideoWindow, &mode); if (SDL_CreateRenderer(SDL_VideoWindow, -1, 0) < 0) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "SDL_SetVideoMode(): Error creating renderer"); return NULL; } SDL_GetRendererInfo(&SDL_VideoRendererInfo); current->hwdata = NULL; if( ! (flags & SDL_HWSURFACE) ) { current->pixels = SDL_malloc(width * height * ANDROID_BYTESPERPIXEL); if ( ! current->pixels ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Couldn't allocate buffer for requested mode"); SDL_SetError("Couldn't allocate buffer for requested mode"); return(NULL); } SDL_memset(current->pixels, 0, width * height * ANDROID_BYTESPERPIXEL); current->hwdata = (struct private_hwdata *)SDL_CreateTexture(SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, width, height); if( !current->hwdata ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Couldn't allocate texture for SDL_CurrentVideoSurface"); SDL_free(current->pixels); current->pixels = NULL; SDL_OutOfMemory(); return(NULL); } if( SDL_ANDROID_SmoothVideo ) SDL_SetTextureScaleMode((SDL_Texture *)current->hwdata, SDL_SCALEMODE_SLOW); // Register main video texture to be recreated when needed HwSurfaceCount++; HwSurfaceList = SDL_realloc( HwSurfaceList, HwSurfaceCount * sizeof(SDL_Surface *) ); HwSurfaceList[HwSurfaceCount-1] = current; DEBUGOUT("ANDROID_SetVideoMode() HwSurfaceCount %d HwSurfaceList %p", HwSurfaceCount, HwSurfaceList); } glViewport(0, 0, SDL_ANDROID_sRealWindowWidth, SDL_ANDROID_sRealWindowHeight); glOrthof(0.0, (GLfloat) SDL_ANDROID_sWindowWidth, (GLfloat) SDL_ANDROID_sWindowHeight, 0.0, 0.0, 1.0); } /* Allocate the new pixel format for the screen */ SDL_memset(&format, 0, sizeof(format)); SDL_PixelFormatEnumToMasks( SDL_PIXELFORMAT_RGB565, &bpp1, &format.Rmask, &format.Gmask, &format.Bmask, &format.Amask ); format.BitsPerPixel = bpp1; format.BytesPerPixel = ANDROID_BYTESPERPIXEL; if ( ! SDL_ReallocFormat(current, ANDROID_BITSPERPIXEL, format.Rmask, format.Gmask, format.Bmask, format.Amask) ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Couldn't allocate new pixel format for requested mode"); SDL_SetError("Couldn't allocate new pixel format for requested mode"); return(NULL); } /* Set up the new mode framebuffer */ SDL_CurrentVideoSurface = current; /* We're done */ return(current); }
static int ANDROID_AllocHWSurface(_THIS, SDL_Surface *surface) { if( !SDL_ANDROID_InsideVideoThread() ) { __android_log_print(ANDROID_LOG_INFO, "libSDL", "Error: calling %s not from the main thread!", __PRETTY_FUNCTION__); return -1; } if ( ! (surface->w && surface->h) ) return(-1); DEBUGOUT("ANDROID_AllocHWSurface() surface %p w %d h %d", surface, surface->w, surface->h); Uint32 format = SDL_PIXELFORMAT_RGBA5551; // 1-bit alpha for color key, every surface will have colorkey so it's easier for us if( surface->format->Amask ) { SDL_PixelFormat format1; int bpp; format = SDL_PIXELFORMAT_RGBA4444; DEBUGOUT("ANDROID_AllocHWSurface() SDL_PIXELFORMAT_RGBA4444"); SDL_memset(&format1, 0, sizeof(format1)); SDL_PixelFormatEnumToMasks( format, &bpp, &format1.Rmask, &format1.Gmask, &format1.Bmask, &format1.Amask ); if( surface->format->BitsPerPixel != bpp || surface->format->Rmask != format1.Rmask || surface->format->Gmask != format1.Gmask || surface->format->Bmask != format1.Bmask || surface->format->Amask != format1.Amask ) return(-1); // Do not allow alpha-surfaces with format other than RGBA4444 (it will be pain to lock/copy them) } else { DEBUGOUT("ANDROID_AllocHWSurface() SDL_PIXELFORMAT_RGBA5551"); // HW-accel surface should be RGB565 if( !( SDL_CurrentVideoSurface->format->BitsPerPixel == surface->format->BitsPerPixel && SDL_CurrentVideoSurface->format->Rmask == surface->format->Rmask && SDL_CurrentVideoSurface->format->Gmask == surface->format->Gmask && SDL_CurrentVideoSurface->format->Bmask == surface->format->Bmask && SDL_CurrentVideoSurface->format->Amask == surface->format->Amask ) ) return(-1); } surface->pitch = surface->w * surface->format->BytesPerPixel; surface->pixels = SDL_malloc(surface->h * surface->w * surface->format->BytesPerPixel); if ( surface->pixels == NULL ) { SDL_OutOfMemory(); return(-1); } SDL_memset(surface->pixels, 0, surface->h*surface->pitch); surface->hwdata = (struct private_hwdata *)SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w, surface->h); if( !surface->hwdata ) { SDL_free(surface->pixels); surface->pixels = NULL; SDL_OutOfMemory(); return(-1); } if( SDL_ANDROID_SmoothVideo ) SDL_SetTextureScaleMode((SDL_Texture *)surface->hwdata, SDL_SCALEMODE_SLOW); if( surface->format->Amask ) { SDL_SetTextureAlphaMod((struct SDL_Texture *)surface->hwdata, SDL_ALPHA_OPAQUE); SDL_SetTextureBlendMode((struct SDL_Texture *)surface->hwdata, SDL_BLENDMODE_BLEND); } surface->flags |= SDL_HWSURFACE | SDL_HWACCEL; HwSurfaceCount++; DEBUGOUT("ANDROID_AllocHWSurface() in HwSurfaceCount %d HwSurfaceList %p", HwSurfaceCount, HwSurfaceList); HwSurfaceList = SDL_realloc( HwSurfaceList, HwSurfaceCount * sizeof(SDL_Surface *) ); DEBUGOUT("ANDROID_AllocHWSurface() out HwSurfaceCount %d HwSurfaceList %p", HwSurfaceCount, HwSurfaceList); HwSurfaceList[HwSurfaceCount-1] = surface; return 0; }
int SDLNet_GetLocalAddresses(IPaddress *addresses, int maxcount) { int count = 0; #ifdef SIOCGIFCONF /* Defined on Mac OS X */ #ifndef _SIZEOF_ADDR_IFREQ #define _SIZEOF_ADDR_IFREQ sizeof #endif SOCKET sock; struct ifconf conf; char data[4096]; struct ifreq *ifr; struct sockaddr_in *sock_addr; sock = socket(AF_INET, SOCK_DGRAM, 0); if ( sock == INVALID_SOCKET ) { return 0; } conf.ifc_len = sizeof(data); conf.ifc_buf = (caddr_t) data; if ( ioctl(sock, SIOCGIFCONF, &conf) < 0 ) { closesocket(sock); return 0; } ifr = (struct ifreq*)data; while ((char*)ifr < data+conf.ifc_len) { if (ifr->ifr_addr.sa_family == AF_INET) { if (count < maxcount) { sock_addr = (struct sockaddr_in*)&ifr->ifr_addr; addresses[count].host = sock_addr->sin_addr.s_addr; addresses[count].port = sock_addr->sin_port; } ++count; } ifr = (struct ifreq*)((char*)ifr + _SIZEOF_ADDR_IFREQ(*ifr)); } closesocket(sock); #elif defined(__WIN32__) PIP_ADAPTER_INFO pAdapterInfo; PIP_ADAPTER_INFO pAdapter; PIP_ADDR_STRING pAddress; DWORD dwRetVal = 0; ULONG ulOutBufLen = sizeof (IP_ADAPTER_INFO); pAdapterInfo = (IP_ADAPTER_INFO *) SDL_malloc(sizeof (IP_ADAPTER_INFO)); if (pAdapterInfo == NULL) { return 0; } if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == ERROR_BUFFER_OVERFLOW) { pAdapterInfo = (IP_ADAPTER_INFO *) SDL_realloc(pAdapterInfo, ulOutBufLen); if (pAdapterInfo == NULL) { return 0; } dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen); } if (dwRetVal == NO_ERROR) { for (pAdapter = pAdapterInfo; pAdapter; pAdapter = pAdapter->Next) { for (pAddress = &pAdapterInfo->IpAddressList; pAddress; pAddress = pAddress->Next) { if (count < maxcount) { addresses[count].host = inet_addr(pAddress->IpAddress.String); addresses[count].port = 0; } ++count; } } } SDL_free(pAdapterInfo); #endif return count; }
int WIN_CreateWindow(_THIS, SDL_Window * window) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); RAWINPUTDEVICE Rid; AXIS TabX, TabY; LOGCONTEXTA lc; HWND hwnd; HWND top; RECT rect; SDL_Rect bounds; DWORD style = (WS_CLIPSIBLINGS | WS_CLIPCHILDREN); int x, y; int w, h; if (window->flags & (SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN)) { style |= WS_POPUP; } else { style |= (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX); } if ((window->flags & SDL_WINDOW_RESIZABLE) && !(window->flags & SDL_WINDOW_FULLSCREEN)) { style |= (WS_THICKFRAME | WS_MAXIMIZEBOX); } /* Figure out what the window area will be */ if (window->flags & SDL_WINDOW_FULLSCREEN) { top = HWND_TOPMOST; } else { top = HWND_NOTOPMOST; } rect.left = 0; rect.top = 0; rect.right = window->w; rect.bottom = window->h; AdjustWindowRectEx(&rect, style, FALSE, 0); w = (rect.right - rect.left); h = (rect.bottom - rect.top); WIN_GetDisplayBounds(_this, display, &bounds); if ((window->flags & SDL_WINDOW_FULLSCREEN) || window->x == SDL_WINDOWPOS_CENTERED) { x = bounds.x + (bounds.w - window->w) / 2; } else if (window->x == SDL_WINDOWPOS_UNDEFINED) { if (bounds.x == 0) { x = CW_USEDEFAULT; } else { x = bounds.x; } } else { x = bounds.x + window->x + rect.left; } if ((window->flags & SDL_WINDOW_FULLSCREEN) || window->y == SDL_WINDOWPOS_CENTERED) { y = bounds.y + (bounds.h - window->h) / 2; } else if (window->x == SDL_WINDOWPOS_UNDEFINED) { if (bounds.x == 0) { y = CW_USEDEFAULT; } else { y = bounds.y; } } else { y = bounds.y + window->y + rect.top; } hwnd = CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL, SDL_Instance, NULL); if (!hwnd) { WIN_SetError("Couldn't create window"); return -1; } /* we're configuring the tablet data. See Wintab reference for more info */ if (videodata->wintabDLL && videodata->WTInfoA(WTI_DEFSYSCTX, 0, &lc) != 0) { lc.lcPktData = PACKETDATA; lc.lcPktMode = PACKETMODE; lc.lcOptions |= CXO_MESSAGES; lc.lcOptions |= CXO_SYSTEM; lc.lcMoveMask = PACKETDATA; lc.lcBtnDnMask = lc.lcBtnUpMask = PACKETDATA; videodata->WTInfoA(WTI_DEVICES, DVC_X, &TabX); videodata->WTInfoA(WTI_DEVICES, DVC_Y, &TabY); lc.lcInOrgX = 0; lc.lcInOrgY = 0; lc.lcInExtX = TabX.axMax; lc.lcInExtY = TabY.axMax; lc.lcOutOrgX = 0; lc.lcOutOrgY = 0; lc.lcOutExtX = GetSystemMetrics(SM_CXSCREEN); lc.lcOutExtY = -GetSystemMetrics(SM_CYSCREEN); if (window->id > highestId) { HCTX *tmp_hctx; highestId = window->id; tmp_hctx = (HCTX *) SDL_realloc(g_hCtx, (highestId + 1) * sizeof(HCTX)); if (!tmp_hctx) { SDL_OutOfMemory(); DestroyWindow(hwnd); return -1; } g_hCtx = tmp_hctx; } g_hCtx[window->id] = videodata->WTOpenA(hwnd, &lc, TRUE); } #ifndef _WIN32_WCE /* has no RawInput */ /* we're telling the window, we want it to report raw input events from mice */ Rid.usUsagePage = 0x01; Rid.usUsage = 0x02; Rid.dwFlags = RIDEV_INPUTSINK; Rid.hwndTarget = hwnd; RegisterRawInputDevices(&Rid, 1, sizeof(Rid)); #endif WIN_PumpEvents(_this); if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) { DestroyWindow(hwnd); return -1; } #ifdef SDL_VIDEO_OPENGL_WGL if (window->flags & SDL_WINDOW_OPENGL) { if (WIN_GL_SetupWindow(_this, window) < 0) { WIN_DestroyWindow(_this, window); return -1; } } #endif return 0; }
int SDL_ResizeVideoMode(int width, int height, int bpp, Uint32 flags) { int w, h; Uint32 format; int access; void *pixels; int pitch; /* We can't resize something we don't have... */ if (!SDL_VideoWindow) { return -1; } /* We probably have to recreate the window in fullscreen mode */ if (flags & SDL_FULLSCREEN) { return -1; } /* I don't think there's any change we can gracefully make in flags */ if (flags != SDL_VideoFlags) { return -1; } /* Resize the window */ SDL_GetWindowSize(SDL_VideoWindow, &w, &h); if (w != width || h != height) { SDL_SetWindowSize(SDL_VideoWindow, width, height); } /* If we're in OpenGL mode, just resize the stub surface and we're done! */ if (flags & SDL_OPENGL) { SDL_VideoSurface->w = width; SDL_VideoSurface->h = height; return 0; } /* Destroy the screen texture and recreate it */ SDL_QueryTexture(SDL_VideoTexture, &format, &access, &w, &h); SDL_DestroyTexture(SDL_VideoTexture); SDL_VideoTexture = SDL_CreateTexture(format, access, width, height); if (!SDL_VideoTexture) { return -1; } SDL_VideoSurface->w = width; SDL_VideoSurface->h = height; if (SDL_QueryTexturePixels(SDL_VideoTexture, &pixels, &pitch) == 0) { SDL_VideoSurface->pixels = pixels; SDL_VideoSurface->pitch = pitch; } else { SDL_CalculatePitch(SDL_VideoSurface); SDL_VideoSurface->pixels = SDL_realloc(SDL_VideoSurface->pixels, SDL_VideoSurface->h * SDL_VideoSurface->pitch); } SDL_SetClipRect(SDL_VideoSurface, NULL); SDL_InvalidateMap(SDL_VideoSurface->map); if (SDL_ShadowSurface) { SDL_ShadowSurface->w = width; SDL_ShadowSurface->h = height; SDL_ShadowSurface->pitch = SDL_CalculatePitch(SDL_ShadowSurface); SDL_ShadowSurface->pixels = SDL_realloc(SDL_ShadowSurface->pixels, SDL_ShadowSurface->h * SDL_ShadowSurface->pitch); SDL_SetClipRect(SDL_ShadowSurface, NULL); SDL_InvalidateMap(SDL_ShadowSurface->map); } ClearVideoSurface(); return 0; }
/* Put a variable into the environment */ int SDL_setenv(const char *name, const char *value, int overwrite) { int added; int len, i; char **new_env; char *new_variable; /* A little error checking */ if (!name || !value) { return (-1); } /* See if it already exists */ if (!overwrite && SDL_getenv(name)) { return 0; } /* Allocate memory for the variable */ len = SDL_strlen(name) + SDL_strlen(value) + 2; new_variable = (char *) SDL_malloc(len); if (!new_variable) { return (-1); } SDL_snprintf(new_variable, len, "%s=%s", name, value); value = new_variable + SDL_strlen(name) + 1; name = new_variable; /* Actually put it into the environment */ added = 0; i = 0; if (SDL_env) { /* Check to see if it's already there... */ len = (value - name); for (; SDL_env[i]; ++i) { if (SDL_strncmp(SDL_env[i], name, len) == 0) { break; } } /* If we found it, just replace the entry */ if (SDL_env[i]) { SDL_free(SDL_env[i]); SDL_env[i] = new_variable; added = 1; } } /* Didn't find it in the environment, expand and add */ if (!added) { new_env = SDL_realloc(SDL_env, (i + 2) * sizeof(char *)); if (new_env) { SDL_env = new_env; SDL_env[i++] = new_variable; SDL_env[i++] = (char *) 0; added = 1; } else { SDL_free(new_variable); } } return (added ? 0 : -1); }
SDL_Surface *VGL_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags) { int mode_found; int i; VGLMode **modes; modes = VGLListModes(bpp, V_INFO_MM_DIRECT | V_INFO_MM_PACKED); mode_found = 0; for (i = 0; modes[i] != NULL; i++) { if ((modes[i]->ModeInfo.Xsize == width) && (modes[i]->ModeInfo.Ysize == height) && ((modes[i]->ModeInfo.Type == VIDBUF8) || (modes[i]->ModeInfo.Type == VIDBUF16) || (modes[i]->ModeInfo.Type == VIDBUF32))) { mode_found = 1; break; } } if (mode_found == 0) { SDL_SetError("No matching video mode found"); return NULL; } /* Shutdown previous videomode (if any) */ if (VGLCurMode != NULL) VGLEnd(); /* Try to set the requested linear video mode */ if (VGLInit(modes[i]->ModeId) != 0) { SDL_SetError("Unable to switch to requested mode"); return NULL; } VGLCurMode = SDL_realloc(VGLCurMode, sizeof(VGLMode)); VGLCurMode->ModeInfo = *VGLDisplay; VGLCurMode->Depth = modes[i]->Depth; VGLCurMode->ModeId = modes[i]->ModeId; VGLCurMode->Rmask = modes[i]->Rmask; VGLCurMode->Gmask = modes[i]->Gmask; VGLCurMode->Bmask = modes[i]->Bmask; /* Workaround a bug in libvgl */ if (VGLCurMode->ModeInfo.PixelBytes == 0) (VGLCurMode->ModeInfo.PixelBytes = 1); current->w = VGLCurMode->ModeInfo.Xsize; current->h = VGLCurMode->ModeInfo.Ysize; current->pixels = VGLCurMode->ModeInfo.Bitmap; current->pitch = VGLCurMode->ModeInfo.Xsize * VGLCurMode->ModeInfo.PixelBytes; current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE); /* Check if we are in a pseudo-color mode */ if (VGLCurMode->ModeInfo.Type == VIDBUF8) current->flags |= SDL_HWPALETTE; /* Check if we can do doublebuffering */ if (flags & SDL_DOUBLEBUF) { if (VGLCurMode->ModeInfo.Xsize * 2 <= VGLCurMode->ModeInfo.VYsize) { current->flags |= SDL_DOUBLEBUF; flip_page = 0; flip_address[0] = (byte *)current->pixels; flip_address[1] = (byte *)current->pixels + current->h * current->pitch; VGL_FlipHWSurface(this, current); } } if (! SDL_ReallocFormat(current, modes[i]->Depth, VGLCurMode->Rmask, VGLCurMode->Gmask, VGLCurMode->Bmask, 0)) { return NULL; } /* Update hardware acceleration info */ VGL_UpdateVideoInfo(this); /* Set the blit function */ this->UpdateRects = VGL_DirectUpdate; /* We're done */ return current; }
static int SetupWindowData(_THIS, SDL_Window * window, Window w, BOOL created) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; SDL_WindowData *data; int numwindows = videodata->numwindows; int windowlistlength = videodata->windowlistlength; SDL_WindowData **windowlist = videodata->windowlist; /* Allocate the window data */ data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data)); if (!data) { SDL_OutOfMemory(); return -1; } data->window = window; data->xwindow = w; #ifdef X_HAVE_UTF8_STRING if (SDL_X11_HAVE_UTF8) { data->ic = pXCreateIC(videodata->im, XNClientWindow, w, XNFocusWindow, w, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, XNResourceName, videodata->classname, XNResourceClass, videodata->classname, NULL); } #endif data->created = created; data->videodata = videodata; /* Associate the data with the window */ if (numwindows < windowlistlength) { windowlist[numwindows] = data; videodata->numwindows++; } else { windowlist = (SDL_WindowData **) SDL_realloc(windowlist, (numwindows + 1) * sizeof(*windowlist)); if (!windowlist) { SDL_OutOfMemory(); SDL_free(data); return -1; } windowlist[numwindows] = data; videodata->numwindows++; videodata->windowlistlength++; videodata->windowlist = windowlist; } /* Fill in the SDL window with the window data */ { XWindowAttributes attrib; XGetWindowAttributes(data->videodata->display, w, &attrib); window->x = attrib.x; window->y = attrib.y; window->w = attrib.width; window->h = attrib.height; if (attrib.map_state != IsUnmapped) { window->flags |= SDL_WINDOW_SHOWN; } else { window->flags &= ~SDL_WINDOW_SHOWN; } data->visual = attrib.visual; } { Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE; Atom _NET_WM_STATE_MAXIMIZED_VERT = data->videodata->_NET_WM_STATE_MAXIMIZED_VERT; Atom _NET_WM_STATE_MAXIMIZED_HORZ = data->videodata->_NET_WM_STATE_MAXIMIZED_HORZ; Atom _NET_WM_STATE_FULLSCREEN = data->videodata->_NET_WM_STATE_FULLSCREEN; Atom actualType; int actualFormat; unsigned long i, numItems, bytesAfter; unsigned char *propertyValue = NULL; long maxLength = 1024; if (XGetWindowProperty(data->videodata->display, w, _NET_WM_STATE, 0l, maxLength, False, XA_ATOM, &actualType, &actualFormat, &numItems, &bytesAfter, &propertyValue) == Success) { Atom *atoms = (Atom *) propertyValue; int maximized = 0; int fullscreen = 0; for (i = 0; i < numItems; ++i) { if (atoms[i] == _NET_WM_STATE_MAXIMIZED_VERT) { maximized |= 1; } else if (atoms[i] == _NET_WM_STATE_MAXIMIZED_HORZ) { maximized |= 2; } else if ( atoms[i] == _NET_WM_STATE_FULLSCREEN) { fullscreen = 1; } } if (maximized == 3) { window->flags |= SDL_WINDOW_MAXIMIZED; } else if (fullscreen == 1) { window->flags |= SDL_WINDOW_FULLSCREEN; } XFree(propertyValue); } } /* FIXME: How can I tell? { DWORD style = GetWindowLong(hwnd, GWL_STYLE); if (style & WS_VISIBLE) { if (style & (WS_BORDER | WS_THICKFRAME)) { window->flags &= ~SDL_WINDOW_BORDERLESS; } else { window->flags |= SDL_WINDOW_BORDERLESS; } if (style & WS_THICKFRAME) { window->flags |= SDL_WINDOW_RESIZABLE; } else { window->flags &= ~SDL_WINDOW_RESIZABLE; } if (style & WS_MINIMIZE) { window->flags |= SDL_WINDOW_MINIMIZED; } else { window->flags &= ~SDL_WINDOW_MINIMIZED; } } if (GetFocus() == hwnd) { int index = data->videodata->keyboard; window->flags |= SDL_WINDOW_INPUT_FOCUS; SDL_SetKeyboardFocus(index, data->window); if (window->flags & SDL_WINDOW_INPUT_GRABBED) { RECT rect; GetClientRect(hwnd, &rect); ClientToScreen(hwnd, (LPPOINT) & rect); ClientToScreen(hwnd, (LPPOINT) & rect + 1); ClipCursor(&rect); } } */ /* All done! */ window->driverdata = data; return 0; }
static int SDL_ResizeVideoMode(int width, int height, int bpp, Uint32 flags) { int w, h; /* We can't resize something we don't have... */ if (!SDL_VideoSurface) { return -1; } /* We probably have to recreate the window in fullscreen mode */ if (flags & SDL_FULLSCREEN) { return -1; } /* I don't think there's any change we can gracefully make in flags */ if (flags != SDL_VideoFlags) { return -1; } if (bpp != SDL_VideoSurface->format->BitsPerPixel) { return -1; } /* Resize the window */ SDL_GetWindowSize(SDL_VideoWindow, &w, &h); if (w != width || h != height) { SDL_SetWindowSize(SDL_VideoWindow, width, height); } /* If we're in OpenGL mode, just resize the stub surface and we're done! */ if (flags & SDL_OPENGL) { SDL_VideoSurface->w = width; SDL_VideoSurface->h = height; return 0; } SDL_WindowSurface = SDL_GetWindowSurface(SDL_VideoWindow); if (!SDL_WindowSurface) { return -1; } if (SDL_VideoSurface->format != SDL_WindowSurface->format) { return -1; } SDL_VideoSurface->w = width; SDL_VideoSurface->h = height; SDL_VideoSurface->pixels = SDL_WindowSurface->pixels; SDL_VideoSurface->pitch = SDL_WindowSurface->pitch; SDL_SetClipRect(SDL_VideoSurface, NULL); if (SDL_ShadowSurface) { SDL_ShadowSurface->w = width; SDL_ShadowSurface->h = height; SDL_ShadowSurface->pitch = SDL_CalculatePitch(SDL_ShadowSurface); SDL_ShadowSurface->pixels = SDL_realloc(SDL_ShadowSurface->pixels, SDL_ShadowSurface->h * SDL_ShadowSurface->pitch); SDL_SetClipRect(SDL_ShadowSurface, NULL); SDL_InvalidateMap(SDL_ShadowSurface->map); } else { SDL_PublicSurface = SDL_VideoSurface; } ClearVideoSurface(); return 0; }
SDL_AudioSpec *Mix_LoadMP3_RW(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len) { /* note: spec is initialized to mixer spec */ #if defined(MP3_MUSIC) SMPEG* mp3 = 0; SMPEG_Info info; #elif defined(MP3_MAD_MUSIC) mad_data *mp3_mad; #endif long samplesize; int read_len; const Uint32 chunk_len = 4096; int err = 0; if ((!src) || (!spec) || (!audio_buf) || (!audio_len)) { return NULL; } if (!err) { *audio_len = 0; *audio_buf = (Uint8*) SDL_malloc(chunk_len); err = (*audio_buf == NULL); } if (!err) { err = ((Mix_Init(MIX_INIT_MP3) & MIX_INIT_MP3) == 0); } if (!err) { #if defined(MP3_MUSIC) mp3 = smpeg.SMPEG_new_rwops(src, &info, freesrc, 0); err = (mp3 == NULL); #elif defined(MP3_MAD_MUSIC) mp3_mad = mad_openFileRW(src, spec, freesrc); err = (mp3_mad == NULL); #endif } #if defined(MP3_MUSIC) if (!err) { err = !info.has_audio; } #endif if (!err) { #if defined(MP3_MUSIC) smpeg.SMPEG_actualSpec(mp3, spec); smpeg.SMPEG_enableaudio(mp3, 1); smpeg.SMPEG_enablevideo(mp3, 0); smpeg.SMPEG_play(mp3); /* read once for audio length */ while ((read_len = smpeg.SMPEG_playAudio(mp3, *audio_buf, chunk_len)) > 0) { *audio_len += read_len; } smpeg.SMPEG_stop(mp3); #elif defined(MP3_MAD_MUSIC) mad_start(mp3_mad); /* read once for audio length */ while ((read_len = mad_getSamples(mp3_mad, *audio_buf, chunk_len)) > 0) { *audio_len += read_len; } mad_stop(mp3_mad); #endif err = (read_len < 0); } if (!err) { /* reallocate, if needed */ if ((*audio_len > 0) && (*audio_len != chunk_len)) { *audio_buf = (Uint8*) SDL_realloc(*audio_buf, *audio_len); err = (*audio_buf == NULL); } } if (!err) { /* read again for audio buffer, if needed */ if (*audio_len > chunk_len) { #if defined(MP3_MUSIC) smpeg.SMPEG_rewind(mp3); smpeg.SMPEG_play(mp3); err = (*audio_len != smpeg.SMPEG_playAudio(mp3, *audio_buf, *audio_len)); smpeg.SMPEG_stop(mp3); #elif defined(MP3_MAD_MUSIC) mad_seek(mp3_mad, 0); mad_start(mp3_mad); err = (*audio_len != mad_getSamples(mp3_mad, *audio_buf, *audio_len)); mad_stop(mp3_mad); #endif } } if (!err) { /* Don't return a buffer that isn't a multiple of samplesize */ samplesize = ((spec->format & 0xFF)/8)*spec->channels; *audio_len &= ~(samplesize-1); } #if defined(MP3_MUSIC) if (mp3) { smpeg.SMPEG_delete(mp3); mp3 = NULL; /* Deleting the MP3 closed the source if desired */ freesrc = SDL_FALSE; } #elif defined(MP3_MAD_MUSIC) if (mp3_mad) { mad_closeFile(mp3_mad); mp3_mad = NULL; /* Deleting the MP3 closed the source if desired */ freesrc = SDL_FALSE; } #endif if (freesrc) { SDL_RWclose(src); src = NULL; } /* handle error */ if (err) { if (*audio_buf != NULL) { SDL_free(*audio_buf); *audio_buf = NULL; } *audio_len = 0; spec = NULL; } return spec; }
static BOOL VManQueryVideoModes(SDL_PrivateVideoData *pPVData) { ULONG ulRC; GDDMODEINFO sCurModeInfo; VMIQCI sVmiQCI; CHAININFO *pChainInfo; PGRADDINFO pGraddInfo; GDDMODEINFO *pModeInfo; ULONG ulIdx; PVIDEOMODE pVideoMode; SDL_Rect **ppSDLRectList; ULONG ulRectIdx; LONG lPos; static ULONG aModeItemBPP[OS2VMAN_FSMODELIST_SIZE] = {15,8,16,24,32}; // Query avaible video modes from VMAN, fill pVideoModes, detect current mode ulRC = pfnVMIEntry( 0, VMI_CMD_QUERYCURRENTMODE, NULL, &sCurModeInfo ); if ( ulRC != RC_SUCCESS ) { SDL_SetError( "Could not query desktop video mode." ); return FALSE; } sVmiQCI.ulLength = sizeof(VMIQCI); ulRC = pfnVMIEntry( 0, VMI_CMD_QUERYCHAININFO, NULL, &sVmiQCI ); if ( ulRC != RC_SUCCESS ) { SDL_SetError( "pfnVMIEntry(,VMI_CMD_QUERYCHAININFO,,), rc = %u", ulRC ); return FALSE; } for( pChainInfo = sVmiQCI.pciHead; pChainInfo != NULL; pChainInfo = pChainInfo->pNextChainInfo ) { for( pGraddInfo = pChainInfo->pGraddList; pGraddInfo != NULL; pGraddInfo = pGraddInfo->pNextGraddInfo ) { pModeInfo = pGraddInfo->pModeInfo; for( ulIdx = 0; ulIdx < pGraddInfo->cModes; ulIdx++, pModeInfo = (GDDMODEINFO *)&((PCHAR)pModeInfo)[pModeInfo->ulLength] ) { if ( pModeInfo->ulBpp == 16 && pModeInfo->cColors == 32768 ) pModeInfo->ulBpp = 15; debug( "Mode %X %ux%u, BPP: %u (%.4s), colors: %d%s%s", pModeInfo->ulModeId, pModeInfo->ulHorizResolution, pModeInfo->ulVertResolution, pModeInfo->ulBpp, &pModeInfo->fccColorEncoding, pModeInfo->cColors, pModeInfo->ulModeId == sCurModeInfo.ulModeId ? " - CURRENT" : "", /*pModeInfo->ulBpp <= 8 ? " - IGNORED" : */"" ); // if ( pModeInfo->ulBpp <= 8 ) // continue; pVideoMode = SDL_malloc( sizeof(VIDEOMODE) ); if ( pVideoMode == NULL ) { SDL_NotEnoughMemory(); VManFreeVideoModes( pPVData ); return FALSE; } if ( pModeInfo->ulModeId == sCurModeInfo.ulModeId ) pPVData->pDesktopVideoMode = pVideoMode; pVideoMode->uiModeID = pModeInfo->ulModeId; pVideoMode->sSDLRect.x = 0; pVideoMode->sSDLRect.y = 0; pVideoMode->sSDLRect.w = pModeInfo->ulHorizResolution; pVideoMode->sSDLRect.h = pModeInfo->ulVertResolution; pVideoMode->uiBPP = pModeInfo->ulBpp; pVideoMode->uiScanLineSize = pModeInfo->ulScanLineSize; pVideoMode->fccColorEncoding = pModeInfo->fccColorEncoding; pVideoMode->pNext = pPVData->pVideoModes; pPVData->pVideoModes = pVideoMode; } } } if ( pPVData->pDesktopVideoMode == NULL ) { SDL_SetError( "Current video mode not found" ); VManFreeVideoModes( pPVData ); return FALSE; } // Sort video modes, fill pListVideoModes - it will be returned to SDL for( ulIdx = 0; ulIdx < OS2VMAN_FSMODELIST_SIZE; ulIdx++ ) { ppSDLRectList = pPVData->pListVideoModes[ulIdx]; for( pVideoMode = pPVData->pVideoModes; pVideoMode != NULL; pVideoMode = pVideoMode->pNext ) { if ( pVideoMode->uiBPP != aModeItemBPP[ulIdx] ) continue; if ( ppSDLRectList == NULL ) { // First record in list ppSDLRectList = SDL_malloc( 2 * sizeof(SDL_Rect*) ); if ( ppSDLRectList == NULL ) continue; ppSDLRectList[0] = &pVideoMode->sSDLRect; ppSDLRectList[1] = NULL; pPVData->pListVideoModes[ulIdx] = ppSDLRectList; continue; } // Search position in sorted list, count number of items lPos = -1; for( ulRectIdx = 0; ppSDLRectList[ulRectIdx] != NULL; ulRectIdx++ ) { if ( lPos != -1 ) // Position found - continue calc number of items continue; if ( ( ppSDLRectList[ulRectIdx]->w * ppSDLRectList[ulRectIdx]->h ) < ( pVideoMode->sSDLRect.w * pVideoMode->sSDLRect.h ) ) lPos = ulRectIdx; } if ( lPos == -1 ) lPos = ulRectIdx; // Position not found, get position of NULL ulRectIdx++; // Insert new item ppSDLRectList = SDL_realloc( ppSDLRectList, ( ulRectIdx + 1 ) * sizeof(SDL_Rect*) ); if ( ppSDLRectList == NULL ) continue; pPVData->pListVideoModes[ulIdx] = ppSDLRectList; SDL_memmove( &ppSDLRectList[lPos + 1], &ppSDLRectList[lPos], ( ulRectIdx - lPos ) * sizeof(SDL_Rect*) ); ppSDLRectList[lPos] = &pVideoMode->sSDLRect; } } #ifdef DEBUG_BUILD // Debug. Show sorted lists for( ulIdx = 0; ulIdx < OS2VMAN_FSMODELIST_SIZE; ulIdx++ ) { ppSDLRectList = pPVData->pListVideoModes[ulIdx]; if ( ppSDLRectList == NULL ) continue; debug( "Modes list #%u for %u BPP:", ulIdx, aModeItemBPP[ulIdx] ); for( ulRectIdx = 0; ppSDLRectList[ulRectIdx] != NULL; ulRectIdx++ ) debug( " %u x %u", ppSDLRectList[ulRectIdx]->w, ppSDLRectList[ulRectIdx]->h ); } #endif return TRUE; }