bik_public.cpp

#include "bik_public.hpp"
#include "bik_descriptor.hpp"
#include "bik_internal.hpp"
#include "bik_version.hpp"
#include "bik_utils.hpp"

#include <assert.h>

using namespace Bik::Internal;
using namespace Bik::Utils;

//////////////////////////////////////////////////////////////////////////

// BINK_GENERATE - Determines if we're compiling this library in order to generate export table (.def) only.

#define BinkMakeDescriptorName(FunctionName, ParameterCount) FunctionName##Descriptor##ParameterCount

#if !defined(BINK_GENERATE)

	#define BinkDeclareDescriptor(FunctionName, ParameterCount) \
		static BinkFunctionDescriptor BinkMakeDescriptorName(FunctionName, ParameterCount)(#FunctionName, ParameterCount)
#else
	// In this case we're generating export table, so everything is dummy only.
	#define BinkDeclareDescriptor(FunctionName, ParameterCount) \
		static Bool _dummy##FunctionName##ParameterCount = generateExport(#FunctionName, ParameterCount)

#endif // BINK_GENERATE

#define BikModDeclareDescriptor(FunctionName, ParameterCount)

//////////////////////////////////////////////////////////////////////////

#define BinkFunctionVars(FunctionName, ParameterCount) \
	static const Char* _name = #FunctionName; \
	static const Int32u _count = ParameterCount; \
	static const BinkMakeFunctionPointer(FunctionName, ParameterCount) _function =

#if !defined(BINK_GENERATE)
	#define BinkFunctionVars2(FunctionName, ParameterCount) \
		/*_function =*/ reinterpret_cast<BinkMakeFunctionPointer(FunctionName, ParameterCount)> \
			(BinkMakeDescriptorName(FunctionName, ParameterCount).getAddress(True))
#else
	#define BinkFunctionVars2(FunctionName, ParameterCount) \
		/*_function*/ NULL
#endif // BINK_GENERATE

#define BinkFunctionCallLog() logCall(_name, _count);

#define NoReturn
#define ReturnValue(Value) Value

#define BinkCallValidate(...) \
	if (_function == NULL) \
		return __VA_ARGS__;

#define BinkFunctionProlog(FunctionName, ParameterCount, DefaultReturnValue) \
	BinkFunctionVars(FunctionName, ParameterCount) \
	BinkFunctionVars2(FunctionName, ParameterCount); \
	BinkFunctionCallLog(); \
	BinkCallValidate(DefaultReturnValue);

#define BinkCall(...) (*_function)(__VA_ARGS__)
#define BinkMakeCall(FunctionName, ParameterCount, ...) \
	(reinterpret_cast<BinkMakeFunctionPointer(FunctionName, ParameterCount)> \
			(BinkMakeDescriptorName(FunctionName, ParameterCount).getAddress(True)))(__VA_ARGS__)

#define BinkCheckError() \
	do { \
		GlobalConfig& config = getConfig(); \
		if (config.checkAfterCall) \
		{ \
			Char* error = BinkMakeCall(BinkGetError, 0); \
			if ((error != NULL) && (error[0] != '\0')) \
				logError("Bink => %s", error); \
		} \
	} while (0); \


#define BinkFunctionEpilog(...) \
	BinkCheckError(); return __VA_ARGS__;

#define BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, ParameterCount, ...) \
	BinkDeclareDescriptor(FunctionName, ParameterCount); \
	ReturnType BINK_CALL BinkMakeFunctionName(FunctionName, ParameterCount)(__VA_ARGS__) \
	{ \
		BinkFunctionProlog(FunctionName, ParameterCount, DefaultReturnValue);

#define BinkDefineFunction0(ReturnType, FunctionName, DefaultReturnValue, ...) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 0);

#define BinkDefineFunction1(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 1, ParamType1 ParamName1);

#define BinkDefineFunction2(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 2, ParamType1 ParamName1, ParamType2 ParamName2);

#define BinkDefineFunction3(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 3, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3);

#define BinkDefineFunction4(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 4, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4);

#define BinkDefineFunction5(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 5, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5);

#define BinkDefineFunction6(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 6, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6);

#define BinkDefineFunction7(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 7, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7);

#define BinkDefineFunction8(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7, ParamType8, ParamName8) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 8, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7, ParamType8 ParamName8);

#define BinkDefineFunction9(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7, ParamType8, ParamName8, ParamType9, ParamName9) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 9, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7, ParamType8 ParamName8, ParamType9 ParamName9);

#define BinkDefineFunction10(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7, ParamType8, ParamName8, ParamType9, ParamName9, ParamType10, ParamName10) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 10, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7, ParamType8 ParamName8, ParamType9 ParamName9, ParamType10 ParamName10);

#define BinkDefineFunction11(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7, ParamType8, ParamName8, ParamType9, ParamName9, ParamType10, ParamName10, ParamType11, ParamName11) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 11, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7, ParamType8 ParamName8, ParamType9 ParamName9, ParamType10 ParamName10, ParamType11 ParamName11);

#define BinkDefineFunction12(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7, ParamType8, ParamName8, ParamType9, ParamName9, ParamType10, ParamName10, ParamType11, ParamName11, ParamType12, ParamName12) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 12, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7, ParamType8 ParamName8, ParamType9 ParamName9, ParamType10 ParamName10, ParamType11 ParamName11, ParamType12 ParamName12);

#define BinkDefineFunction13(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7, ParamType8, ParamName8, ParamType9, ParamName9, ParamType10, ParamName10, ParamType11, ParamName11, ParamType12, ParamName12, ParamType13, ParamName13) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 13, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7, ParamType8 ParamName8, ParamType9 ParamName9, ParamType10 ParamName10, ParamType11 ParamName11, ParamType12 ParamName12, ParamType13 ParamName13);

#define BinkDefineFunction14(ReturnType, FunctionName, DefaultReturnValue, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4, ParamType5, ParamName5, ParamType6, ParamName6, ParamType7, ParamName7, ParamType8, ParamName8, ParamType9, ParamName9, ParamType10, ParamName10, ParamType11, ParamName11, ParamType12, ParamName12, ParamType13, ParamName13, ParamType14, ParamName14) \
	BinkDefineFunctionBase(ReturnType, FunctionName, DefaultReturnValue, 14, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3, ParamType4 ParamName4, ParamType5 ParamName5, ParamType6 ParamName6, ParamType7 ParamName7, ParamType8 ParamName8, ParamType9 ParamName9, ParamType10 ParamName10, ParamType11 ParamName11, ParamType12 ParamName12, ParamType13 ParamName13, ParamType14 ParamName14);

//////////////////////////////////////////////////////////////////////////

Char* BINK_CALL BikModGetVersion0()
{
	static Char buffer[128];
	sprintf(buffer, "%s v%s", BIKMOD_CAPTION, BIKMOD_VERSION_STRING);

	return buffer;
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction0(Char*, BinkGetError, ReturnValue(NULL),
	/*Parameter*/ Void
)

	Char* result = BinkCall();

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Void, BinkSetError, ReturnValue(NoReturn),
	/*Parameter*/ Char*, error
)
		
	BinkCall(error);

	BinkFunctionEpilog();
}

BinkDefineFunction0(Void*, BinkLogoAddress, ReturnValue(NULL),
	/*Parameter*/ Void
)
	Void* result = BinkCall();

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(BinkHandle, BinkOpen, ReturnValue(NULL),
	/*Parameter*/ Char*, fileName,
	/*Parameter*/ Int32u, flags
)

	const Char* newFileName = getBinkFileName(fileName, flags);
	logDebug("Opening bink video: %s", newFileName);

	BinkHandle binkHandle = BinkCall(fileName, flags);

	if (binkHandle != NULL)
	{
		Char* formatString = NULL;
		if ((flags & BINK_FILE_HANDLE) == BINK_FILE_HANDLE)
			formatString = "New bink opened => (FileHandle: 0x%p, Flags: 0x%.8X, Handle: 0x%p)";
		else if ((flags & BINK_FROM_MEMORY) == BINK_FROM_MEMORY)
			formatString = "New bink opened => (MemoryAddress: 0x%p, Flags: 0x%.8X, Handle: 0x%p)";
		else formatString = "New bink opened => (FileName: '%s', Flags: 0x%.8X, Handle: 0x%p)";

		logDebug(formatString, fileName, flags, binkHandle);

		if ((flags & BINK_NO_FRAMEBUFFERS) == BINK_NO_FRAMEBUFFERS)
			logDebug("Using application-allocated framebuffers!");

		LocalData& localData = allocateLocalData(binkHandle);
		Utils::stringCopy(localData.fileName, newFileName);

		loadSubtitleFile(localData);
	}

	return binkHandle;
}

BinkDefineFunction1(Int32s, BinkDoFrame, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle
)

	Int32s result = BinkCall(binkHandle);

	LocalData& localData = getLocalData(binkHandle);
	if (localData.useBinkFramebuffers)
	{
		BinkFramebuffers& frameBuffers = localData.binkFramebuffers;
		
		logDebug("FrameBuffers->TotalFrames: %d", frameBuffers.TotalFrames);
		logDebug("FrameBuffers->YABufferWidth: %d", frameBuffers.YABufferWidth);
		logDebug("FrameBuffers->YABufferHeight: %d", frameBuffers.YABufferHeight);
		logDebug("FrameBuffers->cRcBBufferWidth: %d", frameBuffers.cRcBBufferWidth);
		logDebug("FrameBuffers->cRcBBufferHeight: %d", frameBuffers.cRcBBufferHeight);
		logDebug("FrameBuffers->FrameNum: %d", frameBuffers.FrameNum);

		for (Int32u i = 0; i < frameBuffers.TotalFrames; i++)
		{
			BinkFramePlaneSet& framePlaneSet = frameBuffers.Frames[i];

			logDebug("FramePlane %d:", i);
			logDebug("YPlane: Buffer: %p, Pitch: %d", framePlaneSet.YPlane.Buffer, framePlaneSet.YPlane.BufferPitch);
			logDebug("cRPlane: Buffer: %p, Pitch: %d", framePlaneSet.cRPlane.Buffer, framePlaneSet.cRPlane.BufferPitch);
			logDebug("cBPlane: Buffer: %p, Pitch: %d", framePlaneSet.cBPlane.Buffer, framePlaneSet.cBPlane.BufferPitch);
			logDebug("APlane: Buffer: %p, Pitch: %d", framePlaneSet.APlane.Buffer, framePlaneSet.APlane.BufferPitch);

			Utils::eraseMemory(framePlaneSet.YPlane.Buffer, framePlaneSet.YPlane.BufferPitch * frameBuffers.YABufferHeight);
			Utils::eraseMemory(framePlaneSet.cRPlane.Buffer, framePlaneSet.cRPlane.BufferPitch * frameBuffers.cRcBBufferHeight);
			Utils::eraseMemory(framePlaneSet.cBPlane.Buffer, framePlaneSet.cBPlane.BufferPitch * frameBuffers.cRcBBufferHeight);
			Utils::eraseMemory(framePlaneSet.APlane.Buffer, framePlaneSet.APlane.BufferPitch * frameBuffers.YABufferHeight);
		}

	}
	else
	{
		localData.updateBuffer = True;
	}
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Void, BinkNextFrame, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle
)

	BinkCall(binkHandle);

	BinkFunctionEpilog();
}

BinkDefineFunction1(Int32s, BinkWait, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle
)

	Int32s result = BinkCall(binkHandle);

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Void, BinkClose, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle
)

	if (binkHandle != NULL)
		releaseLocalData(binkHandle);

	BinkCall(binkHandle);

	BinkFunctionEpilog();
}

BinkDefineFunction2(Int32s, BinkPause, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32s, pause
)

	Int32s result = BinkCall(binkHandle, pause);

	BinkFunctionEpilog(result);
}

BinkDefineFunction7(Int32u, BinkCopyToBuffer, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Void*, targetBuffer,
	/*Parameter*/ Int32u, targetPitch,
	/*Parameter*/ Int32u, targetHeight,
	/*Parameter*/ Int32u, targetX,
	/*Parameter*/ Int32u, targetY,
	/*Parameter*/ Int32u, flags
)

	logDebug("BinkCopyToBuffer(Handle: %p, TargetBuffer: %p, TargetPitch: %d, TargetHeight: %d, TargetX: %d, TargetY: %d, Flags: 0x%.8X);", 
		binkHandle, targetBuffer, targetPitch, targetHeight, targetX, targetY, flags);

	LocalData& localData = getLocalData(binkHandle);
	FrameBuffer& frameBuffer = localData.frameBuffer;
	
	// check if we need to update output buffer
	static Int32u result = 0; // keep track of previous result
	if (!localData.updateBuffer)
	{
		copyToBuffer(frameBuffer, targetBuffer, targetPitch, targetHeight, 
			targetX, targetY, NULL);

		return result;
	} else localData.updateBuffer = False;

	if ((flags & 0xFFFFFF00) != 0)
		logDebug("BinkCopyToBuffer => Extra flags used (0x%.8X)", flags);

	Int32u surfaceType = flags & 0x000000FF;
	if (!validateBuffer(binkHandle, frameBuffer, surfaceType))
	{
		result = BinkCall(binkHandle, targetBuffer, targetPitch, targetHeight, 
			targetX, targetY, flags);

		BinkFunctionEpilog(result);
	}

	flags = BINK_COPY_ALL | frameBuffer.surfaceType;
	result = BinkCall(binkHandle, frameBuffer.data, frameBuffer.pitch, frameBuffer.height, 
		0, 0, flags);

	drawFrame(localData);

	GlobalConfig& config = getConfig();
	if (config.videoForcePosition)
	{
		targetX = config.videoForceX;
		targetY = config.videoForceY;
	}

	copyToBuffer(frameBuffer, targetBuffer, targetPitch, targetHeight, targetX, targetY, NULL);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction11(Int32u, BinkCopyToBufferRect, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Void*, targetBuffer,
	/*Parameter*/ Int32s, targetPitch,
	/*Parameter*/ Int32u, targetHeight,
	/*Parameter*/ Int32u, targetX,
	/*Parameter*/ Int32u, targetY,
	/*Parameter*/ Int32u, sourceX,
	/*Parameter*/ Int32u, sourceY,
	/*Parameter*/ Int32u, sourceWidth,
	/*Parameter*/ Int32u, sourceHeight,
	/*Parameter*/ Int32u, flags
)
	
	//logDebug("BinkCopyToBufferRect(Handle: %p, TargetBuffer: %p, TargetPitch: %d, TargetHeight: %d, TargetX: %d, TargetY: %d, SourceX: %d, SourceY: %d, SourceWidth: %d, SourceHeight: %d, Flags: %p);", 
	//	binkHandle, targetBuffer, targetPitch, targetHeight, targetX, targetY, sourceX, sourceY, sourceWidth, sourceHeight, flags);
	
	Rect sourceArea = {sourceX, sourceY, sourceWidth, sourceHeight};

	LocalData& localData = getLocalData(binkHandle);
	FrameBuffer& frameBuffer = localData.frameBuffer;
	
	// check if we need to update output buffer
	static Int32u result = 0; // keep track of previous result
	if (!localData.updateBuffer)
	{
		copyToBuffer(frameBuffer, targetBuffer, targetPitch, targetHeight, 
			targetX, targetY, &sourceArea);

		return result;
	} else localData.updateBuffer = False;

	if ((flags & 0xFFFFFF00) != 0)
		logDebug("BinkCopyToBufferRect => Extra flags used (0x%p)", flags);

	Int32u surfaceType = flags & 0x000000FF;
	if (!validateBuffer(binkHandle, frameBuffer, surfaceType))
	{
		result = BinkCall(binkHandle, targetBuffer, targetPitch, targetHeight, 
			targetX, targetY, sourceX, sourceY, sourceWidth, sourceHeight, flags);

		BinkFunctionEpilog(result);
	}

	flags = BINK_COPY_ALL | frameBuffer.surfaceType;
	result = BinkCall(binkHandle, frameBuffer.data, frameBuffer.pitch, frameBuffer.height, 
		0, 0, 0, 0, frameBuffer.width, frameBuffer.height, flags);

	drawFrame(localData);

	GlobalConfig& config = getConfig();
	if (config.videoForcePosition)
	{
		targetX = config.videoForceX;
		targetY = config.videoForceY;
	}

	copyToBuffer(frameBuffer, targetBuffer, targetPitch, targetHeight, 
		targetX, targetY, &sourceArea);

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32s, BinkGetRects, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, flags
)

	Int32s result = BinkCall(binkHandle, flags);

	BinkFunctionEpilog(result);
}

BinkDefineFunction3(Void, BinkGoto, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, frameNumber,
	/*Parameter*/ Int32u, flags
)
	
	BinkCall(binkHandle, frameNumber, flags);
	
	LocalData& localData = getLocalData(binkHandle);

	SubtitleFile* subtitleFile = localData.subtitleList;
	while (subtitleFile != NULL)
	{	
		subtitleFile->lastEntry = NULL; // TODO: it will be faster to seek to correct entry
		subtitleFile = subtitleFile->next;
	}

	BinkFunctionEpilog();
}

BinkDefineFunction3(Int32u, BinkGetKeyFrame, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, frameNumber,
	/*Parameter*/ Int32u, flags
)

	Int32u result = BinkCall(binkHandle, frameNumber, flags);

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32s, BinkSetVideoOnOff, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32s, turnOn
)

	Int32s result = BinkCall(binkHandle, turnOn);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32s, BinkSetSoundOnOff, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32s, turnOn
)

	Int32s result = BinkCall(binkHandle, turnOn);

	BinkFunctionEpilog(result);
}

BinkDefineFunction3(Void, BinkSetVolume, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackId,
	/*Parameter*/ Int32s, volume
)

	BinkCall(binkHandle, trackId, volume);

	BinkFunctionEpilog();
}

BinkDefineFunction3(Void, BinkSetPan, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackId,
	/*Parameter*/ Int32s, pan
)

	BinkCall(binkHandle, trackId, pan);

	BinkFunctionEpilog();
}

BinkDefineFunction4(Void, BinkSetMixBins, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackId,
	/*Parameter*/ Int32u*, mixBinList,
	/*Parameter*/ Int32u, total
)
	
	BinkCall(binkHandle, trackId, mixBinList, total);

	BinkFunctionEpilog();
}

BinkDefineFunction5(Void, BinkSetMixBinVolumes, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackId,
	/*Parameter*/ Int32u*, volumeMixBinList,
	/*Parameter*/ Int32s*, volumeList,
	/*Parameter*/ Int32u, total
)

	BinkCall(binkHandle, trackId, volumeMixBinList, volumeList, total);

	BinkFunctionEpilog();
}

BinkDefineFunction1(Void, BinkService, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle
)

	BinkCall(binkHandle);

	BinkFunctionEpilog();
}

BinkDefineFunction2(BinkTrackHandle, BinkOpenTrack, ReturnValue(NULL),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackIndex
)

	BinkTrackHandle result = BinkCall(binkHandle, trackIndex);

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Void, BinkCloseTrack, ReturnValue(NoReturn),
	/*Parameter*/ BinkTrackHandle, trackHandle
)
	
	BinkCall(trackHandle);

	BinkFunctionEpilog();
}

BinkDefineFunction2(Int32u, BinkGetTrackData, ReturnValue(0),
	/*Parameter*/ BinkTrackHandle, trackHandle,
	/*Parameter*/ Void*, buffer
)

	Int32u result = BinkCall(trackHandle, buffer);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32u, BinkGetTrackType, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackIndex
)

	Int32u result = BinkCall(binkHandle, trackIndex);

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32u, BinkGetTrackMaxSize, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackIndex
)

	Int32u result = BinkCall(binkHandle, trackIndex);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32u, BinkGetTrackID, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, trackIndex
)

	Int32u result = BinkCall(binkHandle, trackIndex);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Void, BinkGetSummary, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ BinkSummary*, summary
)

	BinkCall(binkHandle, summary);

	BinkFunctionEpilog();
}

BinkDefineFunction3(Void, BinkGetRealtime, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ BinkRealTimeInfo*, info,
	/*Parameter*/ Int32u, frameCount
)

	BinkCall(binkHandle, info, frameCount);

	BinkFunctionEpilog();
}

BinkDefineFunction2(Void, BinkSetSoundTrack, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, trackCount,
	/*Parameter*/ Int32u*, trackList
)

	BinkCall(trackCount, trackList);

	setSoundTrack(trackList, trackCount);

	BinkFunctionEpilog()
}

BinkDefineFunction1(Void, BinkSetIO, ReturnValue(NoReturn),
	/*Parameter*/ BinkIoOpenFunction, ioFunction
)

	BinkCall(ioFunction);

	BinkFunctionEpilog();
}

BinkDefineFunction2(Void, BinkSetFrameRate, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, frameRate,
	/*Parameter*/ Int32u, frameRateDiv
)
	
	BinkCall(frameRate, frameRateDiv);

	BinkFunctionEpilog();
}

BinkDefineFunction1(Void, BinkSetSimulate, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, simulate
)

	BinkCall(simulate);

	BinkFunctionEpilog();
}

BinkDefineFunction1(Void, BinkSetIOSize, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, ioSize
)

	BinkCall(ioSize);

	BinkFunctionEpilog();
}

BinkDefineFunction2(Int32s, BinkSetSoundSystem, ReturnValue(0),
	/*Parameter*/ BinkSoundSysOpenFunction, openFunction,
	/*Parameter*/ Int32u, param
)

	Int32s result = BinkCall(openFunction, param);

	BinkFunctionEpilog(result);
}

#if defined(CMF_PLATFORM_WIN32)

BinkDefineFunction1(BinkSoundOpenFunction, BinkOpenDirectSound, ReturnValue(NULL),
	/*Parameter*/ Int32u, param
)

	BinkSoundOpenFunction result = BinkCall(param);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction1(BinkSoundOpenFunction, BinkOpenWaveOut, ReturnValue(NULL),
	/*Parameter*/ Int32u, param
)

	BinkSoundOpenFunction result = BinkCall(param);

	BinkFunctionEpilog(result);
}

#endif // CMF_PLATFORM_WIN32

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction1(BinkSoundOpenFunction, BinkOpenMiles, ReturnValue(NULL),
	/*Parameter*/ Int32u, param
)

	BinkSoundOpenFunction result = BinkCall(param);

	BinkFunctionEpilog(result);
}


#if defined(CMF_PLATFORM_WIN32)

BinkDefineFunction1(Int32s, BinkDX8SurfaceType, ReturnValue(NULL),
	/*Parameter*/ Void*, lpD3DSurface
)
	
	Int32s result = BinkCall(lpD3DSurface);

	BinkFunctionEpilog(result);
}

BinkDefineFunction4(BinkBufferHandle, BinkBufferOpen, ReturnValue(NULL),
	/*Parameter*/ Void*, windowHandle,
	/*Parameter*/ Int32u, width,
	/*Parameter*/ Int32u, height,
	/*Parameter*/ Int32u, bufferFlags
)

	BinkBufferHandle result = BinkCall(windowHandle, width, height, bufferFlags);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32s, BinkBufferSetHWND, ReturnValue(0),
	/*Parameter*/ BinkBufferHandle, bufferHandle,
	/*Parameter*/ Void*, windowHandle
)

	Int32s result = BinkCall(bufferHandle, windowHandle);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Int32s, BinkDDSurfaceType, ReturnValue(0),
	/*Parameter*/ Void*, directDrawSurface
)

	Int32s result = BinkCall(directDrawSurface);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32s, BinkIsSoftwareCursor, ReturnValue(0),
	/*Parameter*/ Void*, directDrawSurface,
	/*Parameter*/ Void*, cursorHandle
)

	Int32s result = BinkCall(directDrawSurface, cursorHandle);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction5(Int32s, BinkCheckCursor, ReturnValue(0),
	/*Parameter*/ Void*, windowHandle,
	/*Parameter*/ Int32s, x,
	/*Parameter*/ Int32s, y,
	/*Parameter*/ Int32s, width,
	/*Parameter*/ Int32s, height
)

	Int32s result = BinkCall(windowHandle, x, y, width, height);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32s, BinkBufferSetDirectDraw, ReturnValue(0),
	/*Parameter*/ Void*, directDraw,
	/*Parameter*/ Void*, directDrawSurface
)

	Int32s result = BinkCall(directDraw, directDrawSurface);

	BinkFunctionEpilog(result);
}

#endif // CMF_PLATFORM_WIN32


BinkDefineFunction1(Void, BinkBufferClose, ReturnValue(NoReturn),
	/*Parameter*/ BinkBufferHandle, bufferHandle
)
	
	BinkCall(bufferHandle);

	BinkFunctionEpilog();
}

BinkDefineFunction1(Int32s, BinkBufferLock, ReturnValue(0),
	/*Parameter*/ BinkBufferHandle, bufferHandle
)

	Int32s result = BinkCall(bufferHandle);

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Int32s, BinkBufferUnlock, ReturnValue(0),
	/*Parameter*/ BinkBufferHandle, bufferHandle
)

	Int32s result = BinkCall(bufferHandle);

	BinkFunctionEpilog(result);
}

BinkDefineFunction3(Void, BinkBufferSetResolution, ReturnValue(NoReturn),
	/*Parameter*/ Int32s, width,
	/*Parameter*/ Int32s, height,
	/*Parameter*/ Int32s, bitCount
)
	
	BinkCall(width, height, bitCount);

	BinkFunctionEpilog();
}

BinkDefineFunction3(Void, BinkBufferCheckWinPos, ReturnValue(NoReturn),
	/*Parameter*/ BinkBufferHandle, bufferHandle,
	/*Parameter*/ Int32s*, newWindowX,
	/*Parameter*/ Int32s*, newWindowY
)

	BinkCall(bufferHandle, newWindowX, newWindowY);

	BinkFunctionEpilog();
}

BinkDefineFunction3(Int32s, BinkBufferSetOffset, ReturnValue(0),
	/*Parameter*/ BinkBufferHandle, bufferHandle,
	/*Parameter*/ Int32s, x,
	/*Parameter*/ Int32s, y
)

	Int32s result = BinkCall(bufferHandle, x, y);

	BinkFunctionEpilog(result);
}

BinkDefineFunction3(Void, BinkBufferBlit, ReturnValue(NoReturn),
	/*Parameter*/ BinkBufferHandle, bufferHandle,
	/*Parameter*/ BinkRect*, rectList,
	/*Parameter*/ Int32u, rectCount
)

	BinkCall(bufferHandle, rectList, rectCount);

	BinkFunctionEpilog();
}

BinkDefineFunction3(Int32s, BinkBufferSetScale, ReturnValue(0),
	/*Parameter*/ BinkBufferHandle, bufferHandle,
	/*Parameter*/ Int32u, width,
	/*Parameter*/ Int32u, height
)

	Int32s result = BinkCall(bufferHandle, width, height);

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Char*, BinkBufferGetDescription, ReturnValue(NULL),
	/*Parameter*/ BinkBufferHandle, bufferHandle
)

	Char* result = BinkCall(bufferHandle);

	BinkFunctionEpilog(result);
}

BinkDefineFunction0(Char*, BinkBufferGetError, ReturnValue(NULL),
	/*Parameter*/ Void
)

	Char* result = BinkCall();

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32s, BinkBufferClear, ReturnValue(0),
	/*Parameter*/ BinkBufferHandle, bufferHandle,
	/*Parameter*/ Int32u, rgb
)

	Int32s result = BinkCall(bufferHandle, rgb);

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Void, BinkRestoreCursor, ReturnValue(NoReturn),
	/*Parameter*/ Int32s, checkCount
)

	BinkCall(checkCount);

	BinkFunctionEpilog();
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction1(Void, BinkSetSoundTrack, ReturnValue(NoReturn),
	/*Parameter*/ Int32u*, trackList
)

	BinkCall(trackList);

	setSoundTrack(trackList, 0);

	BinkFunctionEpilog();
}

BinkDefineFunction14(Void, ExpandBink, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12,
	/*Parameter*/ Int32u, unknown13
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12, unknown13);
	
	BinkFunctionEpilog();
}

BinkDefineFunction11(Void, ExpandPlane, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10);
	
	BinkFunctionEpilog();
}

BinkDefineFunction2(Void, ExpandBundleSizes, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1
)

	BinkCall(unknown0, unknown1);

	BinkFunctionEpilog();
}

BinkDefineFunction1(Void*, radmalloc, ReturnValue(NULL),
	/*Parameter*/ Int32u, size
)

	Void* result = BinkCall(size);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Void, radfree, ReturnValue(NoReturn),
	/*Parameter*/ Void*, memory
)

	BinkCall(memory);

	BinkFunctionEpilog();
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction0(Int32u, RADTimerRead, ReturnValue(0),
	/*Parameter*/ Void
)

	Int32u result = BinkCall();

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Void, RADSetMemory, ReturnValue(NoReturn),
	/*Parameter*/ Void*, buffer,
	/*Parameter*/ Int32u, size
)

	BinkCall(buffer, size);

	BinkFunctionEpilog();
}

//////////////////////////////////////////////////////////////////////////

#if defined(CMF_PLATFORM_WIN32)

BinkDefineFunction1(Int32s, BinkDX9SurfaceType, ReturnValue(0),
	/*Parameter*/ Void*, lpD3DSurface
)

	Int32s result = BinkCall(lpD3DSurface);

	BinkFunctionEpilog(result);
}

#endif // CMF_PLATFORM_WIN32

BinkDefineFunction2(Void, BinkGetFrameBuffersInfo, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ BinkFramebuffers*, framebufferSet
)

	BinkCall(binkHandle, framebufferSet);

	LocalData& localData = getLocalData(binkHandle);
	localData.useBinkFramebuffers = True;
	localData.binkFramebuffers = *framebufferSet;

	BinkFunctionEpilog();
}

BinkDefineFunction2(Void, BinkRegisterFrameBuffers, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ BinkFramebuffers*, framebufferSet
)

	BinkCall(binkHandle, framebufferSet);

	LocalData& localData = getLocalData(binkHandle);
	localData.useBinkFramebuffers = True;
	localData.binkFramebuffers = *framebufferSet;

	BinkFunctionEpilog();
}

BinkDefineFunction2(Void, BinkSetMemory, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1
)

	BinkCall(unknown0, unknown1);

	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_16a1bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_16a1bpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_16a4bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_16a4bpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_16bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_24bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_24rbpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_32bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_32rbpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_32abpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_32abpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_32rabpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_32rabpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_UYVY, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction10(Void, YUV_blit_YUY2, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9);
	
	BinkFunctionEpilog();
}

BinkDefineFunction11(Void, YUV_blit_YV12, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10);
	
	BinkFunctionEpilog();
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction13(Void, YUV_blit_16a1bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_16a1bpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)
	
	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_16a4bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_16a4bpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_16bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_16bpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_24bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_24bpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)
	
	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_24rbpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_24rbpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_32bpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_32bpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_32rbpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_32rbpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_32abpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_32abpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_32rabpp, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_32rabpp_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_UYVY, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_UYVY_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_YUY2, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction12(Void, YUV_blit_YUY2_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11);
	
	BinkFunctionEpilog();
}

BinkDefineFunction13(Void, YUV_blit_YV12, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12);
	
	BinkFunctionEpilog();
}

BinkDefineFunction1(Void, YUV_init, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0
)

	BinkCall(unknown0);
	
	BinkFunctionEpilog();
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction14(Void, YUV_blit, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12,
	/*Parameter*/ Int32u, unknown13
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12, unknown13);
	
	BinkFunctionEpilog();
}

BinkDefineFunction14(Void, YUV_blit_mask, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4,
	/*Parameter*/ Int32u, unknown5,
	/*Parameter*/ Int32u, unknown6,
	/*Parameter*/ Int32u, unknown7,
	/*Parameter*/ Int32u, unknown8,
	/*Parameter*/ Int32u, unknown9,
	/*Parameter*/ Int32u, unknown10,
	/*Parameter*/ Int32u, unknown11,
	/*Parameter*/ Int32u, unknown12,
	/*Parameter*/ Int32u, unknown13
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8, unknown9, unknown10, unknown11, unknown12, unknown13);
	
	BinkFunctionEpilog();
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction2(Void, BinkSetVolume, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32s, volume
)

	BinkCall(binkHandle, volume);
	
	BinkFunctionEpilog();
}

BinkDefineFunction2(Void, BinkSetPan, ReturnValue(NoReturn),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32s, pan
)

	BinkCall(binkHandle, pan);
	
	BinkFunctionEpilog();
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction1(Int32u, BinkShouldSkip, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle
)

	Int32u result = BinkCall(binkHandle);
	
	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Void*, BinkGetPalette, ReturnValue(NULL),
	/*Parameter*/ BinkHandle, binkHandle
)

	Void* result = BinkCall(binkHandle);

	BinkFunctionEpilog(result);
}

//////////////////////////////////////////////////////////////////////////

BinkDefineFunction2(Int32u, BinkControlBackgroundIO, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, control
)

	Int32u result = BinkCall(binkHandle, control);

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32u, BinkControlPlatformFeatures, ReturnValue(0),
	/*Parameter*/ Int32u, use,
	/*Parameter*/ Int32u, dontUse
)

	Int32u result = BinkCall(use, dontUse);

	BinkFunctionEpilog(result);
}

BinkDefineFunction3(Int32u, BinkDoFrameAsync, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, yPlaneThreadNumber,
	/*Parameter*/ Int32u, otherWorkThreadNumber
)

	Int32u result = BinkCall(binkHandle, yPlaneThreadNumber, otherWorkThreadNumber);

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32u, BinkDoFrameAsyncWait, ReturnValue(0),
	/*Parameter*/ BinkHandle, binkHandle,
	/*Parameter*/ Int32u, us
)

	Int32u result = BinkCall(binkHandle, us);

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Int32u, BinkDoFramePlane, ReturnValue(0),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1
)

	Int32u result = BinkCall(unknown0, unknown1);

	BinkFunctionEpilog(result);
}

BinkDefineFunction0(Void, BinkFreeGlobals, ReturnValue(NoReturn),
	/*Parameter*/ Void
)

	BinkCall();

	BinkFunctionEpilog();
}

BinkDefineFunction2(Int32u, BinkGetPlatformInfo, ReturnValue(0),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1
)

	Int32u result = BinkCall(unknown0, unknown1);

	BinkFunctionEpilog(result);
}

BinkDefineFunction3(Void, BinkOpenWithOptions, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2
)

	BinkCall(unknown0, unknown1, unknown2);

	BinkFunctionEpilog();
}

BinkDefineFunction1(Void*, BinkOpenXAudio2, ReturnValue(NULL),
	/*Parameter*/ Int32u, unknown0
)

	Void* result = BinkCall(unknown0);

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Int32u, BinkRequestStopAsyncThread, ReturnValue(0),
	/*Parameter*/ Int32u, threadNumber
)

	Int32u result = BinkCall(threadNumber);

	BinkFunctionEpilog(result);
}

BinkDefineFunction0(Int32u, BinkServiceSound, ReturnValue(0),
	/*Parameter*/ Void
)

	Int32u result = BinkCall();

	BinkFunctionEpilog(result);
}

BinkDefineFunction2(Void, BinkSetFileOffset, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1
)

	BinkCall(unknown0, unknown1);

	BinkFunctionEpilog();
}

BinkDefineFunction5(Void, BinkSetSpeakerVolumes, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1,
	/*Parameter*/ Int32u, unknown2,
	/*Parameter*/ Int32u, unknown3,
	/*Parameter*/ Int32u, unknown4
)

	BinkCall(unknown0, unknown1, unknown2, unknown3, unknown4);

	BinkFunctionEpilog();
}

BinkDefineFunction2(Void, BinkSetWillLoop, ReturnValue(NoReturn),
	/*Parameter*/ Int32u, unknown0,
	/*Parameter*/ Int32u, unknown1
)

	BinkCall(unknown0, unknown1);

	BinkFunctionEpilog();
}

BinkDefineFunction2(Int32u, BinkStartAsyncThread, ReturnValue(0),
	/*Parameter*/ Int32u, threadNumber,
	/*Parameter*/ Void*, userData
)

	Int32u result = BinkCall(threadNumber, userData);

	BinkFunctionEpilog(result);
}

BinkDefineFunction1(Int32u, BinkWaitStopAsyncThread, ReturnValue(0),
	/*Parameter*/ Int32u, threadNumber
)

	Int32u result = BinkCall(threadNumber);

	BinkFunctionEpilog(result);
}

//////////////////////////////////////////////////////////////////////////

#undef BinkFunctionVars
#undef BinkFunctionProlog
#undef BinkFunctionCallLog
#undef BinkCallValidate
#undef BinkCall
#undef BinkCheckError
#undef BinkFunctionEpilog

#undef BinkMakeDescriptorName
#undef BinkMakeCall

#undef BinkDeclareDescriptor
#undef BikModDeclareDescriptor