xref: /haiku/src/servers/app/drawing/Overlay.cpp (revision a81f65eae5f9a0577ae33a0293c3a04acf36aa6d)

/*
 * Copyright 2006-2009, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 */


#include "Overlay.h"

#include <BitmapPrivate.h>

#include "HWInterface.h"
#include "ServerBitmap.h"


//#define TRACE_OVERLAY
#ifdef TRACE_OVERLAY
#	define TRACE(x...) ktrace_printf(x);
#else
#	define TRACE(x...) ;
#endif


const static bigtime_t kOverlayTimeout = 1000000LL;
	// after 1 second, the team holding the lock will be killed

class SemaphoreLocker {
public:
	SemaphoreLocker(sem_id semaphore, bigtime_t timeout = B_INFINITE_TIMEOUT)
		:
		fSemaphore(semaphore)
	{
		do {
			fStatus = acquire_sem_etc(fSemaphore, 1, B_RELATIVE_TIMEOUT,
				timeout);
		} while (fStatus == B_INTERRUPTED);
	}

	~SemaphoreLocker()
	{
		if (fStatus == B_OK)
			release_sem_etc(fSemaphore, 1, B_DO_NOT_RESCHEDULE);
	}

	status_t LockStatus()
	{
		return fStatus;
	}

private:
	sem_id		fSemaphore;
	status_t	fStatus;
};


//	#pragma mark -


Overlay::Overlay(HWInterface& interface, ServerBitmap* bitmap,
		overlay_token token)
	:
	fHWInterface(interface),
	fOverlayBuffer(NULL),
	fClientData(NULL),
	fOverlayToken(token)
{
	fSemaphore = create_sem(1, "overlay lock");
	fColor = (rgb_color){ 0, 80, 0, 0 };
		// TODO: whatever fine color we want to use here...

	fWindow.offset_top = 0;
	fWindow.offset_left = 0;
	fWindow.offset_right = 0;
	fWindow.offset_bottom = 0;

	fWindow.flags = B_OVERLAY_COLOR_KEY;

	_AllocateBuffer(bitmap);

	TRACE("overlay: created %p, bitmap %p\n", this, bitmap);
}


Overlay::~Overlay()
{
	fHWInterface.ReleaseOverlayChannel(fOverlayToken);
	_FreeBuffer();

	delete_sem(fSemaphore);
	TRACE("overlay: deleted %p\n", this);
}


status_t
Overlay::InitCheck() const
{
	if (fSemaphore < B_OK)
		return fSemaphore;

	if (fOverlayBuffer == NULL)
		return B_NO_MEMORY;

	return B_OK;
}


status_t
Overlay::Resume(ServerBitmap* bitmap)
{
	SemaphoreLocker locker(fSemaphore, kOverlayTimeout);
	if (locker.LockStatus() == B_TIMED_OUT) {
		// TODO: kill app!
	}

	TRACE("overlay: resume %p (lock status %ld)\n", this, locker.LockStatus());

	status_t status = _AllocateBuffer(bitmap);
	if (status < B_OK)
		return status;

	fClientData->buffer = (uint8*)fOverlayBuffer->buffer;
	return B_OK;
}


status_t
Overlay::Suspend(ServerBitmap* bitmap, bool needTemporary)
{
	SemaphoreLocker locker(fSemaphore, kOverlayTimeout);
	if (locker.LockStatus() == B_TIMED_OUT) {
		// TODO: kill app!
	}

	TRACE("overlay: suspend %p (lock status %ld)\n", this, locker.LockStatus());

	_FreeBuffer();
	fClientData->buffer = NULL;

	return B_OK;
}


void
Overlay::_FreeBuffer()
{
	fHWInterface.FreeOverlayBuffer(fOverlayBuffer);
	fOverlayBuffer = NULL;
}


status_t
Overlay::_AllocateBuffer(ServerBitmap* bitmap)
{
	fOverlayBuffer = fHWInterface.AllocateOverlayBuffer(bitmap->Width(),
		bitmap->Height(), bitmap->ColorSpace());
	if (fOverlayBuffer == NULL)
		return B_NO_MEMORY;

	return B_OK;
}


void
Overlay::SetClientData(overlay_client_data* clientData)
{
	fClientData = clientData;
	fClientData->lock = fSemaphore;
	fClientData->buffer = (uint8*)fOverlayBuffer->buffer;
}


void
Overlay::SetFlags(uint32 flags)
{
	if (flags & B_OVERLAY_FILTER_HORIZONTAL)
		fWindow.flags |= B_OVERLAY_HORIZONTAL_FILTERING;
	if (flags & B_OVERLAY_FILTER_VERTICAL)
		fWindow.flags |= B_OVERLAY_VERTICAL_FILTERING;
	if (flags & B_OVERLAY_MIRROR)
		fWindow.flags |= B_OVERLAY_HORIZONTAL_MIRRORING;
}


void
Overlay::TakeOverToken(Overlay* other)
{
	overlay_token token = other->OverlayToken();
	if (token == NULL)
		return;

	fOverlayToken = token;
	//other->fOverlayToken = NULL;
}


const overlay_buffer*
Overlay::OverlayBuffer() const
{
	return fOverlayBuffer;
}


overlay_client_data*
Overlay::ClientData() const
{
	return fClientData;
}


overlay_token
Overlay::OverlayToken() const
{
	return fOverlayToken;
}


void
Overlay::Hide()
{
	if (fOverlayToken == NULL)
		return;

	fHWInterface.HideOverlay(this);
	TRACE("overlay: hide %p\n", this);
}


void
Overlay::SetColorSpace(uint32 colorSpace)
{
	if ((fWindow.flags & B_OVERLAY_COLOR_KEY) == 0)
		return;

	uint8 colorShift = 0, greenShift = 0, alphaShift = 0;
	rgb_color colorKey = fColor;

	switch (colorSpace) {
		case B_RGB15:
			greenShift = colorShift = 3;
			alphaShift = 7;
			break;
		case B_RGB16:
			colorShift = 3;
			greenShift = 2;
			alphaShift = 8;
			break;
	}

	fWindow.red.value = colorKey.red >> colorShift;
	fWindow.green.value = colorKey.green >> greenShift;
	fWindow.blue.value = colorKey.blue >> colorShift;
	fWindow.alpha.value = colorKey.alpha >> alphaShift;
	fWindow.red.mask = 0xff >> colorShift;
	fWindow.green.mask = 0xff >> greenShift;
	fWindow.blue.mask = 0xff >> colorShift;
	fWindow.alpha.mask = 0xff >> alphaShift;
}


void
Overlay::Configure(const BRect& source, const BRect& destination)
{
	if (fOverlayToken == NULL) {
		fOverlayToken = fHWInterface.AcquireOverlayChannel();
		if (fOverlayToken == NULL)
			return;
	}

	TRACE("overlay: configure %p\n", this);

	fView.h_start = (uint16)source.left;
	fView.v_start = (uint16)source.top;
	fView.width = (uint16)source.IntegerWidth() + 1;
	fView.height = (uint16)source.IntegerHeight() + 1;

	fWindow.h_start = (int16)destination.left;
	fWindow.v_start = (int16)destination.top;
	fWindow.width = (uint16)destination.IntegerWidth() + 1;
	fWindow.height = (uint16)destination.IntegerHeight() + 1;

	fHWInterface.ConfigureOverlay(this);
}