Work/vidcap/CAPPARMS.HPP

#ifndef _VIDCAP_CAPTUREPARAMS_HPP_
#define _VIDCAP_CAPTUREPARAMS_HPP_
#include <memory.h>
#include <common/vfw.hpp>

class CaptureParams : private CAPTUREPARMS
{
public:
	CaptureParams(void);
	CaptureParams(const CaptureParams &someCaptureParams);
	CaptureParams(const CAPTUREPARMS &someCAPTUREPARMS);
	virtual ~CaptureParams(void);
	CaptureParams &operator=(const CaptureParams &someCaptureParams);
	CaptureParams &operator=(const CAPTUREPARMS &someCAPTUREPARMS);
	WORD operator==(const CaptureParams &someCaptureParams);
	WORD operator==(const CAPTUREPARMS &someCAPTUREPARMS);
	DWORD requestMicroSecondsPerFrame(void)const;
	void requestMicroSecondsPerFrame(DWORD requestMicroSecondsPerFrame);
	WORD hitOkToCapture(void)const;
	void hitOkToCapture(WORD hitOkToCapture);
	WORD percentDropForError(void)const;
	void percentDropForError(WORD percentDropForError);
	WORD yield(void)const;
	void yield(WORD yield);
	DWORD sizeIndex(void)const;
	void sizeIndex(DWORD sizeIndex);
	WORD chunkGranularity(void)const;
	void chunkGranularity(WORD chunkGranularity);
	WORD usingDOSMemory(void)const;
	void usingDOSMemory(WORD usingDOSMemory);
	WORD numVideoRequested(void)const;
	void numVideoRequested(WORD numVideoRequested);
	WORD captureAudio(void)const;
	void captureAudio(WORD captureAudio);
	WORD numAudioRequested(void)const;
	void numAudioRequested(WORD numAudioRequested);
	WORD keyAbort(void)const;
	void keyAbort(WORD keyAbort);
	WORD abortLeftMouse(void)const;
	void abortLeftMouse(WORD abortLeftMouse);
	WORD abortRightMouse(void)const;
	void abortRightMouse(WORD abortRightMouse);
	WORD limitEnabled(void)const;
	void limitEnabled(WORD limitEnabled);
	WORD timeLimit(void)const;
	void timeLimit(WORD timeLimit);
	WORD mciControl(void)const;
	void mciControl(WORD mciControl);
	WORD stepMCIDevice(void)const;
	void stepMCIDevice(WORD stepMCIDevice);
	DWORD mciStartTime(void)const;
	void mciStartTime(DWORD mciStartTime);
	DWORD mciStopTime(void)const;
	void mciStopTime(DWORD mciStopTime);
	WORD stepCaptureAt2x(void)const;
	void stepCaptureAt2x(WORD stepCaptureAt2x);
	WORD stepCaptureAverageFrames(void)const;
	void stepCaptureAverageFrames(WORD stepCaptureAverageFrames);
	DWORD audioBufferSize(void)const;
	void audioBufferSize(DWORD audioBufferSize);
	WORD disableWriteCache(void)const;
	void disableWriteCache(WORD disableWriteCache);
	UINT streamMaster(void)const;
	void streamMaster(UINT streamMaster);
private:
	void setZero(void);
};

inline
CaptureParams::CaptureParams(void)
{
	setZero();
}

inline
CaptureParams::CaptureParams(const CaptureParams &someCaptureParams)
{
	*this=someCaptureParams;
}

inline
CaptureParams::CaptureParams(const CAPTUREPARMS &someCAPTUREPARMS)
{
	*this=someCAPTUREPARMS;
}

inline
CaptureParams::~CaptureParams(void)
{
}

inline
CaptureParams &CaptureParams::operator=(const CaptureParams &someCaptureParams)
{
	::memcpy((char*)&((CAPTUREPARMS&)*this),(char*)&((CAPTUREPARMS&)someCaptureParams),sizeof(CAPTUREPARMS));
	return *this;
}

inline
CaptureParams &CaptureParams::operator=(const CAPTUREPARMS &someCAPTUREPARMS)
{
	::memcpy((char*)&((CAPTUREPARMS&)*this),(char*)&someCAPTUREPARMS,sizeof(CAPTUREPARMS));
	return *this;
}

inline
WORD CaptureParams::operator==(const CaptureParams &someCaptureParams)
{
	return ::memcmp((char*)&((CAPTUREPARMS&)*this),(char*)&((CAPTUREPARMS&)someCaptureParams),sizeof(CAPTUREPARMS))?FALSE:TRUE;
}

inline
WORD CaptureParams::operator==(const CAPTUREPARMS &someCAPTUREPARMS)
{
	return ::memcmp((char*)&((CAPTUREPARMS&)*this),(char*)&someCAPTUREPARMS,sizeof(CAPTUREPARMS))?FALSE:TRUE;
}

inline
DWORD CaptureParams::requestMicroSecondsPerFrame(void)const
{
	return CAPTUREPARMS::dwRequestMicroSecPerFrame;
}

inline
void CaptureParams::requestMicroSecondsPerFrame(DWORD requestMicroSecondsPerFrame)
{
	CAPTUREPARMS::dwRequestMicroSecPerFrame=requestMicroSecondsPerFrame;
}

inline
WORD CaptureParams::hitOkToCapture(void)const
{
	return CAPTUREPARMS::fMakeUserHitOKToCapture;
}

inline
void CaptureParams::hitOkToCapture(WORD hitOkToCapture)
{
	CAPTUREPARMS::fMakeUserHitOKToCapture=hitOkToCapture;
}

inline
WORD CaptureParams::percentDropForError(void)const
{
	return CAPTUREPARMS::wPercentDropForError;
}

inline
void CaptureParams::percentDropForError(WORD percentDropForError)
{
	CAPTUREPARMS::wPercentDropForError=percentDropForError;
}

inline
WORD CaptureParams::yield(void)const
{
	return CAPTUREPARMS::fYield;
}

inline
void CaptureParams::yield(WORD yield)
{
	CAPTUREPARMS::fYield=yield;
}

inline
DWORD CaptureParams::sizeIndex(void)const
{
	return CAPTUREPARMS::dwIndexSize;
}

inline
void CaptureParams::sizeIndex(DWORD sizeIndex)
{
	CAPTUREPARMS::dwIndexSize=sizeIndex;
}

inline
WORD CaptureParams::chunkGranularity(void)const
{
	return CAPTUREPARMS::wChunkGranularity;
}

inline
void CaptureParams::chunkGranularity(WORD chunkGranularity)
{
	CAPTUREPARMS::wChunkGranularity=chunkGranularity;
}

inline
WORD CaptureParams::usingDOSMemory(void)const
{
	return CAPTUREPARMS::fUsingDOSMemory;
}

inline
void CaptureParams::usingDOSMemory(WORD usingDOSMemory)
{
	CAPTUREPARMS::fUsingDOSMemory=usingDOSMemory;
}

inline
WORD CaptureParams::numVideoRequested(void)const
{
	return CAPTUREPARMS::wNumVideoRequested;
}

inline
void CaptureParams::numVideoRequested(WORD numVideoRequested)
{
	CAPTUREPARMS::wNumVideoRequested=numVideoRequested;
}

inline
WORD CaptureParams::captureAudio(void)const
{
	return CAPTUREPARMS::fCaptureAudio;
}

inline
void CaptureParams::captureAudio(WORD captureAudio)
{
	CAPTUREPARMS::fCaptureAudio=captureAudio;
}

inline
WORD CaptureParams::numAudioRequested(void)const
{
	return CAPTUREPARMS::wNumAudioRequested;
}

inline
void CaptureParams::numAudioRequested(WORD numAudioRequested)
{
	CAPTUREPARMS::wNumAudioRequested=numAudioRequested;
}

inline
WORD CaptureParams::keyAbort(void)const
{
	return CAPTUREPARMS::vKeyAbort;
}

inline
void CaptureParams::keyAbort(WORD keyAbort)
{
	CAPTUREPARMS::vKeyAbort=keyAbort;
}

inline
WORD CaptureParams::abortLeftMouse(void)const
{
	return CAPTUREPARMS::fAbortLeftMouse;
}

inline
void CaptureParams::abortLeftMouse(WORD abortLeftMouse)
{
	CAPTUREPARMS::fAbortLeftMouse=abortLeftMouse;
}

inline
WORD CaptureParams::abortRightMouse(void)const
{
	return CAPTUREPARMS::fAbortRightMouse;
}

inline
void CaptureParams::abortRightMouse(WORD abortRightMouse)
{
	CAPTUREPARMS::fAbortRightMouse=abortRightMouse;
}

inline
WORD CaptureParams::limitEnabled(void)const
{
	return CAPTUREPARMS::fLimitEnabled;
}

inline
void CaptureParams::limitEnabled(WORD limitEnabled)
{
	CAPTUREPARMS::fLimitEnabled=limitEnabled;
}

inline
WORD CaptureParams::timeLimit(void)const
{
	return CAPTUREPARMS::wTimeLimit;
}

inline
void CaptureParams::timeLimit(WORD timeLimit)
{
	CAPTUREPARMS::wTimeLimit=timeLimit;
}

inline
WORD CaptureParams::mciControl(void)const
{
	return CAPTUREPARMS::fMCIControl;
}

inline
void CaptureParams::mciControl(WORD mciControl)
{
	CAPTUREPARMS::fMCIControl=mciControl;
}

inline
WORD CaptureParams::stepMCIDevice(void)const
{
	return CAPTUREPARMS::fStepMCIDevice;
}

inline
void CaptureParams::stepMCIDevice(WORD stepMCIDevice)
{
	CAPTUREPARMS::fStepMCIDevice=stepMCIDevice;
}

inline
DWORD CaptureParams::mciStartTime(void)const
{
	return CAPTUREPARMS::dwMCIStartTime;
}

inline
void CaptureParams::mciStartTime(DWORD mciStartTime)
{
	CAPTUREPARMS::dwMCIStartTime=mciStartTime;
}

inline
DWORD CaptureParams::mciStopTime(void)const
{
	return CAPTUREPARMS::dwMCIStopTime;
}

inline
void CaptureParams::mciStopTime(DWORD mciStopTime)
{
	CAPTUREPARMS::dwMCIStopTime=mciStopTime;
}

inline
WORD CaptureParams::stepCaptureAt2x(void)const
{
	return CAPTUREPARMS::fStepCaptureAt2x;
}

inline
void CaptureParams::stepCaptureAt2x(WORD stepCaptureAt2x)
{
	CAPTUREPARMS::fStepCaptureAt2x=stepCaptureAt2x;
}


inline
WORD CaptureParams::stepCaptureAverageFrames(void)const
{
	return CAPTUREPARMS::wStepCaptureAverageFrames;
}

inline
void CaptureParams::stepCaptureAverageFrames(WORD stepCaptureAverageFrames)
{
	CAPTUREPARMS::wStepCaptureAverageFrames=stepCaptureAverageFrames;
}

inline
DWORD CaptureParams::audioBufferSize(void)const
{
	return CAPTUREPARMS::dwAudioBufferSize;
}

inline
void CaptureParams::audioBufferSize(DWORD audioBufferSize)
{
	CAPTUREPARMS::dwAudioBufferSize=audioBufferSize;
}

inline
WORD CaptureParams::disableWriteCache(void)const
{
	return CAPTUREPARMS::fDisableWriteCache;
}

inline
void CaptureParams::disableWriteCache(WORD disableWriteCache)
{
	CAPTUREPARMS::fDisableWriteCache=disableWriteCache;
}

inline
UINT CaptureParams::streamMaster(void)const
{
  return CAPTUREPARMS::AVStreamMaster;
}

inline
void CaptureParams::streamMaster(UINT streamMaster)
{
  CAPTUREPARMS::AVStreamMaster=streamMaster;
}

inline
void CaptureParams::setZero(void)
{
	::memset((char*)&((CAPTUREPARMS&)*this),0,sizeof(CAPTUREPARMS));
}
#endif