/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2004 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org
*/

#ifdef SAVE_RCSID
static char rcsid =
 "@(#) $Id$";
#endif

/* This is the BeOS version of SDL YUV video overlays */

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

#include "SDL_error.h"
#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*)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*)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*)calloc(overlay->planes, sizeof(Uint16));
	overlay->pixels  = (Uint8**)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* dstrect)
{
    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+dstrect->x,top+dstrect->y);
    } else {
	    bview->MoveTo(dstrect->x,dstrect->y);
    }
    bview->ResizeTo(dstrect->w,dstrect->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;

    free(overlay->hwdata);
}

}; // extern "C"