Initial

avifile/hold/ADDHDR.CPP

@@ -0,0 +1,21 @@
+#include <avifile/addhdr.hpp>
+
+bool AVIAdditionalHeader::read(File &inFile)
+{
+	String strdLiteral("strd");
+	String strdHeader;
+  DWORD sizeHeader;
+
+	strdHeader.reserve(strdLiteral.length()+1);
+	inFile.read(strdHeader,strdLiteral.length());
+	if(!(strdHeader==strdLiteral))
+	{
+		inFile-=strdLiteral.length();
+    return false;
+	}
+	::OutputDebugString(String("[AVIAdditionalHeader::operator<<]")+strdHeader+String("\n"));
+	inFile.read(sizeHeader);
+	inFile+=sizeHeader;
+  return true;
+}
+

avifile/hold/ADDHDR.HPP

@@ -0,0 +1,47 @@
+#ifndef _AVIFILE_ADDITIONALHEADER_HPP_
+#define _AVIFILE_ADDITIONALHEAEDR_HPP_
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+
+class AVIAdditionalHeader
+{
+public:
+	AVIAdditionalHeader(void);
+	AVIAdditionalHeader(const AVIAdditionalHeader &someAVIAdditionalHeader);
+	virtual ~AVIAdditionalHeader(void);
+  bool read(File &inFile);
+	AVIAdditionalHeader &operator=(const AVIAdditionalHeader &someAVIAdditionalHeader);
+	bool operator==(const AVIAdditionalHeader &someAVIAdditionalHeader)const;
+private:
+};
+
+inline
+AVIAdditionalHeader::AVIAdditionalHeader(void)
+{
+}
+
+inline
+AVIAdditionalHeader::AVIAdditionalHeader(const AVIAdditionalHeader &someAVIAdditionalHeader)
+{
+  *this=someAVIAdditionalHeader;
+}
+
+inline
+AVIAdditionalHeader::~AVIAdditionalHeader(void)
+{
+}
+
+inline
+AVIAdditionalHeader &AVIAdditionalHeader::operator=(const AVIAdditionalHeader &/*someAVIAdditionalHeader*/)
+{
+	return *this;
+}
+
+inline
+bool AVIAdditionalHeader::operator==(const AVIAdditionalHeader &/*someAVIAdditionalHeader*/)const
+{
+  return true;
+}
+#endif
+

avifile/hold/AVIBMP.CPP

@@ -0,0 +1,38 @@
+#include <avifile/avibmp.hpp>
+
+bool AVIBitmap::read(File &inFile)
+{
+  DWORD sizeHeader;
+
+	inFile.read(sizeHeader);
+//  inFile+=4;
+
+  inFile.read((char*)((BITMAPINFO*)*this),sizeof(BITMAPINFO)-sizeof(RGBQUAD)); 
+	if(BitmapInfo::TrueColor==bitCount())return false;
+	if(colorUsed())
+	{
+		rgbColors(colorUsed());
+		inFile.read((char*)((RGBQUAD*)*this),sizeof(RGBQUAD));
+    inFile.read((char*)(((RGBQUAD*)*this)+1),(colorUsed()-1)*sizeof(RGBQUAD));
+	}
+  return true;
+}
+
+bool AVIBitmap::write(File &outFile)
+{
+  DWORD sizeHeader;
+
+	sizeHeader=sizeof(BITMAPINFOHEADER);
+	outFile.write(sizeHeader);
+//  outFile+=4;
+
+  outFile.write((char*)((BITMAPINFO*)*this),sizeof(BITMAPINFO)-sizeof(RGBQUAD)); 
+	if(BitmapInfo::TrueColor==bitCount())return false;
+	if(colorUsed())
+	{
+		rgbColors(colorUsed());
+		outFile.write((char*)((RGBQUAD*)*this),sizeof(RGBQUAD));
+    outFile.write((char*)(((RGBQUAD*)*this)+1),(colorUsed()-1)*sizeof(RGBQUAD));
+	}
+  return true;
+}

avifile/hold/AVIBMP.HPP

@@ -0,0 +1,52 @@
+#ifndef _AVIFILE_AVIBITMAP_HPP_
+#define _AVIFILE_AVIBITMAP_HPP_
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_BITMAPINFO_HPP_
+#include <common/bminfo.hpp>
+#endif
+
+class AVIBitmap : public BitmapInfo
+{
+public:
+	AVIBitmap(void);
+	AVIBitmap(const AVIBitmap &someAVIBitmap);
+	virtual ~AVIBitmap();
+	AVIBitmap &operator=(const AVIBitmap &someAVIBitmap);
+	bool operator==(const AVIBitmap &someAVIBitmap)const;
+  bool read(File &inFile);
+	bool write(File &outFile);
+private:
+	enum {TrueColor=24};
+};
+
+inline
+AVIBitmap::AVIBitmap(void)
+{
+}
+
+inline
+AVIBitmap::AVIBitmap(const AVIBitmap &someAVIBitmap)
+{
+  *this=someAVIBitmap;
+}
+
+inline
+AVIBitmap::~AVIBitmap()
+{
+}
+
+inline
+AVIBitmap &AVIBitmap::operator=(const AVIBitmap &someAVIBitmap)
+{
+  (BitmapInfo&)*this=(BitmapInfo&)someAVIBitmap;
+	return *this;
+}
+
+inline
+bool AVIBitmap::operator==(const AVIBitmap &someAVIBitmap)const
+{
+	return (BitmapInfo&)*this==(BitmapInfo&)someAVIBitmap;
+}
+#endif

avifile/hold/AVIDEFS.HPP

@@ -0,0 +1,11 @@
+#ifndef _AVIFILE_AVIDEFS_HPP_
+#define _AVIFILE_AVIDEFS_HPP_
+#define AVI(name) AVIVFW##name
+#define AVIStreamHeader AVIVFWStreamHeader
+#define FOURCC VFWFOURCC
+#ifndef _COMMON_VFW_HPP_
+#include <common/vfw.hpp>
+#endif
+#undef AVIStreamHeader
+#undef FOURCC
+#endif

avifile/hold/AVIDV.cpp

@@ -0,0 +1,59 @@
+#include <avifile/AVIDV.hpp>
+
+AVIDigitalVideo::AVIDigitalVideo(void)
+{
+}
+
+AVIDigitalVideo::AVIDigitalVideo(const AVIDigitalVideo &aviDigitalVideo)
+{
+  *this=aviDigitalVideo;
+}
+
+AVIDigitalVideo::~AVIDigitalVideo()
+{
+}
+
+AVIDigitalVideo &AVIDigitalVideo::operator=(const AVIDigitalVideo &aviDigitalVideo)
+{
+  (DVINFO&)*this=(DVINFO&)aviDigitalVideo;
+	return *this;
+
+}
+
+bool AVIDigitalVideo::operator==(const AVIDigitalVideo &aviDigitalVideo)
+{
+  if(DVINFO::dwDVAAuxSrc!=aviDigitalVideo.dwDVAAuxSrc)return false;
+	if(DVINFO::dwDVAAuxCtl!=aviDigitalVideo.dwDVAAuxCtl)return false;
+	if(DVINFO::dwDVAAuxSrc1!=aviDigitalVideo.dwDVAAuxSrc1)return false;
+	if(DVINFO::dwDVAAuxCtl1!=aviDigitalVideo.dwDVAAuxCtl1)return false;
+	if(DVINFO::dwDVVAuxSrc!=aviDigitalVideo.dwDVVAuxSrc)return false;
+	if(DVINFO::dwDVVAuxCtl!=aviDigitalVideo.dwDVVAuxCtl)return false;
+	return true;
+}
+
+bool AVIDigitalVideo::read(File &inFile)
+{
+  inFile.read(DVINFO::dwDVAAuxSrc);
+	inFile.read(DVINFO::dwDVAAuxCtl);
+  inFile.read(DVINFO::dwDVAAuxSrc1);
+	inFile.read(DVINFO::dwDVAAuxCtl1);
+  inFile.read(DVINFO::dwDVVAuxSrc);
+	inFile.read(DVINFO::dwDVVAuxCtl);
+	inFile.read(DVINFO::dwDVReserved[0]);
+  inFile.read(DVINFO::dwDVReserved[1]);
+  return true;
+}
+
+bool AVIDigitalVideo::write(File &outFile)
+{
+  outFile.write(DVINFO::dwDVAAuxSrc);
+	outFile.write(DVINFO::dwDVAAuxCtl);
+  outFile.write(DVINFO::dwDVAAuxSrc1);
+	outFile.write(DVINFO::dwDVAAuxCtl1);
+  outFile.write(DVINFO::dwDVVAuxSrc);
+	outFile.write(DVINFO::dwDVVAuxCtl);
+	outFile.write(DVINFO::dwDVReserved[0]);
+  outFile.write(DVINFO::dwDVReserved[1]);
+	return true;
+}
+

avifile/hold/AVIDV.hpp

@@ -0,0 +1,26 @@
+#ifndef _AVIFILE_AVIDV_HPP_
+#define _AVIFILE_AVIDV_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_VFW_HPP_
+#include <common/vfw.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+
+class AVIDigitalVideo : private DVINFO
+{
+public:
+  AVIDigitalVideo(void);
+	AVIDigitalVideo(const AVIDigitalVideo &aviDigitalVideo);
+	virtual ~AVIDigitalVideo();
+	AVIDigitalVideo &operator=(const AVIDigitalVideo &aviDigitalVideo);
+	bool operator==(const AVIDigitalVideo &aviDigitalVideo);
+	bool read(File &inFile);
+	bool write(File &outFile);
+private:
+};
+
+#endif

avifile/hold/AVIFILE.CPP

@@ -0,0 +1,30 @@
+#include <common/string.hpp>
+#include <avifile/avifile.hpp>
+#include <avifile/riffhdr.hpp>
+
+AVIFile::AVIFile(const String &pathFileName)
+: mAVIFile(pathFileName,"rb")
+{
+	RIFFHeader riffHeader;
+	AVIListChunk aviListChunk;
+
+	if(!isOkay())return;
+  if(!riffHeader.read(mAVIFile))return;
+	while(TRUE)
+	{
+    aviListChunk.read(mAVIFile);
+		::OutputDebugString(aviListChunk.toString()+String("\n"));
+		if(AVIListChunk::Header==aviListChunk.chunkType())
+		{
+			mAVIMainHeader.read(mAVIFile);
+			::OutputDebugString(mAVIMainHeader.toString());
+		}
+    else if(AVIListChunk::Stream==aviListChunk.chunkType())mAVIStreamData.read(mAVIFile);
+		else if(AVIListChunk::Movie==aviListChunk.chunkType())mAVIMovieHeader.read(mAVIFile);
+		else if(AVIListChunk::Info==aviListChunk.chunkType())mAVIInfoHeader.read(mAVIFile);
+		else if(AVIListChunk::OpenDML==aviListChunk.chunkType())mAVIOpenDMLHeader.read(mAVIFile);
+		else if(AVIListChunk::Unknown==aviListChunk.chunkType())break;
+		else break;
+	}
+}
+

avifile/hold/AVIFILE.HPP

@@ -0,0 +1,73 @@
+#ifndef _AVIFILE_AVIFILE_HPP_
+#define _AVIFILE_AVIFILE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _AVIFILE_AVIMAINHEADER_HPP_
+#include <avifile/mainhdr.hpp>
+#endif
+#ifndef _AVIFILE_AVISTREAMDATA_HPP_
+#include <avifile/strmdata.hpp>
+#endif
+#ifndef _AVIFILE_AVIMOVIEHEADER_HPP_
+#include <avifile/moviehdr.hpp>
+#endif
+#ifndef _AVIFILE_AVIINFOHEADER_HPP_
+#include <avifile/infohdr.hpp>
+#endif
+#ifndef _AVIFILE_AVIOPENDMLHEADER_HPP_
+#include <avifile/AVIOpenDMLHeader.hpp>
+#endif
+
+class String;
+
+class AVIFile
+{
+public:
+	AVIFile(const String &pathFileName);
+	virtual ~AVIFile();
+	bool isOkay(void)const;
+	operator AVIMainHeader&(void);
+	operator AVIStreamData&(void);
+  operator AVIMovieHeader&(void);
+private:
+  File mAVIFile;
+	AVIMainHeader mAVIMainHeader;
+  AVIStreamData mAVIStreamData;
+	AVIMovieHeader mAVIMovieHeader;
+  AVIInfoHeader mAVIInfoHeader;
+	AVIOpenDMLHeader mAVIOpenDMLHeader;
+};
+
+inline
+AVIFile::~AVIFile()
+{
+}
+
+inline
+AVIFile::operator AVIMainHeader&(void)
+{
+  return mAVIMainHeader;
+}
+
+inline
+AVIFile::operator AVIStreamData&(void)
+{
+  return mAVIStreamData;
+}
+
+inline
+AVIFile::operator AVIMovieHeader&(void)
+{
+  return mAVIMovieHeader;
+}
+
+inline
+bool AVIFile::isOkay(void)const
+{
+  return mAVIFile.isOkay();
+}
+#endif

avifile/hold/AVIIndexHeader.cpp

@@ -0,0 +1,83 @@
+#include <avifile/AVIIndexHeader.hpp>
+
+AVIIndexHeader::AVIIndexHeader()
+{
+}
+
+AVIIndexHeader::~AVIIndexHeader()
+{
+}
+
+FOURCC AVIIndexHeader::fcc(void)const
+{
+  return FOURCC(mFCC);
+}
+
+UINT AVIIndexHeader::cb(void)const
+{
+  return mCB;
+}
+
+WORD AVIIndexHeader::longsPerEntry(void)const
+{
+  return mLongsPerEntry;
+}
+
+BYTE AVIIndexHeader::indexSubType(void)const
+{
+  return mIndexType;
+}
+
+DWORD AVIIndexHeader::entriesInUse(void)const
+{
+  return mEntriesInUse;
+}
+
+DWORD AVIIndexHeader::chunkID(void)const
+{
+  return mChunkId;
+}
+
+// skip through data until we understand more about the contents
+
+//bool AVIIndexHeader::operator<<(PureViewOfFile &pureView)
+bool AVIIndexHeader::read(File &inFile)
+{
+	String indexLiteral("indx");
+	String indexHeader;
+	DWORD sizeHeader;
+
+	indexHeader.reserve(indexLiteral.length()+1);
+//	pureView.read(indexHeader,indexLiteral.length());
+	inFile.read(indexHeader,indexLiteral.length());
+	if(!(indexLiteral==indexHeader))
+	{
+//		pureView-=indexLiteral.length();
+		inFile-=indexLiteral.length();
+		return FALSE;
+	}
+	inFile.read(sizeHeader);
+	inFile+=sizeHeader;
+
+//	pureView.read(sizeHeader);
+//	pureView+=sizeHeader;
+
+/*
+	pureView.read(mFCC);  
+	pureView.read(mCB);
+	pureView.read(mLongsPerEntry);
+	pureView.read(mIndexSubType);
+	pureView.read(mIndexType);
+	pureView.read(mEntriesInUse);
+	pureView.read(mChunkId);
+	pureView.read(mReserved[0]);
+	pureView.read(mReserved[1]);
+	pureView.read(mReserved[2]);
+	mADW.size(mLongsPerEntry);
+	pureView.read((char*)&mADW[0],mADW.size()*sizeof(DWORD));
+*/
+  return true;
+}
+
+
+

avifile/hold/AVIIndexHeader.hpp

@@ -0,0 +1,47 @@
+#ifndef _AVIFILE_AVIINDEXHEADER_HPP_
+#define _AVIFILE_AVIINDEXHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+//#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+//#include <common/pview.hpp>
+//#endif
+#ifndef _COMMON_ARRAY_HPP_
+#include <common/array.hpp>
+#endif
+#ifndef _AVIFILE_FOURCC_HPP_
+#include <avifile/fourcc.hpp>
+#endif
+#ifndef _COMMON_VFW_HPP_
+#include <common/vfw.hpp>
+#endif
+
+
+class AVIIndexHeader
+{
+public:
+  AVIIndexHeader();
+	virtual ~AVIIndexHeader();
+	bool read(File &inFile);
+// bool operator<<(PureViewOfFile &pureView);
+	FOURCC fcc(void)const;
+	UINT cb(void)const;
+	WORD longsPerEntry(void)const;
+	BYTE indexSubType(void)const;
+	DWORD entriesInUse(void)const;
+	DWORD chunkID(void)const;
+private:
+  DWORD mFCC;
+  UINT mCB;
+  WORD mLongsPerEntry;
+  BYTE mIndexSubType;
+  BYTE mIndexType;
+  DWORD mEntriesInUse;
+  DWORD mChunkId;
+  DWORD mReserved[3];
+	Array<DWORD> mADW;
+};
+#endif

avifile/hold/AVIOpenDMLHeader.cpp

@@ -0,0 +1,35 @@
+#include <avifile/AVIOpenDMLHeader.hpp>
+#include <avifile/junkhdr.hpp>
+
+AVIOpenDMLHeader::AVIOpenDMLHeader()
+{
+}
+
+AVIOpenDMLHeader::~AVIOpenDMLHeader()
+{
+}
+
+// skip through data until we understand more about the contents
+
+bool AVIOpenDMLHeader::read(File &inFile)
+{
+  AVIJunkHeader aviJunkHeader;
+	String literal("dmlh");
+	String header;
+	DWORD sizeHeader;
+
+	header.reserve(literal.length()+1);
+	inFile.read(header,literal.length());
+	if(!(literal==header))
+	{
+		inFile-=literal.length();
+		return false;
+	}
+	inFile.read(sizeHeader);
+	inFile+=sizeHeader;
+	aviJunkHeader.read(inFile);
+  return true;
+}
+
+
+

avifile/hold/AVIOpenDMLHeader.hpp

@@ -0,0 +1,35 @@
+#ifndef _AVIFILE_AVIOPENDMLHEADER_HPP_
+#define _AVIFILE_AVIOPENDMLHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_ARRAY_HPP_
+#include <common/array.hpp>
+#endif
+#ifndef _AVIFILE_FOURCC_HPP_
+#include <avifile/fourcc.hpp>
+#endif
+#ifndef _COMMON_VFW_HPP_
+#include <common/vfw.hpp>
+#endif
+
+class AVIOpenDMLHeader
+{
+public:
+  AVIOpenDMLHeader();
+	virtual ~AVIOpenDMLHeader();
+  bool read(File &inFile);
+	DWORD totalFrames(void)const;
+private:
+  DWORD mTotalFrames;
+};
+
+inline
+DWORD AVIOpenDMLHeader::totalFrames(void)const
+{
+  return mTotalFrames;
+}
+#endif

avifile/hold/AVITHRD.HPP

@@ -0,0 +1,97 @@
+#ifndef _AVIFILE_AVITHREAD_HPP_
+#define _AVIFILE_AVITHREAD_HPP_
+#ifndef _THREAD_MESSAGETHREAD_HPP_
+#include <thread/mthread.hpp>
+#endif
+
+class AVIThread : private MessageThread 
+{
+public:
+	AVIThread(void);
+	virtual ~AVIThread();
+protected:
+	enum AVIMessage{HeaderMessage,StreamMessage,MovieMessage,InfoMessage,UnknownMessage};
+	virtual void processHeader(void);
+	virtual void streamHeader(void);
+	virtual void movieHeader(void);
+	virtual void infoHeader(void);
+	virtual void unknownHeader(void);
+private:
+  AVIThread(const AVIThread &someAVIThread);
+	AVIThread &operator=(const AVIThread &someAVIThread);
+	WORD operator==(const AVIThread &someAVIThread);
+	DWORD aviThreadHandler(ThreadMessage &someThreadMessage);
+  ThreadCallback<AVIThread> mThreadHandler;
+};
+
+AVIThread::AVIThread(void)
+: mThreadHandler(this,&AVIThread::aviThreadHandler)
+{
+	insertHandler(&mThreadHandler);
+}
+
+AVIThread::AVIThread(const AVIThread &someAVIThread)
+: mThreadHandler(this,&AVIThread::aviThreadHandler)
+{
+  insertHandler(&mThreadHandler);
+}
+
+AVIThread::~AVIThread()
+{
+	removeHandler(&mThreadHandler);
+}
+
+AVIThread &operator=(const AVIThread &/*someAVIThread*/)
+{
+  return *this;
+}
+
+WORD AVIThread::operator==(const AVIThread &/*someAVIThread*/)
+{
+  return FALSE;
+}
+
+DWORD AVIThread::aviThreadHandler(ThreadMessage &someThreadMessage)
+{
+	switch(someThreadMessage.message())
+	{
+		case ThreadMessage::TM_CREATE :
+			break;
+		case ThreadMessage::TM_DESTROY :
+			break;
+		case ThreadMessage::TM_USER :
+			if(HeaderMessage==(AVIMessage)someThreadMessage.userDataOne())processHeader();
+			else if(StreamMessage==(AVIMessage)someThreadMessage.userDataOne())streamHeader();
+			else if(MovieMessage==(AVIMessage)someThreadMessage.userDataOne())movieHeader();
+			else if(InfoMessage==(AVIMessage)someThreadMessage.userDataOne())infoMessge();
+			else if(UnknownMessage==(AVIMessage)someThreadMessage.userDataOne())unknownHeader();
+      break;
+  }
+}
+
+void AVIThread::processHeader(void)
+{
+	return;
+}
+
+void AVIThread::streamHeader(void)
+{
+	return;
+}
+
+void AVIThread::movieHeader(void)
+{
+	return;
+}
+
+void AVIThread::infoHeader(void)
+{
+	return;
+}
+
+void AVIThread::unknownHeader(void)
+{
+  return;
+}
+#endif
+

avifile/hold/AVIWAVE.CPP

@@ -0,0 +1,63 @@
+#include <avifile/aviwave.hpp>
+#include <common/array.hpp>
+
+bool AVIWaveFormatEx::read(File &inFile)
+{
+  Array<BYTE> extraInfo;
+	DWORD dwParam;
+	WORD wParam;
+
+	inFile.read(wParam);
+	formatTag(wParam);
+	inFile.read(wParam);
+	channels(wParam);
+	inFile.read(dwParam);
+	samplesPerSecond(dwParam);
+	inFile.read(dwParam);
+	averageBytesPerSecond(dwParam);
+	inFile.read(wParam);
+	blockAlign(wParam);
+	inFile.read(wParam);
+	bitsPerSample(wParam);
+	inFile.read(wParam);
+	size(wParam);
+	extraInfo.size(size());
+	inFile.read((char*)&extraInfo[0],extraInfo.size());
+	return true;
+}
+
+bool AVIWaveFormatEx::write(File &outFile)
+{
+  Array<BYTE> extraInfo;
+	DWORD dwParam;
+	WORD wParam;
+
+	wParam=formatTag();
+	outFile.write(wParam);
+  wParam=channels;
+	outFile.write(wParam);
+  dwParam=samplesPerSecond();
+	outFile.write(dwParam);
+  dwParam=averageBytesPerSecond();
+	outFile.write(dwParam);
+  wParam=blockAlign();
+	outFile.write(wParam);
+  wParam=bitsPerSample();
+	outFile.write(wParam);
+	wParam=0;    // no extra info
+	outFile.write(wParam);
+	return true;
+}
+
+String AVIWaveFormatEx::toString(void)const
+{
+  String str;
+	str+=String("[AVIWaveFormatEx::toString]WAVEFORMATEX::wFormatTag=")+String().fromInt(formatTag())+String("\n");
+	str+=String("[AVIWaveFormatEx::toString]WAVEFORMATEX::nChannels=")+String().fromInt(channels())+String("\n");
+	str+=String("[AVIWaveFormatEx::toString]WAVEFORMATEX::nSamplesPerSec=")+String().fromInt(samplesPerSecond())+String("\n");
+	str+=String("[AVIWaveFormatEx::toString]WAVEFORMATEX::nAvgBytesPerSec=")+String().fromInt(averageBytesPerSecond())+String("\n");
+	str+=String("[AVIWaveFormatEx::toString]WAVEFORMATEX::nBlockAlign=")+String().fromInt(blockAlign())+String("\n");
+	str+=String("[AVIWaveFormatEx::toString]WAVEFORMATEX::wBitsPerSample=")+String().fromInt(bitsPerSample())+String("\n");
+	str+=String("[AVIWaveFormatEx::toString]WAVEFORMATEX::cbSize=")+String().fromInt(size())+String("\n");
+	return str;
+}

avifile/hold/AVIWAVE.HPP

@@ -0,0 +1,56 @@
+#ifndef _AVIFILE_AVIWAVE_HPP_
+#define _AVIFILE_AVIWAVE_HPP_
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_WAVEFORMATEX_HPP_
+#include <common/wavefrmx.hpp>
+#endif
+
+class AVIWaveFormatEx : public WaveFormatEx
+{
+public:
+	AVIWaveFormatEx(void);
+	AVIWaveFormatEx(const AVIWaveFormatEx &someWaveFormatEx);
+	virtual ~AVIWaveFormatEx();
+	AVIWaveFormatEx &operator=(const AVIWaveFormatEx &someAVIWaveFormatEx);
+	bool operator==(const WaveFormatEx &someWaveFormatEx)const;
+	bool read(File &inFile);
+	bool write(File &outFile);
+	String toString(void)const;
+private:
+};
+
+inline
+AVIWaveFormatEx::AVIWaveFormatEx(void)
+{
+}
+
+inline
+AVIWaveFormatEx::AVIWaveFormatEx(const AVIWaveFormatEx &someAVIWaveFormatEx)
+{
+  *this=someAVIWaveFormatEx;
+}
+
+inline
+AVIWaveFormatEx::~AVIWaveFormatEx()
+{
+}
+
+inline
+AVIWaveFormatEx &AVIWaveFormatEx::operator=(const AVIWaveFormatEx &someAVIWaveFormatEx)
+{
+	(WaveFormatEx&)*this=(WaveFormatEx&)someAVIWaveFormatEx;
+  return *this;
+}
+
+inline
+bool AVIWaveFormatEx::operator==(const WaveFormatEx &someWaveFormatEx)const
+{
+  return (WaveFormatEx&)*this==(WaveFormatEx&)someWaveFormatEx;
+}
+#endif
+
+
+
+

avifile/hold/DRVNAME.HPP

@@ -0,0 +1,85 @@
+#ifndef _AVIFILE_DRIVERNAME_HPP_
+#define _AVIFILE_DRIVERNAME_HPP_
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class DriverName
+{
+public:
+	DriverName(void);
+	DriverName(const String &driverName,const String &driverLoadName);
+  DriverName(const DriverName &someDriverName);
+	~DriverName();
+	DriverName &operator=(const DriverName &someDriverName);
+  WORD operator==(const DriverName &someDriverName)const;
+	String driverName(void)const;
+	void driverName(const String &driverName);
+	String driverLoadName(void)const;
+  void driverLoadName(const String &driverLoadName);
+private:
+	String mDriverName;
+  String mDriverLoadName;
+};
+
+inline
+DriverName::DriverName(void)
+{
+}
+
+inline
+DriverName::DriverName(const String &driverName,const String &driverLoadName)
+: mDriverName(driverName), mDriverLoadName(driverLoadName)
+{
+}
+
+inline
+DriverName::DriverName(const DriverName &someDriverName)
+{
+  *this=someDriverName;
+}
+
+inline
+DriverName::~DriverName()
+{
+}
+
+inline
+DriverName &DriverName::operator=(const DriverName &someDriverName)
+{
+	driverName(someDriverName.driverName());
+	driverLoadName(someDriverName.driverLoadName());
+  return *this;
+}
+
+inline
+WORD DriverName::operator==(const DriverName &someDriverName)const
+{
+	return (driverName()==someDriverName.driverName()&&
+          driverLoadName()==someDriverName.driverLoadName());
+}
+
+inline
+String DriverName::driverName(void)const
+{
+	return mDriverName;
+}
+
+inline
+void DriverName::driverName(const String &driverName)
+{
+	mDriverName=driverName;
+}
+
+inline
+String DriverName::driverLoadName(void)const
+{
+	return mDriverLoadName;
+}
+
+inline
+void DriverName::driverLoadName(const String &driverLoadName)
+{
+	mDriverLoadName=driverLoadName;
+}
+#endif

avifile/hold/FOURCC.CPP

@@ -0,0 +1,24 @@
+#include <avifile/fourcc.hpp>
+
+DWORD FOURCC::makeFOURCC(String driverName)const
+{
+	char *lpDriverName=(char*)driverName;
+	if(4!=driverName.length())return FALSE;
+	return MKFOURCC(lpDriverName[0],lpDriverName[1],lpDriverName[2],lpDriverName[3]);
+}
+
+String FOURCC::makeFOURCCString(void)const
+{
+	String fccString;
+
+	fccString.reserve(5);
+	((char*)fccString)[0]=(BYTE)(mFOURCC&0xFF);
+	((char*)fccString)[1]=(BYTE)((mFOURCC>>0x08)&0xFF);
+	((char*)fccString)[2]=(BYTE)((mFOURCC>>0x10)&0xFF);
+	((char*)fccString)[3]=(BYTE)((mFOURCC>>0x18)&0xFF);
+	return fccString;
+}
+
+
+
+

avifile/hold/FOURCC.HPP

@@ -0,0 +1,85 @@
+#ifndef _AVIFILE_FOURCC_HPP_
+#define _AVIFILE_FOURCC_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _AVIFILE_AVIDEFS_HPP_
+#include <avifile/avidefs.hpp>
+#endif
+
+class FOURCC
+{
+public:
+	FOURCC(void);
+	FOURCC(String driverName);
+	FOURCC(DWORD fccValue);
+  FOURCC(const FOURCC &someFOURCC);
+	virtual ~FOURCC();
+	FOURCC &operator=(const FOURCC &someFOURCC);
+  WORD operator==(const FOURCC &someFOURCC)const;
+	String toString(void)const;
+  operator DWORD(void)const;
+private:
+	DWORD makeFOURCC(String stringFOURCC)const;
+	String makeFOURCCString(void)const;
+	VFWFOURCC mFOURCC;
+};
+
+inline
+FOURCC::FOURCC(void)
+: mFOURCC(0)
+{
+}
+
+inline
+FOURCC::FOURCC(const FOURCC &someFOURCC)
+{
+  *this=someFOURCC;
+}
+
+inline
+FOURCC::FOURCC(String stringFOURCC)
+: mFOURCC(makeFOURCC(stringFOURCC))
+{
+}
+
+inline
+FOURCC::FOURCC(DWORD fccValue)
+: mFOURCC(fccValue)
+{
+}
+
+inline
+FOURCC::~FOURCC()
+{
+}
+
+inline
+String FOURCC::toString(void)const
+{
+  return makeFOURCCString();
+}
+
+inline
+FOURCC::operator DWORD(void)const
+{
+  return mFOURCC;
+}
+
+inline
+FOURCC &FOURCC::operator=(const FOURCC &someFOURCC)
+{
+	mFOURCC=(DWORD)someFOURCC;
+  return *this;
+}
+
+inline
+WORD FOURCC::operator==(const FOURCC &someFOURCC)const
+{
+	return (DWORD)*this==(DWORD)someFOURCC;
+}
+#endif
+

avifile/hold/FRMHDR.CPP

@@ -0,0 +1,40 @@
+#include <avifile/frmhdr.hpp>
+#include <common/gdata.hpp>
+
+bool AVIFormatHeader::read(File &inFile)
+{
+	String strfLiteral("strf");
+	String strfHeader;
+
+	strfHeader.reserve(strfLiteral.length()+1);
+	inFile.read(strfHeader,strfLiteral.length());
+	if(!(strfLiteral==strfHeader))
+	{
+		inFile-=strfLiteral.length();
+		return false;
+	}
+	if(StreamType::Video==streamType())
+	{
+    mAVIBitmap.read(inFile);
+		::OutputDebugString(mAVIBitmap.toString());
+	}
+	else if(StreamType::Audio==streamType())
+	{
+	  mAVIWaveFormatEx.read(inFile);
+		::OutputDebugString(mAVIWaveFormatEx.toString());
+	}
+	else if(StreamType::IAVS==streamType())mAVIDigitalVideo.read(inFile);
+	else if(StreamType::Text==streamType())return true;
+	return true;
+}
+
+bool AVIFormatHeader::write(File &outFile)
+{
+  outFile.write("strf");
+	if(StreamType::Video==streamType())mAVIBitmap.write(outFile);
+	else if(StreamType::Audio==streamType())mAVIWaveFormatEx.write(outFile);
+	else if(StreamType::IAVS==streamType())mAVIDigitalVideo.write(outFile);
+	else if(StreamType::Text==streamType())return true;
+	return true;
+}
+

avifile/hold/FRMHDR.HPP

@@ -0,0 +1,123 @@
+#ifndef _AVIFILE_FORMATHEADER_HPP_
+#define _AVIFILE_FORMATHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_MMSYSTEM_HPP_
+#include <common/mmsystem.hpp>
+#endif
+#ifndef _AVIFILE_AVILISTCHUNK_HPP_
+#include <avifile/lstchnk.hpp>
+#endif
+#ifndef _AVIFILE_STREAMTYPE_HPP_
+#include <avifile/strmtype.hpp>
+#endif
+#ifndef _AVIFILE_AVIBITMAP_HPP_
+#include <avifile/avibmp.hpp>
+#endif
+#ifndef _AVIFILE_AVIWAVE_HPP_
+#include <avifile/aviwave.hpp>
+#endif
+#ifndef _AVIFILE_AVIDV_HPP_
+#include <avifile/avidv.hpp>
+#endif
+
+class AVIFormatHeader : public StreamType
+{
+public:
+	AVIFormatHeader(void);
+	AVIFormatHeader(const StreamType &someStreamType);
+	AVIFormatHeader(const AVIFormatHeader &someAVIFormatHeader);
+	virtual ~AVIFormatHeader();
+	bool read(File &inFile);
+	bool write(File &outFile);
+	AVIFormatHeader &operator=(const StreamType &someStreamType);
+	AVIFormatHeader &operator=(const AVIFormatHeader &someAVIFormatHeader);
+	WORD operator==(const AVIFormatHeader &someAVIFormatHeader)const;
+	AVIBitmap &getBitmap(void);
+	AVIWaveFormatEx &getWave(void);
+private:
+	AVIBitmap mAVIBitmap;
+  AVIWaveFormatEx mAVIWaveFormatEx;
+	AVIDigitalVideo mAVIDigitalVideo;
+};
+
+inline
+AVIFormatHeader::AVIFormatHeader(void)
+{
+}
+
+inline
+AVIFormatHeader::AVIFormatHeader(const StreamType &someStreamType)
+: StreamType(someStreamType)
+{
+}
+
+inline
+AVIFormatHeader::AVIFormatHeader(const AVIFormatHeader &someAVIFormatHeader)
+{
+	*this=someAVIFormatHeader;
+}
+
+inline
+AVIFormatHeader::~AVIFormatHeader()
+{
+}
+
+inline
+AVIFormatHeader &AVIFormatHeader::operator=(const AVIFormatHeader &someAVIFormatHeader)
+{
+	if(StreamType::Video==streamType())mAVIBitmap=someAVIFormatHeader.mAVIBitmap;
+	else if(StreamType::Audio==streamType())mAVIWaveFormatEx=someAVIFormatHeader.mAVIWaveFormatEx;
+	else if(StreamType::Text==streamType()){;}
+  return *this;
+}
+
+inline
+AVIFormatHeader &AVIFormatHeader::operator=(const StreamType &someStreamType)
+{
+	(StreamType&)*this=someStreamType;
+  return *this;
+}
+
+inline
+WORD AVIFormatHeader::operator==(const AVIFormatHeader &someAVIFormatHeader)const
+{
+	if(StreamType::Video==streamType())return mAVIBitmap==someAVIFormatHeader.mAVIBitmap;
+	else if(StreamType::Audio==streamType())return mAVIWaveFormatEx==someAVIFormatHeader.mAVIWaveFormatEx;
+	else if(StreamType::Text==streamType())return FALSE;
+  return FALSE;
+}
+
+inline
+AVIBitmap &AVIFormatHeader::getBitmap(void)
+{
+  return mAVIBitmap;
+}
+
+inline
+AVIWaveFormatEx &AVIFormatHeader::getWave(void)
+{
+  return mAVIWaveFormatEx;
+} 
+
+/*
+inline
+AVIFormatHeader::operator AVIBitmap&(void)
+{
+  return mAVIBitmap;
+}
+
+inline
+AVIFormatHeader::operator AVIWaveFormatEx&(void)
+{
+  return mAVIWaveFormatEx;
+} 
+*/
+#endif

avifile/hold/ICMDCPRS.HPP

@@ -0,0 +1,219 @@
+#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;
+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;
+}
+#endif
+

avifile/hold/ICMINFO.CPP

@@ -0,0 +1,35 @@
+#include <avifile/icminfo.hpp>
+
+void ICMInfo::name(String name)
+{
+	WORD nameLength;
+
+	if(name.isNull())return;
+	nameLength=name.length();
+	if(nameLength>=sizeof(ICINFO::szName))name.length(sizeof(ICINFO::szName)-1);
+	::memset(ICINFO::szName,0,sizeof(ICINFO::szName));
+	::memcpy(ICINFO::szName,name,name.length());
+}
+
+void ICMInfo::driver(String driver)
+{
+	WORD stringLength;
+
+	if(driver.isNull())return;
+	stringLength=driver.length();
+	if(stringLength>=sizeof(ICINFO::szDriver))driver.length(sizeof(ICINFO::szDriver)-1);
+	::memset(ICINFO::szDriver,0,sizeof(ICINFO::szDriver));
+	::memcpy(ICINFO::szDriver,driver,driver.length());
+}
+
+void ICMInfo::description(String description)
+{
+	WORD stringLength;
+
+	if(description.isNull())return;
+	stringLength=description.length();
+	if(stringLength>=sizeof(ICINFO::szDescription))description.length(sizeof(ICINFO::szDescription)-1);
+	::memset(ICINFO::szDescription,0,sizeof(ICINFO::szDescription));
+	::memcpy(ICINFO::szDescription,description,description.length());
+}
+

avifile/hold/ICMINFO.HPP

@@ -0,0 +1,228 @@
+#ifndef _AVIFILE_ICMINFO_HPP_
+#define _AVIFILE_ICMINFO_HPP_
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _AVIFILE_AVIDEFS_HPP_
+#include <avifile/avidefs.hpp>
+#endif
+
+class ICMInfo : private ICINFO
+{
+public:
+	enum Flags{Quality=VIDCF_QUALITY,Crunch=VIDCF_CRUNCH,Temporal=VIDCF_TEMPORAL,
+						 Draw=VIDCF_DRAW,FastTemporalCompression=VIDCF_FASTTEMPORALC,
+						 FastTemporalDecompression=VIDCF_FASTTEMPORALD,
+						 CompressFrames=VIDCF_COMPRESSFRAMES};
+	ICMInfo(void);
+	ICMInfo(const ICMInfo &someICMInfo);
+	~ICMInfo();
+	ICMInfo &operator=(const ICMInfo &someICMInfo);
+	WORD operator==(const ICMInfo &someICMInfo);
+  WORD size(void)const;
+	DWORD fccType(void)const;
+	void fccType(DWORD fccType);
+	DWORD fccHandler(void)const;
+	void fccHandler(DWORD fccType);
+	DWORD flags(void)const;
+	void flags(DWORD flags);
+	DWORD version(void)const;
+	void version(DWORD version);
+	DWORD versionICM(void)const;
+	void versionICM(DWORD version);
+	String name(void)const;
+	void name(String name);
+	String description(void)const;
+	void description(String description);
+	String driver(void)const;
+	void driver(String driver);
+	WORD hasQuality(void)const;
+  WORD hasDraw(void)const;
+	WORD hasCrunch(void)const;
+	WORD hasTemporal(void)const;
+	WORD hasFastTemporalCompression(void)const;
+	WORD hasFastTemporalDeCompression(void)const;
+  WORD hasCompressFrames(void)const;
+private:
+};
+
+inline
+ICMInfo::ICMInfo(void)
+{
+	ICINFO::dwSize=sizeof(ICINFO);
+	fccType(0);
+	fccHandler(0);
+	flags(0);
+	version(0);
+	versionICM(0);
+	::memset(ICINFO::szName,0,sizeof(ICINFO::szName));
+	::memset(ICINFO::szDescription,0,sizeof(ICINFO::szDescription));
+  ::memset(ICINFO::szDriver,0,sizeof(ICINFO::szDriver));
+}
+
+inline
+ICMInfo::ICMInfo(const ICMInfo &someICMInfo)
+{
+	ICINFO::dwSize=sizeof(ICINFO);
+	*this=someICMInfo;
+}
+
+inline
+ICMInfo::~ICMInfo()
+{
+}
+
+inline
+ICMInfo &ICMInfo::operator=(const ICMInfo &someICMInfo)
+{
+	fccType(someICMInfo.fccType());
+	fccHandler(someICMInfo.fccHandler());
+	flags(someICMInfo.flags());
+	version(someICMInfo.version());
+	versionICM(someICMInfo.versionICM());
+	name(someICMInfo.name());
+	description(someICMInfo.description());
+	driver(someICMInfo.driver());
+  return *this;
+}
+
+inline
+WORD ICMInfo::operator==(const ICMInfo &someICMInfo)
+{
+	return(fccType()==someICMInfo.fccType()&&
+				 fccHandler()==someICMInfo.fccHandler()&&
+				 flags()==someICMInfo.flags()&&
+				 version()==someICMInfo.version()&&
+				 versionICM()==someICMInfo.versionICM()&&
+				 name()==someICMInfo.name()&&
+				 description()==someICMInfo.name()&&
+				 driver()==someICMInfo.driver());
+}
+
+inline
+DWORD ICMInfo::fccType(void)const
+{
+	return ICINFO::fccType;
+}
+
+inline
+void ICMInfo::fccType(DWORD fccType)
+{
+	ICINFO::fccType=fccType;
+}
+
+inline
+DWORD ICMInfo::fccHandler(void)const
+{
+	return ICINFO::fccHandler;
+}
+
+inline
+void ICMInfo::fccHandler(DWORD fccHandler)
+{
+	ICINFO::fccHandler=fccHandler;
+}
+
+inline
+DWORD ICMInfo::flags(void)const
+{
+	return ICINFO::dwFlags;
+}
+
+inline
+void ICMInfo::flags(DWORD flags)
+{
+	ICINFO::dwFlags=flags;
+}
+
+inline
+DWORD ICMInfo::version(void)const
+{
+	return ICINFO::dwVersion;
+}
+
+inline
+void ICMInfo::version(DWORD version)
+{
+	ICINFO::dwVersion=version;
+}
+
+inline
+DWORD ICMInfo::versionICM(void)const
+{
+	return ICINFO::dwVersionICM;
+}
+
+inline
+void ICMInfo::versionICM(DWORD version)
+{
+	ICINFO::dwVersionICM=version;
+}
+
+inline
+String ICMInfo::name(void)const
+{
+	return String((char*)ICINFO::szName);
+}
+
+inline
+String ICMInfo::description(void)const
+{
+	return String((char*)ICINFO::szDescription);
+}
+
+inline
+String ICMInfo::driver(void)const
+{
+	return String((char*)ICINFO::szDriver);
+}
+
+inline
+WORD ICMInfo::size(void)const
+{
+  return sizeof(ICINFO);
+}
+
+inline
+WORD ICMInfo::hasQuality(void)const
+{
+  return flags()&Quality;
+}
+
+inline
+WORD ICMInfo::hasCrunch(void)const
+{
+  return flags()&Crunch;
+}
+
+inline
+WORD ICMInfo::hasDraw(void)const
+{
+  return flags()&Draw;
+}
+
+inline
+WORD ICMInfo::hasTemporal(void)const
+{
+  return flags()&Temporal;
+}
+
+inline
+WORD ICMInfo::hasFastTemporalCompression(void)const
+{
+  return flags()&FastTemporalCompression;
+}
+
+inline
+WORD ICMInfo::hasFastTemporalDeCompression(void)const
+{
+  return flags()&FastTemporalDecompression;
+}
+
+inline
+WORD ICMInfo::hasCompressFrames(void)const
+{
+  return flags()&CompressFrames;
+}
+#endif
+

avifile/hold/ICMOPEN.HPP

@@ -0,0 +1,141 @@
+#ifndef _AVIFILE_ICMOPEN_HPP_
+#define _AVIFILE_ICMOPEN_HPP_
+#ifndef _AVIFILE_AVIDEFS_HPP_
+#include <avifile/avidefs.hpp>
+#endif
+
+class ICMOpen : private ICOPEN
+{
+public:
+	enum Flags{Compress=ICMODE_COMPRESS,DeCompress=ICMODE_DECOMPRESS,
+						 FastDecompress=ICMODE_FASTDECOMPRESS,Query=ICMODE_QUERY,
+						 Draw=ICMODE_DRAW};
+	ICMOpen(void);
+	ICMOpen(const ICMOpen &someICMOpen);
+	virtual ~ICMOpen();
+	ICMOpen &operator=(const ICMOpen &someICMOpen);
+	WORD operator==(const ICMOpen &someICMOpen);
+	operator ICOPEN(void);
+	DWORD fccType(void)const;
+	void fccType(DWORD fccType);
+	DWORD fccHandler(void)const;
+	void fccHandler(DWORD fccHandler);
+	DWORD version(void)const;
+	void version(DWORD version);
+	Flags flags(void)const;
+	void flags(Flags flags);
+	DWORD error(void)const;
+	void error(DWORD error);
+private:
+};
+
+inline
+ICMOpen::ICMOpen(void)
+{
+	ICOPEN::dwSize=sizeof(ICOPEN);
+	ICOPEN::fccType=0;
+	ICOPEN::fccHandler=0;
+	ICOPEN::dwVersion=0;
+	ICOPEN::dwFlags=0;
+	ICOPEN::dwError=0;
+}
+
+inline
+ICMOpen::ICMOpen(const ICMOpen &someICMOpen)
+{
+	ICOPEN::dwSize=sizeof(ICOPEN);
+	*this=someICMOpen;
+}
+
+inline
+ICMOpen::~ICMOpen()
+{
+}
+
+inline
+ICMOpen &ICMOpen::operator=(const ICMOpen &someICMOpen)
+{
+	fccType(someICMOpen.fccType());
+	fccHandler(someICMOpen.fccHandler());
+	version(someICMOpen.version());
+	flags(someICMOpen.flags());
+	error(someICMOpen.error());
+  return *this;
+}
+
+inline
+WORD ICMOpen::operator==(const ICMOpen &someICMOpen)
+{
+	return (fccType()==someICMOpen.fccType()&&
+					fccHandler()==someICMOpen.fccHandler()&&
+					version()==someICMOpen.version()&&
+					flags()==someICMOpen.flags()&&
+					error()==someICMOpen.error());
+}
+
+inline
+ICMOpen::operator ICOPEN(void)
+{
+	return (ICOPEN&)*this;
+}
+
+inline
+DWORD ICMOpen::fccType(void)const
+{
+	return ICOPEN::fccType;
+}
+
+inline
+void ICMOpen::fccType(DWORD fccType)
+{
+	ICOPEN::fccType=fccType;
+}
+
+inline
+DWORD ICMOpen::fccHandler(void)const
+{
+	return ICOPEN::fccHandler;
+}
+
+inline
+void ICMOpen::fccHandler(DWORD fccHandler)
+{
+	ICOPEN::fccHandler=fccHandler;
+}
+
+inline
+DWORD ICMOpen::version(void)const
+{
+	return ICOPEN::dwVersion;
+}
+
+inline
+void ICMOpen::version(DWORD version)
+{
+	ICOPEN::dwVersion=version;
+}
+
+inline
+ICMOpen::Flags ICMOpen::flags(void)const
+{
+	return (Flags)ICOPEN::dwFlags;
+}
+
+inline
+void ICMOpen::flags(Flags flags)
+{
+	ICOPEN::dwFlags=(DWORD)flags;
+}
+
+inline
+DWORD ICMOpen::error(void)const
+{
+	return ICOPEN::dwError;
+}
+
+inline
+void ICMOpen::error(DWORD error)
+{
+	ICOPEN::dwError=error;
+}
+#endif

avifile/hold/IDXCHNK.CPP

@@ -0,0 +1,11 @@
+#include <avifile/idxchnk.hpp>
+
+bool IndexChunk::read(File &inFile)
+{
+	if(!inFile.read(AVIINDEXENTRY::ckid))return false;
+	if(!inFile.read(AVIINDEXENTRY::dwFlags))return false;
+	if(!inFile.read(AVIINDEXENTRY::dwChunkOffset))return false;
+	if(!inFile.read(AVIINDEXENTRY::dwChunkLength))return false;
+	return true;
+}
+

avifile/hold/IDXCHNK.HPP

@@ -0,0 +1,116 @@
+#ifndef _AVIFILE_INDEXCHUNK_HPP_
+#define _AVIFILE_INDEXCHUNK_HPP_
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_VFW_HPP_
+#include <common/vfw.hpp>
+#endif
+
+class IndexChunk : private AVIINDEXENTRY
+{
+public:
+	IndexChunk(void);
+  IndexChunk(const IndexChunk &someIndexChunk);
+	virtual ~IndexChunk();
+	bool read(File &inFile);
+	IndexChunk &operator=(const IndexChunk &someIndexChunk);
+	bool operator==(const IndexChunk &someIndexChunk);
+	DWORD indexID(void)const;
+	DWORD flags(void)const;
+	DWORD offset(void)const;
+	DWORD length(void)const;
+private:
+	void indexID(DWORD indexID);
+	void flags(DWORD flags);
+	void offset(DWORD offset);
+	void length(DWORD length);
+};
+
+inline
+IndexChunk::IndexChunk(void)
+{
+	AVIINDEXENTRY::ckid=0;
+	AVIINDEXENTRY::dwFlags=0;
+	AVIINDEXENTRY::dwChunkOffset=0;
+	AVIINDEXENTRY::dwChunkLength=0;
+}
+
+inline
+IndexChunk::IndexChunk(const IndexChunk &someIndexChunk)
+{
+	*this=someIndexChunk;
+}
+
+inline
+IndexChunk::~IndexChunk()
+{
+}
+
+inline
+IndexChunk &IndexChunk::operator=(const IndexChunk &someIndexChunk)
+{
+	indexID(someIndexChunk.indexID());
+	flags(someIndexChunk.flags());
+	offset(someIndexChunk.offset());
+	length(someIndexChunk.length());
+	return *this;
+}
+
+inline
+bool IndexChunk::operator==(const IndexChunk &someIndexChunk)
+{
+	return (indexID()==someIndexChunk.indexID()&&
+					flags()==someIndexChunk.flags()&&
+					offset()==someIndexChunk.offset()&&
+					length()==someIndexChunk.length());
+}
+
+inline
+DWORD IndexChunk::indexID(void)const
+{
+	return AVIINDEXENTRY::ckid;
+}
+
+inline
+void IndexChunk::indexID(DWORD indexID)
+{
+	AVIINDEXENTRY::ckid=indexID;
+}
+
+inline
+DWORD IndexChunk::flags(void)const
+{
+	return AVIINDEXENTRY::dwFlags;
+}
+
+inline
+void IndexChunk::flags(DWORD flags)
+{
+	AVIINDEXENTRY::dwFlags=0;
+}
+
+inline
+DWORD IndexChunk::offset(void)const
+{
+	return AVIINDEXENTRY::dwChunkOffset;
+}
+
+inline
+void IndexChunk::offset(DWORD offset)
+{
+	AVIINDEXENTRY::dwChunkOffset=offset;
+}
+
+inline
+DWORD IndexChunk::length(void)const
+{
+	return AVIINDEXENTRY::dwChunkLength;
+}
+
+inline
+void IndexChunk::length(DWORD length)
+{
+	AVIINDEXENTRY::dwChunkLength;
+}
+#endif

avifile/hold/INFOHDR.CPP

@@ -0,0 +1,36 @@
+#include <avifile/infohdr.hpp>
+
+bool AVIInfoHeader::read(File &inFile)
+{
+  String infoLiteral("xxxx");
+	String isbjLiteral("ISBJ");
+	String inamLiteral("INAM");
+  String icmtLiteral("ICMT");
+	String infoHeader;
+	WORD infoFiller;
+
+	infoHeader.reserve(infoLiteral.length()+1);
+	inFile.read(infoHeader,infoLiteral.length());
+	if(icmtLiteral==infoHeader)
+	{
+		DWORD byteCount;
+		inFile.read(byteCount);
+		String fillString;
+		fillString.reserve(byteCount+1);
+    inFile.read(fillString,byteCount);
+	}
+	else
+	{
+		if(!(isbjLiteral==infoHeader))return false;
+		inFile.read(infoFiller);
+		inFile.read(infoFiller);
+		inFile.read(infoFiller);
+		inFile.read(infoHeader,inamLiteral.length());
+		if(!(inamLiteral==infoHeader))return false;
+		inFile.read(infoFiller);
+		inFile.read(infoFiller);
+	  inFile.read(infoFiller);
+	}
+	return true;
+}
+

avifile/hold/INFOHDR.HPP

@@ -0,0 +1,28 @@
+#ifndef _AVIFILE_AVIINFOHEADER_HPP_
+#define _AVIFILE_AVIINFOHEADER_HPP_
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+
+class AVIInfoHeader
+{
+public:
+	AVIInfoHeader(void);
+	virtual ~AVIInfoHeader();
+	bool read(File &inFile);
+private:
+	DWORD mFillerOne;
+	DWORD mFillerTwo;
+	DWORD mFillerThree;
+};
+
+inline
+AVIInfoHeader::AVIInfoHeader(void)
+{
+}
+
+inline
+AVIInfoHeader::~AVIInfoHeader()
+{
+}
+#endif

avifile/hold/IndexChunk.hpp

@@ -0,0 +1,134 @@
+#ifndef _AVIFILE_INDEXCHUNK_HPP_
+#define _AVIFILE_INDEXCHUNK_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+typedef WORD QUADWORD[4];
+
+class Index
+{
+public:
+  typedef enum IndexType{Type1=2,Type2=3};
+  typedef enum IndexItem{IndexOffset,IndexSize,IndexOffset2};
+  Index();
+	virtual ~Index();
+	DWORD getItem(IndexItem index)const;
+	void setItem(IndexItem index,DWORD value);
+	IndexType getType(void)const;
+	void setType(IndexType type);
+private:
+  Array<DWORD> mIndex;
+};
+
+Index::Index()
+{
+}
+
+inline
+Index::~Index()
+{
+}
+
+inline
+DWORD Index::getItem(IndexItem index)
+{
+  return mIndex[index];
+}
+
+inline
+void Index::setItem(IndexItem index,DWORD value)
+{
+  mIndex[index]=value;
+}
+
+inline
+Index::IndexType Index::getType(void)const
+{
+  return (IndexType)mIndex.size();
+}
+
+inline
+void Index::setType(IndexType type)
+{
+  mIndex.size((int)type);
+}
+
+
+// *********************************************************************************************
+
+class IndexChunk
+{
+public:
+  IndexChunk();
+	virtual ~IndexChunk();
+	DWORD longsPerEntry(void)const;
+	DWORD indexSubType(void)const;
+	DWORD entriesInUse(void)const;
+	DWORD chunkID(void)const;
+	QUADWORD baseOffset(void)const;
+	bool operator<<(PureViewOfFile &pureView);
+private:
+  WORD mLongsPerEntry;
+	BYTE mIndexSubType;
+	DWORD mEntriesInUse;
+	DWORD mChunkID;
+	QUADWORD mBaseOffset;
+	DWORD mReserved;
+	Array<Index> mIndex;
+};
+
+inline
+IndexChunk<T>::IndexChunk()
+: mLongsPerEntry(0), mIndexSubType(0), mEntriesInUse(0), mChunkID(0), mBaseOffset(0), mReserved(0)
+{
+}
+
+inline
+IndexChunk<T>::~IndexChunk()
+{
+}
+
+inline
+DWORD IndexChunk<T>::longsPerEntry(void)const
+{
+  return mLongsPerEntry;
+}
+
+inline
+DWORD IndexChunk<T>::indexSubType(void)const
+{
+  return mIndexSubType;
+}
+
+inline
+DWORD IndexChunk<T>::entriesInUse(void)const
+{
+  return mEntriesInUse;
+}
+
+inline
+DWORD IndexChunk<T>::chunkID(void)const
+{
+  return mChunkID;
+}
+
+inline
+QUADWORD IndexChunk<T>::baseOffset(void)const
+{
+  return mBaseOffset;
+}
+
+inline
+bool IndexChunk<T>::operator<<(PureViewOfFile &pureView)
+{
+  pureView.read(mLongsPerEntry);
+	pureView.read(mIndexSubType);
+	pureView.read(mEntriesInUse);
+	pureView.read(mChunkID);
+	pureView.read((char*)&mBaseOffset,sizeof(mBaseOffset));
+	pureView.read(mReserved);
+	mIndex.size();
+
+}
+#endif

avifile/hold/JUNKHDR.CPP

@@ -0,0 +1,20 @@
+#include <avifile/junkhdr.hpp>
+
+bool AVIJunkHeader::read(File &inFile)
+{
+	String junkLiteral("JUNK");
+	String junkHeader;
+	DWORD junkCount;
+
+	junkHeader.reserve(junkLiteral.length()+1);
+	inFile.read(junkHeader,junkLiteral.length());
+	if(!(junkHeader==junkLiteral))
+	{
+		inFile-=junkLiteral.length();
+		return FALSE;
+	}
+	inFile.read(junkCount);
+	inFile+=junkCount;
+	::OutputDebugString(String("[AVIJunkHeader::operator<<]")+junkHeader+String(" size=")+String().fromInt(junkCount)+String("\n"));
+	return TRUE;
+}

avifile/hold/JUNKHDR.HPP

@@ -0,0 +1,28 @@
+#ifndef _AVIFILE_JUNKHEADER_HPP_
+#define _AVIFILE_JUNKHEADER_HPP_
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+
+class AVIJunkHeader
+{
+public:
+	AVIJunkHeader(void);
+	virtual ~AVIJunkHeader();
+  bool read(File &inFile);
+private:
+};
+
+inline
+AVIJunkHeader::AVIJunkHeader(void)
+{
+}
+
+inline
+AVIJunkHeader::~AVIJunkHeader()
+{
+}
+#endif

avifile/hold/LSTCHNK.CPP

@@ -0,0 +1,67 @@
+#include <avifile/lstchnk.hpp>
+
+bool AVIListChunk::read(File &inFile)
+{
+	String hdrlLiteral("hdrl");
+	String moviLiteral("movi");
+	String strlLiteral("strl");
+	String odmlLiteral("odml");
+  String recLiteral("rec ");
+  String infoLiteral("INFO");
+	String listLiteral("LIST");
+	String listHeader;
+	String chunkHeader;
+	DWORD sizeHeader; 
+
+	listHeader.reserve(listLiteral.length()+1);
+	chunkHeader.reserve(hdrlLiteral.length()+1);
+	inFile.read(listHeader,listLiteral.length());
+	if(!(listHeader==listLiteral))
+	{
+	  ::OutputDebugString(String("[AVIListChunk::operator<<] expected 'LIST' found '")+listHeader+String("'.\n"));
+		inFile-=listLiteral.length();
+		mChunkType=Unknown;
+		return FALSE;
+	}
+	inFile.read(sizeHeader);  // I know this is 4 bytes, just don't know if it's the size
+	inFile.read(chunkHeader,hdrlLiteral.length());
+	if(hdrlLiteral==chunkHeader)mChunkType=Header;
+	else if(moviLiteral==chunkHeader)mChunkType=Movie;
+	else if(strlLiteral==chunkHeader)mChunkType=Stream;
+	else if(infoLiteral==chunkHeader)mChunkType=Info;
+  else if(recLiteral==chunkHeader)mChunkType=Record;
+	else if(odmlLiteral==chunkHeader)mChunkType=OpenDML;
+	else 
+	{
+	  ::OutputDebugString(String("[AVIListChunk::operator<<] '")+chunkHeader+String("' unexpected at this time.\n"));
+    inFile-=hdrlLiteral.length();    
+		mChunkType=Unknown;
+		return FALSE;
+	}
+	return TRUE;
+}
+ 
+String AVIListChunk::toString(void)const
+{
+  switch(mChunkType)
+	{
+	  case Header :
+		  return "[AVIListChunk::toString]ChunkType=Header";
+		case Movie :
+		  return "[AVIListChunk::toString]ChunkType=Movie";
+		case Stream :
+		  return "[AVIListChunk::toString]ChunkType=Stream";
+		case Index :
+		  return "[AVIListChunk::toString]ChunkType=Index";
+		case Info :
+		  return "[AVIListChunk::toString]ChunkType=Info";
+		case Record :
+		  return "[AVIListChunk::toString]ChunkType=Record";
+		case OpenDML :
+		  return "[AVIListChunk::toString]ChunkType=OpenDML";
+		case Unknown :
+		default :
+		  return "[AVIListChunk::toString]ChunkType=Unknown";
+	}
+}
+

avifile/hold/LSTCHNK.HPP

@@ -0,0 +1,76 @@
+#ifndef _AVIFILE_AVILISTCHUNK_HPP_
+#define _AVIFILE_AVILISTCHUNK_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+
+//#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+//#include <common/pview.hpp>
+//#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class AVIListChunk
+{
+public:
+  enum ChunkType{Header,Movie,Stream,Index,Info,Record,OpenDML,Unknown};
+	AVIListChunk(void);
+  AVIListChunk(const AVIListChunk &someAVIListChunk);
+	virtual ~AVIListChunk();
+	AVIListChunk &operator=(const AVIListChunk &someAVIListChunk);
+  WORD operator==(const AVIListChunk &someAVIListChunk)const;
+	ChunkType chunkType(void)const;
+	bool read(File &inFile);
+//	WORD operator<<(PureViewOfFile &pureView);
+	String toString(void)const;
+private:
+  void chunkType(ChunkType chunkType);
+  ChunkType mChunkType;
+};
+
+inline
+AVIListChunk::AVIListChunk(void)
+: mChunkType(Unknown)
+{
+}
+
+inline
+AVIListChunk::AVIListChunk(const AVIListChunk &someAVIListChunk)
+{
+  *this=someAVIListChunk;
+}
+
+inline
+AVIListChunk::~AVIListChunk()
+{
+}
+
+inline
+AVIListChunk &AVIListChunk::operator=(const AVIListChunk &someAVIListChunk)
+{
+	chunkType(someAVIListChunk.chunkType());
+	return *this;
+}
+
+inline
+WORD AVIListChunk::operator==(const AVIListChunk &someAVIListChunk)const
+{
+	return chunkType()==someAVIListChunk.chunkType();
+}
+
+inline
+AVIListChunk::ChunkType AVIListChunk::chunkType(void)const
+{
+	return mChunkType;
+}
+
+inline
+void AVIListChunk::chunkType(AVIListChunk::ChunkType chunkType)
+{
+  mChunkType=chunkType;
+}
+#endif

avifile/hold/MAIN.CPP

@@ -0,0 +1,286 @@
+#include <common/bitmap.hpp>
+#include <common/file.hpp>
+
+#include <jpgimg/jpgimg.hpp>
+
+#include <avifile/avifile.hpp>
+#include <avifile/mainhdr.hpp>
+#include <avifile/vidc.hpp>
+#include <avifile/riffhdr.hpp>
+
+bool proto1(void);
+bool proto2(const String &pathAVIFile);
+bool createAVIFile(const String &pathAVIFile,Block<Bitmap> &images);
+bool createAVIFile(const String &pathAVIFile,Block<SmartPointer<JPGImage> >&images);
+bool createAVI(const String &pathAVIFile);
+
+int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR lpszCmdLine,int /*nCmdShow*/)
+{
+  Block<SmartPointer<JPGImage> > images;
+
+	images.insert(&SmartPointer<JPGImage>());
+	images[0]=new JPGImage();
+	images[0].disposition(PointerDisposition::Delete);
+	images[0]->decode("d:\\im000256.jpg");
+
+	createAVIFile("d:\\foo.avi",images);
+
+//  return proto2("c:\\winnt\\clock.avi");
+//  return proto2("d:\\foo.avi");
+//  return proto2("d:\\avi\\capture2.avi");
+
+//   return createAVI("d:\\foo.avi"); 
+	return 0;
+}
+
+bool createAVI(const String &pathAVIFile)
+{
+  Block<Bitmap> bitmaps;
+	bitmaps.insert(&Bitmap());
+	Bitmap &bitmap=bitmaps[0];
+ 	bitmap="d:\\work\\avifile\\frm00011.bmp";
+
+//  return createAVIFile(pathAVIFile,bitmaps); 
+  return createAVIFile(pathAVIFile,bitmaps); 
+}
+
+bool createAVIFile(const String &pathAVIFile,Block<SmartPointer<JPGImage> >&images)
+{
+  PAVIFILE pFile;
+  PAVISTREAM pStream;
+  AVISTREAMINFO aviStreamInfo;
+	HRESULT hResult;
+
+  pFile=0;
+	pStream=0;
+  AVIFileInit();
+  hResult=AVIFileOpen(&pFile,pathAVIFile,OF_WRITE|OF_CREATE,NULL);
+  if(hResult!=AVIERR_OK)return false;
+	JPGImage &image=*images[0];
+	::memset(&aviStreamInfo,0,sizeof(AVISTREAMINFO));
+	aviStreamInfo.fccType=streamtypeVIDEO;
+	aviStreamInfo.fccHandler=0;
+	aviStreamInfo.dwScale=1;
+	aviStreamInfo.dwRate=1;
+	aviStreamInfo.dwSuggestedBufferSize=image.getBitmapInfo().sizeImage();
+	SetRect(&aviStreamInfo.rcFrame,0,0,image.width(),image.height());
+	hResult=AVIFileCreateStream(pFile,&pStream,&aviStreamInfo);
+	if(hResult==AVIERR_OK)
+	{
+    hResult=AVIStreamSetFormat(pStream,0,&image.getBitmapInfo().getBITMAPINFOHEADER(),
+		  image.getBitmapInfo().getBITMAPINFOHEADER().biSize+(image.getBitmapInfo().getBITMAPINFOHEADER().biClrUsed*sizeof(RGBQUAD)));
+		if(hResult==AVIERR_OK)
+		{
+		  for(int index=0;index<images.size();index++)
+			{
+			  JPGImage &image=*images[index];
+				GlobalData<BYTE> rawData;
+				image.getRawData(rawData);
+			  hResult=AVIStreamWrite(pStream,index,1,
+				&rawData[0],
+				rawData.size(),
+				AVIIF_KEYFRAME,0,0);
+        if(hResult!=AVIERR_OK)break;
+			}
+		}
+	}
+  if(pStream)AVIStreamClose(pStream);
+	if(pFile)AVIFileClose(pFile);
+	AVIFileExit();
+	return true;
+}
+
+bool createAVIFile(const String &pathAVIFile,Block<Bitmap> &images)
+{
+  PAVIFILE pFile;
+  PAVISTREAM pStream;
+  AVISTREAMINFO aviStreamInfo;
+	HRESULT hResult;
+
+  pFile=0;
+	pStream=0;
+  AVIFileInit();
+  hResult=AVIFileOpen(&pFile,pathAVIFile,OF_WRITE|OF_CREATE,NULL);
+  if(hResult!=AVIERR_OK)return false;
+	Bitmap bitmap=images[0];
+	::memset(&aviStreamInfo,0,sizeof(AVISTREAMINFO));
+	aviStreamInfo.fccType=streamtypeVIDEO;
+	aviStreamInfo.fccHandler=0;
+	aviStreamInfo.dwScale=1;
+	aviStreamInfo.dwRate=1;
+	aviStreamInfo.dwSuggestedBufferSize=bitmap.getInfoPtr()->bmiHeader.biSizeImage;
+	SetRect(&aviStreamInfo.rcFrame,0,0,bitmap.width(),bitmap.height());
+	hResult=AVIFileCreateStream(pFile,&pStream,&aviStreamInfo);
+	if(hResult==AVIERR_OK)
+	{
+    hResult=AVIStreamSetFormat(pStream,0,&bitmap.getInfoPtr()->bmiHeader,bitmap.getInfoPtr()->bmiHeader.biSize+(bitmap.getInfoPtr()->bmiHeader.biClrUsed*sizeof(RGBQUAD)));
+		if(hResult==AVIERR_OK)
+		{
+		  for(int index=0;index<images.size();index++)
+			{
+			  Bitmap &bitmap=images[index];
+			  hResult=AVIStreamWrite(pStream,index,1,
+				bitmap.ptrData(),
+				bitmap.getInfoPtr()->bmiHeader.biSizeImage,
+				AVIIF_KEYFRAME,0,0);
+        if(hResult!=AVIERR_OK)break;
+			}
+		}
+	}
+  if(pStream)AVIStreamClose(pStream);
+	if(pFile)AVIFileClose(pFile);
+	AVIFileExit();
+	return true;
+}
+
+
+bool proto2(const String &pathAVIFile)
+{
+	VideoCodec videoCodec;
+	ICMOpen icmOpen;
+	ICMInfo icmInfo;
+	ICMDecompress icmDecompress;
+  WORD streamCount;
+	WORD frameCount(0);
+
+	AVIFile aviFile(pathAVIFile);
+	AVIStreamData &aviStreamData=(AVIStreamData&)aviFile;
+	if(0==(streamCount=aviStreamData.size()))return FALSE;
+  ::OutputDebugString(String("FCCType:")+aviStreamData[0].fccType().toString()+String("\n"));
+  ::OutputDebugString(String("FCCHandler:")+aviStreamData[0].fccHandler().toString()+String("\n"));
+
+  FOURCC driverName("mrle");
+  Block<DriverName> driverNames;
+  videoCodec.enumerateDrivers(driverNames);
+	for(int index=0;index<driverNames.size();index++)
+	{
+	  ::OutputDebugString(driverNames[index].driverName()+String("\n"));
+	}
+
+	if(!(VideoCodec::OkResult==videoCodec.openDriver(driverName)))return false;
+  icmOpen.fccType(aviStreamData[0].fccType());
+	icmOpen.fccHandler(aviStreamData[0].fccHandler());
+	icmOpen.flags(ICMOpen::DeCompress);
+	icmOpen.version(1);
+	videoCodec.driverLoad();
+	videoCodec.driverEnable();
+	videoCodec.driverProc(icmOpen);
+	videoCodec.driverProc(icmInfo);
+//	videoCodec.icmConfigure(::GetFocus());
+
+	for(short streamIndex=0;streamIndex<streamCount;streamIndex++)
+	{
+		if(!StreamType::Video==aviStreamData[streamIndex].streamType())continue;
+		AVIBitmap &aviBitmap=aviStreamData[streamIndex].getBitmap();
+		AVIBitmap dstBitmap(aviBitmap);
+		dstBitmap.compression(BI_RGB);
+		dstBitmap.sizeImage(dstBitmap.width()*dstBitmap.height());
+		dstBitmap.colorUsed(aviBitmap.colorUsed());
+
+		if(VideoCodec::FailResult==videoCodec.canDecompress(aviBitmap))continue;
+		WORD movieCount(((AVIMovieHeader&)aviFile).size());
+		for(short movieIndex=0;movieIndex<movieCount;movieIndex++)
+		{
+			MovieData &srcMovieData=((AVIMovieHeader&)aviFile)[movieIndex];
+			if(!((srcMovieData.streamNumber()==streamIndex)&&
+					 (MovieData::DIBCompressed==srcMovieData.dataType()||
+						MovieData::IV==srcMovieData.dataType()||
+						MovieData::DIBUnCompressed==srcMovieData.dataType())))continue;
+			String pathFileName;
+			MovieData dstMovieData;
+			dstMovieData.dataType(srcMovieData.dataType());
+			dstMovieData.streamNumber(srcMovieData.streamNumber());
+			::sprintf(pathFileName,"FRM%05d.BMP",frameCount++);
+			if(VideoCodec::OkResult!=videoCodec.decompressFrame(aviBitmap,dstBitmap,srcMovieData,dstMovieData))
+			{
+			  ::printf("Error decompressing frame\n");
+				continue;
+			}
+			Bitmap imageBitmap(pathFileName,(BitmapInfo&)dstBitmap,(GlobalData<BYTE>&)dstMovieData);
+			imageBitmap.saveBitmap();
+    }
+	}
+	videoCodec.closeDriver();
+	return FALSE;
+}
+
+bool proto1(void)
+{
+	VideoCodec videoCodec;
+	ICMOpen icmOpen;
+	ICMInfo icmInfo;
+	ICMDecompress icmDecompress;
+  WORD streamCount;
+	WORD frameCount(0);
+	String commandLine;
+
+//	if(!(VideoCodec::OkResult==videoCodec.openDriver(FOURCC("I420"))))return FALSE;
+
+//	lpszCmdLine="D:\\CAPTURE1.AVI";  
+	commandLine="D:\\CAPTURE2.AVI";  
+//  commandLine="c:\\winnt\\clock.avi";
+
+	AVIFile aviFile(commandLine);
+	AVIStreamData &aviStreamData=(AVIStreamData&)aviFile;
+	if(0==(streamCount=aviStreamData.size()))return FALSE;
+  ::OutputDebugString(String("FCCType:")+aviStreamData[0].fccType().toString()+String("\n"));
+  ::OutputDebugString(String("FCCHandler:")+aviStreamData[0].fccHandler().toString()+String("\n"));
+
+  icmOpen.fccType(aviStreamData[0].fccType());
+//	icmOpen.fccType(FOURCC("vidc"));
+	icmOpen.fccHandler(aviStreamData[0].fccHandler());
+//  icmOpen.fccType(aviStreamData[0].fccType());
+//	icmOpen.fccHandler(FOURCC("DIVX"));
+
+	icmOpen.flags(ICMOpen::DeCompress);
+	icmOpen.version(1);
+	videoCodec.driverLoad();
+	videoCodec.driverEnable();
+	videoCodec.driverProc(icmOpen);
+	videoCodec.driverProc(icmInfo);
+//	videoCodec.icmConfigure(::GetFocus());
+	for(short streamIndex=0;streamIndex<streamCount;streamIndex++)
+	{
+		if(!StreamType::Video==aviStreamData[streamIndex].streamType())continue;
+		AVIBitmap &aviBitmap=(AVIBitmap&)(aviStreamData[streamIndex]);
+		AVIBitmap dstBitmap(aviBitmap);
+		dstBitmap.compression(BI_RGB);
+		dstBitmap.sizeImage(dstBitmap.width()*dstBitmap.height());
+		dstBitmap.colorUsed(0);
+
+//		if(VideoCodec::FailResult==videoCodec.canDecompress(aviBitmap))continue;
+		WORD movieCount(((AVIMovieHeader&)aviFile).size());
+		for(short movieIndex=0;movieIndex<movieCount;movieIndex++)
+		{
+			MovieData &srcMovieData=((AVIMovieHeader&)aviFile)[movieIndex];
+			if(!((srcMovieData.streamNumber()==streamIndex)&&
+					 (MovieData::DIBCompressed==srcMovieData.dataType()||
+						MovieData::IV==srcMovieData.dataType()||
+						MovieData::DIBUnCompressed==srcMovieData.dataType())))continue;
+
+
+      File outfile;
+			outfile.open("d:\\frame.dvsd","wb");
+			outfile.write((char*)&srcMovieData[0],srcMovieData.size());
+
+			String pathFileName;
+			MovieData dstMovieData;
+			dstMovieData.dataType(srcMovieData.dataType());
+			dstMovieData.streamNumber(srcMovieData.streamNumber());
+			::sprintf(pathFileName,"FRM%05d.BMP",frameCount++);
+
+			  Bitmap imageBitmap(pathFileName,(BitmapInfo&)aviBitmap,(GlobalData<BYTE>&)srcMovieData);
+			  imageBitmap.saveBitmap();
+
+			if(VideoCodec::OkResult!=videoCodec.decompressFrame(aviBitmap,dstBitmap,srcMovieData,dstMovieData))
+			{
+			  ::printf("Error decompressing frame\n");
+				continue;
+			}
+//			Bitmap imageBitmap(pathFileName,(BitmapInfo&)dstBitmap,(GlobalData<BYTE>&)dstMovieData);
+//			imageBitmap.saveBitmap();
+    }
+	}
+	videoCodec.closeDriver();
+	return FALSE;
+}

avifile/hold/MAIN.HPP

@@ -0,0 +1,67 @@
+#ifndef _AVIFILE_MAIN_HPP_
+#define _AVIFILE_MAIN_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class Main
+{
+public:
+  static HINSTANCE processInstance(HWND hWnd);
+  static HINSTANCE processInstance(void);
+  static HINSTANCE previousProcessInstance(void);
+  static void processInstance(HINSTANCE processInstance);
+  static void previousProcessInstance(HINSTANCE previousProcessInstance);
+  static void cmdShow(int nCmdShow);
+private:
+  static HINSTANCE smhInstance;
+  static HINSTANCE smhPrevInstance;
+  static int smnCmdShow;
+};
+
+inline
+void Main::processInstance(HINSTANCE hProcessInstance)
+{
+  smhInstance=hProcessInstance;
+}
+
+inline
+void Main::previousProcessInstance(HINSTANCE previousProcessInstance)
+{
+  smhPrevInstance=previousProcessInstance;
+}
+
+inline
+void Main::cmdShow(int nCmdShow)
+{
+}
+
+inline
+HINSTANCE Main::processInstance(void)
+{
+  return smhInstance;
+}
+
+inline
+HINSTANCE Main::previousProcessInstance(void)
+{
+  return smhPrevInstance;
+}
+
+#if defined(__FLAT__)
+inline
+HINSTANCE Main::processInstance(HWND hWnd)
+{
+  return (HINSTANCE)::GetWindowLong(hWnd,GWL_HINSTANCE);
+}
+#else
+inline
+HINSTANCE Main::processInstance(HWND hWnd)
+{
+  return (HINSTANCE)::GetWindowWord(hWnd,GWW_HINSTANCE);
+}
+#endif
+#define WM_REACTIVATE WM_USER+1
+#endif
+
+

avifile/hold/MAINHDR.CPP

@@ -0,0 +1,117 @@
+#include <avifile/mainhdr.hpp>
+
+AVIMainHeader &AVIMainHeader::operator=(const AVIMainHeader &someAVIMainHeader)
+{
+	microSecondsPerFrame(someAVIMainHeader.microSecondsPerFrame());
+	maxBytesPerSecond(someAVIMainHeader.maxBytesPerSecond());
+  granularity(someAVIMainHeader.granularity());
+	flags(someAVIMainHeader.flags());
+	totalFrames(someAVIMainHeader.totalFrames());
+	initialFrames(someAVIMainHeader.initialFrames());
+	streams(someAVIMainHeader.streams());
+	suggestedBufferSize(someAVIMainHeader.suggestedBufferSize());
+	width(someAVIMainHeader.width());
+	height(someAVIMainHeader.height());
+	return *this;
+}
+
+WORD AVIMainHeader::operator==(const AVIMainHeader &someAVIMainHeader)const
+{
+	return (microSecondsPerFrame()==someAVIMainHeader.microSecondsPerFrame()&&
+					maxBytesPerSecond()==someAVIMainHeader.maxBytesPerSecond()&&
+          granularity()==someAVIMainHeader.granularity()&&
+					flags()==someAVIMainHeader.flags()&&
+					totalFrames()==someAVIMainHeader.totalFrames()&&
+					initialFrames()==someAVIMainHeader.initialFrames()&&
+					streams()==someAVIMainHeader.streams()&&
+					suggestedBufferSize()==someAVIMainHeader.suggestedBufferSize()&&
+					width()==someAVIMainHeader.width()&&
+          height()==someAVIMainHeader.height());
+}
+
+bool AVIMainHeader::read(File &inFile)
+{
+	String aviLiteral("avih");
+  String aviHeader;
+	DWORD sizeHeader;
+
+	aviHeader.reserve(aviLiteral.length()+1);
+	inFile.read(aviHeader,aviLiteral.length());
+	if(!(aviLiteral==aviHeader))return FALSE;
+	inFile.read(sizeHeader);
+	inFile.read(MainAVIHeader::dwMicroSecPerFrame);
+	inFile.read(MainAVIHeader::dwMaxBytesPerSec);
+	inFile.read(MainAVIHeader::dwPaddingGranularity);
+	inFile.read(MainAVIHeader::dwFlags);
+	inFile.read(MainAVIHeader::dwTotalFrames);
+	inFile.read(MainAVIHeader::dwInitialFrames);
+	inFile.read(MainAVIHeader::dwStreams);
+	inFile.read(MainAVIHeader::dwSuggestedBufferSize);
+	inFile.read(MainAVIHeader::dwWidth);
+	inFile.read(MainAVIHeader::dwHeight);
+	inFile.read(MainAVIHeader::dwReserved[0]);
+	inFile.read(MainAVIHeader::dwReserved[1]);
+	inFile.read(MainAVIHeader::dwReserved[2]);
+	inFile.read(MainAVIHeader::dwReserved[3]);
+	::OutputDebugString(toString()+String("\n"));
+  return true;
+}
+
+bool AVIMainHeader::write(File &outFile)
+{
+  outFile.write("avih");
+  DWORD sizeHeader;
+
+  sizeHeader=sizeof(MainAVIHeader::dwMicroSecPerFrame)+
+	           sizeof(MainAVIHeader::dwMaxBytesPerSec)+
+						 sizeof(MainAVIHeader::dwPaddingGranularity)+
+						 sizeof(MainAVIHeader::dwFlags)+
+						 sizeof(MainAVIHeader::dwTotalFrames)+
+						 sizeof(MainAVIHeader::dwInitialFrames)+
+						 sizeof(MainAVIHeader::dwStreams)+
+						 sizeof(MainAVIHeader::dwSuggestedBufferSize)+
+						 sizeof(MainAVIHeader::dwWidth)+
+						 sizeof(MainAVIHeader::dwHeight)+
+						 sizeof(MainAVIHeader::dwReserved[0])+
+						 sizeof(MainAVIHeader::dwReserved[1])+
+						 sizeof(MainAVIHeader::dwReserved[2])+
+						 sizeof(MainAVIHeader::dwReserved[3]);
+	outFile.write(sizeHeader);
+	outFile.write(MainAVIHeader::dwMicroSecPerFrame);
+	outFile.write(MainAVIHeader::dwMaxBytesPerSec);
+	outFile.write(MainAVIHeader::dwPaddingGranularity);
+	outFile.write(MainAVIHeader::dwFlags);
+	outFile.write(MainAVIHeader::dwTotalFrames);
+	outFile.write(MainAVIHeader::dwInitialFrames);
+	outFile.write(MainAVIHeader::dwStreams);
+	outFile.write(MainAVIHeader::dwSuggestedBufferSize);
+	outFile.write(MainAVIHeader::dwWidth);
+	outFile.write(MainAVIHeader::dwHeight);
+	outFile.write(MainAVIHeader::dwReserved[0]);
+	outFile.write(MainAVIHeader::dwReserved[1]);
+	outFile.write(MainAVIHeader::dwReserved[2]);
+	outFile.write(MainAVIHeader::dwReserved[3]);
+	::OutputDebugString(toString()+String("\n"));
+	return true;
+}
+
+String AVIMainHeader::toString(void)const
+{
+  String str;
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwMicroSecPerFrame=")+String().fromInt(MainAVIHeader::dwMicroSecPerFrame)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwMaxBytesPerSec=")+String().fromInt(MainAVIHeader::dwMaxBytesPerSec)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwPaddingGranularity=")+String().fromInt(MainAVIHeader::dwPaddingGranularity)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwFlags=")+String().fromInt(MainAVIHeader::dwFlags)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwTotalFrames=")+String().fromInt(MainAVIHeader::dwTotalFrames)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwInitialFrames=")+String().fromInt(MainAVIHeader::dwInitialFrames)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwStreams=")+String().fromInt(MainAVIHeader::dwStreams)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwSuggestedBufferSize=")+String().fromInt(MainAVIHeader::dwSuggestedBufferSize)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwWidth=")+String().fromInt(MainAVIHeader::dwWidth)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwHeight=")+String().fromInt(MainAVIHeader::dwHeight)+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwReserved[0]=")+String().fromInt(MainAVIHeader::dwReserved[0])+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwReserved[1]=")+String().fromInt(MainAVIHeader::dwReserved[1])+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwReserved[2]=")+String().fromInt(MainAVIHeader::dwReserved[2])+String("\n");
+	str+=String("[AVIMainHeader::toString]MainAVIHeader::dwReserved[3]=")+String().fromInt(MainAVIHeader::dwReserved[3])+String("\n");
+	return str;
+}
+

avifile/hold/MAINHDR.HPP

@@ -0,0 +1,265 @@
+#ifndef _AVIFILE_AVIMAINHEADER_HPP_
+#define _AVIFILE_AVIMAINHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _AVIFILE_AVIDEFS_HPP_
+#include <avifile/avidefs.hpp>
+#endif
+
+class AVIMainHeader : private MainAVIHeader 
+{
+public:
+	AVIMainHeader(void);
+	AVIMainHeader(const AVIMainHeader &someAVIMainHeader);
+	virtual ~AVIMainHeader();
+  bool read(File &inFile);
+	bool write(File &outFile);
+	AVIMainHeader &operator=(const AVIMainHeader &someAVIMainHeader);
+  WORD operator==(const AVIMainHeader &someAVIMainHeader)const;
+	DWORD microSecondsPerFrame(void)const;
+	void microSecondsPerFrame(DWORD microSecondsPerFrame);
+	DWORD maxBytesPerSecond(void)const;
+	void maxBytesPerSecond(DWORD maxBytesPerSecond);
+  DWORD granularity(void)const;
+  void granularity(DWORD granularity);
+	DWORD flags(void)const;
+	void flags(DWORD flags);
+	DWORD totalFrames(void)const;
+	void totalFrames(DWORD totalFrames);
+	DWORD initialFrames(void)const;
+	void initialFrames(DWORD initialFrames);
+	DWORD streams(void)const;
+	void streams(DWORD streams);
+	DWORD suggestedBufferSize(void)const;
+	void suggestedBufferSize(DWORD suggestedBufferSize);
+	DWORD width(void)const;
+	void width(DWORD width);
+	DWORD height(void)const;
+	void height(DWORD height);
+	bool hasIndex(void)const;
+	void hasIndex(bool hasIndex);
+	bool mustUseIndex(void)const;
+	void mustUseIndex(bool mustUseIndex);
+	bool isInterleaved(void)const;
+	void isInterleaved(bool isInterleaved);
+	bool wasCaptureFile(void)const;
+	void wasCaptureFile(bool wasCaptureFile);
+	bool isCopyrighted(void)const;
+	void isCopyrighted(bool isCopyrighted);
+	String toString(void)const;
+private:
+  void setZero(void);
+};
+
+inline
+AVIMainHeader::AVIMainHeader(void)
+{
+  setZero();
+}
+
+inline
+AVIMainHeader::AVIMainHeader(const AVIMainHeader &someAVIMainHeader)
+{
+	*this=someAVIMainHeader;
+}
+
+inline
+AVIMainHeader::~AVIMainHeader()
+{
+}
+
+inline
+DWORD AVIMainHeader::microSecondsPerFrame(void)const
+{
+  return MainAVIHeader::dwMicroSecPerFrame;
+}
+
+inline
+void AVIMainHeader::microSecondsPerFrame(DWORD msPerFrame)
+{
+  MainAVIHeader::dwMicroSecPerFrame=msPerFrame;
+}
+
+inline
+DWORD AVIMainHeader::maxBytesPerSecond(void)const
+{
+  return MainAVIHeader::dwMaxBytesPerSec;
+}
+
+inline
+void AVIMainHeader::maxBytesPerSecond(DWORD maxBytesPerSecond)
+{
+	MainAVIHeader::dwMaxBytesPerSec=maxBytesPerSecond;
+}
+
+inline
+DWORD AVIMainHeader::granularity(void)const
+{
+	return MainAVIHeader::dwPaddingGranularity;
+}
+
+inline
+void AVIMainHeader::granularity(DWORD granularity)
+{
+	MainAVIHeader::dwPaddingGranularity=granularity;
+}
+
+inline
+DWORD AVIMainHeader::flags(void)const
+{
+  return MainAVIHeader::dwFlags;
+}
+
+inline
+void AVIMainHeader::flags(DWORD flags)
+{
+  MainAVIHeader::dwFlags=flags;
+}
+
+inline
+DWORD AVIMainHeader::totalFrames(void)const
+{
+  return MainAVIHeader::dwTotalFrames;
+}
+
+inline
+void AVIMainHeader::totalFrames(DWORD totalFrames)
+{
+  MainAVIHeader::dwTotalFrames=totalFrames;
+}
+
+inline
+DWORD AVIMainHeader::initialFrames(void)const
+{
+  return MainAVIHeader::dwInitialFrames;
+}
+
+inline
+void AVIMainHeader::initialFrames(DWORD initialFrames)
+{
+  MainAVIHeader::dwInitialFrames=initialFrames;
+}
+
+inline
+DWORD AVIMainHeader::streams(void)const
+{
+  return MainAVIHeader::dwStreams;
+}
+
+inline
+void AVIMainHeader::streams(DWORD streams)
+{
+  MainAVIHeader::dwStreams=streams;
+}
+
+inline
+DWORD AVIMainHeader::suggestedBufferSize(void)const
+{
+  return MainAVIHeader::dwSuggestedBufferSize;
+}
+
+inline
+void AVIMainHeader::suggestedBufferSize(DWORD suggestedBufferSize)
+{
+	MainAVIHeader::dwSuggestedBufferSize=suggestedBufferSize;
+}
+
+inline
+DWORD AVIMainHeader::width(void)const
+{
+	return MainAVIHeader::dwWidth;
+}
+
+inline
+void AVIMainHeader::width(DWORD width)
+{
+	MainAVIHeader::dwWidth=width;
+}
+
+inline
+DWORD AVIMainHeader::height(void)const
+{
+  return MainAVIHeader::dwHeight;
+}
+
+inline
+void AVIMainHeader::height(DWORD height)
+{
+  MainAVIHeader::dwHeight=height;
+}
+
+inline
+bool AVIMainHeader::hasIndex(void)const
+{
+	return (MainAVIHeader::dwFlags&AVIF_HASINDEX);
+}
+
+inline
+void AVIMainHeader::hasIndex(bool hasIndex)
+{
+  if(hasIndex)MainAVIHeader::dwFlags|=AVIF_HASINDEX;
+	else MainAVIHeader::dwFlags^=AVIF_HASINDEX;
+}
+
+inline
+bool AVIMainHeader::mustUseIndex(void)const
+{
+	return (MainAVIHeader::dwFlags&AVIF_MUSTUSEINDEX);
+}
+
+inline
+void AVIMainHeader::mustUseIndex(bool mustUseIndex)
+{
+  if(mustUseIndex)MainAVIHeader::dwFlags|=AVIF_MUSTUSEINDEX;
+	else MainAVIHeader::dwFlags^=AVIF_MUSTUSEINDEX;
+}
+
+inline
+bool AVIMainHeader::isInterleaved(void)const
+{
+	return (MainAVIHeader::dwFlags&AVIF_ISINTERLEAVED);
+}
+
+inline
+void AVIMainHeader::isInterleaved(bool isInterleaved)
+{
+  if(isInterleaved)MainAVIHeader::dwFlags|=AVIF_ISINTERLEAVED;
+	else MainAVIHeader::dwFlags^=AVIF_ISINTERLEAVED;
+}
+
+inline
+bool AVIMainHeader::wasCaptureFile(void)const
+{
+	return (MainAVIHeader::dwFlags&AVIF_WASCAPTUREFILE);
+}
+
+inline
+void AVIMainHeader::wasCaptureFile(bool wasCaptureFile)
+{
+  if(wasCaptureFile)MainAVIHeader::dwFlags|=AVIF_WASCAPTUREFILE;
+	else MainAVIHeader::dwFlags^=AVIF_WASCAPTUREFILE;
+}
+
+inline
+bool AVIMainHeader::isCopyrighted(void)const
+{
+	return (MainAVIHeader::dwFlags&AVIF_COPYRIGHTED);
+}
+
+inline
+void AVIMainHeader::isCopyrighted(bool isCopyrighted)
+{
+  if(isCopyrighted)MainAVIHeader::dwFlags|=AVIF_COPYRIGHTED;
+	else MainAVIHeader::dwFlags^=AVIF_COPYRIGHTED;
+}
+
+inline
+void AVIMainHeader::setZero(void)
+{
+  ::memset(&((MainAVIHeader&)*this),0,sizeof(MainAVIHeader));
+}
+#endif

avifile/hold/MISCHDR.CPP

@@ -0,0 +1,50 @@
+#include <avifile/mischdr.hpp>
+
+AVIMiscHeader::AVIMiscHeader(void)
+{
+	mMiscHeaders.insert(&String("ISFT"));
+	mMiscHeaders.insert(&String("strn"));
+}
+
+AVIMiscHeader::~AVIMiscHeader()
+{
+}
+
+bool AVIMiscHeader::read(File &inFile)
+{
+	String miscLiteral("xxxx");
+	String miscHeader;
+	DWORD miscCount;
+	WORD returnCode;
+	MiscType miscType;
+
+  returnCode=FALSE;
+	miscHeader.reserve(miscLiteral.length()+1);
+	inFile.read(miscHeader,miscLiteral.length());
+	miscType=miscEvaluate(miscHeader);
+	switch(miscType)
+	{
+		case MiscSTRN :
+	  case MiscISFT :
+		  inFile.read(miscCount);
+		  inFile+=miscCount;
+		  inFile.read(miscHeader,5);
+		  inFile.read(miscCount);
+		  inFile+=miscCount;
+			returnCode=TRUE;
+		  break;
+		case MiscUnknown :  // another level will handle this, just put the string back into the read buffer
+//		  ::OutputDebugString(String("[AVIMiscHeader::operator<<] Don't know how to handle header '")+miscHeader+String("'\n"));
+			inFile-=miscLiteral.length();
+			break;
+	}
+	return returnCode;
+}
+
+AVIMiscHeader::MiscType AVIMiscHeader::miscEvaluate(const String &headerLiteral)
+{
+	for(int headerIndex=0;headerIndex<mMiscHeaders.size();headerIndex++)
+		if(headerLiteral==mMiscHeaders[headerIndex])return MiscType(headerIndex);
+	return MiscUnknown;
+}
+

avifile/hold/MISCHDR.HPP

@@ -0,0 +1,30 @@
+#ifndef _AVIFILE_MISCHEADER_HPP_
+#define _AVIFILE_MISCHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+
+template <class T>
+class Block;
+class String;
+class PureViewOfFile;
+
+class AVIMiscHeader
+{
+public:
+	AVIMiscHeader(void);
+	virtual ~AVIMiscHeader();
+	bool read(File &inFile);
+private:
+  enum MiscType{MiscISFT,MiscSTRN,MiscUnknown};
+	MiscType miscEvaluate(const String &headerLiteral);
+
+  Block<String> mMiscHeaders;
+};
+#endif

avifile/hold/MOVIDATA.HPP

@@ -0,0 +1,82 @@
+#ifndef _AVIFILE_MOVIEDATA_HPP_
+#define _AVIFILE_MOVIEDATA_HPP_
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+
+class MovieData : public GlobalData<BYTE>
+{
+public:
+  enum DataType{Audio,DIBCompressed,DIBUnCompressed,IV,Unknown};
+	MovieData(DataType dataType=Unknown);
+  MovieData(const MovieData &someMovieData);
+	virtual ~MovieData();
+	MovieData &operator=(const MovieData &someMovieData);
+  WORD operator==(const MovieData &someMovieData)const;
+	DataType dataType(void)const;
+	void dataType(DataType dataType);
+	WORD streamNumber(void)const;
+  void streamNumber(WORD streamNumber);
+private:
+	DataType mDataType;
+  WORD mStreamNumber;
+};
+
+inline
+MovieData::MovieData(DataType dataType)
+: mDataType(dataType)
+{
+}
+
+inline
+MovieData::MovieData(const MovieData &someMovieData)
+{
+  *this=someMovieData;
+}
+
+inline
+MovieData::~MovieData()
+{
+}
+
+inline
+MovieData &MovieData::operator=(const MovieData &someMovieData)
+{
+	dataType(someMovieData.dataType());
+  streamNumber(someMovieData.streamNumber());
+	(GlobalData<BYTE>&)*this=(GlobalData<BYTE>&)someMovieData;
+  return *this;
+}
+
+inline
+WORD MovieData::operator==(const MovieData &someMovieData)const
+{
+	if(!(dataType()==someMovieData.dataType()))return FALSE;
+	if(!(streamNumber()==someMovieData.streamNumber()))return FALSE;
+  return (GlobalData<BYTE>&)*this==(GlobalData<BYTE>&)someMovieData;
+}
+
+inline
+MovieData::DataType MovieData::dataType(void)const
+{
+	return mDataType;
+}
+
+inline
+void MovieData::dataType(DataType dataType)
+{
+	mDataType=dataType;
+}
+
+inline
+WORD MovieData::streamNumber(void)const
+{
+	return mStreamNumber;
+}
+
+inline
+void MovieData::streamNumber(WORD streamNumber)
+{
+  mStreamNumber=streamNumber;
+}
+#endif

avifile/hold/MOVIEHDR.CPP

@@ -0,0 +1,137 @@
+#include <avifile/moviehdr.hpp>
+#include <avifile/lstchnk.hpp>
+#include <avifile/subchnk.hpp>
+#include <avifile/junkhdr.hpp>
+
+bool AVIMovieHeader::read(File &inFile)
+{
+	String audioDataChunkID("wb");
+	String compressedDIBChunkID("dc");
+	String uncompressedDIBChunkID("db");
+  String ivChunkID("iv");
+	String ixChunkID("ix");
+	String movieHeaderLiteral("xxxx");
+	String movieHeader;
+  String movieStream;
+  DWORD byteCount;
+
+	remove();
+	while(TRUE)
+	{
+		movieHeader.reserve(movieHeaderLiteral.length()+1);
+		inFile.read(movieHeader,movieHeaderLiteral.length());
+		movieHeader=movieHeader.extractAlpha();
+    movieStream=movieHeader.extractDigits();
+		if(audioDataChunkID==movieHeader)
+		{
+			MovieData movieData;
+			inFile.read(byteCount);
+			if(byteCount%2)byteCount++;
+			movieData.dataType(MovieData::Audio);
+			movieData.streamNumber(movieStream.toInt());
+			movieData.size(byteCount);
+			inFile.read((char*)((BYTE HUGE*)&movieData[0]),movieData.size());
+      insert(&movieData);
+		}
+		else if(compressedDIBChunkID==movieHeader)
+		{
+			MovieData movieData;
+			inFile.read(byteCount);
+			if(byteCount%2)byteCount++;
+			movieData.dataType(MovieData::DIBCompressed);
+			movieData.streamNumber(movieStream.toInt());
+			movieData.size(byteCount);
+			inFile.read((char*)((BYTE HUGE*)&movieData[0]),movieData.size());
+			insert(&movieData);
+		}
+		else if(uncompressedDIBChunkID==movieHeader)
+		{
+      MovieData movieData;
+			inFile.read(byteCount);
+			if(byteCount%2)byteCount++;
+			movieData.dataType(MovieData::DIBUnCompressed);
+			movieData.streamNumber(movieStream.toInt());
+			movieData.size(byteCount);
+			inFile.read((char*)((BYTE HUGE*)&movieData[0]),movieData.size());
+      insert(&movieData);
+		}
+		else if(ivChunkID==movieHeader)
+		{
+			MovieData movieData;
+			inFile.read(byteCount);
+			if(byteCount%2)byteCount++;
+			movieData.dataType(MovieData::IV);
+			movieData.streamNumber(movieStream.toInt());
+			movieData.size(byteCount);
+			inFile.read((char*)((BYTE HUGE*)&movieData[0]),movieData.size());
+      insert(&movieData);
+		}
+		else if(ixChunkID==movieHeader)
+		{
+		  DWORD sizeHeader;
+			inFile.read(sizeHeader);
+			inFile+=sizeHeader;
+		}
+		else
+		{
+			AVIJunkHeader aviJunkHeader;
+			AVIListChunk aviListChunk;
+
+			inFile-=movieHeaderLiteral.length();
+			if(aviJunkHeader.read(inFile))continue;
+      else if(aviListChunk.read(inFile)&&AVIListChunk::Record==aviListChunk.chunkType())continue;
+			else break;
+		}
+	}
+	AVISubChunk aviSubChunk;
+	aviSubChunk.read(inFile);
+	if(AVISubChunk::Index==aviSubChunk.chunkType())
+	{
+		IndexChunk indexChunk;
+		inFile+=4;
+		for(short itemIndex=0;itemIndex<size();itemIndex++)indexChunk.read(inFile);
+  }
+	return true;
+}
+
+bool AVIMovieHeader::write(File &outFile)
+{
+  String streamHeader;
+  DWORD byteCount;
+
+  for(int index=0;index<size();index++)
+	{
+	  MovieData &movieData=operator[](index);
+		switch(movieData.dataType())
+		{
+		  case MovieData::Audio :
+			  ::sprintf(streamHeader,"%02dwb",movieData.streamNumber());
+				outFile.write(streamHeader);
+			  outFile.write(movieData.size());
+				outFile.write((char*)&movieData[0],movieData.size());
+			  break;
+			case MovieData::DIBCompressed :
+			  ::sprintf(streamHeader,"%02ddc",movieData.streamNumber());
+				outFile.write(streamHeader);
+			  outFile.write(movieData.size());
+				outFile.write((char*)&movieData[0],movieData.size());
+			  break;
+			case MovieData::DIBUnCompressed :
+			  ::sprintf(streamHeader,"%02ddb",movieData.streamNumber());
+				outFile.write(streamHeader);
+			  outFile.write(movieData.size());
+				outFile.write((char*)&movieData[0],movieData.size());
+			  break;
+			case MovieData::IV :
+			  ::sprintf(streamHeader,"%02div",movieData.streamNumber());
+				outFile.write(streamHeader);
+			  outFile.write(movieData.size());
+				outFile.write((char*)&movieData[0],movieData.size());
+			  break;
+			case MovieData::Unknown :
+			  break;
+		}
+	}
+	return true;
+}
+

avifile/hold/MOVIEHDR.HPP

@@ -0,0 +1,42 @@
+#ifndef _AVIFILE_AVIMOVIEHEADER_HPP_
+#define _AVIFILE_AVIMOVIEHEADER_HPP_
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _AVIFILE_INDEXCHUNK_HPP_
+#include <avifile/idxchnk.hpp>
+#endif
+#ifndef _AVIFILE_MOVIEDATA_HPP_
+#include <avifile/movidata.hpp>
+#endif
+
+class AVIMovieHeader : public Block<MovieData>
+{
+public:
+	AVIMovieHeader(void);
+	virtual ~AVIMovieHeader();
+	bool read(File &inFile);
+	bool write(File &outFile);
+	DWORD movieChunks(void)const;
+private:
+};
+
+inline
+AVIMovieHeader::AVIMovieHeader(void)
+{
+}
+
+inline
+AVIMovieHeader::~AVIMovieHeader()
+{
+}
+
+inline
+DWORD AVIMovieHeader::movieChunks(void)const
+{
+  return size();
+}
+#endif

avifile/hold/RIFFHDR.CPP

@@ -0,0 +1,29 @@
+#include <avifile/riffhdr.hpp>
+
+bool RIFFHeader::read(File &inFile)
+{
+	String riffLiteral("RIFF");
+	String aviLiteral("AVI ");
+	String riffHeader;
+	String aviHeader;
+
+	riffHeader.reserve(riffLiteral.length()+1);
+	aviHeader.reserve(aviLiteral.length()+1);
+	inFile.read(riffHeader,riffLiteral.length());
+	if(!(riffHeader==riffLiteral))return false;
+	inFile.read(mFileSize);
+  inFile.read(aviHeader,aviLiteral.length());
+	if(!(aviHeader==aviLiteral))return false;
+	return true;
+}
+
+bool RIFFHeader::write(File &outFile)
+{
+	String riffLiteral("RIFF");
+	String aviLiteral("AVI ");
+
+	outFile.write(riffLiteral); 
+	outFile.write(mFileSize);
+	outFile.write(aviLiteral);
+	return true;
+}

avifile/hold/RIFFHDR.HPP

@@ -0,0 +1,65 @@
+#ifndef _AVIFILE_RIFFHEADER_HPP_
+#define _AVIFILE_RIFFHEADER_HPP_
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+
+class RIFFHeader
+{
+public:
+	RIFFHeader(void);
+	virtual ~RIFFHeader();
+  RIFFHeader &operator=(const RIFFHeader &someRIFFHeader);
+	bool read(File &inFile);
+	bool write(File &outFile);
+	DWORD size(void)const;
+	void size(DWORD size);
+	static DWORD sizeHeader(void);
+private:
+	RIFFHeader(const RIFFHeader &someRIFFHeader);
+  RIFFHeader &operator==(const RIFFHeader &someRIFFHeader);
+	DWORD mFileSize;
+};
+
+inline
+RIFFHeader::RIFFHeader(void)
+: mFileSize(0)
+{
+}
+
+inline
+RIFFHeader::RIFFHeader(const RIFFHeader &/*someRIFFHeaderfs*/)
+{
+}
+
+inline
+RIFFHeader::~RIFFHeader()
+{
+}
+
+inline
+RIFFHeader &RIFFHeader::operator==(const RIFFHeader &/*someRIFFHeader*/)
+{
+	return *this;
+}
+
+inline
+DWORD RIFFHeader::size(void)const
+{
+  return mFileSize;
+}
+
+inline
+void RIFFHeader::size(DWORD size)
+{
+  mFileSize=size;
+}
+
+inline
+DWORD RIFFHeader::sizeHeader(void)
+{
+  return 8;
+}
+#endif
+
+

avifile/hold/STDTMPL.CPP

@@ -0,0 +1,31 @@
+#define _EXPAND_BLOCK_TEMPLATES_
+#define _EXPAND_VECTOR_TEMPLATES_
+#include <common/point.hpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/gdata.hpp>
+#include <common/gdata.tpp>
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <common/string.hpp>
+#include <common/rgbquad.hpp>
+#include <common/rgbcolor.hpp>
+#include <avifile/movidata.hpp>
+#include <avifile/strmhdr.hpp>
+#include <avifile/drvname.hpp>
+#include <thread/tcallbck.hpp>
+#include <thread/tcallbck.tpp>
+
+typedef Block<CallbackPointer> a;
+typedef Block<String> b;
+typedef Block<MovieData> c;
+typedef Block<DriverName> d;
+typedef Block<AVIStreamHeader> e;
+typedef PureVector<Point> f;
+typedef PureVector<RGBQuad> g;
+typedef PureVector<RGBColor> h;
+typedef GlobalData<BYTE> i;
+
+

avifile/hold/STRMDATA.CPP

@@ -0,0 +1,29 @@
+#include <avifile/strmdata.hpp>
+
+bool AVIStreamData::read(File &inFile)
+{
+	AVIListChunk aviListChunk;
+  AVIStreamHeader aviStreamHeader;
+	AVIIndexHeader aviIndexHeader;
+
+  remove();
+  inFile-=12;
+	while(TRUE)
+  {
+	  aviIndexHeader.read(inFile);
+		aviListChunk.read(inFile);
+		::OutputDebugString(aviListChunk.toString()+String("\n"));
+		if(AVIListChunk::Unknown!=aviListChunk.chunkType()&&
+			 AVIListChunk::Stream!=aviListChunk.chunkType())
+		{
+			inFile-=12;
+			return size();
+		}
+		if(aviStreamHeader.read(inFile))
+		{
+		  ::OutputDebugString(aviStreamHeader.toString());
+		  insert(&aviStreamHeader);
+		}
+    else return size();
+	}
+}

avifile/hold/STRMDATA.HPP

@@ -0,0 +1,54 @@
+#ifndef _AVIFILE_AVISTREAMDATA_HPP_
+#define _AVIFILE_AVISTREAMDATA_HPP_
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _AVIFILE_STREAMHEADER_HPP_
+#include <avifile/strmhdr.hpp>
+#endif
+
+class AVIStreamData : public Block<AVIStreamHeader>
+{
+public:
+	AVIStreamData(void);
+	AVIStreamData(const AVIStreamData &someAVIStreamData);
+	virtual ~AVIStreamData();
+  bool read(File &inFile);
+	AVIStreamData &operator=(const AVIStreamData &someAVIStreamData);
+	WORD operator==(const AVIStreamData &someAVIStreamData);
+private:
+};
+
+inline
+AVIStreamData::AVIStreamData(void)
+{
+}
+
+inline
+AVIStreamData::AVIStreamData(const AVIStreamData &someAVIStreamData)
+{
+  *this=someAVIStreamData;
+}
+
+inline
+AVIStreamData::~AVIStreamData()
+{
+}
+
+inline
+AVIStreamData &AVIStreamData::operator=(const AVIStreamData &someAVIStreamData)
+{
+	(Block<AVIStreamHeader>&)*this=(Block<AVIStreamHeader>&)someAVIStreamData;
+  return *this;
+}
+
+inline
+WORD AVIStreamData::operator==(const AVIStreamData &someAVIStreamData)
+{
+	return (Block<AVIStreamHeader>&)*this==(Block<AVIStreamHeader>&)someAVIStreamData;
+}
+#endif
+

avifile/hold/STRMHDR.CPP

@@ -0,0 +1,166 @@
+#include <avifile/strmhdr.hpp>
+#include <avifile/junkhdr.hpp>
+#include <avifile/mischdr.hpp>
+
+AVIStreamHeader &AVIStreamHeader::operator=(const AVIStreamHeader &someAVIStreamHeader)
+{
+	fccType(someAVIStreamHeader.fccType());
+	fccHandler(someAVIStreamHeader.fccHandler());
+	flags(someAVIStreamHeader.flags());
+	priority(someAVIStreamHeader.priority());
+	language(someAVIStreamHeader.language());
+	initialFrames(someAVIStreamHeader.initialFrames());
+	scale(someAVIStreamHeader.scale());
+	rate(someAVIStreamHeader.rate());
+	start(someAVIStreamHeader.start());
+	length(someAVIStreamHeader.length());
+	suggestedBufferSize(someAVIStreamHeader.suggestedBufferSize());
+	quality(someAVIStreamHeader.quality());
+	sampleSize(someAVIStreamHeader.sampleSize());
+	frame(someAVIStreamHeader.frame());
+  (AVIFormatHeader&)*this=(AVIFormatHeader&)someAVIStreamHeader;
+  mAVIVedtHeader=someAVIStreamHeader.mAVIVedtHeader;
+	return *this;
+}
+
+WORD AVIStreamHeader::operator==(const AVIStreamHeader &someAVIStreamHeader)const
+{
+	return (fccType()==someAVIStreamHeader.fccType()&&
+					fccHandler()==someAVIStreamHeader.fccHandler()&&
+					flags()==someAVIStreamHeader.flags()&&
+					priority()==someAVIStreamHeader.priority()&&
+					language()==someAVIStreamHeader.language()&&
+					initialFrames()==someAVIStreamHeader.initialFrames()&&
+					scale()==someAVIStreamHeader.scale()&&
+					rate()==someAVIStreamHeader.rate()&&
+					start()==someAVIStreamHeader.start()&&
+					length()==someAVIStreamHeader.length()&&
+					suggestedBufferSize()==someAVIStreamHeader.suggestedBufferSize()&&
+					quality()==someAVIStreamHeader.quality()&&
+					sampleSize()==someAVIStreamHeader.sampleSize()&&
+					frame()==someAVIStreamHeader.frame()&&
+          (AVIFormatHeader&)*this==(AVIFormatHeader&)someAVIStreamHeader&&
+					mAVIVedtHeader==someAVIStreamHeader.mAVIVedtHeader);
+}
+
+bool AVIStreamHeader::read(File &inFile)
+{
+	AVIJunkHeader aviJunkHeader;
+  AVIMiscHeader aviMiscHeader;
+	String streamLiteral("strh");
+	String streamHeader;
+	Rect frameRect;
+	WORD rectLeft;
+	WORD rectTop;
+	WORD rectRight;
+	WORD rectBottom;
+  int headerLength;
+
+	streamHeader.reserve(streamLiteral.length()+1);
+	inFile.read(streamHeader,streamLiteral.length());
+	if(!(streamLiteral==streamHeader))
+	{
+		inFile-=streamLiteral.length();
+		return FALSE;
+	}
+	inFile.read(headerLength);  
+  int startPos(inFile.tell());
+	inFile.read(AVIVFWStreamHeader::fccType);
+	inFile.read(AVIVFWStreamHeader::fccHandler);
+	inFile.read(AVIVFWStreamHeader::dwFlags);
+	inFile.read(AVIVFWStreamHeader::wPriority);
+	inFile.read(AVIVFWStreamHeader::wLanguage);
+	inFile.read(AVIVFWStreamHeader::dwInitialFrames);
+	inFile.read(AVIVFWStreamHeader::dwScale);
+	inFile.read(AVIVFWStreamHeader::dwRate);
+	inFile.read(AVIVFWStreamHeader::dwStart);
+	inFile.read(AVIVFWStreamHeader::dwLength);
+	inFile.read(AVIVFWStreamHeader::dwSuggestedBufferSize);
+	inFile.read(AVIVFWStreamHeader::dwQuality);
+	inFile.read(AVIVFWStreamHeader::dwSampleSize);
+	inFile.read(rectLeft);
+	inFile.read(rectTop);
+	inFile.read(rectRight);
+	inFile.read(rectBottom);
+	int endPos(inFile.tell());
+  inFile+=headerLength-(endPos-startPos);
+	frameRect.left(rectLeft);
+	frameRect.top(rectTop);
+	frameRect.right(rectRight);
+	frameRect.bottom(rectBottom);
+	frame(frameRect);
+	(AVIFormatHeader&)*this=StreamType(fccType());
+  ((AVIFormatHeader&)*this).read(inFile);
+	mAVIVedtHeader.read(inFile);
+	mAVIAdditionalHeader.read(inFile);
+	mAVIIndexHeader.read(inFile);
+  while(aviMiscHeader.read(inFile));
+	aviJunkHeader.read(inFile);
+	return true;
+}
+
+bool AVIStreamHeader::write(File &outFile)
+{
+  WORD rectLeft;
+	WORD rectTop;
+	WORD rectRight;
+	WORD rectBottom;
+	int sizeHeader;
+
+  outFile.write("strh");
+  sizeHeader=sizeof(AVIVFWStreamHeader::fccType)+
+	           sizeof(AVIVFWStreamHeader::fccHandler)+
+						 sizeof(AVIVFWStreamHeader::dwFlags)+
+						 sizeof(AVIVFWStreamHeader::wPriority)+
+						 sizeof(AVIVFWStreamHeader::wLanguage)+
+						 sizeof(AVIVFWStreamHeader::dwInitialFrames)+
+						 sizeof(AVIVFWStreamHeader::dwScale)+
+						 sizeof(AVIVFWStreamHeader::dwRate)+
+						 sizeof(AVIVFWStreamHeader::dwStart)+
+						 sizeof(AVIVFWStreamHeader::dwLength)+
+						 sizeof(AVIVFWStreamHeader::dwSuggestedBufferSize)+
+						 sizeof(AVIVFWStreamHeader::dwQuality)+
+						 sizeof(AVIVFWStreamHeader::dwSampleSize)+
+						 sizeof(rectLeft)+
+						 sizeof(rectTop)+
+						 sizeof(rectRight)+
+						 sizeof(rectBottom);
+	outFile.write(sizeHeader);
+	outFile.write(AVIVFWStreamHeader::fccType);
+	outFile.write(AVIVFWStreamHeader::fccHandler);
+	outFile.write(AVIVFWStreamHeader::dwFlags);
+	outFile.write(AVIVFWStreamHeader::wPriority);
+	outFile.write(AVIVFWStreamHeader::wLanguage);
+	outFile.write(AVIVFWStreamHeader::dwInitialFrames);
+	outFile.write(AVIVFWStreamHeader::dwScale);
+	outFile.write(AVIVFWStreamHeader::dwRate);
+	outFile.write(AVIVFWStreamHeader::dwStart);
+	outFile.write(AVIVFWStreamHeader::dwLength);
+	outFile.write(AVIVFWStreamHeader::dwSuggestedBufferSize);
+	outFile.write(AVIVFWStreamHeader::dwQuality);
+	outFile.write(AVIVFWStreamHeader::dwSampleSize);
+  outFile.write(rectLeft=frame().left());
+	outFile.write(rectTop=frame().top());
+	outFile.write(rectRight=frame().right());
+	outFile.write(rectBottom=frame().bottom());
+	return true;
+}
+
+String AVIStreamHeader::toString(void)const
+{
+  String str;
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::fccType=")+FOURCC(AVIVFWStreamHeader::fccType).toString()+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::fccHandler=")+FOURCC(AVIVFWStreamHeader::fccHandler).toString()+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwFlags=")+String().fromInt(AVIVFWStreamHeader::dwFlags)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::wPriority=")+String().fromInt(AVIVFWStreamHeader::wPriority)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::wLanguage=")+String().fromInt(AVIVFWStreamHeader::wLanguage)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwInitialFrames=")+String().fromInt(AVIVFWStreamHeader::dwInitialFrames)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwScale=")+String().fromInt(AVIVFWStreamHeader::dwScale)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwRate=")+String().fromInt(AVIVFWStreamHeader::dwRate)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwStart=")+String().fromInt(AVIVFWStreamHeader::dwStart)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwLength=")+String().fromInt(AVIVFWStreamHeader::dwLength)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwSuggestedBufferSize=")+String().fromInt(AVIVFWStreamHeader::dwSuggestedBufferSize)+String("\n");
+	str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwQuality=")+String().fromInt(AVIVFWStreamHeader::dwQuality)+String("\n");
+  str+=String("[AVIStreamHeader::toString]AVIVFWStreamHeader::dwSampleSize=")+String().fromInt(AVIVFWStreamHeader::dwSampleSize)+String("\n");
+	return str;
+}

avifile/hold/STRMHDR.HPP

@@ -0,0 +1,289 @@
+#ifndef _AVIFILE_STREAMHEADER_HPP_
+#define _AVIFILE_STREAMHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _AVIFILE_AVILISTCHUNK_HPP_
+#include <avifile/lstchnk.hpp>
+#endif
+#ifndef _AVIFILE_AVIDEFS_HPP_
+#include <avifile/avidefs.hpp>
+#endif
+#ifndef _AVIFILE_FORMATHEADER_HPP_
+#include <avifile/frmhdr.hpp>
+#endif
+#ifndef _AVIFILE_VEDTHEADER_HPP_
+#include <avifile/vedthdr.hpp>
+#endif
+#ifndef _AVIFILE_ADDITIONALHEADER_HPP_
+#include <avifile/addhdr.hpp>
+#endif
+#ifndef _AVIFILE_AVIINDEXHEADER_HPP_
+#include <avifile/AVIIndexHeader.hpp>
+#endif
+#ifndef _AVIFILE_FOURCC_HPP_
+#include <avifile/fourcc.hpp>
+#endif
+
+/*
+  additional fcchandlers 'dvsd','dvhd','dvsl' for digital video
+
+*/
+
+class AVIStreamHeader : public AVIFormatHeader, private AVIVFWStreamHeader 
+{
+public:
+	AVIStreamHeader(void);
+	AVIStreamHeader(const AVIStreamHeader &someAVIStreamHeader);
+	virtual ~AVIStreamHeader();
+  bool read(File &inFile);
+  bool write(File &outFile);
+	AVIStreamHeader &operator=(const AVIStreamHeader &someAVIStreamHeader);
+	WORD operator==(const AVIStreamHeader &someAVIStreamHeader)const;
+	FOURCC fccType(void)const;
+	void fccType(FOURCC fccType);
+	FOURCC fccHandler(void)const;
+	void fccHandler(FOURCC fccHandler);
+	DWORD flags(void)const;
+	void flags(DWORD flags);
+	WORD priority(void)const;
+	void priority(WORD priority);
+	WORD language(void)const;
+  void language(WORD language);
+	DWORD initialFrames(void)const;
+	void initialFrames(DWORD initialFrames);
+	DWORD scale(void)const;
+	void scale(DWORD scale);
+	DWORD rate(void)const;
+	void rate(DWORD rate);                                
+	DWORD start(void)const;
+	void start(DWORD start);
+	DWORD length(void)const;
+	void length(DWORD length);
+	DWORD suggestedBufferSize(void)const;
+	void suggestedBufferSize(DWORD suggestedBufferSize);
+	DWORD quality(void)const;
+	void quality(DWORD quiality);
+	DWORD sampleSize(void)const;
+	void sampleSize(DWORD sampleSize);
+	Rect frame(void)const;
+	void frame(const Rect &frame);
+	String toString(void)const;
+private:
+	AVIVedtHeader mAVIVedtHeader;
+  AVIAdditionalHeader mAVIAdditionalHeader;
+	AVIIndexHeader mAVIIndexHeader;
+};
+
+inline
+AVIStreamHeader::AVIStreamHeader(void)
+{
+	fccType((FOURCC)0);
+	fccHandler((FOURCC)0);
+	flags(0L);
+	priority(0);
+	language(0);
+	initialFrames(0L);
+	scale(0L);
+	rate(0L);
+	start(0L);
+	length(0L);
+	suggestedBufferSize(0L);
+	quality(0L);
+	sampleSize(0L);
+	frame(Rect());
+}
+
+inline
+AVIStreamHeader::AVIStreamHeader(const AVIStreamHeader &someAVIStreamHeader)
+{
+	*this=someAVIStreamHeader;
+}
+
+inline
+AVIStreamHeader::~AVIStreamHeader()
+{
+}
+
+inline
+FOURCC AVIStreamHeader::fccType(void)const
+{
+	return AVIVFWStreamHeader::fccType;
+}
+
+inline
+void AVIStreamHeader::fccType(FOURCC fccType)
+{
+	AVIVFWStreamHeader::fccType=fccType;
+}
+
+inline
+FOURCC AVIStreamHeader::fccHandler(void)const
+{
+	return AVIVFWStreamHeader::fccHandler;
+}
+
+inline
+void AVIStreamHeader::fccHandler(FOURCC fccHandler)
+{
+	AVIVFWStreamHeader::fccHandler=fccHandler;
+}
+
+inline
+DWORD AVIStreamHeader::flags(void)const
+{
+	return AVIVFWStreamHeader::dwFlags;
+}
+
+inline
+void AVIStreamHeader::flags(DWORD flags)
+{
+	AVIVFWStreamHeader::dwFlags=flags;
+}
+
+inline
+WORD AVIStreamHeader::priority(void)const
+{
+	return AVIVFWStreamHeader::wPriority;
+}
+
+inline
+void AVIStreamHeader::priority(WORD priority)
+{
+	AVIVFWStreamHeader::wPriority=priority;
+}
+
+inline
+WORD AVIStreamHeader::language(void)const
+{
+	return AVIVFWStreamHeader::wLanguage;
+}
+
+inline
+void AVIStreamHeader::language(WORD language)
+{
+	AVIVFWStreamHeader::wLanguage=language;
+}
+
+inline
+DWORD AVIStreamHeader::initialFrames(void)const
+{
+	return AVIVFWStreamHeader::dwInitialFrames;
+}
+
+inline
+void AVIStreamHeader::initialFrames(DWORD initialFrames)
+{
+	AVIVFWStreamHeader::dwInitialFrames=initialFrames;
+}
+
+inline
+DWORD AVIStreamHeader::scale(void)const
+{
+	return AVIVFWStreamHeader::dwScale;
+}
+
+inline
+void AVIStreamHeader::scale(DWORD scale)
+{
+	AVIVFWStreamHeader::dwScale=scale;
+}
+
+inline
+DWORD AVIStreamHeader::rate(void)const
+{
+	return AVIVFWStreamHeader::dwRate;
+}
+
+inline
+void AVIStreamHeader::rate(DWORD rate)
+{
+	AVIVFWStreamHeader::dwRate=rate;
+}
+
+inline
+DWORD AVIStreamHeader::start(void)const
+{
+	return AVIVFWStreamHeader::dwStart;
+}
+
+inline
+void AVIStreamHeader::start(DWORD start)
+{
+  AVIVFWStreamHeader::dwStart=start;
+}
+
+inline
+DWORD AVIStreamHeader::length(void)const
+{
+	return AVIVFWStreamHeader::dwLength;
+}
+
+inline
+void AVIStreamHeader::length(DWORD length)
+{
+	AVIVFWStreamHeader::dwLength=length;
+}
+
+inline
+DWORD AVIStreamHeader::suggestedBufferSize(void)const
+{
+	return AVIVFWStreamHeader::dwSuggestedBufferSize;
+}
+
+inline
+void AVIStreamHeader::suggestedBufferSize(DWORD suggestedBufferSize)
+{
+	AVIVFWStreamHeader::dwSuggestedBufferSize=suggestedBufferSize;
+}
+
+inline
+DWORD AVIStreamHeader::quality(void)const
+{
+	return AVIVFWStreamHeader::dwQuality;
+}
+
+inline
+void AVIStreamHeader::quality(DWORD quality)
+{
+	AVIVFWStreamHeader::dwQuality=quality;
+}
+
+inline
+DWORD AVIStreamHeader::sampleSize(void)const
+{
+  return AVIVFWStreamHeader::dwSampleSize;
+}
+
+inline
+void AVIStreamHeader::sampleSize(DWORD sampleSize)
+{
+  AVIVFWStreamHeader::dwSampleSize=sampleSize;
+}
+
+inline
+void AVIStreamHeader::frame(const Rect &frame)
+{
+	AVIVFWStreamHeader::rcFrame.left=(WORD)frame.left();
+	AVIVFWStreamHeader::rcFrame.top=(WORD)frame.top();
+	AVIVFWStreamHeader::rcFrame.right=(WORD)frame.right();
+	AVIVFWStreamHeader::rcFrame.bottom=(WORD)frame.bottom();
+}
+
+inline
+Rect AVIStreamHeader::frame(void)const
+{
+	return Rect(AVIVFWStreamHeader::rcFrame.left,
+							AVIVFWStreamHeader::rcFrame.top,
+							AVIVFWStreamHeader::rcFrame.right,
+							AVIVFWStreamHeader::rcFrame.bottom);
+}
+#endif
+
+

avifile/hold/STRMTYPE.HPP

@@ -0,0 +1,68 @@
+#ifndef _AVIFILE_STREAMTYPE_HPP_
+#define _AVIFILE_STREAMTYPE_HPP_
+
+class StreamType
+{
+public:
+	enum Type{Video=0x73646976,Audio=0x73647561,Text=0x54584554,IAVS=0x73766169};
+	StreamType(Type streamType=Video);
+  StreamType(DWORD streamType);
+	StreamType(const StreamType &someStreamType);
+	~StreamType();
+	StreamType &operator=(const StreamType &someStreamType);
+  WORD operator==(const StreamType &someStreamType)const;
+	Type streamType(void)const;
+  void streamType(Type streamType);
+private:
+  Type mStreamType;
+};
+
+inline
+StreamType::StreamType(DWORD streamType)
+: mStreamType((Type)streamType)
+{
+}
+
+inline
+StreamType::StreamType(Type streamType)
+: mStreamType(streamType)
+{
+}
+
+inline
+StreamType::StreamType(const StreamType &someStreamType)
+{
+  *this=someStreamType;
+}
+
+inline
+StreamType::~StreamType()
+{
+}
+
+inline
+StreamType &StreamType::operator=(const StreamType &someStreamType)
+{
+	streamType(someStreamType.streamType());
+  return *this;
+}
+
+inline
+WORD StreamType::operator==(const StreamType &someStreamType)const
+{
+  return streamType()==someStreamType.streamType();
+}
+
+inline
+StreamType::Type StreamType::streamType(void)const
+{
+  return mStreamType;
+}
+
+inline
+void StreamType::streamType(Type streamType)
+{
+  mStreamType=streamType;
+}
+#endif
+

avifile/hold/SUBCHNK.CPP

@@ -0,0 +1,15 @@
+#include <avifile/subchnk.hpp>
+
+bool AVISubChunk::read(File &inFile)
+{
+	String idxLiteral("idx1");
+	String subChunk;
+
+  mChunkType=Unknown;
+	subChunk.reserve(idxLiteral.length()+1);
+	inFile.read(subChunk,idxLiteral.length());
+	if(subChunk==idxLiteral)mChunkType=Index;
+	else inFile-=idxLiteral.length();
+  return true;
+}
+

avifile/hold/SUBCHNK.HPP

@@ -0,0 +1,70 @@
+#ifndef _AVIFILE_AVISUBCHUNK_HPP_
+#define _AVIFILE_AVISUBCHUNK_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class AVISubChunk
+{
+public:
+  enum ChunkType{Index,Unknown};
+	AVISubChunk(void);
+	AVISubChunk(const AVISubChunk &someAVISubChunk);
+	virtual ~AVISubChunk();
+	AVISubChunk &operator=(const AVISubChunk &someAVISubChunk);
+	WORD operator==(AVISubChunk &someAVISubChunk)const;
+	ChunkType chunkType(void)const;
+  void chunkType(ChunkType chunkType);
+	bool read(File &inFile);
+private:
+  ChunkType mChunkType;
+};
+								 
+inline
+AVISubChunk::AVISubChunk(void)
+: mChunkType(Unknown)
+{
+}
+
+inline
+AVISubChunk::AVISubChunk(const AVISubChunk &someAVISubChunk)
+{
+  *this=someAVISubChunk;
+}
+
+inline
+AVISubChunk::~AVISubChunk()
+{
+}
+
+inline
+AVISubChunk &AVISubChunk::operator=(const AVISubChunk &someAVISubChunk)
+{
+	chunkType(someAVISubChunk.chunkType());
+	return *this;  
+}
+
+inline
+WORD AVISubChunk::operator==(AVISubChunk &someAVISubChunk)const
+{
+  return (chunkType()==someAVISubChunk.chunkType());
+}
+
+inline
+AVISubChunk::ChunkType AVISubChunk::chunkType(void)const
+{
+  return mChunkType;
+}
+
+inline
+void AVISubChunk::chunkType(ChunkType chunkType)
+{
+  mChunkType=chunkType;  
+}
+#endif

avifile/hold/VEDTHDR.CPP

@@ -0,0 +1,20 @@
+#include <avifile/vedthdr.hpp>
+
+bool AVIVedtHeader::read(File &inFile)
+{
+	String vedtLiteral("vedt");
+	String vedtHeader;
+	GlobalData<BYTE> vedtData;
+
+	vedtHeader.reserve(vedtLiteral.length()+1);
+	inFile.read(vedtHeader,vedtLiteral.length());
+	if(!(vedtHeader==vedtLiteral))
+	{
+    inFile-=vedtLiteral.length();
+		return FALSE;
+	}
+	vedtData.size(ByteCount);
+  inFile.read((char*)((BYTE HUGE*)&vedtData[0]),vedtData.size());
+	return TRUE;
+}
+																						 

avifile/hold/VEDTHDR.HPP

@@ -0,0 +1,53 @@
+#ifndef _AVIFILE_VEDTHEADER_HPP_
+#define _AVIFILE_VEDTHEADER_HPP_
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+#ifndef _COMMON_FILE_HPP_
+#include <common/file.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class AVIVedtHeader
+{
+public:
+	AVIVedtHeader(void);
+  AVIVedtHeader(const AVIVedtHeader &someAVIVedtHeader);
+	virtual ~AVIVedtHeader();
+	bool read(File &inFile);
+  AVIVedtHeader &operator=(const AVIVedtHeader &someAVIVedtHeader);
+	bool operator==(const AVIVedtHeader &someAVIVedtHeader)const;
+private:
+  enum {ByteCount=0x0C};
+};
+
+inline
+AVIVedtHeader::AVIVedtHeader(void)
+{
+}
+
+inline
+AVIVedtHeader::AVIVedtHeader(const AVIVedtHeader &someAVIVedtHeader)
+{
+	*this=someAVIVedtHeader;
+}
+
+inline
+AVIVedtHeader::~AVIVedtHeader()
+{
+}
+
+inline
+AVIVedtHeader &AVIVedtHeader::operator=(const AVIVedtHeader &/*someVedtHeader*/)
+{
+	return *this;
+}
+
+inline
+bool AVIVedtHeader::operator==(const AVIVedtHeader &/*someVedtHeader*/)const
+{
+  return true;
+}
+#endif

avifile/hold/VIDC.CPP

@@ -0,0 +1,200 @@
+#include <avifile/vidc.hpp>
+#include <avifile/fourcc.hpp>
+
+VideoCodec::ReturnCode VideoCodec::openDriver(const DriverName &driverName)
+{
+	return openDriver(driverName.driverLoadName());
+}
+
+VideoCodec::ReturnCode VideoCodec::openDriver(DWORD fccHandler)
+{
+	DriverName driverName;
+
+	if(!locateDriver(fccHandler,driverName))return FailResult;
+	return openDriver(driverName);
+}
+
+WORD VideoCodec::enumerateDrivers(Block<DriverName> &driverStrings)
+{
+	Profile systemProfile("SYSTEM.INI","UNSET");
+	String sectionName("DRIVERS32");
+	String videoCodecID("VIDC");
+	String driverType;
+	String driverName;
+	String driverLoadName;
+	Block<String> driversBlock;
+
+  driverStrings.remove();
+	systemProfile.readProfileBlock(sectionName,driversBlock);
+	if(!driversBlock.size())return FALSE;
+	for(short itemIndex=0;itemIndex<driversBlock.size();itemIndex++)
+	{
+		driverType=driversBlock[itemIndex].betweenString(0,'.');
+		if(driverType.isNull())continue;
+		driverType.upper();
+		if(!(driverType==videoCodecID))continue;
+		driverName=driversBlock[itemIndex].betweenString('.','=');
+    if(driverName.isNull())continue;
+		driverLoadName=driversBlock[itemIndex].betweenString('=',0);
+    if(driverLoadName.isNull())continue;
+    driverStrings.insert(&DriverName(driverName,driverLoadName));
+  }
+	return FALSE;
+}
+
+WORD VideoCodec::locateDriver(DWORD fccType,DriverName &driverName)
+{
+	Block<DriverName> driverNames;
+	String fccString;
+	WORD driverCount;
+
+  ::OutputDebugString(String("\nsearching for a driver to handle type '")+FOURCC(fccType).toString()+String("'\n"));
+	enumerateDrivers(driverNames);
+	if(0==(driverCount=driverNames.size()))return FALSE;
+	for(short itemIndex=0;itemIndex<driverCount;itemIndex++)
+	{
+		fccString=driverNames[itemIndex].driverName();
+		::OutputDebugString(driverNames[itemIndex].driverName()+String(":")+driverNames[itemIndex].driverLoadName()+String("\n"));
+		if(fccType==FOURCC(fccString)){driverName=driverNames[itemIndex];return TRUE;}
+		fccString.lower();
+		if(fccType==FOURCC(fccString)){driverName=driverNames[itemIndex];return TRUE;}
+	}
+  return FALSE;
+}
+
+VideoCodec::ReturnCode VideoCodec::openDriver(const String &driverLoadName)
+{
+	closeDriver();
+	if((mhVideoCodec=::LoadLibrary(driverLoadName))<(HINSTANCE)HINSTANCE_ERROR)mhVideoCodec=(HINSTANCE)0;
+	if(!mhVideoCodec)return FailResult;
+	mlpfnDriverProc=(LPFNDRIVERPROC)::GetProcAddress(mhVideoCodec,"DriverProc");
+	if(!mlpfnDriverProc){closeDriver();return FailResult;}
+	return OkResult;
+}
+
+void VideoCodec::closeDriver(void)
+{
+	if(!mhVideoCodec)return;
+	::FreeLibrary(mhVideoCodec);
+	mhVideoCodec=(HINSTANCE)0;
+	mlpfnDriverProc=0;
+}
+
+VideoCodec::ReturnCode VideoCodec::driverProc(ICMOpen &someICMOpen)
+{
+	ReturnCode returnCode(FailResult);
+	if(!mlpfnDriverProc)return returnCode;
+  mDriverID=(DWORD)((mlpfnDriverProc)(DriverID,(HDRVR)DriverHandle,DRV_OPEN,0L,(LONG)&someICMOpen));
+	return (ReturnCode)mDriverID;
+}
+
+VideoCodec::ReturnCode VideoCodec::driverProc(ICMInfo &someICMInfo)
+{
+	ReturnCode returnCode(FailResult);
+	if(!mlpfnDriverProc)return returnCode;
+  return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_GETINFO,(LONG)&someICMInfo,(LONG)someICMInfo.size()));
+}
+
+VideoCodec::ReturnCode VideoCodec::canDecompress(AVIBitmap &someAVIBitmap)
+{
+	ReturnCode returnCode(FailResult);
+
+	if(!mlpfnDriverProc)return returnCode;
+	returnCode=(ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_QUERY,(LONG)((BITMAPINFO*)someAVIBitmap),0L));
+	return returnCode;
+}
+
+VideoCodec::ReturnCode VideoCodec::canDecompress(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap)
+{
+	ReturnCode returnCode(FailResult);
+
+	if(!mlpfnDriverProc)return returnCode;
+	returnCode=(ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_QUERY,(LONG)((BITMAPINFO*)srcAVIBitmap),(LONG)((BITMAPINFO*)dstAVIBitmap)));
+  return returnCode;
+}
+
+VideoCodec::ReturnCode VideoCodec::getFormat(AVIBitmap &srcAVIBitmap)
+{
+	if(!mlpfnDriverProc)return FailResult;
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_GET_FORMAT,(LONG)((BITMAPINFO*)srcAVIBitmap),0L));
+}
+
+VideoCodec::ReturnCode VideoCodec::getFormat(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap)
+{
+	if(!mlpfnDriverProc)return FailResult;
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_GET_FORMAT,(LONG)((BITMAPINFO*)srcAVIBitmap),(LONG)((BITMAPINFO*)dstAVIBitmap)));
+}
+
+VideoCodec::ReturnCode VideoCodec::getPalette(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap)
+{
+	if(!mlpfnDriverProc)return FailResult;
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_GET_PALETTE,(LONG)((BITMAPINFOHEADER*)srcAVIBitmap),(LONG)((BITMAPINFOHEADER*)dstAVIBitmap)));
+}
+
+VideoCodec::ReturnCode VideoCodec::driverLoad(void)
+{
+	if(!mlpfnDriverProc)return FailResult;
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,DRV_LOAD,0L,0L));
+}
+
+VideoCodec::ReturnCode VideoCodec::driverEnable(void)
+{
+	if(!mlpfnDriverProc)return FailResult;
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,DRV_ENABLE,0L,0L));
+}
+
+VideoCodec::ReturnCode VideoCodec::icmDecompressBegin(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap)
+{
+	if(!mlpfnDriverProc)return BadFormatResult;
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_BEGIN,(LONG)((BITMAPINFO*)srcAVIBitmap),(LONG)((BITMAPINFO*)dstAVIBitmap)));
+}
+
+VideoCodec::ReturnCode VideoCodec::icmDecompressEnd(void)
+{
+	if(!mlpfnDriverProc)return FailResult;
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_END,0L,0L));
+}
+
+VideoCodec::ReturnCode VideoCodec::icmDecompress(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap,MovieData &srcMovieData,MovieData &dstMovieData)
+{
+	ICMDecompress icmDecompress;
+
+	if(!mlpfnDriverProc)return BadFormatResult;
+	icmDecompress.flags(ICMDecompress::HurryUp);
+	icmDecompress.srcBitmapInfoHeaderPtr(srcAVIBitmap);
+	icmDecompress.dstBitmapInfoHeaderPtr(dstAVIBitmap);
+	icmDecompress.srcInputPtr(srcMovieData);
+	icmDecompress.dstInputPtr(dstMovieData);
+	icmDecompress.chunkID(0x01);
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS,(LONG)&icmDecompress,(LONG)sizeof(ICMDecompress)));
+}
+
+VideoCodec::ReturnCode VideoCodec::icmConfigure(HWND hDisplayWindow)
+{
+	if(!mlpfnDriverProc)return FailResult;
+
+	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_CONFIGURE,(LONG)hDisplayWindow,0L));
+}
+
+VideoCodec::ReturnCode VideoCodec::decompressFrame(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap,MovieData &srcMovieData,MovieData &dstMovieData)
+{
+	ReturnCode returnCode(FailResult);
+
+	if(!mlpfnDriverProc)return returnCode;
+	if(BadFormatResult==canDecompress(srcAVIBitmap))return FailResult;
+	if(BadFormatResult==getFormat(srcAVIBitmap))return FailResult;
+	if(BadFormatResult==getFormat(srcAVIBitmap,dstAVIBitmap))return FailResult;
+	dstMovieData.size(dstAVIBitmap.sizeImage());
+	if(BitmapInfo::TrueColor==dstAVIBitmap.bitCount())
+	{
+		dstAVIBitmap.bitCount(BitmapInfo::Bit8);
+		if(BadFormatResult==canDecompress(srcAVIBitmap,dstAVIBitmap))return FailResult;
+    if(OkResult!=getPalette(srcAVIBitmap,dstAVIBitmap))return FailResult;
+    dstMovieData.size(dstAVIBitmap.sizeImage());
+  }
+	if(BadFormatResult==icmDecompressBegin(srcAVIBitmap,dstAVIBitmap))return FailResult;
+	if(BadFormatResult==icmDecompress(srcAVIBitmap,dstAVIBitmap,srcMovieData,dstMovieData))return FailResult;
+	if(OkResult!=icmDecompressEnd())return FailResult;
+	return OkResult;
+}
+

avifile/hold/VIDC.HPP

@@ -0,0 +1,74 @@
+#ifndef _AVIFILE_VIDEOCODEC_HPP_
+#define _AVIFILE_VIDEOCODEC_HPP_ 
+#ifndef _COMMON_PROFILE_HPP_
+#include <common/profile.hpp>
+#endif
+#ifndef _AVIFILE_AVIDEFS_HPP_
+#include <avifile/avidefs.hpp>
+#endif
+#ifndef _AVIFILE_DRIVERNAME_HPP_
+#include <avifile/drvname.hpp>
+#endif
+#ifndef _AVIFILE_ICMOPEN_HPP_
+#include <avifile/icmopen.hpp>
+#endif
+#ifndef _AVIFILE_ICMINFO_HPP_
+#include <avifile/icminfo.hpp>
+#endif
+#ifndef _AVIFILE_ICMDECOMPRESS_HPP_
+#include <avifile/icmdcprs.hpp>
+#endif
+#ifndef _AVIFILE_FOURCC_HPP_
+#include <avifile/fourcc.hpp>
+#endif
+#ifndef _AVIFILE_AVIBITMAP_HPP_
+#include <avifile/avibmp.hpp>
+#endif
+
+class VideoCodec
+{
+public:
+	enum ReturnCode{OkResult=ICERR_OK,FailResult=ICERR_UNSUPPORTED,BadFormatResult=ICERR_BADFORMAT};
+	typedef LRESULT (FAR PASCAL *LPFNDRIVERPROC)(DWORD dwID,HDRVR hdrvr,UINT uMsg,LONG lParam1,LONG lParam2);
+	VideoCodec(void);
+	virtual ~VideoCodec();
+	void closeDriver(void);
+	static WORD enumerateDrivers(Block<DriverName> &driverStrings);
+	WORD locateDriver(DWORD fccType,DriverName &driverName);
+	ReturnCode openDriver(DWORD fccType);
+	ReturnCode openDriver(const String &driverName);
+	ReturnCode openDriver(const DriverName &driverName);
+	ReturnCode driverLoad(void);
+	ReturnCode driverEnable(void);
+	ReturnCode canDecompress(AVIBitmap &someAVIBitmap);
+	ReturnCode canDecompress(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap);
+	ReturnCode getFormat(AVIBitmap &srcAVIBitmap);
+	ReturnCode getFormat(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap);
+	ReturnCode getPalette(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap);
+	ReturnCode driverProc(ICMOpen &someICMOpen);
+	ReturnCode driverProc(ICMInfo &someICMInfo);
+	ReturnCode decompressFrame(AVIBitmap &srcBitmap,AVIBitmap &dstBitmap,MovieData &srcMovieData,MovieData &dstMovieData);
+	ReturnCode icmConfigure(HWND hDisplayWindow);
+private:
+	enum {DriverID=0x01,DriverHandle=0x01};
+	ReturnCode icmDecompressBegin(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap);
+	ReturnCode icmDecompress(AVIBitmap &srcAVIBitmap,AVIBitmap &dstAVIBitmap,MovieData &srcMovieData,MovieData &dstMovieData);
+	ReturnCode icmDecompressEnd(void);
+
+	DWORD mDriverID;
+	HINSTANCE mhVideoCodec;
+	LPFNDRIVERPROC mlpfnDriverProc;
+};
+
+inline
+VideoCodec::VideoCodec(void)
+: mhVideoCodec(0), mlpfnDriverProc(0), mDriverID(0)
+{
+}
+
+inline
+VideoCodec::~VideoCodec()
+{
+	closeDriver();
+}
+#endif