/*
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, korli@users.berlios.de
* Philippe Houdoin, philippe.houdoin@free.fr
* Artur Wyszynski, harakash@gmail.com
* Alexander von Gluck IV, kallisti5@unixzen.com
*/
#include "SoftwareRenderer.h"
#include <Autolock.h>
#include <interface/DirectWindowPrivate.h>
#include <GraphicsDefs.h>
#include <Screen.h>
#include <stdio.h>
#include <sys/time.h>
#include <new>
#ifdef DEBUG
# define TRACE(x...) printf("SoftwareRenderer: " x)
# define CALLED() TRACE("CALLED: %s\n", __PRETTY_FUNCTION__)
#else
# define TRACE(x...)
# define CALLED()
#endif
#define ERROR(x...) printf("SoftwareRenderer: " x)
extern const char* color_space_name(color_space space);
extern "C" _EXPORT BGLRenderer*
instantiate_gl_renderer(BGLView *view, ulong opts, BGLDispatcher *dispatcher)
{
return new SoftwareRenderer(view, opts, dispatcher);
}
SoftwareRenderer::SoftwareRenderer(BGLView *view, ulong options,
BGLDispatcher* dispatcher)
:
BGLRenderer(view, options, dispatcher),
fBitmap(NULL),
fDirectModeEnabled(false),
fInfo(NULL),
fInfoLocker("info locker"),
fOptions(options),
fColorSpace(B_NO_COLOR_SPACE)
{
CALLED();
// Disable double buffer for the moment.
//options &= ~BGL_DOUBLE;
// Initialize the "Haiku Software GL Pipe"
time_t beg;
time_t end;
beg = time(NULL);
fContextObj = new GalliumContext(options);
end = time(NULL);
TRACE("Haiku Software GL Pipe initialization time: %f.\n",
difftime(end, beg));
// Allocate a bitmap
BRect b = view->Bounds();
fColorSpace = BScreen(view->Window()).ColorSpace();
TRACE("%s: Colorspace:\t%s\n", __func__, color_space_name(fColorSpace));
fWidth = (GLint)b.IntegerWidth();
fHeight = (GLint)b.IntegerHeight();
_AllocateBitmap();
// Initialize the first "Haiku Software GL Pipe" context
beg = time(NULL);
fContextID = fContextObj->CreateContext(fBitmap);
end = time(NULL);
if (fContextID < 0)
ERROR("%s: There was an error creating the context!\n", __func__);
else {
TRACE("%s: Haiku Software GL Pipe context creation time: %f.\n",
__func__, difftime(end, beg));
}
if (!fContextObj->GetCurrentContext())
LockGL();
}
SoftwareRenderer::~SoftwareRenderer()
{
CALLED();
if (fContextObj)
delete fContextObj;
if (fBitmap)
delete fBitmap;
}
void
SoftwareRenderer::LockGL()
{
// CALLED();
BGLRenderer::LockGL();
color_space cs = BScreen(GLView()->Window()).ColorSpace();
BAutolock lock(fInfoLocker);
if (fDirectModeEnabled && fInfo != NULL) {
fWidth = fInfo->window_bounds.right - fInfo->window_bounds.left;
fHeight = fInfo->window_bounds.bottom - fInfo->window_bounds.top;
}
if (fBitmap && cs == fColorSpace && fContextObj->Validate(fWidth, fHeight)) {
fContextObj->SetCurrentContext(fBitmap, fContextID);
return;
}
fColorSpace = cs;
_AllocateBitmap();
fContextObj->SetCurrentContext(fBitmap, fContextID);
}
void
SoftwareRenderer::UnlockGL()
{
// CALLED();
if ((fOptions & BGL_DOUBLE) == 0) {
SwapBuffers();
}
fContextObj->SetCurrentContext(NULL, fContextID);
BGLRenderer::UnlockGL();
}
void
SoftwareRenderer::SwapBuffers(bool vsync)
{
// CALLED();
if (!fBitmap)
return;
BScreen screen(GLView()->Window());
fContextObj->SwapBuffers(fContextID);
BAutolock lock(fInfoLocker);
if (!fDirectModeEnabled || fInfo == NULL) {
if (GLView()->LockLooperWithTimeout(1000) == B_OK) {
GLView()->DrawBitmap(fBitmap, B_ORIGIN);
GLView()->UnlockLooper();
if (vsync)
screen.WaitForRetrace();
}
return;
}
// check the bitmap size still matches the size
if (fInfo->window_bounds.bottom - fInfo->window_bounds.top
!= fBitmap->Bounds().IntegerHeight()
|| fInfo->window_bounds.right - fInfo->window_bounds.left
!= fBitmap->Bounds().IntegerWidth()) {
ERROR("%s: Bitmap size doesn't match size!\n", __func__);
return;
}
uint32 bytesPerRow = fBitmap->BytesPerRow();
uint8 bytesPerPixel = bytesPerRow / fBitmap->Bounds().IntegerWidth();
for (uint32 i = 0; i < fInfo->clip_list_count; i++) {
clipping_rect *clip = &fInfo->clip_list[i];
int32 height = clip->bottom - clip->top + 1;
int32 bytesWidth
= (clip->right - clip->left + 1) * bytesPerPixel;
bytesWidth -= bytesPerPixel;
uint8 *p = (uint8 *)fInfo->bits + clip->top
* fInfo->bytes_per_row + clip->left * bytesPerPixel;
uint8 *b = (uint8 *)fBitmap->Bits()
+ (clip->top - fInfo->window_bounds.top) * bytesPerRow
+ (clip->left - fInfo->window_bounds.left) * bytesPerPixel;
for (int y = 0; y < height - 1; y++) {
memcpy(p, b, bytesWidth);
p += fInfo->bytes_per_row;
b += bytesPerRow;
}
}
if (vsync)
screen.WaitForRetrace();
}
void
SoftwareRenderer::Draw(BRect updateRect)
{
// CALLED();
if ((!fDirectModeEnabled || fInfo == NULL) && fBitmap)
GLView()->DrawBitmap(fBitmap, updateRect, updateRect);
}
status_t
SoftwareRenderer::CopyPixelsOut(BPoint location, BBitmap *bitmap)
{
CALLED();
color_space scs = fBitmap->ColorSpace();
color_space dcs = bitmap->ColorSpace();
if (scs != dcs && (scs != B_RGBA32 || dcs != B_RGB32)) {
ERROR("%s::CopyPixelsOut(): incompatible color space: %s != %s\n",
__PRETTY_FUNCTION__, color_space_name(scs), color_space_name(dcs));
return B_BAD_TYPE;
}
BRect sr = fBitmap->Bounds();
BRect dr = bitmap->Bounds();
// int32 w1 = sr.IntegerWidth();
// int32 h1 = sr.IntegerHeight();
// int32 w2 = dr.IntegerWidth();
// int32 h2 = dr.IntegerHeight();
sr = sr & dr.OffsetBySelf(location);
dr = sr.OffsetByCopy(-location.x, -location.y);
uint8 *ps = (uint8 *) fBitmap->Bits();
uint8 *pd = (uint8 *) bitmap->Bits();
uint32 *s, *d;
uint32 y;
for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
s = (uint32 *)(ps + y * fBitmap->BytesPerRow());
s += (uint32) sr.left;
d = (uint32 *)(pd + (y + (uint32)(dr.top - sr.top))
* bitmap->BytesPerRow());
d += (uint32) dr.left;
memcpy(d, s, dr.IntegerWidth() * 4);
}
return B_OK;
}
status_t
SoftwareRenderer::CopyPixelsIn(BBitmap *bitmap, BPoint location)
{
CALLED();
color_space sourceCS = bitmap->ColorSpace();
color_space destinationCS = fBitmap->ColorSpace();
if (sourceCS != destinationCS
&& (sourceCS != B_RGB32 || destinationCS != B_RGBA32)) {
ERROR("%s::CopyPixelsIn(): incompatible color space: %s != %s\n",
__PRETTY_FUNCTION__, color_space_name(sourceCS),
color_space_name(destinationCS));
return B_BAD_TYPE;
}
BRect sr = bitmap->Bounds();
BRect dr = fBitmap->Bounds();
sr = sr & dr.OffsetBySelf(location);
dr = sr.OffsetByCopy(-location.x, -location.y);
uint8 *ps = (uint8 *) bitmap->Bits();
uint8 *pd = (uint8 *) fBitmap->Bits();
uint32 *s, *d;
uint32 y;
for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
s = (uint32 *)(ps + y * bitmap->BytesPerRow());
s += (uint32) sr.left;
d = (uint32 *)(pd + (y + (uint32)(dr.top - sr.top))
* fBitmap->BytesPerRow());
d += (uint32) dr.left;
memcpy(d, s, dr.IntegerWidth() * 4);
}
return B_OK;
}
void
SoftwareRenderer::EnableDirectMode(bool enabled)
{
fDirectModeEnabled = enabled;
}
void
SoftwareRenderer::DirectConnected(direct_buffer_info *info)
{
// CALLED();
BAutolock lock(fInfoLocker);
if (info) {
if (!fInfo) {
fInfo = (direct_buffer_info *)calloc(1,
DIRECT_BUFFER_INFO_AREA_SIZE);
}
memcpy(fInfo, info, DIRECT_BUFFER_INFO_AREA_SIZE);
} else if (fInfo) {
free(fInfo);
fInfo = NULL;
}
}
void
SoftwareRenderer::FrameResized(float width, float height)
{
TRACE("%s: %f x %f\n", __func__, width, height);
BAutolock lock(fInfoLocker);
fWidth = (GLuint)width;
fHeight = (GLuint)height;
}
void
SoftwareRenderer::_AllocateBitmap()
{
// CALLED();
// allocate new size of back buffer bitmap
BAutolock lock(fInfoLocker);
if (fBitmap)
delete fBitmap;
if (fWidth < 1 || fHeight < 1) {
TRACE("%s: Can't allocate bitmap of %dx%d\n", __func__,
fWidth, fHeight);
return;
}
BRect rect(0.0, 0.0, fWidth, fHeight);
fBitmap = new (std::nothrow) BBitmap(rect, fColorSpace);
if (fBitmap == NULL) {
TRACE("%s: Can't create bitmap!\n", __func__);
return;
}
TRACE("%s: New bitmap size: %" B_PRId32 " x %" B_PRId32 "\n", __func__,
fBitmap->Bounds().IntegerWidth(), fBitmap->Bounds().IntegerHeight());
#if 0
// debug..
void *data = fBitmap->Bits();
memset(data, 0xcc, fBitmap->BitsLength());
#endif
}