pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed 1.2 files.

Browse source
This commit is contained in:
Nathan Heisey 2011-07-12 15:09:44 +00:00
parent 70ba5c8150
commit 461d178134
10 changed files with 0 additions and 1661 deletions
Download patch file Download diff file Expand all files Collapse all files

59
src/video/bwindow/SDL_lowvideo.h
View file

@ -1,59 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#ifndef _SDL_lowvideo_h
#define _SDL_lowvideo_h
#include "SDL_BWin.h"
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
/* Hidden "this" pointer for the video functions */
#define _THIS SDL_VideoDevice *_this
/* Private display data */
struct SDL_PrivateVideoData
{
/* The main window */
SDL_BWin *SDL_Win;
/* The fullscreen mode list */
display_mode saved_mode;
#define NUM_MODELISTS 4 /* 8, 16, 24, and 32 bits-per-pixel */
int SDL_nummodes[NUM_MODELISTS];
SDL_Rect **SDL_modelist[NUM_MODELISTS];
/* A completely clear cursor */
struct WMcursor *BlankCursor;
SDL_Overlay *overlay;
};
/* Old variable names */
#define SDL_Win (_this->hidden->SDL_Win)
#define saved_mode (_this->hidden->saved_mode)
#define SDL_nummodes (_this->hidden->SDL_nummodes)
#define SDL_modelist (_this->hidden->SDL_modelist)
#define SDL_BlankCursor (_this->hidden->BlankCursor)
#define current_overlay (_this->hidden->overlay)
#endif /* _SDL_lowvideo_h */
/* vi: set ts=4 sw=4 expandtab: */

48
src/video/bwindow/SDL_sysevents.cc
View file

@ -1,48 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#include <support/UTF8.h>
#include <stdio.h>
#include <string.h>
#include "SDL_error.h"
#include "SDL_events.h"
#include "SDL_BWin.h"
#include "SDL_lowvideo.h"
extern "C"
{
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_sysevents_c.h"
void BE_PumpEvents(_THIS)
{
}
void BE_InitOSKeymap(_THIS)
{
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

31
src/video/bwindow/SDL_sysevents_c.h
View file

@ -1,31 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#include "SDL_lowvideo.h"
/* Variables and functions exported by SDL_sysevents.c to other parts
of the native video subsystem (SDL_sysvideo.c)
*/
extern void BE_InitOSKeymap(_THIS);
extern void BE_PumpEvents(_THIS);
/* vi: set ts=4 sw=4 expandtab: */

144
src/video/bwindow/SDL_sysmouse.cc
View file

@ -1,144 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#include <AppKit.h>
#include <GameKit.h>
#include "SDL_BWin.h"
extern "C"
{
#include "SDL_sysmouse_c.h"
/* Convert bits to padded bytes */
#define PADDED_BITS(bits) ((bits+7)/8)
/* The implementation dependent data for the window manager cursor */
struct WMcursor
{
char *bits;
};
/* Can this be done in the BeOS? */
WMcursor *BE_CreateWMCursor(_THIS,
Uint8 * data, Uint8 * mask, int w, int h,
int hot_x, int hot_y)
{
WMcursor *cursor;
int allowed_x;
int allowed_y;
int run, pad, i;
char *cptr;
allowed_x = 16; /* BeOS limitation */
allowed_y = 16; /* BeOS limitation */
if ((w > allowed_x) || (h > allowed_y))
{
SDL_SetError("Only cursors of dimension (%dx%d) are allowed",
allowed_x, allowed_y);
return (NULL);
}
/* Allocate the cursor */
cursor = (WMcursor *) SDL_malloc(sizeof(WMcursor));
if (cursor == NULL) {
SDL_OutOfMemory();
return (NULL);
}
cursor->bits =
(char *) SDL_malloc(4 + 2 * ((allowed_x / 8) * allowed_y));
if (cursor->bits == NULL) {
SDL_free(cursor);
SDL_OutOfMemory();
return (NULL);
}
cursor->bits[0] = allowed_y; /* Size of the cursor */
cursor->bits[1] = 1; /* Bit depth of cursor */
cursor->bits[2] = hot_y;
cursor->bits[3] = hot_x;
cptr = &cursor->bits[4];
/* Pad out to the normal cursor size */
run = PADDED_BITS(w);
pad = PADDED_BITS(allowed_x) - run;
for (i = 0; i < h; ++i) {
SDL_memcpy(cptr, data, run);
SDL_memset(cptr + run, 0, pad);
data += run;
cptr += (run + pad);
}
for (; i < allowed_y; ++i) {
SDL_memset(cptr, 0, run + pad);
cptr += (run + pad);
}
for (i = 0; i < h; ++i) {
/* FIXME: The mask should be OR'd with the data to turn
inverted color pixels black, since inverted color pixels
aren't supported under BeOS.
*/
SDL_memcpy(cptr, mask, run);
SDL_memset(cptr + run, 0, pad);
mask += run;
cptr += (run + pad);
}
for (; i < allowed_y; ++i) {
SDL_memset(cptr, 0, run + pad);
cptr += (run + pad);
}
return (cursor);
}
int BE_ShowWMCursor(_THIS, WMcursor * cursor)
{
if (be_app->Lock()) {
if (cursor == NULL) {
if (SDL_BlankCursor != NULL) {
be_app->SetCursor(SDL_BlankCursor->bits);
}
} else {
be_app->SetCursor(cursor->bits);
}
be_app->Unlock();
}
return (1);
}
void BE_FreeWMCursor(_THIS, WMcursor * cursor)
{
SDL_free(cursor->bits);
SDL_free(cursor);
}
/* Implementation by Christian Bauer <cbauer@student.physik.uni-mainz.de> */
void BE_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
{
BPoint pt(x, y);
SDL_Win->Lock();
SDL_Win->ConvertToScreen(&pt);
SDL_Win->Unlock();
set_mouse_position((int32) pt.x, (int32) pt.y);
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

32
src/video/bwindow/SDL_sysmouse_c.h
View file

@ -1,32 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#include "SDL_lowvideo.h"
/* Functions to be exported */
extern void BE_FreeWMCursor(_THIS, WMcursor * cursor);
extern WMcursor *BE_CreateWMCursor(_THIS,
Uint8 * data, Uint8 * mask, int w, int h,
int hot_x, int hot_y);
extern int BE_ShowWMCursor(_THIS, WMcursor * cursor);
extern void BE_WarpWMCursor(_THIS, Uint16 x, Uint16 y);
/* vi: set ts=4 sw=4 expandtab: */

864
src/video/bwindow/SDL_sysvideo.cc
View file

@ -1,864 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
/* BWindow based framebuffer implementation */
#include <unistd.h>
#include "SDL_BWin.h"
#include "SDL_timer.h"
extern "C"
{
#include "../SDL_sysvideo.h"
#include "../../events/SDL_events_c.h"
#include "SDL_sysevents_c.h"
#include "SDL_sysmouse_c.h"
#include "SDL_syswm_c.h"
#include "SDL_lowvideo.h"
#include "../SDL_yuvfuncs.h"
#include "SDL_sysyuv.h"
#include "../blank_cursor.h"
#define BEOS_HIDDEN_SIZE 32 /* starting hidden window size */
/* Initialization/Query functions */
static int BE_VideoInit(_THIS, SDL_PixelFormat * vformat);
static SDL_Rect **BE_ListModes(_THIS, SDL_PixelFormat * format,
Uint32 flags);
static SDL_Surface *BE_SetVideoMode(_THIS, SDL_Surface * current,
int width, int height, int bpp,
Uint32 flags);
static void BE_UpdateMouse(_THIS);
static int BE_SetColors(_THIS, int firstcolor, int ncolors,
SDL_Color * colors);
static void BE_VideoQuit(_THIS);
/* Hardware surface functions */
static int BE_AllocHWSurface(_THIS, SDL_Surface * surface);
static int BE_LockHWSurface(_THIS, SDL_Surface * surface);
static void BE_UnlockHWSurface(_THIS, SDL_Surface * surface);
static void BE_FreeHWSurface(_THIS, SDL_Surface * surface);
static int BE_ToggleFullScreen(_THIS, int fullscreen);
static SDL_Overlay *BE_CreateYUVOverlay(_THIS, int width, int height,
Uint32 format,
SDL_Surface * display);
/* OpenGL functions */
#if SDL_VIDEO_OPENGL
static int BE_GL_LoadLibrary(_THIS, const char *path);
static void *BE_GL_GetProcAddress(_THIS, const char *proc);
static int BE_GL_GetAttribute(_THIS, SDL_GLattr attrib, int *value);
static int BE_GL_MakeCurrent(_THIS);
static void BE_GL_SwapBuffers(_THIS);
#endif
/* FB driver bootstrap functions */
static int BE_Available(void)
{
return (1);
}
static void BE_DeleteDevice(SDL_VideoDevice * device)
{
SDL_free(device->hidden);
SDL_free(device);
}
static SDL_VideoDevice *BE_CreateDevice(int devindex)
{
SDL_VideoDevice *device;
/* Initialize all variables that we clean on shutdown */
device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
if (device) {
SDL_memset(device, 0, (sizeof *device));
device->hidden = (struct SDL_PrivateVideoData *)
SDL_malloc((sizeof *device->hidden));
}
if ((device == NULL) || (device->hidden == NULL)) {
SDL_OutOfMemory();
if (device) {
SDL_free(device);
}
return (0);
}
SDL_memset(device->hidden, 0, (sizeof *device->hidden));
/* Set the function pointers */
/* Initialization/Query functions */
device->VideoInit = BE_VideoInit;
device->ListModes = BE_ListModes;
device->SetVideoMode = BE_SetVideoMode;
device->ToggleFullScreen = BE_ToggleFullScreen;
device->UpdateMouse = BE_UpdateMouse;
device->CreateYUVOverlay = BE_CreateYUVOverlay;
device->SetColors = BE_SetColors;
device->UpdateRects = NULL;
device->VideoQuit = BE_VideoQuit;
/* Hardware acceleration functions */
device->AllocHWSurface = BE_AllocHWSurface;
device->CheckHWBlit = NULL;
device->FillHWRect = NULL;
device->SetHWColorKey = NULL;
device->SetHWAlpha = NULL;
device->LockHWSurface = BE_LockHWSurface;
device->UnlockHWSurface = BE_UnlockHWSurface;
device->FlipHWSurface = NULL;
device->FreeHWSurface = BE_FreeHWSurface;
#if SDL_VIDEO_OPENGL
/* OpenGL support */
device->GL_LoadLibrary = BE_GL_LoadLibrary;
device->GL_GetProcAddress = BE_GL_GetProcAddress;
device->GL_GetAttribute = BE_GL_GetAttribute;
device->GL_MakeCurrent = BE_GL_MakeCurrent;
device->GL_SwapBuffers = BE_GL_SwapBuffers;
#endif
/* Window manager functions */
device->SetCaption = BE_SetWMCaption;
device->SetIcon = NULL;
device->IconifyWindow = BE_IconifyWindow;
device->GrabInput = NULL;
device->GetWMInfo = BE_GetWMInfo;
/* Cursor manager functions */
device->FreeWMCursor = BE_FreeWMCursor;
device->CreateWMCursor = BE_CreateWMCursor;
device->ShowWMCursor = BE_ShowWMCursor;
device->WarpWMCursor = BE_WarpWMCursor;
device->MoveWMCursor = NULL;
device->CheckMouseMode = NULL;
/* Event manager functions */
device->InitOSKeymap = BE_InitOSKeymap;
device->PumpEvents = BE_PumpEvents;
device->free = BE_DeleteDevice;
/* Set the driver flags */
device->handles_any_size = 1;
return device;
}
VideoBootStrap BWINDOW_bootstrap = {
"bwindow", "BDirectWindow graphics",
BE_Available, BE_CreateDevice
};
static inline int ColorSpaceToBitsPerPixel(uint32 colorspace)
{
int bitsperpixel;
bitsperpixel = 0;
switch (colorspace) {
case B_CMAP8:
bitsperpixel = 8;
break;
case B_RGB15:
case B_RGBA15:
case B_RGB15_BIG:
case B_RGBA15_BIG:
bitsperpixel = 15;
break;
case B_RGB16:
case B_RGB16_BIG:
bitsperpixel = 16;
break;
case B_RGB32:
case B_RGBA32:
case B_RGB32_BIG:
case B_RGBA32_BIG:
bitsperpixel = 32;
break;
default:
break;
}
return (bitsperpixel);
}
/* Function to sort the display_list in bscreen */
static int CompareModes(const void *A, const void *B)
{
const display_mode *a = (display_mode *) A;
const display_mode *b = (display_mode *) B;
if (a->space == b->space) {
return ((b->virtual_width * b->virtual_height) -
(a->virtual_width * a->virtual_height));
} else {
return (ColorSpaceToBitsPerPixel(b->space) -
ColorSpaceToBitsPerPixel(a->space));
}
}
/* Yes, this isn't the fastest it could be, but it works nicely */
static int BE_AddMode(_THIS, int index, unsigned int w, unsigned int h)
{
SDL_Rect *mode;
int i;
int next_mode;
/* Check to see if we already have this mode */
if (SDL_nummodes[index] > 0) {
for (i = SDL_nummodes[index] - 1; i >= 0; --i) {
mode = SDL_modelist[index][i];
if ((mode->w == w) && (mode->h == h)) {
#ifdef BWINDOW_DEBUG
fprintf(stderr,
"We already have mode %dx%d at %d bytes per pixel\n",
w, h, index + 1);
#endif
return (0);
}
}
}
/* Set up the new video mode rectangle */
mode = (SDL_Rect *) SDL_malloc(sizeof *mode);
if (mode == NULL) {
SDL_OutOfMemory();
return (-1);
}
mode->x = 0;
mode->y = 0;
mode->w = w;
mode->h = h;
#ifdef BWINDOW_DEBUG
fprintf(stderr, "Adding mode %dx%d at %d bytes per pixel\n", w, h,
index + 1);
#endif
/* Allocate the new list of modes, and fill in the new mode */
next_mode = SDL_nummodes[index];
SDL_modelist[index] = (SDL_Rect **)
SDL_realloc(SDL_modelist[index],
(1 + next_mode + 1) * sizeof(SDL_Rect *));
if (SDL_modelist[index] == NULL) {
SDL_OutOfMemory();
SDL_nummodes[index] = 0;
SDL_free(mode);
return (-1);
}
SDL_modelist[index][next_mode] = mode;
SDL_modelist[index][next_mode + 1] = NULL;
SDL_nummodes[index]++;
return (0);
}
int BE_VideoInit(_THIS, SDL_PixelFormat * vformat)
{
display_mode *modes;
uint32 i, nmodes;
int bpp;
BRect bounds;
/* Initialize the Be Application for appserver interaction */
if (SDL_InitBeApp() < 0) {
return (-1);
}
/* It is important that this be created after SDL_InitBeApp() */
BScreen bscreen;
/* Save the current display mode */
bscreen.GetMode(&saved_mode);
_this->info.current_w = saved_mode.virtual_width;
_this->info.current_h = saved_mode.virtual_height;
/* Determine the screen depth */
vformat->BitsPerPixel =
ColorSpaceToBitsPerPixel(bscreen.ColorSpace());
if (vformat->BitsPerPixel == 0) {
SDL_SetError("Unknown BScreen colorspace: 0x%x",
bscreen.ColorSpace());
return (-1);
}
/* Get the video modes we can switch to in fullscreen mode */
bscreen.GetModeList(&modes, &nmodes);
SDL_qsort(modes, nmodes, sizeof *modes, CompareModes);
for (i = 0; i < nmodes; ++i) {
bpp = ColorSpaceToBitsPerPixel(modes[i].space);
//if ( bpp != 0 ) { // There are bugs in changing colorspace
if (modes[i].space == saved_mode.space) {
BE_AddMode(_this, ((bpp + 7) / 8) - 1,
modes[i].virtual_width, modes[i].virtual_height);
}
}
/* Create the window and view */
bounds.top = 0;
bounds.left = 0;
bounds.right = BEOS_HIDDEN_SIZE;
bounds.bottom = BEOS_HIDDEN_SIZE;
SDL_Win = new SDL_BWin(bounds);
#if SDL_VIDEO_OPENGL
/* testgl application doesn't load library, just tries to load symbols */
/* is it correct? if so we have to load library here */
BE_GL_LoadLibrary(_this, NULL);
#endif
/* Create the clear cursor */
SDL_BlankCursor = BE_CreateWMCursor(_this, blank_cdata, blank_cmask,
BLANK_CWIDTH, BLANK_CHEIGHT,
BLANK_CHOTX, BLANK_CHOTY);
/* Fill in some window manager capabilities */
_this->info.wm_available = 1;
/* We're done! */
return (0);
}
/* We support any dimension at our bit-depth */
SDL_Rect **BE_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
{
SDL_Rect **modes;
modes = ((SDL_Rect **) 0);
if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
modes = SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1];
} else {
if (format->BitsPerPixel == _this->screen->format->BitsPerPixel) {
modes = ((SDL_Rect **) - 1);
}
}
return (modes);
}
/* Various screen update functions available */
static void BE_NormalUpdate(_THIS, int numrects, SDL_Rect * rects);
/* Find the closest display mode for fullscreen */
static bool BE_FindClosestFSMode(_THIS, int width, int height, int bpp,
display_mode * mode)
{
BScreen bscreen;
uint32 i, nmodes;
SDL_Rect **modes;
display_mode *dmodes;
display_mode current;
float current_refresh;
bscreen.GetMode(&current);
current_refresh = (1000 * current.timing.pixel_clock) /
(current.timing.h_total * current.timing.v_total);
modes = SDL_modelist[((bpp + 7) / 8) - 1];
bool exactmatch = false;
for (uint32 x = 0; modes[x]; x++) {
if (modes[x]->w == width && modes[x]->h == height) {
exactmatch = true;
i = x;
break;
}
}
if (!exactmatch) {
for (i = 0; modes[i] && (modes[i]->w > width) &&
(modes[i]->h > height); ++i) {
/* still looking */
}
if (!modes[i] || (modes[i]->w < width) || (modes[i]->h < height)) {
/* We went too far */
--i;
}
}
width = modes[i]->w;
height = modes[i]->h;
bscreen.GetModeList(&dmodes, &nmodes);
for (i = 0; i < nmodes; ++i) {
if ((bpp == ColorSpaceToBitsPerPixel(dmodes[i].space)) &&
(width == dmodes[i].virtual_width) &&
(height == dmodes[i].virtual_height)) {
break;
}
}
if (i != nmodes) {
*mode = dmodes[i];
if ((mode->virtual_width <= current.virtual_width) &&
(mode->virtual_height <= current.virtual_height)) {
float new_refresh = (1000 * mode->timing.pixel_clock) /
(mode->timing.h_total * mode->timing.v_total);
if (new_refresh < current_refresh) {
mode->timing.pixel_clock =
(uint32) ((mode->timing.h_total *
mode->timing.v_total) *
current_refresh / 1000);
}
}
return true;
} else {
return false;
}
}
static int BE_SetFullScreen(_THIS, SDL_Surface * screen, int fullscreen)
{
int was_fullscreen;
bool needs_unlock;
BScreen bscreen;
BRect bounds;
display_mode mode;
int width, height, bpp;
/* Set the fullscreen mode */
was_fullscreen = SDL_Win->IsFullScreen();
SDL_Win->SetFullScreen(fullscreen);
fullscreen = SDL_Win->IsFullScreen();
width = screen->w;
height = screen->h;
/* Set the appropriate video mode */
if (fullscreen) {
bpp = screen->format->BitsPerPixel;
bscreen.GetMode(&mode);
if ((bpp != ColorSpaceToBitsPerPixel(mode.space)) ||
(width != mode.virtual_width) ||
(height != mode.virtual_height)) {
if (BE_FindClosestFSMode(_this, width, height, bpp, &mode)) {
bscreen.SetMode(&mode);
/* This simply stops the next resize event from being
* sent to the SDL handler.
*/
SDL_Win->InhibitResize();
} else {
fullscreen = 0;
SDL_Win->SetFullScreen(fullscreen);
}
}
}
if (was_fullscreen && !fullscreen) {
bscreen.SetMode(&saved_mode);
}
if (SDL_Win->Lock()) {
int xoff, yoff;
if (SDL_Win->Shown()) {
needs_unlock = 1;
SDL_Win->Hide();
} else {
needs_unlock = 0;
}
/* This resizes the window and view area, but inhibits resizing
* of the BBitmap due to the InhibitResize call above. Thus the
* bitmap (pixel data) never changes.
*/
SDL_Win->ResizeTo(width, height);
bounds = bscreen.Frame();
/* Calculate offsets - used either to center window
* (windowed mode) or to set drawing offsets (fullscreen mode)
*/
xoff = (bounds.IntegerWidth() - width) / 2;
yoff = (bounds.IntegerHeight() - height) / 2;
if (fullscreen) {
/* Set offset for drawing */
SDL_Win->SetXYOffset(xoff, yoff);
} else {
/* Center window and reset the drawing offset */
SDL_Win->SetXYOffset(0, 0);
}
if (!needs_unlock || was_fullscreen) {
/* Center the window the first time */
SDL_Win->MoveTo(xoff > 0 ? (float) xoff : 0.0f,
yoff > 0 ? (float) yoff : 0.0f);
}
SDL_Win->Show();
/* Unlock the window manually after the first Show() */
if (needs_unlock) {
SDL_Win->Unlock();
}
}
/* Set the fullscreen flag in the screen surface */
if (fullscreen) {
screen->flags |= SDL_FULLSCREEN;
} else {
screen->flags &= ~SDL_FULLSCREEN;
}
return (1);
}
static int BE_ToggleFullScreen(_THIS, int fullscreen)
{
return BE_SetFullScreen(_this, _this->screen, fullscreen);
}
/* FIXME: check return values and cleanup here */
SDL_Surface *BE_SetVideoMode(_THIS, SDL_Surface * current,
int width, int height, int bpp, Uint32 flags)
{
BScreen bscreen;
BBitmap *bbitmap;
BRect bounds;
Uint32 gl_flags = 0;
/* Only RGB works on r5 currently */
gl_flags = BGL_RGB;
if (_this->gl_config.double_buffer)
gl_flags |= BGL_DOUBLE;
else
gl_flags |= BGL_SINGLE;
if (_this->gl_config.alpha_size > 0 || bpp == 32)
gl_flags |= BGL_ALPHA;
if (_this->gl_config.depth_size > 0)
gl_flags |= BGL_DEPTH;
if (_this->gl_config.stencil_size > 0)
gl_flags |= BGL_STENCIL;
if (_this->gl_config.accum_red_size > 0
|| _this->gl_config.accum_green_size > 0
|| _this->gl_config.accum_blue_size > 0
|| _this->gl_config.accum_alpha_size > 0)
gl_flags |= BGL_ACCUM;
/* Create the view for this window, using found flags */
if (SDL_Win->CreateView(flags, gl_flags) < 0) {
return (NULL);
}
current->flags = 0; /* Clear flags */
current->w = width;
current->h = height;
SDL_Win->SetType(B_TITLED_WINDOW);
if (flags & SDL_NOFRAME) {
current->flags |= SDL_NOFRAME;
SDL_Win->SetLook(B_NO_BORDER_WINDOW_LOOK);
} else {
/* FIXME: What was SDL_INTERNALOPENGL? This used it before, but it
isn't defined anywhere. */
if ((flags & SDL_RESIZABLE) && !(flags & SDL_OPENGL
/*SDL_INTERNALOPENGL*/)) {
current->flags |= SDL_RESIZABLE;
/* We don't want opaque resizing (TM). :-) */
SDL_Win->SetFlags(B_OUTLINE_RESIZE);
} else {
SDL_Win->SetFlags(B_NOT_RESIZABLE | B_NOT_ZOOMABLE);
}
}
if (flags & SDL_OPENGL /*SDL_INTERNALOPENGL*/) {
current->flags |= SDL_OPENGL /*SDL_INTERNALOPENGL*/;
current->pitch = 0;
current->pixels = NULL;
_this->UpdateRects = NULL;
} else {
/* Create the BBitmap framebuffer */
bounds.top = 0;
bounds.left = 0;
bounds.right = width - 1;
bounds.bottom = height - 1;
bbitmap = new BBitmap(bounds, bscreen.ColorSpace());
if (!bbitmap->IsValid()) {
SDL_SetError("Couldn't create screen bitmap");
delete bbitmap;
return (NULL);
}
current->pitch = bbitmap->BytesPerRow();
current->pixels = (void *) bbitmap->Bits();
SDL_Win->SetBitmap(bbitmap);
_this->UpdateRects = BE_NormalUpdate;
}
/* Set the correct fullscreen mode */
BE_SetFullScreen(_this, current, flags & SDL_FULLSCREEN ? 1 : 0);
/* We're done */
return (current);
}
/* Update the current mouse state and position */
void BE_UpdateMouse(_THIS)
{
BPoint point;
uint32 buttons;
if (SDL_Win->Lock()) {
/* Get new input state, if still active */
if (SDL_Win->IsActive()) {
(SDL_Win->View())->GetMouse(&point, &buttons, true);
} else {
point.x = -1;
point.y = -1;
}
SDL_Win->Unlock();
if ((point.x >= 0) && (point.x < SDL_VideoSurface->w) &&
(point.y >= 0) && (point.y < SDL_VideoSurface->h)) {
SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
SDL_PrivateMouseMotion(0, 0,
(Sint16) point.x, (Sint16) point.y);
} else {
SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
}
}
}
/* We don't actually allow hardware surfaces other than the main one */
static int BE_AllocHWSurface(_THIS, SDL_Surface * surface)
{
return (-1);
}
static void BE_FreeHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
static int BE_LockHWSurface(_THIS, SDL_Surface * surface)
{
return (0);
}
static void BE_UnlockHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
static void BE_NormalUpdate(_THIS, int numrects, SDL_Rect * rects)
{
if (SDL_Win->BeginDraw()) {
int i;
for (i = 0; i < numrects; ++i) {
BRect rect;
rect.top = rects[i].y;
rect.left = rects[i].x;
rect.bottom = rect.top + rects[i].h - 1;
rect.right = rect.left + rects[i].w - 1;
SDL_Win->DrawAsync(rect);
}
SDL_Win->EndDraw();
}
}
#if SDL_VIDEO_OPENGL
/* Passing a NULL path means load pointers from the application */
int BE_GL_LoadLibrary(_THIS, const char *path)
{
if (path == NULL) {
if (_this->gl_config.dll_handle == NULL) {
image_info info;
int32 cookie = 0;
while (get_next_image_info(0, &cookie, &info) == B_OK) {
void *location = NULL;
if (get_image_symbol
((image_id) cookie, "glBegin",
B_SYMBOL_TYPE_ANY, &location) == B_OK) {
_this->gl_config.dll_handle = (void *) cookie;
_this->gl_config.driver_loaded = 1;
SDL_strlcpy(_this->gl_config.driver_path,
"libGL.so",
SDL_arraysize(_this->
gl_config.driver_path));
}
}
}
} else {
/*
FIXME None of BeOS libGL.so implementations have exported functions
to load BGLView, which should be reloaded from new lib.
So for now just "load" linked libGL.so :(
*/
if (_this->gl_config.dll_handle == NULL) {
return BE_GL_LoadLibrary(_this, NULL);
}
/* Unload old first */
/*if (_this->gl_config.dll_handle != NULL) { */
/* Do not try to unload application itself (if LoadLibrary was called before with NULL ;) */
/* image_info info;
if (get_image_info((image_id)_this->gl_config.dll_handle, &info) == B_OK) {
if (info.type != B_APP_IMAGE) {
unload_add_on((image_id)_this->gl_config.dll_handle);
}
}
}
if ((_this->gl_config.dll_handle = (void*)load_add_on(path)) != (void*)B_ERROR) {
_this->gl_config.driver_loaded = 1;
SDL_strlcpy(_this->gl_config.driver_path, path, SDL_arraysize(_this->gl_config.driver_path));
} */
}
if (_this->gl_config.dll_handle != NULL) {
return 0;
} else {
_this->gl_config.dll_handle = NULL;
_this->gl_config.driver_loaded = 0;
*_this->gl_config.driver_path = '\0';
return -1;
}
}
void *BE_GL_GetProcAddress(_THIS, const char *proc)
{
if (_this->gl_config.dll_handle != NULL) {
void *location = NULL;
status_t err;
if ((err =
get_image_symbol((image_id) _this->gl_config.dll_handle,
proc, B_SYMBOL_TYPE_ANY,
&location)) == B_OK) {
return location;
} else {
SDL_SetError("Couldn't find OpenGL symbol");
return NULL;
}
} else {
SDL_SetError("OpenGL library not loaded");
return NULL;
}
}
int BE_GL_GetAttribute(_THIS, SDL_GLattr attrib, int *value)
{
/*
FIXME? Right now BE_GL_GetAttribute shouldn't be called between glBegin() and glEnd() - it doesn't use "cached" values
*/
switch (attrib) {
case SDL_GL_RED_SIZE:
glGetIntegerv(GL_RED_BITS, (GLint *) value);
break;
case SDL_GL_GREEN_SIZE:
glGetIntegerv(GL_GREEN_BITS, (GLint *) value);
break;
case SDL_GL_BLUE_SIZE:
glGetIntegerv(GL_BLUE_BITS, (GLint *) value);
break;
case SDL_GL_ALPHA_SIZE:
glGetIntegerv(GL_ALPHA_BITS, (GLint *) value);
break;
case SDL_GL_DOUBLEBUFFER:
glGetBooleanv(GL_DOUBLEBUFFER, (GLboolean *) value);
break;
case SDL_GL_BUFFER_SIZE:
int v;
glGetIntegerv(GL_RED_BITS, (GLint *) & v);
*value = v;
glGetIntegerv(GL_GREEN_BITS, (GLint *) & v);
*value += v;
glGetIntegerv(GL_BLUE_BITS, (GLint *) & v);
*value += v;
glGetIntegerv(GL_ALPHA_BITS, (GLint *) & v);
*value += v;
break;
case SDL_GL_DEPTH_SIZE:
glGetIntegerv(GL_DEPTH_BITS, (GLint *) value); /* Mesa creates 16 only? r5 always 32 */
break;
case SDL_GL_STENCIL_SIZE:
glGetIntegerv(GL_STENCIL_BITS, (GLint *) value);
break;
case SDL_GL_ACCUM_RED_SIZE:
glGetIntegerv(GL_ACCUM_RED_BITS, (GLint *) value);
break;
case SDL_GL_ACCUM_GREEN_SIZE:
glGetIntegerv(GL_ACCUM_GREEN_BITS, (GLint *) value);
break;
case SDL_GL_ACCUM_BLUE_SIZE:
glGetIntegerv(GL_ACCUM_BLUE_BITS, (GLint *) value);
break;
case SDL_GL_ACCUM_ALPHA_SIZE:
glGetIntegerv(GL_ACCUM_ALPHA_BITS, (GLint *) value);
break;
case SDL_GL_STEREO:
case SDL_GL_MULTISAMPLEBUFFERS:
case SDL_GL_MULTISAMPLESAMPLES:
default:
*value = 0;
return (-1);
}
return 0;
}
int BE_GL_MakeCurrent(_THIS)
{
/* FIXME: should we glview->unlock and then glview->lock()? */
return 0;
}
void BE_GL_SwapBuffers(_THIS)
{
SDL_Win->SwapBuffers();
}
#endif
/* Is the system palette settable? */
int BE_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
{
int i;
SDL_Palette *palette;
const color_map *cmap = BScreen().ColorMap();
/* Get the screen colormap */
palette = _this->screen->format->palette;
for (i = 0; i < 256; ++i) {
palette->colors[i].r = cmap->color_list[i].red;
palette->colors[i].g = cmap->color_list[i].green;
palette->colors[i].b = cmap->color_list[i].blue;
}
return (0);
}
void BE_VideoQuit(_THIS)
{
int i, j;
SDL_Win->Quit();
SDL_Win = NULL;
if (SDL_BlankCursor != NULL) {
BE_FreeWMCursor(_this, SDL_BlankCursor);
SDL_BlankCursor = NULL;
}
for (i = 0; i < NUM_MODELISTS; ++i) {
if (SDL_modelist[i]) {
for (j = 0; SDL_modelist[i][j]; ++j) {
SDL_free(SDL_modelist[i][j]);
}
SDL_free(SDL_modelist[i]);
SDL_modelist[i] = NULL;
}
}
/* Restore the original video mode */
if (_this->screen) {
if ((_this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
BScreen bscreen;
bscreen.SetMode(&saved_mode);
}
_this->screen->pixels = NULL;
}
#if SDL_VIDEO_OPENGL
if (_this->gl_config.dll_handle != NULL)
unload_add_on((image_id) _this->gl_config.dll_handle);
#endif
SDL_QuitBeApp();
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

54
src/video/bwindow/SDL_syswm.cc
View file

@ -1,54 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#include "SDL_BWin.h"
extern "C"
{
#include "SDL_syswm_c.h"
#include "SDL_error.h"
void BE_SetWMCaption(_THIS, const char *title, const char *icon)
{
SDL_Win->SetTitle(title);
}
int BE_IconifyWindow(_THIS)
{
SDL_Win->Minimize(true);
}
int BE_GetWMInfo(_THIS, SDL_SysWMinfo * info)
{
if (info->version.major <= SDL_MAJOR_VERSION) {
return 1;
} else {
SDL_SetError("Application not compiled with SDL %d.%d\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
return -1;
}
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

31
src/video/bwindow/SDL_syswm_c.h
View file

@ -1,31 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#include "SDL_syswm.h"
#include "SDL_lowvideo.h"
/* Functions to be exported */
extern void BE_SetWMCaption(_THIS, const char *title, const char *icon);
extern int BE_IconifyWindow(_THIS);
extern int BE_GetWMInfo(_THIS, SDL_SysWMinfo * info);
/* vi: set ts=4 sw=4 expandtab: */

321
src/video/bwindow/SDL_sysyuv.cc
View file

@ -1,321 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
/* This is the BeOS version of SDL YUV video overlays */
#include "SDL_video.h"
#include "SDL_sysyuv.h"
#include "../SDL_yuvfuncs.h"
extern "C"
{
/* The functions used to manipulate software video overlays */
static struct private_yuvhwfuncs be_yuvfuncs = {
BE_LockYUVOverlay,
BE_UnlockYUVOverlay,
BE_DisplayYUVOverlay,
BE_FreeYUVOverlay
};
BBitmap *BE_GetOverlayBitmap(BRect bounds, color_space cs)
{
BBitmap *bbitmap;
bbitmap = new BBitmap(bounds, B_BITMAP_WILL_OVERLAY, cs);
if (!bbitmap || bbitmap->InitCheck() != B_OK) {
delete bbitmap;
return 0;
}
overlay_restrictions r;
bbitmap->GetOverlayRestrictions(&r);
uint32 width = bounds.IntegerWidth() + 1;
uint32 height = bounds.IntegerHeight() + 1;
uint32 width_padding = 0;
uint32 height_padding = 0;
if ((r.source.horizontal_alignment != 0) ||
(r.source.vertical_alignment != 0)) {
delete bbitmap;
return 0;
}
if (r.source.width_alignment != 0) {
uint32 aligned_width = r.source.width_alignment + 1;
if (width % aligned_width > 0) {
width_padding = aligned_width - width % aligned_width;
}
}
if (r.source.height_alignment != 0) {
uint32 aligned_height = r.source.height_alignment + 1;
if (height % aligned_height > 0) {
fprintf(stderr, "GetOverlayBitmap failed height alignment\n");
fprintf(stderr, "- height = %lu, aligned_height = %lu\n",
height, aligned_height);
delete bbitmap;
return 0;
}
}
if ((r.source.min_width > width) ||
(r.source.min_height > height) ||
(r.source.max_width < width) || (r.source.max_height < height)) {
fprintf(stderr, "GetOverlayBitmap failed bounds tests\n");
delete bbitmap;
return 0;
}
if ((width_padding != 0) || (height_padding != 0)) {
delete bbitmap;
bounds.Set(bounds.left, bounds.top,
bounds.right + width_padding,
bounds.bottom + height_padding);
bbitmap = new BBitmap(bounds, B_BITMAP_WILL_OVERLAY, cs);
if (!bbitmap || bbitmap->InitCheck() != B_OK) {
fprintf(stderr, "GetOverlayBitmap failed late\n");
delete bbitmap;
return 0;
}
}
return bbitmap;
}
// See <GraphicsDefs.h> [btw: Cb=U, Cr=V]
// See also http://www.fourcc.org/indexyuv.htm
enum color_space convert_color_space(Uint32 format)
{
switch (format) {
case SDL_YV12_OVERLAY:
return B_YUV9;
case SDL_IYUV_OVERLAY:
return B_YUV12;
case SDL_YUY2_OVERLAY:
return B_YCbCr422;
case SDL_UYVY_OVERLAY:
return B_YUV422;
case SDL_YVYU_OVERLAY: // not supported on beos?
return B_NO_COLOR_SPACE;
default:
return B_NO_COLOR_SPACE;
}
}
// See SDL_video.h
int count_planes(Uint32 format)
{
switch (format) {
case SDL_YV12_OVERLAY:
case SDL_IYUV_OVERLAY:
return 3;
case SDL_YUY2_OVERLAY:
case SDL_UYVY_OVERLAY:
case SDL_YVYU_OVERLAY:
return 1;
default:
return 0;
}
}
SDL_Overlay *BE_CreateYUVOverlay(_THIS, int width, int height,
Uint32 format, SDL_Surface * display)
{
SDL_Overlay *overlay;
struct private_yuvhwdata *hwdata;
BBitmap *bbitmap;
int planes;
BRect bounds;
color_space cs;
/* find the appropriate BeOS colorspace descriptor */
cs = convert_color_space(format);
if (cs == B_NO_COLOR_SPACE) {
return NULL;
}
/* count planes */
planes = count_planes(format);
if (planes == 0) {
return NULL;
}
/* TODO: figure out planar modes, if anyone cares */
if (planes == 3) {
return NULL;
}
/* Create the overlay structure */
overlay = (SDL_Overlay *) SDL_calloc(1, sizeof(SDL_Overlay));
if (overlay == NULL) {
SDL_OutOfMemory();
return NULL;
}
/* Fill in the basic members */
overlay->format = format;
overlay->w = width;
overlay->h = height;
overlay->hwdata = NULL;
/* Set up the YUV surface function structure */
overlay->hwfuncs = &be_yuvfuncs;
/* Create the pixel data and lookup tables */
hwdata =
(struct private_yuvhwdata *) SDL_calloc(1,
sizeof(struct
private_yuvhwdata));
if (hwdata == NULL) {
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
return NULL;
}
overlay->hwdata = hwdata;
overlay->hwdata->display = display;
overlay->hwdata->bview = NULL;
overlay->hwdata->bbitmap = NULL;
overlay->hwdata->locked = 0;
/* Create the BBitmap framebuffer */
bounds.top = 0;
bounds.left = 0;
bounds.right = width - 1;
bounds.bottom = height - 1;
BView *bview =
new BView(bounds, "overlay", B_FOLLOW_NONE, B_WILL_DRAW);
if (!bview) {
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
return NULL;
}
overlay->hwdata->bview = bview;
overlay->hwdata->first_display = true;
bview->Hide();
bbitmap = BE_GetOverlayBitmap(bounds, cs);
if (!bbitmap) {
overlay->hwdata->bbitmap = NULL;
SDL_FreeYUVOverlay(overlay);
return NULL;
}
overlay->hwdata->bbitmap = bbitmap;
overlay->planes = planes;
overlay->pitches =
(Uint16 *) SDL_calloc(overlay->planes, sizeof(Uint16));
overlay->pixels =
(Uint8 **) SDL_calloc(overlay->planes, sizeof(Uint8 *));
if (!overlay->pitches || !overlay->pixels) {
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
return (NULL);
}
overlay->pitches[0] = bbitmap->BytesPerRow();
overlay->pixels[0] = (Uint8 *) bbitmap->Bits();
overlay->hw_overlay = 1;
if (SDL_Win->LockWithTimeout(1000000) != B_OK) {
SDL_FreeYUVOverlay(overlay);
return (NULL);
}
BView *view = SDL_Win->View();
view->AddChild(bview);
rgb_color key;
bview->SetViewOverlay(bbitmap, bounds, bview->Bounds(), &key,
B_FOLLOW_ALL,
B_OVERLAY_FILTER_HORIZONTAL |
B_OVERLAY_FILTER_VERTICAL);
bview->SetViewColor(key);
bview->Flush();
SDL_Win->Unlock();
current_overlay = overlay;
return overlay;
}
int BE_LockYUVOverlay(_THIS, SDL_Overlay * overlay)
{
if (overlay == NULL) {
return 0;
}
overlay->hwdata->locked = 1;
return 0;
}
void BE_UnlockYUVOverlay(_THIS, SDL_Overlay * overlay)
{
if (overlay == NULL) {
return;
}
overlay->hwdata->locked = 0;
}
int BE_DisplayYUVOverlay(_THIS, SDL_Overlay * overlay, SDL_Rect * src,
SDL_Rect * dst)
{
if ((overlay == NULL) || (overlay->hwdata == NULL)
|| (overlay->hwdata->bview == NULL) || (SDL_Win->View() == NULL)) {
return -1;
}
if (SDL_Win->LockWithTimeout(50000) != B_OK) {
return 0;
}
BView *bview = overlay->hwdata->bview;
if (SDL_Win->IsFullScreen()) {
int left, top;
SDL_Win->GetXYOffset(left, top);
bview->MoveTo(left + dst->x, top + dst->y);
} else {
bview->MoveTo(dst->x, dst->y);
}
bview->ResizeTo(dst->w, dst->h);
bview->Flush();
if (overlay->hwdata->first_display) {
bview->Show();
overlay->hwdata->first_display = false;
}
SDL_Win->Unlock();
return 0;
}
void BE_FreeYUVOverlay(_THIS, SDL_Overlay * overlay)
{
if (overlay == NULL) {
return;
}
if (overlay->hwdata == NULL) {
return;
}
current_overlay = NULL;
delete overlay->hwdata->bbitmap;
SDL_free(overlay->hwdata);
}
}; // extern "C"
/* vi: set ts=4 sw=4 expandtab: */

77
src/video/bwindow/SDL_sysyuv.h
View file

@ -1,77 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#ifndef __SDL_SYS_YUV_H__
#define __SDL_SYS_YUV_H__
/* This is the BeOS implementation of YUV video overlays */
#include "SDL_video.h"
#include "SDL_lowvideo.h"
extern "C"
{
struct private_yuvhwdata
{
/* FRAMEDATA* CurrentFrameData;
FRAMEDATA* FrameData0;
FRAMEDATA* FrameData1;
PgScalerProps_t props;
PgScalerCaps_t caps;
PgVideoChannel_t* channel;
PhArea_t CurrentViewPort;
PhPoint_t CurrentWindowPos;
long format;
int scaler_on;
int current;
long YStride;
long VStride;
long UStride;
int ischromakey;
long chromakey;
int forcedredraw;
unsigned long State;
long flags;
*/
SDL_Surface *display;
BView *bview;
bool first_display;
BBitmap *bbitmap;
int locked;
};
extern BBitmap *BE_GetOverlayBitmap(BRect bounds, color_space cs);
extern SDL_Overlay *BE_CreateYUVOverlay(_THIS, int width, int height,
Uint32 format,
SDL_Surface * display);
extern int BE_LockYUVOverlay(_THIS, SDL_Overlay * overlay);
extern void BE_UnlockYUVOverlay(_THIS, SDL_Overlay * overlay);
extern int BE_DisplayYUVOverlay(_THIS, SDL_Overlay * overlay,
SDL_Rect * src, SDL_Rect * dst);
extern void BE_FreeYUVOverlay(_THIS, SDL_Overlay * overlay);
};
#endif /* __SDL_PH_YUV_H__ */
/* vi: set ts=4 sw=4 expandtab: */