scbc_repos/VideoCapture/UI/PictureEx.h

//////////////////////////////////////////////////////////////////////
// PictureEx.cpp: implementation of the CPictureEx class.
//
// Picture displaying control with support for the following formats:
// GIF (including animated GIF87a and GIF89a), JPEG, BMP, WMF, ICO, CUR
// 
// Written by Oleg Bykov (oleg_bykoff@rsdn.ru)
// Copyright (c) 2001
//
// To use CPictureEx, follow these steps:
//   - place a static control on your dialog (either a text or a bitmap)
//   - change its identifier to something else (e.g. IDC_MYPIC)
//   - associate a CStatic with it using ClassWizard
//   - in your dialog's header file replace CStatic with CPictureEx
//     (don't forget to #include "PictureEx.h" and add 
//     PictureEx.h and PictureEx.cpp to your project)
//   - call one of the overloaded CPictureEx::Load() functions somewhere
//     (OnInitDialog is a good place to start)
//   - if the preceding Load() succeeded call Draw()
//  
// You can also add the control by defining a member variable of type 
// CPictureEx, calling CPictureEx::Create (derived from CStatic), then 
// CPictureEx::Load and CPictureEx::Draw.
//
// By default, the control initializes its background to COLOR_3DFACE
// (see CPictureEx::PrepareDC()). You can change the background by
// calling CPictureEx::SetBkColor(COLORREF) after CPictureEx::Load().
//
// I decided to leave in the class the functions to write separate frames from 
// animated GIF to disk. If you want to use them, uncomment #define GIF_TRACING 
// and an appropriate section in CPictureEx::Load(HGLOBAL, DWORD). These functions 
// won't be compiled and linked to your project unless you uncomment #define GIF_TRACING,
// so you don't have to worry.
// 
// Warning: this code hasn't been subject to a heavy testing, so
// use it on your own risk. The author accepts no liability for the 
// possible damage caused by this code.
//
// Version 1.0  7 Aug 2001
//              Initial release
//
// Version 1.1  6 Sept 2001
//              ATL version of the class
//
// Version 1.2  14 Oct 2001
//              - Fixed a problem with loading GIFs from resources
//                in MFC-version of the class for multi-modules apps.
//                Thanks to Ruben Avila-Carretero for finding this out.
//
//              - Got rid of waitable timer in ThreadAnimation()
//                Now CPictureEx[Wnd] works in Win95 too.
//                Thanks to Alex Egiazarov and Wayne King for the idea.
//
//              - Fixed a visual glitch of using SetBkColor.
//                Thanks to Kwangjin Lee for finding this out.
//
// Version 1.3  10 Nov 2001
//              - Fixed a DC leak. One DC leaked per each UnLoad()
//                (forgot to put a ReleaseDC() in the end of 
//                CPictureExWnd::PrepareDC() function).
//
//              - Now it is possible to set a clipping rectangle using
//                CPictureEx[Wnd]::SetPaintRect(const LPRECT) function.
//                The LPRECT parameter tells the class what portion of
//                a picture should it display. If the clipping rect is 
//                not set, the whole picture is shown.
//                Thanks to Fabrice Rodriguez for the idea.
//
//              - Added support for Stop/Draw. Now you can Stop() an
//                animated GIF, then Draw() it again, it will continue
//                animation from the frame it was stopped on. You can 
//                also know if a GIF is currently playing with the 
//                IsPlaying() function.
//             
//              - Got rid of math.h and made m_bExitThread volatile. 
//                Thanks to Piotr Sawicki for the suggestion.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_)
#define AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <vector>

//#define GIF_TRACING  // uncomment it if you want detailed TRACEs

class CPictureEx : public CStatic
{
public:

	struct TFrame    // structure that keeps a single frame info
	{
		IPicture *m_pPicture;  // pointer to the interface used for drawing
		SIZE     m_frameSize;
		SIZE     m_frameOffset;
		UINT     m_nDelay;     // delay (in 1/100s of a second)
		UINT     m_nDisposal;  // disposal method
	};

#pragma pack(1)   // turn byte alignment on

	enum GIFBlockTypes
	{
		BLOCK_UNKNOWN,
		BLOCK_APPEXT,
		BLOCK_COMMEXT,
		BLOCK_CONTROLEXT,
		BLOCK_PLAINTEXT,
		BLOCK_IMAGE,
		BLOCK_TRAILER
	};

	enum ControlExtValues // graphic control extension packed field values
	{
		GCX_PACKED_DISPOSAL,  // disposal method
		GCX_PACKED_USERINPUT,
		GCX_PACKED_TRANSPCOLOR
	};

	enum LSDPackedValues  // logical screen descriptor packed field values
	{
		LSD_PACKED_GLOBALCT,
		LSD_PACKED_CRESOLUTION,
		LSD_PACKED_SORT,
		LSD_PACKED_GLOBALCTSIZE
	};

	enum IDPackedValues   // image descriptor packed field values
	{
		ID_PACKED_LOCALCT,
		ID_PACKED_INTERLACE,
		ID_PACKED_SORT,
		ID_PACKED_LOCALCTSIZE
	};

	struct TGIFHeader       // GIF header  
	{
		char m_cSignature[3]; // Signature - Identifies the GIF Data Stream
		// This field contains the fixed value 'GIF'
		char m_cVersion[3]; // Version number. May be one of the following:
		// "87a" or "89a"
	};

	struct TGIFLSDescriptor // Logical Screen Descriptor
	{
		WORD m_wWidth; // 2 bytes. Logical screen width
		WORD m_wHeight; // 2 bytes. Logical screen height

		unsigned char m_cPacked;      // packed field 

		unsigned char m_cBkIndex;     // 1 byte. Background color index
		unsigned char m_cPixelAspect; // 1 byte. Pixel aspect ratio
		inline int GetPackedValue(enum LSDPackedValues Value);
	};

	struct TGIFAppExtension // application extension block
	{
		unsigned char m_cExtIntroducer; // extension introducer (0x21)
		unsigned char m_cExtLabel; // app. extension label (0xFF)
		unsigned char m_cBlockSize; // fixed value of 11
		char m_cAppIdentifier[8];   // application identifier
		char m_cAppAuth[3];  // application authentication code
	};

	struct TGIFControlExt // graphic control extension block
	{
		unsigned char m_cExtIntroducer; // extension introducer (0x21)
		unsigned char m_cControlLabel;  // control extension label (0xF9)
		unsigned char m_cBlockSize; // fixed value of 4
		unsigned char m_cPacked;    // packed field
		WORD m_wDelayTime; // delay time
		unsigned char m_cTColorIndex; // transparent color index
		unsigned char m_cBlockTerm;   // block terminator (0x00)
	public:
		inline int GetPackedValue(enum ControlExtValues Value);
	};

	struct TGIFCommentExt  // comment extension block
	{
		unsigned char m_cExtIntroducer; // extension introducer (0x21)
		unsigned char m_cCommentLabel;  // comment extension label (0xFE)
	};

	struct TGIFPlainTextExt // plain text extension block
	{
		unsigned char m_cExtIntroducer;  // extension introducer (0x21)
		unsigned char m_cPlainTextLabel; // text extension label (0x01)
		unsigned char m_cBlockSize; // fixed value of 12
		WORD m_wLeftPos;    // text grid left position
		WORD m_wTopPos;     // text grid top position
		WORD m_wGridWidth;  // text grid width
		WORD m_wGridHeight; // text grid height
		unsigned char m_cCellWidth;  // character cell width
		unsigned char m_cCellHeight; // character cell height
		unsigned char m_cFgColor; // text foreground color index
		unsigned char m_cBkColor; // text background color index
	};

	struct TGIFImageDescriptor // image descriptor block
	{
		unsigned char m_cImageSeparator; // image separator byte (0x2C)
		WORD m_wLeftPos; // image left position
		WORD m_wTopPos;  // image top position
		WORD m_wWidth;   // image width
		WORD m_wHeight;  // image height
		unsigned char m_cPacked; // packed field
		inline int GetPackedValue(enum IDPackedValues Value);
	};

#pragma pack() // turn byte alignment off

public:
	BOOL GetPaintRect(RECT *lpRect);
	BOOL SetPaintRect(const RECT *lpRect);
	CPictureEx();
	virtual ~CPictureEx();
	void Stop();   // stops animation
	void UnLoad(); // stops animation plus releases all resources

	BOOL IsGIF() const;
	BOOL IsPlaying() const;
	BOOL IsAnimatedGIF() const;
	SIZE GetSize() const;
	int GetFrameCount() const;
	COLORREF GetBkColor() const;
	void SetBkColor(COLORREF clr);

	// draws the picture (starts an animation thread if needed)
	// if an animation was previously stopped by Stop(),
	// continues it from the last displayed frame
	BOOL Draw();

	// loads a picture from a file
	// i.e. Load(_T("mypic.gif"));
	BOOL Load(LPCTSTR szFileName);

	// loads a picture from a global memory block (allocated by GlobalAlloc)
	// Warning: this function DOES NOT free the global memory, pointed to by hGlobal
	BOOL Load(HGLOBAL hGlobal, DWORD dwSize);

	// loads a picture from a program resource
	// i.e. Load(MAKEINTRESOURCE(IDR_MYPIC),_T("GIFTYPE"));
	BOOL Load(LPCTSTR szResourceName,LPCTSTR szResourceType);

protected:

#ifdef GIF_TRACING
	void EnumGIFBlocks();
	void WriteDataOnDisk(CString szFileName, HGLOBAL hData, DWORD dwSize);
#endif // GIF_TRACING

	RECT m_PaintRect;
	SIZE m_PictureSize;
	COLORREF m_clrBackground;
	UINT m_nCurrFrame;
	UINT m_nDataSize;
	UINT m_nCurrOffset;
	UINT m_nGlobalCTSize;
	BOOL m_bIsGIF;
	BOOL m_bIsPlaying;
	volatile BOOL m_bExitThread;
	BOOL m_bIsInitialized;
	HDC m_hMemDC;

	HDC m_hDispMemDC;
	HBITMAP m_hDispMemBM;
	HBITMAP m_hDispOldBM;

	HBITMAP m_hBitmap;
	HBITMAP m_hOldBitmap;
	HANDLE m_hThread;
	HANDLE m_hExitEvent;
	IPicture * m_pPicture;
	TGIFHeader * m_pGIFHeader;
	unsigned char * m_pRawData;
	TGIFLSDescriptor * m_pGIFLSDescriptor;
	std::vector<TFrame> m_arrFrames;

	void ThreadAnimation();
	static UINT WINAPI _ThreadAnimation(LPVOID pParam);

	int GetNextBlockLen() const;
	BOOL SkipNextBlock();
	BOOL SkipNextGraphicBlock();
	BOOL PrepareDC(int nWidth, int nHeight);
	void ResetDataPointer();
	enum GIFBlockTypes GetNextBlock() const;
	UINT GetSubBlocksLen(UINT nStartingOffset) const;
	HGLOBAL GetNextGraphicBlock(UINT *pBlockLen, UINT *pDelay, 
		SIZE *pBlockSize, SIZE *pBlockOffset, UINT *pDisposal);

	// Generated message map functions
	//{{AFX_MSG(CPictureEx)
	afx_msg void OnDestroy();
	afx_msg void OnPaint();
	//}}AFX_MSG

	DECLARE_MESSAGE_MAP()
};

#endif // !defined(AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_)