Work/avifile/ICMDCPRS.HPP

#ifndef _AVIFILE_ICMDECOMPRESS_HPP_
#define _AVIFILE_ICMDECOMPRESS_HPP_
#ifndef _AVIFILE_AVIDEFS_HPP_
#include <avifile/avidefs.hpp>
#endif
#ifndef _AVIFILE_AVIBITMAP_HPP_
#include <avifile/avibmp.hpp>
#endif
#ifndef _AVIFILE_MOVIEDATA_HPP_
#include <avifile/movidata.hpp>
#endif

class ICMDecompress : private ICDECOMPRESS
{
public:
	enum Flags{HurryUp=ICDECOMPRESS_HURRYUP,Update=ICDECOMPRESS_UPDATE,
			 PreRoll=ICDECOMPRESS_PREROLL,NullFrame=ICDECOMPRESS_NULLFRAME,
			 NotKeyFrame=ICDECOMPRESS_NOTKEYFRAME};
	ICMDecompress(void);
	ICMDecompress(const ICMDecompress &someICMDecompress);
	virtual ~ICMDecompress();
	ICMDecompress &operator=(const ICMDecompress &someICMDecompress);
  WORD operator==(const ICMDecompress &someICMDecompress);
	DWORD flags(void)const;
	void flags(DWORD flags);
	LPBITMAPINFOHEADER srcBitmapInfoHeaderPtr(void)const;
	void srcBitmapInfoHeaderPtr(LPBITMAPINFOHEADER lpBitmapInfoHeader);
  void srcBitmapInfoPtr(AVIBitmap &someAVIBitmap);
	LPBITMAPINFOHEADER dstBitmapInfoHeaderPtr(void)const;
	void dstBitmapInfoHeaderPtr(LPBITMAPINFOHEADER lpBitmapInfoHeader);
  void dstBitmapInfoPtr(AVIBitmap &someAVIBitmap);
	LPVOID srcInputPtr(void)const;
	void srcInputPtr(LPVOID lpDataBuffer);
  void srcInputPtr(MovieData &someMovieData);
	LPVOID dstInputPtr(void)const;
	void dstInputPtr(LPVOID lpDataBuffer);
  void dstInputPtr(MovieData &someMovieData);
	DWORD chunkID(void)const;
	void chunkID(DWORD chunkID);
	WORD hasHurryUp(void)const;
	WORD hasUpdate(void)const;
	WORD hasPreRoll(void)const;
	WORD hasNullFrame(void)const;
	WORD hasNotKeyFrame(void)const;
	static LONG size(void);
private:
};

inline
ICMDecompress::ICMDecompress(void)
{
	flags(0L);
	srcBitmapInfoHeaderPtr((LPBITMAPINFOHEADER)0);
	dstBitmapInfoHeaderPtr((LPBITMAPINFOHEADER)0);
	srcInputPtr((LPVOID)0);
	dstInputPtr((LPVOID)0);
  chunkID(0L);
}

inline
ICMDecompress::ICMDecompress(const ICMDecompress &someICMDecompress)
{
  *this=someICMDecompress;
}

inline
ICMDecompress::~ICMDecompress()
{
}

inline
ICMDecompress &ICMDecompress::operator=(const ICMDecompress &someICMDecompress)
{
	flags(someICMDecompress.flags());
	srcBitmapInfoHeaderPtr(someICMDecompress.srcBitmapInfoHeaderPtr());
	dstBitmapInfoHeaderPtr(someICMDecompress.dstBitmapInfoHeaderPtr());
	srcInputPtr(someICMDecompress.srcInputPtr());
	dstInputPtr(someICMDecompress.dstInputPtr());
	chunkID(someICMDecompress.chunkID());
  return *this;
}

inline
WORD ICMDecompress::operator==(const ICMDecompress &someICMDecompress)
{
	return (flags()==someICMDecompress.flags()&&
					srcBitmapInfoHeaderPtr()==someICMDecompress.srcBitmapInfoHeaderPtr()&&
					dstBitmapInfoHeaderPtr()==someICMDecompress.dstBitmapInfoHeaderPtr()&&
					srcInputPtr()==someICMDecompress.srcInputPtr()&&
					dstInputPtr()==someICMDecompress.dstInputPtr()&&
          chunkID()==someICMDecompress.chunkID());
}

inline
DWORD ICMDecompress::flags(void)const
{
  return ICDECOMPRESS::dwFlags;
}

inline
void ICMDecompress::flags(DWORD flags)
{
  ICDECOMPRESS::dwFlags=flags;
}

inline
LPBITMAPINFOHEADER ICMDecompress::srcBitmapInfoHeaderPtr(void)const
{
  return ICDECOMPRESS::lpbiInput;
}

inline
void ICMDecompress::srcBitmapInfoHeaderPtr(LPBITMAPINFOHEADER lpBitmapInfoHeader)
{
  ICDECOMPRESS::lpbiInput=lpBitmapInfoHeader;
}

inline
LPBITMAPINFOHEADER ICMDecompress::dstBitmapInfoHeaderPtr(void)const
{
  return ICDECOMPRESS::lpbiOutput;
}

inline
void ICMDecompress::dstBitmapInfoHeaderPtr(LPBITMAPINFOHEADER lpBitmapInfoHeader)
{
  ICDECOMPRESS::lpbiOutput=lpBitmapInfoHeader;
}

inline
LPVOID ICMDecompress::srcInputPtr(void)const
{
  return ICDECOMPRESS::lpInput;
}

inline
void ICMDecompress::srcInputPtr(LPVOID lpDataBuffer)
{
  ICDECOMPRESS::lpInput=lpDataBuffer;
}

inline
LPVOID ICMDecompress::dstInputPtr(void)const
{
  return ICDECOMPRESS::lpOutput;
}

inline
void ICMDecompress::dstInputPtr(LPVOID lpDataBuffer)
{
  ICDECOMPRESS::lpOutput=lpDataBuffer;
}

inline
DWORD ICMDecompress::chunkID(void)const
{
  return ICDECOMPRESS::ckid;
}

inline
void ICMDecompress::chunkID(DWORD chunkID)
{
	ICDECOMPRESS::ckid=chunkID;
}

inline
void ICMDecompress::dstBitmapInfoPtr(AVIBitmap &someAVIBitmap)
{
	ICDECOMPRESS::lpbiOutput=&((BITMAPINFOHEADER&)someAVIBitmap);
}

inline
void ICMDecompress::srcBitmapInfoPtr(AVIBitmap &someAVIBitmap)
{
	ICDECOMPRESS::lpbiInput=&((BITMAPINFOHEADER&)someAVIBitmap);
}

inline
void ICMDecompress::srcInputPtr(MovieData &someMovieData)
{
  ICDECOMPRESS::lpInput=(BYTE*)&someMovieData[0];
}

inline
void ICMDecompress::dstInputPtr(MovieData &someMovieData)
{
  ICDECOMPRESS::lpOutput=(BYTE*)&someMovieData[0];
}

inline
WORD ICMDecompress::hasHurryUp(void)const
{
  return flags()&HurryUp;	
}

inline
WORD ICMDecompress::hasUpdate(void)const
{
  return flags()&Update;
}

inline
WORD ICMDecompress::hasPreRoll(void)const
{
  return flags()&PreRoll;
}

inline
WORD ICMDecompress::hasNullFrame(void)const
{
  return flags()&NullFrame;
}

inline
WORD ICMDecompress::hasNotKeyFrame(void)const
{
  return flags()&NotKeyFrame;
}

inline
LONG ICMDecompress::size(void)
{
  return sizeof(ICDECOMPRESS);
}
#endif