// UUCore.cpp: implementation of the CUUCoreUtil class.
//
//////////////////////////////////////////////////////////////////////


#include "stdafx.h"
#define INITGUID
#include <Guiddef.h>
#include <Windows.h>
#include "UUCoreApi.h"
#include "UUCoreUtil.h"

// To use export dll, uncomment following line.
//#define USING_EXPORT_DLL
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#if defined( USING_EXPORT_DLL )
BOOL (FAR WINAPI*_UucGetVersion)(ULONG* pVersion);
HANDLE (FAR WINAPI*_UucOpenCodec)(ULONG  codecId, BOOL bEncoder);
BOOL (FAR WINAPI*_UucCloseCodec)(HANDLE hCodec);
BOOL (FAR WINAPI*_UucSetParam)(HANDLE hCodec, CodecProperty CodecProp);
BOOL (FAR WINAPI*_UucEncodeAudio)(HANDLE hCodec, BYTE* pEncodedBuf, int nEncodedBufSize, int* pEncodedSize, short* pPcmData);
BOOL (FAR WINAPI*_UucDecodeAudio)(HANDLE hCodec, short* pDecodedBuf, int* pDecodedFrameSize, int* pDecodedSize, BYTE* pEncodedBuf, int nEncodedSize);
BOOL (FAR WINAPI*_UucDecodeVideo)(HANDLE hCodec, DecodedVideo* pDecodedBuf, int* pDecodedSize, BYTE* pEncodedBuf, int nEncodedSize, BOOL bDeinterlaced);
BOOL (FAR WINAPI*_UucFlushBuffer)(HANDLE hCodec);
BOOL (FAR WINAPI*_UucDeinterlace)(HANDLE hCodec, DecodedVideo* pDecodedBuf, BOOL bDeinterlace);
#endif

static BOOL CreateInstance(HMODULE hLib,REFIID riid,void ** ppInterface)
{
	if(hLib){

		BOOL rs;
		IUnknown* pUnknown;
		BOOL (FAR WINAPI*_CreateInstance)(IUnknown ** ppInterface);
		FARPROC test_proc=GetProcAddress(hLib,"UucCreateInstance");
		if(test_proc){
			*(FARPROC*)&_CreateInstance=test_proc;
			rs=(*_CreateInstance)(&pUnknown);
			if(rs){
				HRESULT hr;
				hr=pUnknown->QueryInterface(riid,ppInterface);
				pUnknown->Release();
				if(SUCCEEDED(hr))
					return TRUE;
			}
		}
	}

	return FALSE;
}


CUUCoreUtil::CUUCoreUtil()
{
	m_pUucore = NULL;
	m_hCodec  = NULL;

	// do not handle multiple loading of dll for the sake of easy implementation.
	m_hLib=NULL;
	m_hLib=LoadLibrary("uucore");
	if(!m_hLib) {
		return;
	}

#if defined( USING_EXPORT_DLL )
	FARPROC test_proc;
	test_proc=GetProcAddress(m_hLib,"UucGetVersion");
	if(test_proc) *(FARPROC*)&_UucGetVersion=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucOpenCodec");
	if(test_proc) *(FARPROC*)&_UucOpenCodec=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucCloseCodec");
	if(test_proc) *(FARPROC*)&_UucCloseCodec=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucSetParam");
	if(test_proc) *(FARPROC*)&_UucSetParam=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucEncodeAudio");
	if(test_proc) *(FARPROC*)&_UucEncodeAudio=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucDecodeAudio");
	if(test_proc) *(FARPROC*)&_UucDecodeAudio=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucDecodeVideo");
	if(test_proc) *(FARPROC*)&_UucDecodeVideo=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucFlushBuffer");
	if(test_proc) *(FARPROC*)&_UucFlushBuffer=test_proc;
	test_proc=GetProcAddress(m_hLib,"UucDeinterlace");
	if(test_proc) *(FARPROC*)&_UucDeinterlace=test_proc;
#else	
	if (!CreateInstance(m_hLib, IID_IUucore, (void**)&m_pUucore)) {
		return;
	}
#endif
}

CUUCoreUtil::~CUUCoreUtil()
{
#if !defined( USING_EXPORT_DLL )
	m_pUucore->Release();
#endif
	if (m_hLib) {
		FreeLibrary(m_hLib);
	}
}

#if defined( USING_EXPORT_DLL )
	#define UUCAPI(name) _##name
#else
	#define UUCAPI(name) m_pUucore->##name
#endif

#if !defined( USING_EXPORT_DLL )
	#define CHECK_INSTANCE \
		if (!m_pUucore) { \
			return FALSE; \
		}
#else
	#define CHECK_INSTANCE
#endif

BOOL CUUCoreUtil::GetVersion(ULONG pVersion[4])
{
	CHECK_INSTANCE
	return UUCAPI(UucGetVersion(pVersion));
}

BOOL CUUCoreUtil::OpenCodec(ULONG uCodec, BOOL bEncoder)
{
	CHECK_INSTANCE
	m_hCodec = UUCAPI(UucOpenCodec(uCodec, bEncoder));
	if (!m_hCodec) {
		//TRACE("could not open codec\n");
		return FALSE;
	}

	return TRUE;
}

BOOL CUUCoreUtil::CloseCodec()
{
	CHECK_INSTANCE
	if (m_hCodec) {
		UUCAPI(UucCloseCodec(m_hCodec));
		m_hCodec = NULL;
	}
	return TRUE;
}

BOOL CUUCoreUtil::SetParam(CodecProperty CodecProp)
{
	CHECK_INSTANCE
	if (m_hCodec) {
		return UUCAPI(UucSetParam(m_hCodec, CodecProp));
	}
	
	//TRACE("codec is not opened!\n");
	return FALSE;
}

BOOL CUUCoreUtil::DecodeVideo(DecodedVideo* pDecodedBuf, int* pDecodedSize, BYTE* pEncodedBuf, int nEncodedSize, BOOL bDeinterlaced)
{
	CHECK_INSTANCE
	if (nEncodedSize<=0) {
		//TRACE("Encoded size is invalid.\n");
		return FALSE;
	}
	if (m_hCodec) {
		if (!UUCAPI(UucDecodeVideo(m_hCodec, pDecodedBuf, pDecodedSize, pEncodedBuf, nEncodedSize, bDeinterlaced))) {
			if (*pDecodedSize<0) {
				//TRACE("Error while decoding frame\n");
			}
			else {
				//TRACE("Can not get a picture\n");
			}
			return FALSE;
		}
		return TRUE;
	}

	//TRACE("codec is not opened!\n");
	return FALSE;
}

BOOL CUUCoreUtil::EncodeAudio(BYTE* pEncodedBuf, int nEncodedBufSize, int* pEncodedSize, short* pPcmData)
{
	CHECK_INSTANCE
	if (nEncodedBufSize<=0) {
		//TRACE("EncodedBufSize is invalid.\n");
		return FALSE;
	}

	if (!UUCAPI(UucEncodeAudio(m_hCodec, pEncodedBuf, nEncodedBufSize, pEncodedSize, pPcmData))) {
		//TRACE("EncodeAudio fail.\n");
		return FALSE;
	}
		
	return TRUE;
}

BOOL CUUCoreUtil::DecodeAudio(short* pDecodedBuf, int* pDecodedBufSize, int* pDecodedSize, BYTE* pEncodedBuf, int nEncodedSize)
{
	CHECK_INSTANCE
	if (nEncodedSize<=0) {
		//TRACE("Encoded size is invalid.\n");
		return FALSE;
	}

	BYTE*	pOutBuf = new BYTE [UU_MAX_AUDIO_FRAME_SIZE];
	BYTE*	pInBufOrg = new BYTE [nEncodedSize+UU_INPUT_BUFFER_PADDING_SIZE];
	CopyMemory(pInBufOrg, pEncodedBuf, nEncodedSize);
	ZeroMemory(pInBufOrg+nEncodedSize, UU_INPUT_BUFFER_PADDING_SIZE);
	int		nSize=nEncodedSize;
	BYTE*	pInBuf = pInBufOrg;
	while (nSize > 0) {
		if (m_hCodec) {
			if (!UUCAPI(UucDecodeAudio(m_hCodec, (short*)pOutBuf, pDecodedBufSize, pDecodedSize, pInBuf, nEncodedSize))) {
				if (pOutBuf) delete pOutBuf;
				if (pInBuf) delete pInBuf;
				//TRACE("Error while decoding.\n");
				return FALSE;
			}
		}
		else {
			if (pOutBuf) delete pOutBuf;
			if (pInBuf) delete pInBuf;
			//TRACE("codec is not opened!\n");
			return FALSE;
		}
        
        if (pDecodedBufSize > 0) {
			CopyMemory(pDecodedBuf, pOutBuf, *pDecodedBufSize);
			pDecodedBuf += *pDecodedBufSize;
        }
        nSize -= *pDecodedSize;
        pInBuf += *pDecodedSize;
    }

	if (pOutBuf) delete pOutBuf;
	if (pInBufOrg) delete pInBufOrg;
	
	return TRUE;
}

BOOL CUUCoreUtil::FlushBuffer(void)
{
	CHECK_INSTANCE
	return UUCAPI(UucFlushBuffer(m_hCodec));
}

BOOL CUUCoreUtil::Deinterlace(DecodedVideo* pDecodedBuf, BOOL bDeinterlace)
{
	CHECK_INSTANCE
	return UUCAPI(UucDeinterlace(m_hCodec, pDecodedBuf, bDeinterlace));
}