#ifndef _AVIFILE_ICMCOMPRESS_HPP_
#define _AVIFILE_ICMCOMPRESS_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 ICMCompress : private ICCOMPRESS
{
public:
  typedef enum Flags{KeyFrame=AVIIF_KEYFRAME};
  ICMCompress(void);
	virtual ~ICMCompress();
  DWORD flags(void)const;
	void flags(DWORD flags);
  LPBITMAPINFOHEADER dstBitmapInfoHeaderPtr(void);
	void dstBitmapInfoHeaderPtr(LPBITMAPINFOHEADER pBitmapInfoHeader);
	LPVOID dstOutputPtr(void);
	void dstOutputPtr(LPVOID pOutputData);
	void dstOutputPtr(MovieData &movieData);
  LPBITMAPINFOHEADER srcBitmapInfoHeaderPtr(void);
	void srcBitmapInfoHeaderPtr(LPBITMAPINFOHEADER pBitmapInfoHeader);
	LPVOID srcInputPtr(void);
	void srcInputPtr(LPVOID pInputData);
	void srcInputPtr(MovieData &movieData);
  LPBITMAPINFOHEADER prevBitmapInfoHeaderPtr(void);
	void prevBitmapInfoHeaderPtr(LPBITMAPINFOHEADER pBitmapInfoHeader);
	LPVOID prevOutputPtr(void);
	void prevOutputPtr(LPVOID pOutputData);
	LPDWORD chunkID(void);
	void chunkID(LPDWORD ckid);
	LPDWORD indxFlags(void);
	void indxFlags(LPDWORD indxFlags);
	LONG frameNum(void)const;
	void frameNum(LONG frameNum);
	DWORD frameSize(void)const;
	void frameSize(LONG frameSize);
	DWORD quality(void)const;
	void quality(DWORD quality);
  ICCOMPRESS &getICCOMPRESS(void);
	static LONG size(void);
private:
  void setZero(void);
};

inline
ICMCompress::ICMCompress(void)
{
  setZero();
	flags(KeyFrame);
}

inline
ICMCompress::~ICMCompress()
{
}

inline
DWORD ICMCompress::flags(void)const
{
  return ICCOMPRESS::dwFlags;
}

inline
void ICMCompress::flags(DWORD flags)
{
  ICCOMPRESS::dwFlags=flags;
}

inline
LPBITMAPINFOHEADER ICMCompress::dstBitmapInfoHeaderPtr(void)
{
  return ICCOMPRESS::lpbiOutput;
}

inline
void ICMCompress::dstBitmapInfoHeaderPtr(LPBITMAPINFOHEADER pBitmapInfoHeader)
{
  ICCOMPRESS::lpbiOutput=pBitmapInfoHeader;
}

inline
LPVOID ICMCompress::dstOutputPtr(void)
{
  return ICCOMPRESS::lpOutput;
}

inline
void ICMCompress::dstOutputPtr(LPVOID pOutputData)
{
  ICCOMPRESS::lpOutput=pOutputData;
}

inline
void ICMCompress::dstOutputPtr(MovieData &movieData)
{
  ICCOMPRESS::lpOutput=&movieData[0];
}

inline
LPBITMAPINFOHEADER ICMCompress::srcBitmapInfoHeaderPtr(void)
{
  return ICCOMPRESS::lpbiInput;
}

inline
void ICMCompress::srcBitmapInfoHeaderPtr(LPBITMAPINFOHEADER pBitmapInfoHeader)
{
  ICCOMPRESS::lpbiInput=pBitmapInfoHeader;
}

inline
LPVOID ICMCompress::srcInputPtr(void)
{
  return ICCOMPRESS::lpInput;
}

inline
void ICMCompress::srcInputPtr(LPVOID pInputData)
{
  ICCOMPRESS::lpInput=pInputData;
}

inline
void ICMCompress::srcInputPtr(MovieData &movieData)
{
  ICCOMPRESS::lpInput=&movieData[0];
}

inline
LPBITMAPINFOHEADER ICMCompress::prevBitmapInfoHeaderPtr(void)
{
  return ICCOMPRESS::lpbiPrev;
}

inline
void ICMCompress::prevBitmapInfoHeaderPtr(LPBITMAPINFOHEADER pBitmapInfoHeader)
{
  ICCOMPRESS::lpbiPrev=pBitmapInfoHeader;
}

inline
LPVOID ICMCompress::prevOutputPtr(void)
{
  return ICCOMPRESS::lpPrev;
}

inline
void ICMCompress::prevOutputPtr(LPVOID pPrevData)
{
  ICCOMPRESS::lpPrev=pPrevData;
}

inline
LPDWORD ICMCompress::chunkID(void)
{
  return ICCOMPRESS::lpckid;
}

inline
void ICMCompress::chunkID(LPDWORD ckid)
{
  ICCOMPRESS::lpckid=ckid;
}

inline
LPDWORD ICMCompress::indxFlags(void)
{
  return ICCOMPRESS::lpdwFlags;
}

inline
void ICMCompress::indxFlags(LPDWORD indxFlags)
{
  ICCOMPRESS::lpdwFlags=indxFlags;
}

inline
LONG ICMCompress::frameNum(void)const
{
  return ICCOMPRESS::lFrameNum;
}

inline
void ICMCompress::frameNum(LONG frameNum)
{
  ICCOMPRESS::lFrameNum=frameNum;
}

inline
DWORD ICMCompress::frameSize(void)const
{
  return ICCOMPRESS::dwFrameSize;
}

inline
void ICMCompress::frameSize(LONG frameSize)
{
  ICCOMPRESS::dwFrameSize=frameSize;
}

inline
DWORD ICMCompress::quality(void)const
{
  return ICCOMPRESS::dwQuality;
}

inline
void ICMCompress::quality(DWORD quality)
{
  ICCOMPRESS::dwQuality=quality;
}

inline
ICCOMPRESS &ICMCompress::getICCOMPRESS(void)
{
  return (ICCOMPRESS&)*this;
}

inline
void ICMCompress::setZero()
{
  memset(&getICCOMPRESS(),0,sizeof(ICCOMPRESS));
}

inline
LONG ICMCompress::size(void)
{
  return sizeof(ICCOMPRESS);
}
#endif