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

Merged Nathan Heisey's Haiku work into the main SDL 1.3 branch.

Browse source 
This was a Google Summer of Code 2011 project, sponsored by the Haiku project.

We thank Nathan and the other Haiku developers for their support!
This commit is contained in:
Ryan C. Gordon 2011-09-15 23:51:07 -04:00
commit 99f00f09bd
29 changed files with 2642 additions and 2141 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/SDL_compat.c
View file

@ -849,7 +849,7 @@ SDL_WM_ToggleFullScreen(SDL_Surface * surface)
/* Copy the old bits out */
length = SDL_PublicSurface->w * SDL_PublicSurface->format->BytesPerPixel;
pixels = SDL_malloc(SDL_PublicSurface->h * length);
if (pixels) {
if (pixels && SDL_PublicSurface->pixels) {
src = (Uint8*)SDL_PublicSurface->pixels;
dst = (Uint8*)pixels;
for (row = 0; row < SDL_PublicSurface->h; ++row) {

377
src/main/beos/SDL_BApp.h Normal file
View file

@ -0,0 +1,377 @@
/*
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.
*/
#ifndef SDL_BAPP_H
#define SDL_BAPP_H
#include <InterfaceKit.h>
#include <OpenGLKit.h>
#include "../../video/bwindow/SDL_bkeyboard.h"
#ifdef __cplusplus
extern "C" {
#endif
#include "SDL_config.h"
#include "SDL_video.h"
/* Local includes */
#include "../../events/SDL_events_c.h"
#include "../../video/bwindow/SDL_bkeyboard.h"
#include "../../video/bwindow/SDL_bframebuffer.h"
#ifdef __cplusplus
}
#endif
#include <vector>
/* Forward declarations */
class SDL_BWin;
/* Message constants */
enum ToSDL {
/* Intercepted by BWindow on its way to BView */
BAPP_MOUSE_MOVED,
BAPP_MOUSE_BUTTON,
BAPP_MOUSE_WHEEL,
BAPP_KEY,
BAPP_REPAINT, /* from _UPDATE_ */
/* From BWindow */
BAPP_MAXIMIZE, /* from B_ZOOM */
BAPP_MINIMIZE,
BAPP_RESTORE, /* TODO: IMPLEMENT! */
BAPP_SHOW,
BAPP_HIDE,
BAPP_MOUSE_FOCUS, /* caused by MOUSE_MOVE */
BAPP_KEYBOARD_FOCUS, /* from WINDOW_ACTIVATED */
BAPP_WINDOW_CLOSE_REQUESTED,
BAPP_WINDOW_MOVED,
BAPP_WINDOW_RESIZED,
BAPP_SCREEN_CHANGED
};
/* Create a descendant of BApplication */
class SDL_BApp : public BApplication {
public:
SDL_BApp(const char* signature) :
BApplication(signature) {
_current_context = NULL;
}
virtual ~SDL_BApp() {
}
/* Event-handling functions */
virtual void MessageReceived(BMessage* message) {
/* Sort out SDL-related messages */
switch ( message->what ) {
case BAPP_MOUSE_MOVED:
_HandleMouseMove(message);
break;
case BAPP_MOUSE_BUTTON:
_HandleMouseButton(message);
break;
case BAPP_MOUSE_WHEEL:
_HandleMouseWheel(message);
break;
case BAPP_KEY:
_HandleKey(message);
break;
case BAPP_REPAINT:
_HandleBasicWindowEvent(message, SDL_WINDOWEVENT_EXPOSED);
break;
case BAPP_MAXIMIZE:
_HandleBasicWindowEvent(message, SDL_WINDOWEVENT_MAXIMIZED);
break;
case BAPP_MINIMIZE:
_HandleBasicWindowEvent(message, SDL_WINDOWEVENT_MINIMIZED);
break;
case BAPP_SHOW:
_HandleBasicWindowEvent(message, SDL_WINDOWEVENT_SHOWN);
break;
case BAPP_HIDE:
_HandleBasicWindowEvent(message, SDL_WINDOWEVENT_HIDDEN);
break;
case BAPP_MOUSE_FOCUS:
_HandleMouseFocus(message);
break;
case BAPP_KEYBOARD_FOCUS:
_HandleKeyboardFocus(message);
break;
case BAPP_WINDOW_CLOSE_REQUESTED:
_HandleBasicWindowEvent(message, SDL_WINDOWEVENT_CLOSE);
break;
case BAPP_WINDOW_MOVED:
_HandleWindowMoved(message);
break;
case BAPP_WINDOW_RESIZED:
_HandleWindowResized(message);
break;
case BAPP_SCREEN_CHANGED:
/* TODO: Handle screen resize or workspace change */
break;
default:
BApplication::MessageReceived(message);
break;
}
}
/* Window creation/destruction methods */
int32 GetID(SDL_Window *win) {
int32 i;
for(i = 0; i < _GetNumWindowSlots(); ++i) {
if( GetSDLWindow(i) == NULL ) {
_SetSDLWindow(win, i);
return i;
}
}
/* Expand the vector if all slots are full */
if( i == _GetNumWindowSlots() ) {
_PushBackWindow(win);
return i;
}
}
/* FIXME: Bad coding practice, but I can't include SDL_BWin.h here. Is
there another way to do this? */
void ClearID(SDL_BWin *bwin); /* Defined in SDL_BeApp.cc */
SDL_Window *GetSDLWindow(int32 winID) {
return _window_map[winID];
}
void SetCurrentContext(BGLView *newContext) {
if(_current_context)
_current_context->UnlockGL();
_current_context = newContext;
_current_context->LockGL();
}
private:
/* Event management */
void _HandleBasicWindowEvent(BMessage *msg, int32 sdlEventType) {
SDL_Window *win;
int32 winID;
if(
!_GetWinID(msg, &winID)
) {
return;
}
win = GetSDLWindow(winID);
SDL_SendWindowEvent(win, sdlEventType, 0, 0);
}
void _HandleMouseMove(BMessage *msg) {
SDL_Window *win;
int32 winID;
int32 x = 0, y = 0;
if(
!_GetWinID(msg, &winID) ||
msg->FindInt32("x", &x) != B_OK || /* x movement */
msg->FindInt32("y", &y) != B_OK /* y movement */
) {
return;
}
win = GetSDLWindow(winID);
SDL_SendMouseMotion(win, 0, x, y);
/* Tell the application that the mouse passed over, redraw needed */
BE_UpdateWindowFramebuffer(NULL,win,NULL,-1);
}
void _HandleMouseButton(BMessage *msg) {
SDL_Window *win;
int32 winID;
int32 button, state; /* left/middle/right, pressed/released */
if(
!_GetWinID(msg, &winID) ||
msg->FindInt32("button-id", &button) != B_OK ||
msg->FindInt32("button-state", &state) != B_OK
) {
return;
}
win = GetSDLWindow(winID);
SDL_SendMouseButton(win, state, button);
}
void _HandleMouseWheel(BMessage *msg) {
SDL_Window *win;
int32 winID;
int32 xTicks, yTicks;
if(
!_GetWinID(msg, &winID) ||
msg->FindInt32("xticks", &xTicks) != B_OK ||
msg->FindInt32("yticks", &yTicks) != B_OK
) {
return;
}
win = GetSDLWindow(winID);
SDL_SendMouseWheel(win, xTicks, yTicks);
}
void _HandleKey(BMessage *msg) {
int32 scancode, state; /* scancode, pressed/released */
if(
msg->FindInt32("key-state", &state) != B_OK ||
msg->FindInt32("key-scancode", &scancode) != B_OK
) {
return;
}
/* Make sure this isn't a repeated event (key pressed and held) */
if(state == SDL_PRESSED && BE_GetKeyState(scancode) == SDL_PRESSED) {
return;
}
BE_SetKeyState(scancode, state);
SDL_SendKeyboardKey(state, BE_GetScancodeFromBeKey(scancode));
}
void _HandleMouseFocus(BMessage *msg) {
SDL_Window *win;
int32 winID;
bool bSetFocus; /* If false, lose focus */
if(
!_GetWinID(msg, &winID) ||
msg->FindBool("focusGained", &bSetFocus) != B_OK
) {
return;
}
win = GetSDLWindow(winID);
if(bSetFocus) {
SDL_SetMouseFocus(win);
} else if(SDL_GetMouseFocus() == win) {
/* Only lose all focus if this window was the current focus */
SDL_SetMouseFocus(NULL);
}
}
void _HandleKeyboardFocus(BMessage *msg) {
SDL_Window *win;
int32 winID;
bool bSetFocus; /* If false, lose focus */
if(
!_GetWinID(msg, &winID) ||
msg->FindBool("focusGained", &bSetFocus) != B_OK
) {
return;
}
win = GetSDLWindow(winID);
if(bSetFocus) {
SDL_SetKeyboardFocus(win);
} else if(SDL_GetKeyboardFocus() == win) {
/* Only lose all focus if this window was the current focus */
SDL_SetKeyboardFocus(NULL);
}
}
void _HandleWindowMoved(BMessage *msg) {
SDL_Window *win;
int32 winID;
int32 xPos, yPos;
/* Get the window id and new x/y position of the window */
if(
!_GetWinID(msg, &winID) ||
msg->FindInt32("window-x", &xPos) != B_OK ||
msg->FindInt32("window-y", &yPos) != B_OK
) {
return;
}
win = GetSDLWindow(winID);
SDL_SendWindowEvent(win, SDL_WINDOWEVENT_MOVED, xPos, yPos);
}
void _HandleWindowResized(BMessage *msg) {
SDL_Window *win;
int32 winID;
int32 w, h;
/* Get the window id ]and new x/y position of the window */
if(
!_GetWinID(msg, &winID) ||
msg->FindInt32("window-w", &w) != B_OK ||
msg->FindInt32("window-h", &h) != B_OK
) {
return;
}
win = GetSDLWindow(winID);
SDL_SendWindowEvent(win, SDL_WINDOWEVENT_RESIZED, w, h);
}
bool _GetWinID(BMessage *msg, int32 *winID) {
return msg->FindInt32("window-id", winID) == B_OK;
}
/* Vector functions: Wraps vector stuff in case we need to change
implementation */
void _SetSDLWindow(SDL_Window *win, int32 winID) {
_window_map[winID] = win;
}
int32 _GetNumWindowSlots() {
return _window_map.size();
}
void _PopBackWindow() {
_window_map.pop_back();
}
void _PushBackWindow(SDL_Window *win) {
_window_map.push_back(win);
}
/* Members */
vector<SDL_Window*> _window_map; /* Keeps track of SDL_Windows by index-id*/
display_mode *_saved_mode;
BGLView *_current_context;
};
#endif

22
src/main/beos/SDL_BeApp.cc
View file

@ -27,11 +27,17 @@
#include <storage/Entry.h>
#include <unistd.h>
#include "SDL_BApp.h" /* SDL_BApp class definition */
#include "SDL_BeApp.h"
#include "SDL_thread.h"
#include "SDL_timer.h"
#include "SDL_error.h"
#include "../../video/bwindow/SDL_BWin.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Flag to tell whether or not the Be application is active or not */
int SDL_BeAppActive = 0;
static SDL_Thread *SDL_AppThread = NULL;
@ -41,7 +47,7 @@ StartBeApp(void *unused)
{
BApplication *App;
App = new BApplication("application/x-SDL-executable");
App = new SDL_BApp("application/x-SDL-executable");
App->Run();
delete App;
@ -110,4 +116,18 @@ SDL_QuitBeApp(void)
}
}
/* vi: set ts=4 sw=4 expandtab: */
#ifdef __cplusplus
}
#endif
/* SDL_BApp functions */
void SDL_BApp::ClearID(SDL_BWin *bwin) {
_SetSDLWindow(NULL, bwin->GetID());
int32 i = _GetNumWindowSlots() - 1;
while(i >= 0 && GetSDLWindow(i) == NULL) {
_PopBackWindow();
--i;
}
}

8
src/main/beos/SDL_BeApp.h
View file

@ -20,6 +20,10 @@
*/
#include "SDL_config.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Handle the BeApp specific portions of the application */
/* Initialize the Be Application, if it's not already started */
@ -31,3 +35,7 @@ extern void SDL_QuitBeApp(void);
/* Flag to tell whether the app is active or not */
extern int SDL_BeAppActive;
/* vi: set ts=4 sw=4 expandtab: */
#ifdef __cplusplus
}
#endif

5
src/power/beos/SDL_syspower.c
View file

@ -50,6 +50,7 @@ SDL_GetPowerInfo_BeOS(SDL_PowerState * state, int *seconds, int *percent)
uint8 battery_flags;
uint8 battery_life;
uint32 battery_time;
int rc; /* FIXME: This was undefined before; not sure what type it is */
if (fd == -1) {
return SDL_FALSE; /* maybe some other method will work? */
@ -77,7 +78,9 @@ SDL_GetPowerInfo_BeOS(SDL_PowerState * state, int *seconds, int *percent)
if (battery_status == 0xFF) {
battery_flags = 0xFF;
} else {
battery_flags = (1 << status.battery_status);
battery_flags = (1 << battery_status); /* FIXME: Used to be
status.battery_status,
not sure why */
}
}

2
src/thread/beos/SDL_systhread.c
View file

@ -90,7 +90,7 @@ SDL_ThreadID(void)
}
int
SDL_SYS_SetThreadPriority(SDL_Thread * thread, SDL_ThreadPriority priority)
SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
{
int32 value;

120
src/video/bwindow/SDL_BView.h
View file

@ -1,120 +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_BView_h
#define _SDL_BView_h
/* This is the event handling and graphics update portion of SDL_BWin */
extern "C"
{
#include "../../events/SDL_events_c.h"
};
class SDL_BView:public BView
{
public:
SDL_BView(BRect frame):BView(frame, "SDL View", B_FOLLOW_ALL_SIDES,
(B_WILL_DRAW | B_FRAME_EVENTS))
{
image = NULL;
xoff = yoff = 0;
SetViewColor(0, 0, 0, 0);
SetHighColor(0, 0, 0, 0);
}
virtual ~ SDL_BView()
{
SetBitmap(NULL);
}
/* Set drawing offsets for fullscreen mode */
virtual void SetXYOffset(int x, int y)
{
xoff = x;
yoff = y;
}
virtual void GetXYOffset(int &x, int &y)
{
x = xoff;
y = yoff;
}
/* The view changed size. If it means we're in fullscreen, we
* draw a nice black box in the entire view to get black borders.
*/
virtual void FrameResized(float width, float height)
{
BRect bounds;
bounds.top = bounds.left = 0;
bounds.right = width;
bounds.bottom = height;
/* Fill the entire view with black */
FillRect(bounds, B_SOLID_HIGH);
/* And if there's an image, redraw it. */
if (image) {
bounds = image->Bounds();
Draw(bounds);
}
}
/* Drawing portion of this complete breakfast. :) */
virtual void SetBitmap(BBitmap * bitmap)
{
if (image) {
delete image;
}
image = bitmap;
}
virtual void Draw(BRect updateRect)
{
if (image) {
if (xoff || yoff) {
BRect dest;
dest.top = updateRect.top + yoff;
dest.left = updateRect.left + xoff;
dest.bottom = updateRect.bottom + yoff;
dest.right = updateRect.right + xoff;
DrawBitmap(image, updateRect, dest);
} else {
DrawBitmap(image, updateRect, updateRect);
}
}
}
virtual void DrawAsync(BRect updateRect)
{
if (xoff || yoff) {
BRect dest;
dest.top = updateRect.top + yoff;
dest.left = updateRect.left + xoff;
dest.bottom = updateRect.bottom + yoff;
dest.right = updateRect.right + xoff;;
DrawBitmapAsync(image, updateRect, dest);
} else {
DrawBitmapAsync(image, updateRect, updateRect);
}
}
private:
BBitmap * image;
int xoff, yoff;
};
#endif /* _SDL_BView_h */
/* vi: set ts=4 sw=4 expandtab: */

964
src/video/bwindow/SDL_BWin.h
View file

File diff suppressed because it is too large Load diff

99
src/video/bwindow/SDL_bclipboard.cc Normal file
View file

@ -0,0 +1,99 @@
/*
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.
*/
/* BWindow based framebuffer implementation */
#include "SDL_config.h"
#include <unistd.h>
#include <TypeConstants.h>
#include "SDL_BWin.h"
#include "SDL_timer.h"
#include "../SDL_sysvideo.h"
#ifdef __cplusplus
extern "C" {
#endif
int BE_SetClipboardText(_THIS, const char *text) {
BMessage *clip = NULL;
if(be_clipboard->Lock()) {
be_clipboard->Clear();
if((clip = be_clipboard->Data())) {
/* Presumably the string of characters is ascii-format */
ssize_t asciiLength = 0;
for(; text[asciiLength] != 0; ++asciiLength) {}
clip->AddData("text/plain", B_MIME_TYPE, &text, asciiLength);
be_clipboard->Commit();
}
be_clipboard->Unlock();
}
}
char *BE_GetClipboardText(_THIS) {
BMessage *clip = NULL;
const char *text;
ssize_t length;
if(be_clipboard->Lock()) {
if((clip = be_clipboard->Data())) {
/* Presumably the string of characters is ascii-format */
clip->FindData("text/plain", B_MIME_TYPE, (const void**)&text,
&length);
} else {
be_clipboard->Unlock();
return NULL;
}
be_clipboard->Unlock();
} else {
return NULL;
}
/* Copy the data and pass on to SDL */
char *result = (char*)SDL_calloc(1, sizeof(char*)*length);
SDL_strlcpy(result, text, length);
return result;
}
SDL_bool BE_HasClipboardText(_THIS) {
BMessage *clip = NULL;
const char *text;
ssize_t length;
SDL_bool retval = SDL_FALSE;
if(be_clipboard->Lock()) {
if((clip = be_clipboard->Data())) {
/* Presumably the string of characters is ascii-format */
clip->FindData("text/plain", B_MIME_TYPE, (const void**)&text,
&length);
if( text ) retval = SDL_TRUE;
}
be_clipboard->Unlock();
}
return retval;
}
#ifdef __cplusplus
} /* Extern C */
#endif

14
src/video/bwindow/SDL_syswm_c.h → src/video/bwindow/SDL_bclipboard.h
View file

@ -18,14 +18,14 @@
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"
#ifndef SDL_BCLIPBOARD_H
#define SDL_BCLIPBOARD_H
extern int BE_SetClipboardText(_THIS, const char *text);
extern char *BE_GetClipboardText(_THIS);
extern SDL_bool BE_HasClipboardText(_THIS);
/* 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: */
#endif

22
src/video/bwindow/SDL_sysmouse_c.h → src/video/bwindow/SDL_bevents.cc
View file

@ -18,15 +18,17 @@
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"
#include "SDL_bevents.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: */
#ifdef __cplusplus
extern "C" {
#endif
void BE_PumpEvents(_THIS) {
/* Since the event thread is its own thread, this isn't really necessary */
}
#ifdef __cplusplus
}
#endif

20
src/video/bwindow/SDL_sysevents_c.h → src/video/bwindow/SDL_bevents.h
View file

@ -18,14 +18,20 @@
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"
#ifndef SDL_BEVENTS_H
#define SDL_BEVENTS_H
/* Variables and functions exported by SDL_sysevents.c to other parts
of the native video subsystem (SDL_sysvideo.c)
*/
#include "../SDL_sysvideo.h"
#ifdef __cplusplus
extern "C" {
#endif
extern void BE_InitOSKeymap(_THIS);
extern void BE_PumpEvents(_THIS);
/* vi: set ts=4 sw=4 expandtab: */
#ifdef __cplusplus
}
#endif
#endif

251
src/video/bwindow/SDL_bframebuffer.cc Normal file
View file

@ -0,0 +1,251 @@
/*
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_bframebuffer.h"
#include <AppKit.h>
#include <InterfaceKit.h>
#include "SDL_bmodes.h"
#include "SDL_BWin.h"
#include "../../main/beos/SDL_BApp.h"
#ifdef __cplusplus
extern "C" {
#endif
int32 BE_UpdateOnce(SDL_Window *window);
static inline SDL_BWin *_ToBeWin(SDL_Window *window) {
return ((SDL_BWin*)(window->driverdata));
}
static inline SDL_BApp *_GetBeApp() {
return ((SDL_BApp*)be_app);
}
int BE_CreateWindowFramebuffer(_THIS, SDL_Window * window,
Uint32 * format,
void ** pixels, int *pitch) {
SDL_BWin *bwin = _ToBeWin(window);
BScreen bscreen;
if(!bscreen.IsValid()) {
return -1;
}
while(!bwin->Connected()) { snooze(100); }
/* Make sure we have exclusive access to frame buffer data */
bwin->LockBuffer();
/* format */
display_mode bmode;
bscreen.GetMode(&bmode);
int32 bpp = BE_ColorSpaceToBitsPerPixel(bmode.space);
*format = BE_BPPToSDLPxFormat(bpp);
/* Create the new bitmap object */
BBitmap *bitmap = bwin->GetBitmap();
if(bitmap) {
delete bitmap;
}
bitmap = new BBitmap(bwin->Bounds(), (color_space)bmode.space,
false, /* Views not accepted */
true); /* Contiguous memory required */
if(bitmap->InitCheck() != B_OK) {
SDL_SetError("Could not initialize back buffer!\n");
return -1;
}
bwin->SetBitmap(bitmap);
/* Set the pixel pointer */
*pixels = bitmap->Bits();
/* pitch = width of window, in bytes */
*pitch = bitmap->BytesPerRow();
bwin->SetBufferExists(true);
bwin->SetTrashBuffer(false);
bwin->UnlockBuffer();
return 0;
}
int BE_UpdateWindowFramebuffer(_THIS, SDL_Window * window,
SDL_Rect * rects, int numrects) {
if(!window)
return 0;
SDL_BWin *bwin = _ToBeWin(window);
#ifdef DRAWTHREAD
bwin->LockBuffer();
bwin->SetBufferDirty(true);
bwin->UnlockBuffer();
#else
bwin->SetBufferDirty(true);
BE_UpdateOnce(window);
#endif
return 0;
}
int32 BE_DrawThread(void *data) {
SDL_BWin *bwin = (SDL_BWin*)data;
SDL_Window *window = _GetBeApp()->GetSDLWindow(bwin->GetID());
BScreen bscreen;
if(!bscreen.IsValid()) {
return -1;
}
while(bwin->ConnectionEnabled()) {
if( bwin->Connected() && bwin->BufferExists() && bwin->BufferIsDirty() ) {
bwin->LockBuffer();
BBitmap *bitmap = NULL;
bitmap = bwin->GetBitmap();
int32 windowPitch = bitmap->BytesPerRow();
int32 bufferPitch = bwin->GetRowBytes();
uint8 *windowpx;
uint8 *bufferpx;
int32 BPP = bwin->GetBytesPerPx();
int32 windowSub = bwin->GetFbX() * BPP +
bwin->GetFbY() * windowPitch;
clipping_rect *clips = bwin->GetClips();
int32 numClips = bwin->GetNumClips();
int i, y;
/* Blit each clipping rectangle */
bscreen.WaitForRetrace();
for(i = 0; i < numClips; ++i) {
clipping_rect rc = clips[i];
/* Get addresses of the start of each clipping rectangle */
int32 width = clips[i].right - clips[i].left + 1;
int32 height = clips[i].bottom - clips[i].top + 1;
bufferpx = bwin->GetBufferPx() +
clips[i].top * bufferPitch + clips[i].left * BPP;
windowpx = (uint8*)bitmap->Bits() +
clips[i].top * windowPitch + clips[i].left * BPP -
windowSub;
/* Copy each row of pixels from the window buffer into the frame
buffer */
for(y = 0; y < height; ++y)
{
if(bwin->CanTrashWindowBuffer()) {
goto escape; /* Break out before the buffer is killed */
}
memcpy(bufferpx, windowpx, width * BPP);
bufferpx += bufferPitch;
windowpx += windowPitch;
}
}
bwin->SetBufferDirty(false);
escape:
bwin->UnlockBuffer();
} else {
snooze(16000);
}
}
return B_OK;
}
void BE_DestroyWindowFramebuffer(_THIS, SDL_Window * window) {
SDL_BWin *bwin = _ToBeWin(window);
bwin->LockBuffer();
/* Free and clear the window buffer */
BBitmap *bitmap = bwin->GetBitmap();
delete bitmap;
bwin->SetBitmap(NULL);
bwin->SetBufferExists(false);
bwin->UnlockBuffer();
}
/*
* TODO:
* This was written to test if certain errors were caused by threading issues.
* The specific issues have since become rare enough that they may have been
* solved, but I doubt it- they were pretty sporadic before now.
*/
int32 BE_UpdateOnce(SDL_Window *window) {
SDL_BWin *bwin = _ToBeWin(window);
BScreen bscreen;
if(!bscreen.IsValid()) {
return -1;
}
if(bwin->ConnectionEnabled() && bwin->Connected()) {
bwin->LockBuffer();
int32 windowPitch = window->surface->pitch;
int32 bufferPitch = bwin->GetRowBytes();
uint8 *windowpx;
uint8 *bufferpx;
int32 BPP = bwin->GetBytesPerPx();
uint8 *windowBaseAddress = (uint8*)window->surface->pixels;
int32 windowSub = bwin->GetFbX() * BPP +
bwin->GetFbY() * windowPitch;
clipping_rect *clips = bwin->GetClips();
int32 numClips = bwin->GetNumClips();
int i, y;
/* Blit each clipping rectangle */
bscreen.WaitForRetrace();
for(i = 0; i < numClips; ++i) {
clipping_rect rc = clips[i];
/* Get addresses of the start of each clipping rectangle */
int32 width = clips[i].right - clips[i].left + 1;
int32 height = clips[i].bottom - clips[i].top + 1;
bufferpx = bwin->GetBufferPx() +
clips[i].top * bufferPitch + clips[i].left * BPP;
windowpx = windowBaseAddress +
clips[i].top * windowPitch + clips[i].left * BPP - windowSub;
/* Copy each row of pixels from the window buffer into the frame
buffer */
for(y = 0; y < height; ++y)
{
memcpy(bufferpx, windowpx, width * BPP);
bufferpx += bufferPitch;
windowpx += windowPitch;
}
}
bwin->UnlockBuffer();
}
return 0;
}
#ifdef __cplusplus
}
#endif

45
src/video/bwindow/SDL_bframebuffer.h Normal file
View file

@ -0,0 +1,45 @@
/*
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.
*/
#ifndef SDL_BFRAMEBUFFER_H
#define SDL_BFRAMEBUFFER_H
#include <SupportDefs.h>
#ifdef __cplusplus
extern "C" {
#endif
#define DRAWTHREAD
#include "../SDL_sysvideo.h"
extern int BE_CreateWindowFramebuffer(_THIS, SDL_Window * window,
Uint32 * format,
void ** pixels, int *pitch);
extern int BE_UpdateWindowFramebuffer(_THIS, SDL_Window * window,
SDL_Rect * rects, int numrects);
extern void BE_DestroyWindowFramebuffer(_THIS, SDL_Window * window);
extern int32 BE_DrawThread(void *data);
#ifdef __cplusplus
}
#endif
#endif

184
src/video/bwindow/SDL_bkeyboard.cc Normal file
View file

@ -0,0 +1,184 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include <SupportDefs.h>
#include <support/UTF8.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "SDL_events.h"
#include "SDL_keycode.h"
#include "SDL_bkeyboard.h"
#define KEYMAP_SIZE 128
static SDL_Scancode keymap[KEYMAP_SIZE];
static int8 keystate[KEYMAP_SIZE];
void BE_InitOSKeymap() {
for( uint i = 0; i < SDL_TABLESIZE(keymap); ++i ) {
keymap[i] = SDL_SCANCODE_UNKNOWN;
}
for( uint i = 0; i < KEYMAP_SIZE; ++i ) {
keystate[i] = SDL_RELEASED;
}
keymap[0x01] = SDL_GetScancodeFromKey(SDLK_ESCAPE);
keymap[B_F1_KEY] = SDL_GetScancodeFromKey(SDLK_F1);
keymap[B_F2_KEY] = SDL_GetScancodeFromKey(SDLK_F2);
keymap[B_F3_KEY] = SDL_GetScancodeFromKey(SDLK_F3);
keymap[B_F4_KEY] = SDL_GetScancodeFromKey(SDLK_F4);
keymap[B_F5_KEY] = SDL_GetScancodeFromKey(SDLK_F5);
keymap[B_F6_KEY] = SDL_GetScancodeFromKey(SDLK_F6);
keymap[B_F7_KEY] = SDL_GetScancodeFromKey(SDLK_F7);
keymap[B_F8_KEY] = SDL_GetScancodeFromKey(SDLK_F8);
keymap[B_F9_KEY] = SDL_GetScancodeFromKey(SDLK_F9);
keymap[B_F10_KEY] = SDL_GetScancodeFromKey(SDLK_F10);
keymap[B_F11_KEY] = SDL_GetScancodeFromKey(SDLK_F11);
keymap[B_F12_KEY] = SDL_GetScancodeFromKey(SDLK_F12);
keymap[B_PRINT_KEY] = SDL_GetScancodeFromKey(SDLK_PRINTSCREEN);
keymap[B_SCROLL_KEY] = SDL_GetScancodeFromKey(SDLK_SCROLLLOCK);
keymap[B_PAUSE_KEY] = SDL_GetScancodeFromKey(SDLK_PAUSE);
keymap[0x11] = SDL_GetScancodeFromKey(SDLK_BACKQUOTE);
keymap[0x12] = SDL_GetScancodeFromKey(SDLK_1);
keymap[0x13] = SDL_GetScancodeFromKey(SDLK_2);
keymap[0x14] = SDL_GetScancodeFromKey(SDLK_3);
keymap[0x15] = SDL_GetScancodeFromKey(SDLK_4);
keymap[0x16] = SDL_GetScancodeFromKey(SDLK_5);
keymap[0x17] = SDL_GetScancodeFromKey(SDLK_6);
keymap[0x18] = SDL_GetScancodeFromKey(SDLK_7);
keymap[0x19] = SDL_GetScancodeFromKey(SDLK_8);
keymap[0x1a] = SDL_GetScancodeFromKey(SDLK_9);
keymap[0x1b] = SDL_GetScancodeFromKey(SDLK_0);
keymap[0x1c] = SDL_GetScancodeFromKey(SDLK_MINUS);
keymap[0x1d] = SDL_GetScancodeFromKey(SDLK_EQUALS);
keymap[0x1e] = SDL_GetScancodeFromKey(SDLK_BACKSPACE);
keymap[0x1f] = SDL_GetScancodeFromKey(SDLK_INSERT);
keymap[0x20] = SDL_GetScancodeFromKey(SDLK_HOME);
keymap[0x21] = SDL_GetScancodeFromKey(SDLK_PAGEUP);
keymap[0x22] = SDL_GetScancodeFromKey(SDLK_NUMLOCKCLEAR);
keymap[0x23] = SDL_GetScancodeFromKey(SDLK_KP_DIVIDE);
keymap[0x24] = SDL_GetScancodeFromKey(SDLK_KP_MULTIPLY);
keymap[0x25] = SDL_GetScancodeFromKey(SDLK_KP_MINUS);
keymap[0x26] = SDL_GetScancodeFromKey(SDLK_TAB);
keymap[0x27] = SDL_GetScancodeFromKey(SDLK_q);
keymap[0x28] = SDL_GetScancodeFromKey(SDLK_w);
keymap[0x29] = SDL_GetScancodeFromKey(SDLK_e);
keymap[0x2a] = SDL_GetScancodeFromKey(SDLK_r);
keymap[0x2b] = SDL_GetScancodeFromKey(SDLK_t);
keymap[0x2c] = SDL_GetScancodeFromKey(SDLK_y);
keymap[0x2d] = SDL_GetScancodeFromKey(SDLK_u);
keymap[0x2e] = SDL_GetScancodeFromKey(SDLK_i);
keymap[0x2f] = SDL_GetScancodeFromKey(SDLK_o);
keymap[0x30] = SDL_GetScancodeFromKey(SDLK_p);
keymap[0x31] = SDL_GetScancodeFromKey(SDLK_LEFTBRACKET);
keymap[0x32] = SDL_GetScancodeFromKey(SDLK_RIGHTBRACKET);
keymap[0x33] = SDL_GetScancodeFromKey(SDLK_BACKSLASH);
keymap[0x34] = SDL_GetScancodeFromKey(SDLK_DELETE);
keymap[0x35] = SDL_GetScancodeFromKey(SDLK_END);
keymap[0x36] = SDL_GetScancodeFromKey(SDLK_PAGEDOWN);
keymap[0x37] = SDL_GetScancodeFromKey(SDLK_KP_7);
keymap[0x38] = SDL_GetScancodeFromKey(SDLK_KP_8);
keymap[0x39] = SDL_GetScancodeFromKey(SDLK_KP_9);
keymap[0x3a] = SDL_GetScancodeFromKey(SDLK_KP_PLUS);
keymap[0x3b] = SDL_GetScancodeFromKey(SDLK_CAPSLOCK);
keymap[0x3c] = SDL_GetScancodeFromKey(SDLK_a);
keymap[0x3d] = SDL_GetScancodeFromKey(SDLK_s);
keymap[0x3e] = SDL_GetScancodeFromKey(SDLK_d);
keymap[0x3f] = SDL_GetScancodeFromKey(SDLK_f);
keymap[0x40] = SDL_GetScancodeFromKey(SDLK_g);
keymap[0x41] = SDL_GetScancodeFromKey(SDLK_h);
keymap[0x42] = SDL_GetScancodeFromKey(SDLK_j);
keymap[0x43] = SDL_GetScancodeFromKey(SDLK_k);
keymap[0x44] = SDL_GetScancodeFromKey(SDLK_l);
keymap[0x45] = SDL_GetScancodeFromKey(SDLK_SEMICOLON);
keymap[0x46] = SDL_GetScancodeFromKey(SDLK_QUOTE);
keymap[0x47] = SDL_GetScancodeFromKey(SDLK_RETURN);
keymap[0x48] = SDL_GetScancodeFromKey(SDLK_KP_4);
keymap[0x49] = SDL_GetScancodeFromKey(SDLK_KP_5);
keymap[0x4a] = SDL_GetScancodeFromKey(SDLK_KP_6);
keymap[0x4b] = SDL_GetScancodeFromKey(SDLK_LSHIFT);
keymap[0x4c] = SDL_GetScancodeFromKey(SDLK_z);
keymap[0x4d] = SDL_GetScancodeFromKey(SDLK_x);
keymap[0x4e] = SDL_GetScancodeFromKey(SDLK_c);
keymap[0x4f] = SDL_GetScancodeFromKey(SDLK_v);
keymap[0x50] = SDL_GetScancodeFromKey(SDLK_b);
keymap[0x51] = SDL_GetScancodeFromKey(SDLK_n);
keymap[0x52] = SDL_GetScancodeFromKey(SDLK_m);
keymap[0x53] = SDL_GetScancodeFromKey(SDLK_COMMA);
keymap[0x54] = SDL_GetScancodeFromKey(SDLK_PERIOD);
keymap[0x55] = SDL_GetScancodeFromKey(SDLK_SLASH);
keymap[0x56] = SDL_GetScancodeFromKey(SDLK_RSHIFT);
keymap[0x57] = SDL_GetScancodeFromKey(SDLK_UP);
keymap[0x58] = SDL_GetScancodeFromKey(SDLK_KP_1);
keymap[0x59] = SDL_GetScancodeFromKey(SDLK_KP_2);
keymap[0x5a] = SDL_GetScancodeFromKey(SDLK_KP_3);
keymap[0x5b] = SDL_GetScancodeFromKey(SDLK_KP_ENTER);
keymap[0x5c] = SDL_GetScancodeFromKey(SDLK_LCTRL);
keymap[0x5d] = SDL_GetScancodeFromKey(SDLK_LALT);
keymap[0x5e] = SDL_GetScancodeFromKey(SDLK_SPACE);
keymap[0x5f] = SDL_GetScancodeFromKey(SDLK_RALT);
keymap[0x60] = SDL_GetScancodeFromKey(SDLK_RCTRL);
keymap[0x61] = SDL_GetScancodeFromKey(SDLK_LEFT);
keymap[0x62] = SDL_GetScancodeFromKey(SDLK_DOWN);
keymap[0x63] = SDL_GetScancodeFromKey(SDLK_RIGHT);
keymap[0x64] = SDL_GetScancodeFromKey(SDLK_KP_0);
keymap[0x65] = SDL_GetScancodeFromKey(SDLK_KP_PERIOD);
keymap[0x66] = SDL_GetScancodeFromKey(SDLK_LGUI);
keymap[0x67] = SDL_GetScancodeFromKey(SDLK_RGUI);
keymap[0x68] = SDL_GetScancodeFromKey(SDLK_MENU);
keymap[0x69] = SDL_GetScancodeFromKey(SDLK_2); /* SDLK_EURO */
keymap[0x6a] = SDL_GetScancodeFromKey(SDLK_KP_EQUALS);
keymap[0x6b] = SDL_GetScancodeFromKey(SDLK_POWER);
}
SDL_Scancode BE_GetScancodeFromBeKey(int32 bkey) {
if(bkey > 0 && bkey < SDL_TABLESIZE(keymap)) {
return keymap[bkey];
} else {
return SDL_SCANCODE_UNKNOWN;
}
}
int8 BE_GetKeyState(int32 bkey) {
if(bkey > 0 && bkey < KEYMAP_SIZE) {
return keystate[bkey];
} else {
return SDL_RELEASED;
}
}
void BE_SetKeyState(int32 bkey, int8 state) {
if(bkey > 0 && bkey < KEYMAP_SIZE) {
keystate[bkey] = state;
}
}
#ifdef __cplusplus
}
#endif

43
src/video/bwindow/SDL_bkeyboard.h Normal file
View file

@ -0,0 +1,43 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#ifndef SDL_BKEYBOARD_H
#define SDL_BKEYBOARD_H
#include <SupportDefs.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "../../../include/SDL_keyboard.h"
extern void BE_InitOSKeymap();
extern SDL_Scancode BE_GetScancodeFromBeKey(int32 bkey);
extern int8 BE_GetKeyState(int32 bkey);
extern void BE_SetKeyState(int32 bkey, int8 state);
#ifdef __cplusplus
}
#endif
#endif

324
src/video/bwindow/SDL_bmodes.cc Normal file
View file

@ -0,0 +1,324 @@
/*
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 <AppKit.h>
#include <InterfaceKit.h>
#include "SDL_bmodes.h"
#include "SDL_BWin.h"
#if SDL_VIDEO_OPENGL
#include "SDL_bopengl.h"
#endif
#include "../../main/beos/SDL_BApp.h"
#ifdef __cplusplus
extern "C" {
#endif
#define WRAP_BMODE 1 /* FIXME: Some debate as to whether this is necessary */
#if WRAP_BMODE
/* This wrapper is here so that the driverdata can be freed without freeing
the display_mode structure */
typedef struct SDL_DisplayModeData {
display_mode *bmode;
};
#endif
static inline SDL_BWin *_ToBeWin(SDL_Window *window) {
return ((SDL_BWin*)(window->driverdata));
}
static inline SDL_BApp *_GetBeApp() {
return ((SDL_BApp*)be_app);
}
static inline display_mode * _ExtractBMode(SDL_DisplayMode *mode) {
#if WRAP_BMODE
return ((SDL_DisplayModeData*)mode->driverdata)->bmode;
#else
return (display_mode*)(mode->driverdata);
#endif
}
/* Copied from haiku/trunk/src/preferences/screen/ScreenMode.cpp */
static float get_refresh_rate(display_mode &mode) {
return float(mode.timing.pixel_clock * 1000)
/ float(mode.timing.h_total * mode.timing.v_total);
}
#if 0
/* TODO:
* This is a useful debugging tool. Uncomment and insert into code as needed.
*/
void _SpoutModeData(display_mode *bmode) {
printf("BMode:\n");
printf("\tw,h = (%i,%i)\n", bmode->virtual_width, bmode->virtual_height);
printf("\th,v = (%i,%i)\n", bmode->h_display_start,
bmode->v_display_start);
if(bmode->flags) {
printf("\tFlags:\n");
if(bmode->flags & B_SCROLL) {
printf("\t\tB_SCROLL\n");
}
if(bmode->flags & B_8_BIT_DAC) {
printf("\t\tB_8_BIT_DAC\n");
}
if(bmode->flags & B_HARDWARE_CURSOR) {
printf("\t\tB_HARDWARE_CURSOR\n");
}
if(bmode->flags & B_PARALLEL_ACCESS) {
printf("\t\tB_PARALLEL_ACCESS\n");
}
if(bmode->flags & B_DPMS) {
printf("\t\tB_DPMS\n");
}
if(bmode->flags & B_IO_FB_NA) {
printf("\t\tB_IO_FB_NA\n");
}
}
printf("\tTiming:\n");
printf("\t\tpx clock: %i\n", bmode->timing.pixel_clock);
printf("\t\th - display: %i sync start: %i sync end: %i total: %i\n",
bmode->timing.h_display, bmode->timing.h_sync_start,
bmode->timing.h_sync_end, bmode->timing.h_total);
printf("\t\tv - display: %i sync start: %i sync end: %i total: %i\n",
bmode->timing.v_display, bmode->timing.v_sync_start,
bmode->timing.v_sync_end, bmode->timing.v_total);
if(bmode->timing.flags) {
printf("\t\tFlags:\n");
if(bmode->timing.flags & B_BLANK_PEDESTAL) {
printf("\t\t\tB_BLANK_PEDESTAL\n");
}
if(bmode->timing.flags & B_TIMING_INTERLACED) {
printf("\t\t\tB_TIMING_INTERLACED\n");
}
if(bmode->timing.flags & B_POSITIVE_HSYNC) {
printf("\t\t\tB_POSITIVE_HSYNC\n");
}
if(bmode->timing.flags & B_POSITIVE_VSYNC) {
printf("\t\t\tB_POSITIVE_VSYNC\n");
}
if(bmode->timing.flags & B_SYNC_ON_GREEN) {
printf("\t\t\tB_SYNC_ON_GREEN\n");
}
}
}
#endif
int32 BE_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);
}
int32 BE_BPPToSDLPxFormat(int32 bpp) {
/* Translation taken from SDL_windowsmodes.c */
switch (bpp) {
case 32:
return SDL_PIXELFORMAT_RGB888;
break;
case 24: /* May not be supported by Haiku */
return SDL_PIXELFORMAT_RGB24;
break;
case 16:
return SDL_PIXELFORMAT_RGB565;
break;
case 15:
return SDL_PIXELFORMAT_RGB555;
break;
case 8:
return SDL_PIXELFORMAT_INDEX8;
break;
case 4: /* May not be supported by Haiku */
return SDL_PIXELFORMAT_INDEX4LSB;
break;
}
}
static void _BDisplayModeToSdlDisplayMode(display_mode *bmode,
SDL_DisplayMode *mode) {
mode->w = bmode->virtual_width;
mode->h = bmode->virtual_height;
mode->refresh_rate = (int)get_refresh_rate(*bmode);
#if WRAP_BMODE
SDL_DisplayModeData *data = (SDL_DisplayModeData*)SDL_calloc(1,
sizeof(SDL_DisplayModeData));
data->bmode = bmode;
mode->driverdata = data;
#else
mode->driverdata = bmode;
#endif
/* Set the format */
int32 bpp = BE_ColorSpaceToBitsPerPixel(bmode->space);
mode->format = BE_BPPToSDLPxFormat(bpp);
}
/* Later, there may be more than one monitor available */
static void _AddDisplay(BScreen *screen) {
SDL_VideoDisplay display;
SDL_DisplayMode *mode = (SDL_DisplayMode*)SDL_calloc(1,
sizeof(SDL_DisplayMode));
display_mode *bmode = (display_mode*)SDL_calloc(1, sizeof(display_mode));
screen->GetMode(bmode);
_BDisplayModeToSdlDisplayMode(bmode, mode);
SDL_zero(display);
display.desktop_mode = *mode;
display.current_mode = *mode;
SDL_AddVideoDisplay(&display);
}
/*
* Functions called by SDL
*/
int BE_InitModes(_THIS) {
BScreen screen;
/* TODO: When Haiku supports multiple display screens, call
_AddDisplayScreen() for each of them. */
_AddDisplay(&screen);
}
int BE_QuitModes(_THIS) {
/* FIXME: Nothing really needs to be done here at the moment? */
return 0;
}
int BE_GetDisplayBounds(_THIS, SDL_VideoDisplay *display, SDL_Rect *rect) {
BScreen bscreen;
BRect rc = bscreen.Frame();
rect->x = (int)rc.left;
rect->y = (int)rc.top;
rect->w = (int)rc.Width() + 1;
rect->h = (int)rc.Height() + 1;
return 0;
}
void BE_GetDisplayModes(_THIS, SDL_VideoDisplay *display) {
/* Get the current screen */
BScreen bscreen;
/* Iterate through all of the modes */
SDL_DisplayMode mode;
display_mode this_bmode;
display_mode *bmodes;
uint32 count, i;
/* Get graphics-hardware supported modes */
bscreen.GetModeList(&bmodes, &count);
bscreen.GetMode(&this_bmode);
for(i = 0; i < count; ++i) {
//FIXME: Apparently there are errors with colorspace changes
if (bmodes[i].space == this_bmode.space) {
_BDisplayModeToSdlDisplayMode(&bmodes[i], &mode);
SDL_AddDisplayMode(display, &mode);
}
}
free(bmodes);
}
int BE_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode){
/* Get the current screen */
BScreen bscreen;
if(!bscreen.IsValid()) {
printf(__FILE__": %d - ERROR: BAD SCREEN\n", __LINE__);
}
/* Set the mode using the driver data */
display_mode *bmode = _ExtractBMode(mode);
/* FIXME: Is the first option always going to be the right one? */
uint32 c = 0, i;
display_mode *bmode_list;
bscreen.GetModeList(&bmode_list, &c);
for(i = 0; i < c; ++i) {
if( bmode_list[i].space == bmode->space &&
bmode_list[i].virtual_width == bmode->virtual_width &&
bmode_list[i].virtual_height == bmode->virtual_height ) {
bmode = &bmode_list[i];
break;
}
}
if(bscreen.SetMode(bmode) != B_OK) {
SDL_SetError("Bad video mode\n");
return -1;
}
free(bmode_list);
#if SDL_VIDEO_OPENGL
/* FIXME: Is there some way to reboot the OpenGL context? This doesn't
help */
// BE_GL_RebootContexts(_this);
#endif
return 0;
}
#ifdef __cplusplus
}
#endif

46
src/video/bwindow/SDL_bmodes.h Normal file
View file

@ -0,0 +1,46 @@
/*
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.
*/
#ifndef SDL_BMODES_H
#define SDL_BMODES_H
#ifdef __cplusplus
extern "C" {
#endif
#include "../SDL_sysvideo.h"
extern int32 BE_ColorSpaceToBitsPerPixel(uint32 colorspace);
extern int32 BE_BPPToSDLPxFormat(int32 bpp);
extern int BE_InitModes(_THIS);
extern int BE_QuitModes(_THIS);
extern int BE_GetDisplayBounds(_THIS, SDL_VideoDisplay *display,
SDL_Rect *rect);
extern void BE_GetDisplayModes(_THIS, SDL_VideoDisplay *display);
extern int BE_SetDisplayMode(_THIS, SDL_VideoDisplay *display,
SDL_DisplayMode *mode);
#ifdef __cplusplus
}
#endif
#endif

218
src/video/bwindow/SDL_bopengl.cc Normal file
View file

@ -0,0 +1,218 @@
/*
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_bopengl.h"
#include <unistd.h>
#include <KernelKit.h>
#include <OpenGLKit.h>
#include "SDL_BWin.h"
#include "../../main/beos/SDL_BApp.h"
#ifdef __cplusplus
extern "C" {
#endif
#define BGL_FLAGS BGL_RGB | BGL_DOUBLE
static inline SDL_BWin *_ToBeWin(SDL_Window *window) {
return ((SDL_BWin*)(window->driverdata));
}
static inline SDL_BApp *_GetBeApp() {
return ((SDL_BApp*)be_app);
}
/* Passing a NULL path means load pointers from the application */
int BE_GL_LoadLibrary(_THIS, const char *path)
{
/* FIXME: Is this working correctly? */
image_info info;
int32 cookie = 0;
while (get_next_image_info(0, &cookie, &info) == B_OK) {
void *location = NULL;
if( get_image_symbol(info.id, "glBegin", B_SYMBOL_TYPE_ANY,
&location) == B_OK) {
_this->gl_config.dll_handle = (void *) info.id;
_this->gl_config.driver_loaded = 1;
SDL_strlcpy(_this->gl_config.driver_path, "libGL.so",
SDL_arraysize(_this->gl_config.driver_path));
}
}
}
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;
}
}
void BE_GL_SwapWindow(_THIS, SDL_Window * window) {
_ToBeWin(window)->SwapBuffers();
}
int BE_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context) {
_GetBeApp()->SetCurrentContext(((SDL_BWin*)context)->GetGLView());
return 0;
}
SDL_GLContext BE_GL_CreateContext(_THIS, SDL_Window * window) {
/* FIXME: Not sure what flags should be included here; may want to have
most of them */
SDL_BWin *bwin = _ToBeWin(window);
bwin->CreateGLView(BGL_FLAGS);
return (SDL_GLContext)(bwin);
}
void BE_GL_DeleteContext(_THIS, SDL_GLContext context) {
/* Currently, automatically unlocks the view */
((SDL_BWin*)context)->RemoveGLView();
}
int BE_GL_SetSwapInterval(_THIS, int interval) {
/* TODO: Implement this, if necessary? */
return 0;
}
int BE_GL_GetSwapInterval(_THIS) {
/* TODO: Implement this, if necessary? */
return 0;
}
void BE_GL_UnloadLibrary(_THIS) {
/* TODO: Implement this, if necessary? */
}
/* FIXME: This function is meant to clear the OpenGL context when the video
mode changes (see SDL_bmodes.cc), but it doesn't seem to help, and is not
currently in use. */
void BE_GL_RebootContexts(_THIS) {
SDL_Window *window = _this->windows;
while(window) {
SDL_BWin *bwin = _ToBeWin(window);
if(bwin->GetGLView()) {
bwin->LockLooper();
bwin->RemoveGLView();
bwin->CreateGLView(BGL_FLAGS);
bwin->UnlockLooper();
}
window = window->next;
}
}
#if 0 /* Functions from 1.2 that do not appear to be used in 1.3 */
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;
}
#endif
#ifdef __cplusplus
}
#endif

51
src/video/bwindow/SDL_syswm.cc → src/video/bwindow/SDL_bopengl.h
View file

@ -18,37 +18,32 @@
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"
#ifndef SDL_BOPENGL_H
#define SDL_BOPENGL_H
extern "C"
{
#ifdef __cplusplus
extern "C" {
#endif
#include "SDL_syswm_c.h"
#include "SDL_error.h"
#include "../SDL_sysvideo.h"
void BE_SetWMCaption(_THIS, const char *title, const char *icon)
{
SDL_Win->SetTitle(title);
extern int BE_GL_LoadLibrary(_THIS, const char *path); //FIXME
extern void *BE_GL_GetProcAddress(_THIS, const char *proc); //FIXME
extern void BE_GL_UnloadLibrary(_THIS); //TODO
extern int BE_GL_MakeCurrent(_THIS, SDL_Window * window,
SDL_GLContext context);
extern int BE_GL_SetSwapInterval(_THIS, int interval); //TODO
extern int BE_GL_GetSwapInterval(_THIS); //TODO
extern void BE_GL_SwapWindow(_THIS, SDL_Window * window);
extern SDL_GLContext BE_GL_CreateContext(_THIS, SDL_Window * window);
extern void BE_GL_DeleteContext(_THIS, SDL_GLContext context);
extern void BE_GL_RebootContexts(_THIS);
#ifdef __cplusplus
}
#endif
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: */
#endif

170
src/video/bwindow/SDL_bvideo.cc Normal file
View file

@ -0,0 +1,170 @@
/*
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.
*/
#ifdef __cplusplus
extern "C" {
#endif
#include "SDL_bkeyboard.h"
#include "SDL_bwindow.h"
#include "SDL_bclipboard.h"
#include "SDL_bvideo.h"
#include "SDL_bopengl.h"
#include "SDL_bmodes.h"
#include "SDL_bframebuffer.h"
#include "SDL_bevents.h"
/* FIXME: Undefined functions */
// #define BE_PumpEvents NULL
#define BE_StartTextInput NULL
#define BE_StopTextInput NULL
#define BE_SetTextInputRect NULL
// #define BE_DeleteDevice NULL
/* End undefined functions */
static SDL_VideoDevice *
BE_CreateDevice(int devindex)
{
SDL_VideoDevice *device;
/*SDL_VideoData *data;*/
/* Initialize all variables that we clean on shutdown */
device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
device->driverdata = NULL; /* FIXME: Is this the cause of some of the
SDL_Quit() errors? */
/* TODO: Figure out if any initialization needs to go here */
/* Set the function pointers */
device->VideoInit = BE_VideoInit;
device->VideoQuit = BE_VideoQuit;
device->GetDisplayBounds = BE_GetDisplayBounds;
device->GetDisplayModes = BE_GetDisplayModes;
device->SetDisplayMode = BE_SetDisplayMode;
device->PumpEvents = BE_PumpEvents;
device->CreateWindow = BE_CreateWindow;
device->CreateWindowFrom = BE_CreateWindowFrom;
device->SetWindowTitle = BE_SetWindowTitle;
device->SetWindowIcon = BE_SetWindowIcon;
device->SetWindowPosition = BE_SetWindowPosition;
device->SetWindowSize = BE_SetWindowSize;
device->ShowWindow = BE_ShowWindow;
device->HideWindow = BE_HideWindow;
device->RaiseWindow = BE_RaiseWindow;
device->MaximizeWindow = BE_MaximizeWindow;
device->MinimizeWindow = BE_MinimizeWindow;
device->RestoreWindow = BE_RestoreWindow;
device->SetWindowFullscreen = BE_SetWindowFullscreen;
device->SetWindowGammaRamp = BE_SetWindowGammaRamp;
device->GetWindowGammaRamp = BE_GetWindowGammaRamp;
device->SetWindowGrab = BE_SetWindowGrab;
device->DestroyWindow = BE_DestroyWindow;
device->GetWindowWMInfo = BE_GetWindowWMInfo;
device->CreateWindowFramebuffer = BE_CreateWindowFramebuffer;
device->UpdateWindowFramebuffer = BE_UpdateWindowFramebuffer;
device->DestroyWindowFramebuffer = BE_DestroyWindowFramebuffer;
device->shape_driver.CreateShaper = NULL;
device->shape_driver.SetWindowShape = NULL;
device->shape_driver.ResizeWindowShape = NULL;
device->GL_LoadLibrary = BE_GL_LoadLibrary;
device->GL_GetProcAddress = BE_GL_GetProcAddress;
device->GL_UnloadLibrary = BE_GL_UnloadLibrary;
device->GL_CreateContext = BE_GL_CreateContext;
device->GL_MakeCurrent = BE_GL_MakeCurrent;
device->GL_SetSwapInterval = BE_GL_SetSwapInterval;
device->GL_GetSwapInterval = BE_GL_GetSwapInterval;
device->GL_SwapWindow = BE_GL_SwapWindow;
device->GL_DeleteContext = BE_GL_DeleteContext;
device->StartTextInput = BE_StartTextInput;
device->StopTextInput = BE_StopTextInput;
device->SetTextInputRect = BE_SetTextInputRect;
device->SetClipboardText = BE_SetClipboardText;
device->GetClipboardText = BE_GetClipboardText;
device->HasClipboardText = BE_HasClipboardText;
device->free = BE_DeleteDevice;
return device;
}
VideoBootStrap BWINDOW_bootstrap = {
"bwindow", "BDirectWindow graphics",
BE_Available, BE_CreateDevice
};
void BE_DeleteDevice(SDL_VideoDevice * device)
{
SDL_free(device->driverdata);
SDL_free(device);
}
int BE_VideoInit(_THIS)
{
/* Initialize the Be Application for appserver interaction */
if (SDL_InitBeApp() < 0) {
return -1;
}
/* Initialize video modes */
BE_InitModes(_this);
/* Init the keymap */
BE_InitOSKeymap();
#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
/* We're done! */
return (0);
}
int BE_Available(void)
{
return (1);
}
void BE_VideoQuit(_THIS)
{
BE_QuitModes(_this);
SDL_QuitBeApp();
}
#ifdef __cplusplus
}
#endif

38
src/video/bwindow/SDL_sysevents.cc → src/video/bwindow/SDL_bvideo.h
View file

@ -18,31 +18,25 @@
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"
#ifndef BVIDEO_H
#define BVIDEO_H
extern "C"
{
#ifdef __cplusplus
extern "C" {
#endif
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_sysevents_c.h"
#include "../../main/beos/SDL_BeApp.h"
#include "../SDL_sysvideo.h"
void BE_PumpEvents(_THIS)
{
extern void BE_VideoQuit(_THIS);
extern int BE_VideoInit(_THIS);
extern void BE_DeleteDevice(_THIS);
extern int BE_Available(void);
#ifdef __cplusplus
}
#endif
void BE_InitOSKeymap(_THIS)
{
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */
#endif

212
src/video/bwindow/SDL_bwindow.cc Normal file
View file

@ -0,0 +1,212 @@
/*
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_sysvideo.h"
#include "SDL_BWin.h"
#include <new>
/* Define a path to window's BWIN data */
#ifdef __cplusplus
extern "C" {
#endif
static inline SDL_BWin *_ToBeWin(SDL_Window *window) {
return ((SDL_BWin*)(window->driverdata));
}
static inline SDL_BApp *_GetBeApp() {
return ((SDL_BApp*)be_app);
}
static int _InitWindow(_THIS, SDL_Window *window) {
uint32 flags = 0;
BRect bounds(
window->x,
window->y,
window->x + window->w - 1, //BeWindows have an off-by-one px w/h thing
window->y + window->h - 1
);
if(window->flags & SDL_WINDOW_FULLSCREEN) {
/* TODO: Add support for this flag */
printf(__FILE__": %d!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n",__LINE__);
}
if(window->flags & SDL_WINDOW_OPENGL) {
/* TODO: Add support for this flag */
}
if(!(window->flags & SDL_WINDOW_RESIZABLE)) {
flags |= B_NOT_RESIZABLE | B_NOT_ZOOMABLE;
}
if(window->flags & SDL_WINDOW_BORDERLESS) {
/* TODO: Add support for this flag */
}
SDL_BWin *bwin = new(std::nothrow) SDL_BWin(bounds, flags);
if(bwin == NULL)
return ENOMEM;
window->driverdata = bwin;
int32 winID = _GetBeApp()->GetID(window);
bwin->SetID(winID);
return 0;
}
int BE_CreateWindow(_THIS, SDL_Window *window) {
if(_InitWindow(_this, window) == ENOMEM)
return ENOMEM;
/* Start window loop */
_ToBeWin(window)->Show();
return 0;
}
int BE_CreateWindowFrom(_THIS, SDL_Window * window, const void *data) {
SDL_BWin *otherBWin = (SDL_BWin*)data;
if(!otherBWin->LockLooper())
return -1;
/* Create the new window and initialize its members */
window->x = (int)otherBWin->Frame().left;
window->y = (int)otherBWin->Frame().top;
window->w = (int)otherBWin->Frame().Width();
window->h = (int)otherBWin->Frame().Height();
/* Set SDL flags */
if(!(otherBWin->Flags() & B_NOT_RESIZABLE)) {
window->flags |= SDL_WINDOW_RESIZABLE;
}
/* If we are out of memory, return the error code */
if(_InitWindow(_this, window) == ENOMEM)
return ENOMEM;
/* TODO: Add any other SDL-supported window attributes here */
_ToBeWin(window)->SetTitle(otherBWin->Title());
/* Start window loop and unlock the other window */
_ToBeWin(window)->Show();
otherBWin->UnlockLooper();
return 0;
}
void BE_SetWindowTitle(_THIS, SDL_Window * window) {
BMessage msg(BWIN_SET_TITLE);
msg.AddString("window-title", window->title);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon) {
/* FIXME: Icons not supported by BeOs/Haiku */
}
void BE_SetWindowPosition(_THIS, SDL_Window * window) {
BMessage msg(BWIN_MOVE_WINDOW);
msg.AddInt32("window-x", window->x);
msg.AddInt32("window-y", window->y);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_SetWindowSize(_THIS, SDL_Window * window) {
BMessage msg(BWIN_RESIZE_WINDOW);
msg.AddInt32("window-w", window->w - 1);
msg.AddInt32("window-h", window->h - 1);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_ShowWindow(_THIS, SDL_Window * window) {
BMessage msg(BWIN_SHOW_WINDOW);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_HideWindow(_THIS, SDL_Window * window) {
BMessage msg(BWIN_HIDE_WINDOW);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_RaiseWindow(_THIS, SDL_Window * window) {
BMessage msg(BWIN_SHOW_WINDOW); /* Activate this window and move to front */
_ToBeWin(window)->PostMessage(&msg);
}
void BE_MaximizeWindow(_THIS, SDL_Window * window) {
BMessage msg(BWIN_MAXIMIZE_WINDOW);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_MinimizeWindow(_THIS, SDL_Window * window) {
BMessage msg(BWIN_MINIMIZE_WINDOW);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_RestoreWindow(_THIS, SDL_Window * window) {
BMessage msg(BWIN_RESTORE_WINDOW);
_ToBeWin(window)->PostMessage(&msg);
}
void BE_SetWindowFullscreen(_THIS, SDL_Window * window,
SDL_VideoDisplay * display, SDL_bool fullscreen) {
/* Haiku tracks all video display information */
BMessage msg(BWIN_FULLSCREEN);
msg.AddBool("fullscreen", fullscreen);
_ToBeWin(window)->PostMessage(&msg);
}
int BE_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp) {
/* FIXME: Not BeOs/Haiku supported */
return -1;
}
int BE_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp) {
/* FIXME: Not BeOs/Haiku supported */
return -1;
}
void BE_SetWindowGrab(_THIS, SDL_Window * window) {
/* TODO: Implement this! */
}
void BE_DestroyWindow(_THIS, SDL_Window * window) {
_ToBeWin(window)->LockLooper(); /* This MUST be locked */
_GetBeApp()->ClearID(_ToBeWin(window));
_ToBeWin(window)->Quit();
window->driverdata = NULL;
}
SDL_bool BE_GetWindowWMInfo(_THIS, SDL_Window * window,
struct SDL_SysWMinfo *info) {
/* FIXME: What is the point of this? What information should be included? */
return SDL_FALSE;
}
#ifdef __cplusplus
}
#endif

52
src/video/bwindow/SDL_bwindow.h Normal file
View file

@ -0,0 +1,52 @@
/*
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.
*/
#ifndef SDL_BWINDOW_H
#define SDL_BWINDOW_H
#include "../SDL_sysvideo.h"
extern int BE_CreateWindow(_THIS, SDL_Window *window);
extern int BE_CreateWindowFrom(_THIS, SDL_Window * window, const void *data);
extern void BE_SetWindowTitle(_THIS, SDL_Window * window);
extern void BE_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon);
extern void BE_SetWindowPosition(_THIS, SDL_Window * window);
extern void BE_SetWindowSize(_THIS, SDL_Window * window);
extern void BE_ShowWindow(_THIS, SDL_Window * window);
extern void BE_HideWindow(_THIS, SDL_Window * window);
extern void BE_RaiseWindow(_THIS, SDL_Window * window);
extern void BE_MaximizeWindow(_THIS, SDL_Window * window);
extern void BE_MinimizeWindow(_THIS, SDL_Window * window);
extern void BE_RestoreWindow(_THIS, SDL_Window * window);
extern void BE_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
extern int BE_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp);
extern int BE_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp);
extern void BE_SetWindowGrab(_THIS, SDL_Window * window);
extern void BE_DestroyWindow(_THIS, SDL_Window * window);
extern SDL_bool BE_GetWindowWMInfo(_THIS, SDL_Window * window,
struct SDL_SysWMinfo *info);
#endif

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 */
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: */

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: */

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

@ -1,861 +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 {
if ((flags & SDL_RESIZABLE) && !(flags & 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_INTERNALOPENGL) {
current->flags |= 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: */

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: */