/*
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction, 
 * including without limitation the rights to use, copy, modify, 
 * merge, publish, distribute, sublicense, and/or sell copies of 
 * the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <Bitmap.h>
#include <MediaRoster.h>
#include <MessageRunner.h>
#include "VideoView.h"
#include "VideoNode.h"
#include "ConvertBitmap.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CHECK_ACTIVITY 'ChkA'

VideoView::VideoView(BRect frame, const char *name, uint32 resizeMask, 
	uint32 flags)
 :	BView(frame, name, resizeMask, flags)
 ,	fVideoNode(0)
 ,	fVideoActive(false)
 ,	fOverlayActive(false)
 ,	fActivityCheckMsgRunner(0)
 ,	fLastFrame(0)
{
	SetViewColor(B_TRANSPARENT_COLOR);

	status_t err = B_OK;
	BMediaRoster *mroster = BMediaRoster::Roster(&err);
	if (!mroster || err) {
		printf("VideoView::VideoView: media_server is dead\n");
		exit(1);
	} else {
		fVideoNode = new VideoNode("video in", this);
		err = mroster->RegisterNode(fVideoNode);
	}
}


VideoView::~VideoView()
{
	delete fActivityCheckMsgRunner;
	
	if (fVideoNode) {
		BMediaRoster::Roster()->UnregisterNode(fVideoNode);
		delete fVideoNode;
	}
}


void
VideoView::AttachedToWindow()
{
	BMessage msg(CHECK_ACTIVITY);
	fActivityCheckMsgRunner = new BMessageRunner(BMessenger(this), &msg, 
		200000);
}	


VideoNode *
VideoView::Node()
{
	return fVideoNode;
}


void
VideoView::OverlayLockAcquire()
{
   printf("VideoView::OverlayLockAcquire\n");
}


void
VideoView::OverlayLockRelease()
{ /* [19:54] <Francois> Rudolf forwarded me a mail once about it
   * [19:55] <Francois> when you get relmease msg you are supposed to 
   				UnlockBits() on the overlay bitmaps you use
   * [19:55] <Francois> it's used when switching workspaces
   * [19:55] <Francois> as the bits might get relocated
   */
   printf("VideoView::OverlayLockRelease\n");

}


void
VideoView::OverlayScreenshotPrepare()
{
	printf("OverlayScreenshotPrepare enter\n");
/*
	fVideoNode->LockBitmap();
	if (fOverlayActive) {
		BBitmap *bmp = fVideoNode->Bitmap();
		if (bmp) {
//			Window()->UpdateIfNeeded();
//			Sync();
			BBitmap *tmp = new BBitmap(bmp->Bounds(), 0, B_RGB32);
//			ConvertBitmap(tmp, bmp);
			ClearViewOverlay();
			DrawBitmap(tmp, Bounds());
			delete tmp;
//			Sync();
		}
	}
	fVideoNode->UnlockBitmap();
*/
	printf("OverlayScreenshotPrepare leave\n");
}


void
VideoView::OverlayScreenshotCleanup()
{
	printf("OverlayScreenshotCleanup enter\n");
/*
	snooze(50000); // give app server some time to take the screenshot
	fVideoNode->LockBitmap();
	if (fOverlayActive) {
		BBitmap *bmp = fVideoNode->Bitmap();
		if (bmp) {
			DrawBitmap(bmp, Bounds());
			SetViewOverlay(bmp, bmp->Bounds(), Bounds(), &fOverlayKeyColor,
				B_FOLLOW_ALL, B_OVERLAY_FILTER_HORIZONTAL 
				| B_OVERLAY_FILTER_VERTICAL);
			Invalidate();
		}
	}
	fVideoNode->UnlockBitmap();
*/
	printf("OverlayScreenshotCleanup leave\n");
}


void
VideoView::RemoveVideoDisplay()
{
	printf("VideoView::RemoveVideoDisplay\n");
	
	if (fOverlayActive) {
		ClearViewOverlay();
		fOverlayActive = false;
	}
	fVideoActive = false;
	Invalidate();
}


void
VideoView::RemoveOverlay()
{
	printf("VideoView::RemoveOverlay\n");
	if (LockLooperWithTimeout(50000) == B_OK) {
		ClearViewOverlay();
		fOverlayActive = false;
		UnlockLooper();
	}
}


void
VideoView::CheckActivity()
{
	if (!fVideoActive)
		return;
	if (system_time() - fLastFrame < 700000)
		return;

	printf("VideoView::CheckActivity: lag detected\n");

	fVideoActive = false;
	Invalidate();
}


void
VideoView::Draw(BRect updateRect)
{
	if (!fVideoActive) {
		DrawTestImage();
		return;
	}
	if (fOverlayActive) {
		SetHighColor(fOverlayKeyColor);
		FillRect(updateRect);
	} else {
		fVideoNode->LockBitmap();
		BBitmap *bmp = fVideoNode->Bitmap();
		if (bmp)
			DrawBitmap(bmp, bmp->Bounds(), Bounds(), B_FILTER_BITMAP_BILINEAR);
		fVideoNode->UnlockBitmap();
	}
}


void
VideoView::DrawFrame()
{
//	printf("VideoView::DrawFrame\n");
	if (!fVideoActive) {
		fVideoActive = true;
		if (LockLooperWithTimeout(50000) != B_OK)
			return;
		Invalidate();
		UnlockLooper();
	}
	fLastFrame = system_time();
	
	bool want_overlay = fVideoNode->IsOverlayActive();

	if (!want_overlay && fOverlayActive) {
		if (LockLooperWithTimeout(50000) == B_OK) {
			ClearViewOverlay();
			UnlockLooper();			
			fOverlayActive = false;
		} else {
			printf("can't ClearViewOverlay, as LockLooperWithTimeout "
				"failed\n");
		}
	}
	if (want_overlay && !fOverlayActive) {
		fVideoNode->LockBitmap();
		BBitmap *bmp = fVideoNode->Bitmap();
		if (bmp && LockLooperWithTimeout(50000) == B_OK) {
			SetViewOverlay(bmp, bmp->Bounds(), Bounds(), &fOverlayKeyColor,
				B_FOLLOW_ALL, B_OVERLAY_FILTER_HORIZONTAL 
				| B_OVERLAY_FILTER_VERTICAL);
			fOverlayActive = true;

			Invalidate();
			UnlockLooper();
		}
		fVideoNode->UnlockBitmap();
	}
	if (!fOverlayActive) {
		if (LockLooperWithTimeout(50000) != B_OK)
			return;
		Invalidate();
		UnlockLooper();
	}
}


void
VideoView::DrawTestImage()
{
	static const rgb_color cols[8] = { 
		{255,255,255}, {255,255,0}, {0,255,255}, {0,255,0},
		{255,0,255}, {255,0,0}, {0,0,255}, {0,0,0} 
//		{255,255,255}, {255,255,0}, {0,255,255}, 
//		{255,0,255}, {255,0,0}, {0,255,0}, {0,0,255}, {0,0,0} 
	};
	float bar_width;
	float left;
	float right;

	BRect bnd = Bounds();
	int seperator_y1 = int(0.60 * (bnd.Height() + 1));
	int seperator_y2 = int(0.80 * (bnd.Height() + 1));
	int steps;

	bar_width = bnd.Width() / 8;
	if (bar_width < 1)
		bar_width = 1;
	
	left = 0;
	for (int i = 0; i < 8; i++) {
		SetHighColor(cols[i]);
		right = (i != 7) ? left + bar_width - 1 : bnd.right;
		FillRect(BRect(left, 0, right, seperator_y1));
		left = right + 1;
	}
	
	steps = 32;
	
	bar_width = bnd.Width() / steps;
//	if (bar_width < 1)
//		bar_width = 1;

	left = 0;
	for (int i = 0; i < steps; i++) {
		uint8 c = i * 255 / (steps - 1);
		SetHighColor(c, c, c);
		right = (i != steps - 1) ? left + bar_width - 1 : bnd.right;
		FillRect(BRect(left, seperator_y1 + 1, right, seperator_y2));
		left = right + 1;
	}

	steps = 256;
	
	bar_width = bnd.Width() / steps;
	if (bar_width < 1)
		bar_width = 1;

	left = 0;
	for (int i = 0; i < steps; i++) {
		uint8 c = 255 - (i * 255 / (steps - 1));
		SetHighColor(c, c, c);
		right = (i != steps - 1) ? left + bar_width - 1 : bnd.right;
		FillRect(BRect(left, seperator_y2 + 1, right, bnd.bottom));
		left = right + 1;
	}
}


void
VideoView::MessageReceived(BMessage *msg)
{
	switch (msg->what) {
		case CHECK_ACTIVITY:
			CheckActivity();
			break;
		default:
			BView::MessageReceived(msg);
	}
}


bool
VideoView::IsOverlaySupported()
{
	struct colorcombo {
		color_space colspace;
		const char *name;
	} colspace[] = {
		{ B_RGB32,		"B_RGB32"},
		{ B_RGBA32,		"B_RGBA32"},
		{ B_RGB24,		"B_RGB24"},
		{ B_RGB16,		"B_RGB16"},
		{ B_RGB15,		"B_RGB15"},
		{ B_RGBA15,		"B_RGBA15"},
		{ B_RGB32_BIG,	"B_RGB32_BIG"},
		{ B_RGBA32_BIG,	"B_RGBA32_BIG "},
		{ B_RGB24_BIG,	"B_RGB24_BIG "},
		{ B_RGB16_BIG,	"B_RGB16_BIG "},
		{ B_RGB15_BIG,	"B_RGB15_BIG "},
		{ B_RGBA15_BIG, "B_RGBA15_BIG "},
		{ B_YCbCr422,	"B_YCbCr422"},
		{ B_YCbCr411,	"B_YCbCr411"},
		{ B_YCbCr444,	"B_YCbCr444"},
		{ B_YCbCr420,	"B_YCbCr420"},
		{ B_YUV422,		"B_YUV422"},
		{ B_YUV411,		"B_YUV411"},
		{ B_YUV444,		"B_YUV444"},
		{ B_YUV420,		"B_YUV420"},
		{ B_NO_COLOR_SPACE, NULL}
	};
	
	bool supported = false;
	for (int i = 0; colspace[i].name; i++) {
		BBitmap *test = new BBitmap(BRect(0,0,320,240),	B_BITMAP_WILL_OVERLAY 
			| B_BITMAP_RESERVE_OVERLAY_CHANNEL, colspace[i].colspace);
		if (test->InitCheck() == B_OK) {
			printf("Display supports %s (0x%08x) overlay\n", colspace[i].name, 
				colspace[i].colspace);
			overlay_restrictions restrict;
			if (B_OK == test->GetOverlayRestrictions(&restrict)) {
				printf(
					"Overlay restrictions: source horizontal_alignment %d\n", 
					restrict.source.horizontal_alignment);
				printf("Overlay restrictions: source vertical_alignment %d\n", 
					restrict.source.vertical_alignment);
				printf("Overlay restrictions: source width_alignment %d\n", 
					restrict.source.width_alignment);
				printf("Overlay restrictions: source height_alignment %d\n", 
					restrict.source.height_alignment);
				printf("Overlay restrictions: source min_width %d\n", 
					restrict.source.min_width);
				printf("Overlay restrictions: source max_width %d\n", 
					restrict.source.max_width);
				printf("Overlay restrictions: source min_height %d\n", 
					restrict.source.min_height);
				printf("Overlay restrictions: source max_height %d\n", 
					restrict.source.max_height);
				printf(
					"Overlay restrictions: destination horizontal_alignment "
					"%d\n", restrict.destination.horizontal_alignment);
				printf("Overlay restrictions: destination vertical_alignment "
					"%d\n", restrict.destination.vertical_alignment);
				printf("Overlay restrictions: destination width_alignment "
					"%d\n", restrict.destination.width_alignment);
				printf("Overlay restrictions: destination height_alignment "
					"%d\n", restrict.destination.height_alignment);
				printf("Overlay restrictions: destination min_width %d\n", 
					restrict.destination.min_width);
				printf("Overlay restrictions: destination max_width %d\n", 
					restrict.destination.max_width);
				printf("Overlay restrictions: destination min_height %d\n", 
					restrict.destination.min_height);
				printf("Overlay restrictions: destination max_height %d\n", 
					restrict.destination.max_height);
				printf("Overlay restrictions: min_width_scale %.3f\n", 
					restrict.min_width_scale);
				printf("Overlay restrictions: max_width_scale %.3f\n", 
					restrict.max_width_scale);
				printf("Overlay restrictions: min_height_scale %.3f\n", 
					restrict.min_height_scale);
				printf("Overlay restrictions: max_height_scale %.3f\n", 
					restrict.max_height_scale);
			}
			supported = true;
		}
		delete test;
//		if (supported)
//			break;
	}
	return supported;
}