/*
 * DrawYUV.cpp
 *
 * Draw YUV420P raw
 *
 * DirectDraw YUV420P project
 *
 * Copyright (c) 2004-2005 for Cyansoft Studio.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Log: DrawYUV.cpp,v $
 * Revision 1.2  2005/01/18 12:44:23  jin.bai
 * Remove rectOverlay
 *
 * Revision 1.1  2005/01/17 13:43:00  jin.bai
 * Initial revision
 *
 *
 */
#include <windows.h>
#include <ddraw.h>

#include "DisplayWindow.h"
#include "Convert.h"
#include "DrawYUV.h"

/*
 * Overlay Destination ColorKey
 */
#define DD_OVERLAY_COLORKEY_16BPP      0x00000001 // 16 bpp only
#define DD_OVERLAY_COLORKEY_32BPP      0x0000000F // 24 & 32 bpp
#define DD_OVERLAY_COLORREF            0x000F0000 // 32, 24, and 16 bpp

#define  SOURCE_BIT_COUNT       12
#define  SOURCE_COLOR_SPACE     mmioFOURCC ('I', '4', '2', '0')  // YUV420P or I420 or IYUV

#define SAFE_RELEASE(x) {if(x){ x->Release(); x = NULL;}}

//
// Dll Entry
//
BOOL APIENTRY DllMain(HANDLE hMoudle, DWORD dwReason, LPVOID lpReserved)
{
	switch (dwReason)
	{
	case DLL_PROCESS_ATTACH:		
		break;
		
	case DLL_PROCESS_DETACH:		
		break;
		
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	default: break;
	}
	
	return TRUE;
}

DRAWYUV_API BOOL DrawYUVCreate(LPVOID *ppControl, LPCTSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent/* = NULL */, BOOL fOverlay/* = FALSE */)
{
	if (!ppControl)
	{
		return FALSE;
	}	
	
	DrawYUV *pDrawYUV = new DrawYUV;
	if (pDrawYUV)
	{
		if (pDrawYUV->Create(lpszWindowName, dwStyle, x, y, nWidth, nHeight, hwndParent, fOverlay))
		{
			(*ppControl) = pDrawYUV;
			
			return TRUE;
		}
	}
	
	return FALSE;
}

DRAWYUV_API BOOL DrawYUVSetWindowPos(LPVOID pControl, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags)
{
	if (pControl)
	{		
		return ((DrawYUV *) pControl)->SetWindowPos(hWndInsertAfter, x, y, cx, cy, uFlags);
	}
	
	return FALSE;
}

DRAWYUV_API BOOL DrawYUVDraw(LPVOID pControl, LPBYTE lpBuffer, DWORD dwSize)
{
	if (pControl)
	{
		return ((DrawYUV *) pControl)->Draw(lpBuffer, dwSize);
	}
	
	return FALSE;
}

DRAWYUV_API BOOL DrawYUVShowWindow(LPVOID pControl, int nCmdShow)
{
	if (pControl)
	{
		return ((DrawYUV *) pControl)->ShowWindow(nCmdShow);
	}
	
	return FALSE;
}

DRAWYUV_API BOOL DrawYUVClose(LPVOID pControl)
{
	if (pControl)
	{
		BOOL bRtn = ((DrawYUV *) pControl)->Close();
		delete pControl;
		pControl = NULL;
		
		return bRtn;
	}
	
	return FALSE;
}

DRAWYUV_API BOOL DrawYUVIsClose(LPVOID pControl)
{
	if (pControl)
	{
		return ((DrawYUV *) pControl)->IsClose();
	}
	
	return FALSE;
}

//
// DrawYUV class
//
DrawYUV::DrawYUV() : m_pConverter (NULL), m_pDisplayWindow (NULL),
m_lpDD (NULL), m_lpDDSPrimary (NULL), m_lpDDClipper (NULL),
m_lpDDSBack (NULL), m_lpDDSOverlay (NULL), m_bClosed (FALSE), m_bIsOverlay (FALSE)
{

}

DrawYUV::~DrawYUV()
{
	this->Close();
}

BOOL DrawYUV::Create(LPCTSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent /* = NULL */, BOOL fOverlay /* = FALSE */)
{
	DDSURFACEDESC ddsd;	
    DDPIXELFORMAT ddPixelFormat;// Pixel format description for the overlay surface 
    HRESULT ddrval;
	BOOL bSuccess = FALSE;
	BOOL bRtn = FALSE;
	VIDEO_FORMAT_T vfSource;
	VIDEO_FORMAT_T vfDest;

	// 
	do
	{
		/*************************/
		/* Initialise DirectDraw */
		/*************************/
		ddrval = DirectDrawCreate(NULL, &m_lpDD, NULL);
		if(ddrval != DD_OK) break;

		if (fOverlay)
		{
			if (!this->AreOverlaysSupported()) break;
		}		

		ddrval = IDirectDraw_SetCooperativeLevel(m_lpDD, NULL, DDSCL_NORMAL);
		if(ddrval != DD_OK) break;
		
		/******************************/
		/* Create the primary surface */
		/******************************/
		ddsd.dwSize = sizeof(ddsd);
		ddsd.dwFlags = DDSD_CAPS;
		ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
		
		ddrval = IDirectDraw_CreateSurface(m_lpDD, &ddsd, &m_lpDDSPrimary, NULL);		
		if( ddrval != DD_OK ) break;
		
		if (fOverlay)
		{
			/******************************/
			/* Create the overlay surface */
			/******************************/
			ddPixelFormat.dwSize = sizeof(ddPixelFormat);
			ddPixelFormat.dwFlags = DDPF_FOURCC;
			ddPixelFormat.dwFourCC = SOURCE_COLOR_SPACE;
			ddPixelFormat.dwYUVBitCount = SOURCE_BIT_COUNT;
			
			ddsd.dwSize = sizeof(ddsd);
			ddsd.dwFlags = DDSD_CAPS |
				           DDSD_HEIGHT |
				           DDSD_WIDTH |
				           DDSD_PIXELFORMAT;
			ddsd.ddsCaps.dwCaps = DDSCAPS_OVERLAY;
			ddsd.dwHeight = nHeight;
			ddsd.dwWidth = nWidth;
			
			memcpy(&(ddsd.ddpfPixelFormat), &ddPixelFormat, sizeof(DDPIXELFORMAT));
			
			ddrval = IDirectDraw_CreateSurface(m_lpDD, &ddsd, &m_lpDDSOverlay, NULL);
			
			if( ddrval != DD_OK )
			{
				ddPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
				ddPixelFormat.dwFlags = DDPF_FOURCC;
				ddPixelFormat.dwFourCC = mmioFOURCC('Y','U','Y','2');
				ddPixelFormat.dwYUVBitCount = 16;
				
				ddsd.dwSize = sizeof(DDSURFACEDESC);
				ddsd.dwFlags = DDSD_CAPS |
					           DDSD_HEIGHT |
					           DDSD_WIDTH |
					           DDSD_PIXELFORMAT;
				ddsd.ddsCaps.dwCaps = DDSCAPS_OVERLAY;
				ddsd.dwHeight = nHeight;
				ddsd.dwWidth = nWidth;
				
				memcpy(&(ddsd.ddpfPixelFormat), &ddPixelFormat, sizeof(DDPIXELFORMAT));
				
				ddrval = IDirectDraw_CreateSurface(m_lpDD, &ddsd, &m_lpDDSOverlay, NULL);
				if( ddrval != DD_OK ) break;
				
				m_bIsOverlay = TRUE;
				m_dwBitCount  = 16;

				// Create a converter
				vfSource.vfWidth = vfDest.vfWidth = nWidth;
				vfSource.vfHeight = vfDest.vfHeight = nHeight;
				vfSource.vfBitCount = SOURCE_BIT_COUNT;
				vfSource.vfFourCC = SOURCE_COLOR_SPACE;
				vfDest.vfBitCount = 16;
				vfDest.vfFourCC = mmioFOURCC('Y','U','Y','2');

				m_pConverter = new Converter;
				if (!m_pConverter) break;

				if (!m_pConverter->Create(&vfSource, &vfDest)) break;					
			}
			else
			{
				m_bIsOverlay = TRUE;
				m_dwBitCount  = SOURCE_BIT_COUNT;
			}
		}
		else
		{
			/******************************/
			/* Create the back surface    */
			/******************************/
			ZeroMemory(&ddsd, sizeof(ddsd));
			ddsd.dwSize     = sizeof(ddsd);
			
			ddsd.dwFlags        = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
			ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
			
			ddsd.dwWidth  = nWidth;
			ddsd.dwHeight = nHeight;

			ddrval = IDirectDraw_CreateSurface(m_lpDD, &ddsd, &m_lpDDSBack, NULL);
			if( ddrval != DD_OK ) break;

			/*
			 * Now get the Physical Depth
			 */
			ZeroMemory(&ddsd, sizeof(ddsd));
			ddsd.dwSize     = sizeof(ddsd);

			ddrval = m_lpDDSPrimary->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WRITEONLY | DDLOCK_WAIT, NULL);
			if (ddrval != DD_OK) break;

			m_lpDDSPrimary->Unlock(NULL);
			
			switch (ddsd.ddpfPixelFormat.dwRGBBitCount)
			{
			case 16:
				if ((ddsd.ddpfPixelFormat.dwRBitMask & 0xf800) && // 1111 1000 0000 0000b
					(ddsd.ddpfPixelFormat.dwGBitMask & 0x07e0) && // 0000 0111 1110 0000b
					(ddsd.ddpfPixelFormat.dwBBitMask & 0x001f))   // 0000 0000 0001 1111b
				{
					vfDest.vfBitCount = 16; // RGB565
				}
				else if ((ddsd.ddpfPixelFormat.dwRBitMask & 0x7c00) && // 0111 1100 0000 0000b
						(ddsd.ddpfPixelFormat.dwGBitMask & 0x03e0) &&  // 0000 0011 1110 0000b
						(ddsd.ddpfPixelFormat.dwBBitMask & 0x001f))    // 0000 0000 0001 1111b
				{
					vfDest.vfBitCount = 15; // RGB555
				}
				
				break;

			case 24:
				vfDest.vfBitCount = 24;
				break;

			case 32: