PictureEx.h和PictureEx.cpp源文件(2)

作者：loose_went 来源：VC在线整理日期：2007-10-26

case LSD_PACKED_CRESOLUTION:
nRet = ((nRet & 0x70) >> 4) + 1;
break;

case LSD_PACKED_SORT:
nRet = (nRet & 8) >> 3;
break;

case LSD_PACKED_GLOBALCTSIZE:
nRet &= 7;
break;
};

return nRet;
}

inline int CPictureEx::TGIFImageDescriptor::GetPackedValue(enum IDPackedValues Value)
{
int nRet = (int)m_cPacked;

switch (Value)
{
case ID_PACKED_LOCALCT:
nRet >>= 7;
break;

case ID_PACKED_INTERLACE:
nRet = ((nRet & 0x40) >> 6);
break;

case ID_PACKED_SORT:
nRet = (nRet & 0x20) >> 5;
break;

case ID_PACKED_LOCALCTSIZE:
nRet &= 7;
break;
};

return nRet;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPictureEx::CPictureEx()
{
// check structures size
ASSERT(sizeof(TGIFImageDescriptor) == 10);
ASSERT(sizeof(TGIFAppExtension)    == 14);
ASSERT(sizeof(TGIFPlainTextExt)    == 15);
ASSERT(sizeof(TGIFLSDescriptor)    == 7);
ASSERT(sizeof(TGIFControlExt)    == 8);
ASSERT(sizeof(TGIFCommentExt)    == 2);
ASSERT(sizeof(TGIFHeader)     == 6);

m_pGIFLSDescriptor = NULL;
m_pGIFHeader    = NULL;
m_pPicture     = NULL;
m_pRawData     = NULL;
m_hThread     = NULL;
m_hBitmap          = NULL;
m_hMemDC     = NULL;

m_hDispMemDC       = NULL;
m_hDispMemBM       = NULL;
m_hDispOldBM       = NULL;

m_bIsInitialized   = FALSE;
m_bExitThread    = FALSE;
m_bIsPlaying       = FALSE;
m_bIsGIF     = FALSE;
m_clrBackground    = RGB(255,255,255); // white by default
m_nGlobalCTSize    = 0;
m_nCurrOffset    = 0;
m_nCurrFrame    = 0;
m_nDataSize     = 0;
m_PictureSize.cx = m_PictureSize.cy = 0;
SetRect(&m_PaintRect,0,0,0,0);

m_hExitEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
}

CPictureEx::~CPictureEx()
{
UnLoad();
CloseHandle(m_hExitEvent);
}

BEGIN_MESSAGE_MAP(CPictureEx, CStatic)
//{{AFX_MSG_MAP(CPictureEx)
ON_WM_DESTROY()
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BOOL CPictureEx::Load(HGLOBAL hGlobal, DWORD dwSize)
{
IStream *pStream = NULL;
UnLoad();

if (!(m_pRawData = reinterpret_cast<unsigned char*> (GlobalLock(hGlobal))) )
{
TRACE(_T("Load: Error locking memory\n"));
return FALSE;
};

m_nDataSize = dwSize;
m_pGIFHeader = reinterpret_cast<TGIFHeader *> (m_pRawData);

if ((memcmp(&m_pGIFHeader->m_cSignature,"GIF",3) != 0) &&
((memcmp(&m_pGIFHeader->m_cVersion,"87a",3) != 0) ||
(memcmp(&m_pGIFHeader->m_cVersion,"89a",3) != 0)) )
{
// its neither GIF87a nor GIF89a
// do the default processing

// clear GIF variables
m_pRawData = NULL;
GlobalUnlock(hGlobal);

// dont delete memory on objects release
if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
return FALSE;

if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
   reinterpret_cast<LPVOID *>(&m_pPicture)) != S_OK)
{
   pStream->Release();
   return FALSE;
};
pStream->Release();

// store pictures size

long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

HDC hDC = ::GetDC(m_hWnd);
m_PictureSize.cx = MulDiv(hmWidth, GetDeviceCaps(hDC,LOGPIXELSX), 2540);
m_PictureSize.cy = MulDiv(hmHeight, GetDeviceCaps(hDC,LOGPIXELSY), 2540);
::ReleaseDC(m_hWnd,hDC);
}
else
{
// its a GIF
m_bIsGIF = TRUE;
m_pGIFLSDescriptor = reinterpret_cast<TGIFLSDescriptor *>
   (m_pRawData + sizeof(TGIFHeader));
if (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT) == 1)
{
   // calculate the globat color table size
   m_nGlobalCTSize = static_cast<int>
    (3* (1 << (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE)+1)));
   // get the background color if GCT is present
   unsigned char *pBkClr = m_pRawData + sizeof(TGIFHeader) +
    sizeof(TGIFLSDescriptor) + 3*m_pGIFLSDescriptor->m_cBkIndex;
   m_clrBackground = RGB(pBkClr[0],pBkClr[1],pBkClr[2]);
};

// store the pictures size
m_PictureSize.cx = m_pGIFLSDescriptor->m_wWidth;
m_PictureSize.cy = m_pGIFLSDescriptor->m_wHeight;

// determine frame count for this picture
UINT nFrameCount=0;
ResetDataPointer();
while (SkipNextGraphicBlock())
nFrameCount++;

#ifdef GIF_TRACING
TRACE(
   _T(" -= GIF encountered\n"
      "Logical Screen dimensions = %dx%d\n"
      "Global color table = %d\n"
      "Color depth = %d\n"
      "Sort flag = %d\n"
      "Size of Global Color Table = %d\n"
      "Background color index = %d\n"
      "Pixel aspect ratio = %d\n"
      "Frame count = %d\n"
      "Background color = %06Xh\n\n"
     ),
   m_pGIFLSDescriptor->m_wWidth,
   m_pGIFLSDescriptor->m_wHeight,
   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT),
   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_CRESOLUTION),
   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_SORT),
   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE),
   m_pGIFLSDescriptor->m_cBkIndex,
   m_pGIFLSDescriptor->m_cPixelAspect,
   nFrameCount,
   m_clrBackground
   );
EnumGIFBlocks();
#endif

if (nFrameCount == 0) // its an empty GIF!
{
   m_pRawData = NULL;
   GlobalUnlock(hGlobal);
   return FALSE;
};

// now check the frame count
// if theres only one frame, no need to animate this GIF
// therefore, treat it like any other pic

if (nFrameCount == 1)
{
   // clear GIF variables
   m_pRawData = NULL;
   GlobalUnlock(hGlobal);

   // dont delete memory on objects release
   if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
    return FALSE;

   if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
    (LPVOID *)&m_pPicture) != S_OK)
   {
    pStream->Release();
    return FALSE;
   };

pStream->Release();
}
else
{
// if, on the contrary, there are several frames
// then store separate frames in an array

   TFrame frame;
   UINT nBlockLen;
   HGLOBAL hFrameData;
   UINT nCurFrame = 0;

   ResetDataPointer();
   while (hFrameData = GetNextGraphicBlock(&nBlockLen,
    &frame.m_nDelay, &frame.m_frameSize,
    &frame.m_frameOffset, &frame.m_nDisposal) )
   {
    #ifdef GIF_TRACING
    //////////////////////////////////////////////
    // uncomment the following strings if you want
    // to write separate frames on disk
    //
    // CString szName;
    // szName.Format(_T("%.4d.gif"),nCurFrame);
    // WriteDataOnDisk(szName,hFrameData,nBlockLen);
    // nCurFrame++;
    #endif // GIF_TRACING

IStream *pStream = NULL;

    // delete memory on objects release
    if (CreateStreamOnHGlobal(hFrameData,TRUE,&pStream) != S_OK)
    {
     GlobalFree(hFrameData);
     continue;
    };

    if (OleLoadPicture(pStream,nBlockLen,FALSE,
     IID_IPicture,
     reinterpret_cast<LPVOID *>(&frame.m_pPicture)) != S_OK)
    {
     pStream->Release();
     continue;
    };
    pStream->Release();

    // everything went well, add this frame
    m_arrFrames.push_back(frame);
   };

   // clean after ourselves
   m_pRawData = NULL;
   GlobalUnlock(hGlobal);

if (m_arrFrames.empty()) // couldnt load any frames
return FALSE;
};
}; // if (!IsGIF...

return PrepareDC(m_PictureSize.cx,m_PictureSize.cy);
}

void CPictureEx::UnLoad()
{
Stop();
if (m_pPicture)
{
m_pPicture->Release();
m_pPicture = NULL;
};

std::vector<TFrame>::iterator it;
for (it=m_arrFrames.begin();it<m_arrFrames.end();it++)
(*it).m_pPicture->Release();
m_arrFrames.clear();

if (m_hMemDC)
{
SelectObject(m_hMemDC,m_hOldBitmap);
::DeleteDC(m_hMemDC);
::DeleteObject(m_hBitmap);
m_hMemDC = NULL;
m_hBitmap = NULL;
};

if (m_hDispMemDC)
{
SelectObject(m_hDispMemDC,m_hDispOldBM);
::DeleteDC(m_hDispMemDC);
::DeleteObject(m_hDispMemBM);
m_hDispMemDC = NULL;
m_hDispMemBM = NULL;
};

SetRect(&m_PaintRect,0,0,0,0);
m_pGIFLSDescriptor = NULL;
m_pGIFHeader    = NULL;
m_pRawData     = NULL;
m_hThread     = NULL;
m_bIsInitialized   = FALSE;
m_bExitThread    = FALSE;
m_bIsGIF     = FALSE;
m_clrBackground    = RGB(255,255,255); // white by default
m_nGlobalCTSize    = 0;
m_nCurrOffset    = 0;
m_nCurrFrame    = 0;
m_nDataSize     = 0;
}

BOOL CPictureEx::Draw()
{
if (!m_bIsInitialized)
{
TRACE(_T("Call one of the CPictureEx::Load() member functions before calling Draw()\n"));
return FALSE;
};

if (IsAnimatedGIF())
{
// the picture needs animation
// well start the thread that will handle it for us

unsigned int nDummy;
m_hThread = (HANDLE) _beginthreadex(NULL,0,_ThreadAnimation,this,
   CREATE_SUSPENDED,&nDummy);
if (!m_hThread)
{
   TRACE(_T("Draw: Couldnt start a GIF animation thread\n"));
   return FALSE;
}
else
   ResumeThread(m_hThread);
}
else
{
if (m_pPicture)
{
   long hmWidth;
   long hmHeight;
   m_pPicture->get_Width(&hmWidth);
   m_pPicture->get_Height(&hmHeight);
   if (m_pPicture->Render(m_hMemDC, 0, 0, m_PictureSize.cx, m_PictureSize.cy,
    0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
   {
    Invalidate(FALSE);
    return TRUE;
   };
};
};

return FALSE;
}

SIZE CPictureEx::GetSize() const
{
return m_PictureSize;
}

BOOL CPictureEx::Load(LPCTSTR szFileName)
{
ASSERT(szFileName);

CFile file;
HGLOBAL hGlobal;
DWORD dwSize;

if (!file.Open(szFileName,
CFile::modeRead |
CFile::shareDenyWrite) )
{
TRACE(_T("Load (file): Error opening file %s\n"),szFileName);
return FALSE;
};

dwSize = file.GetLength();
hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
if (!hGlobal)
{
TRACE(_T("Load (file): Error allocating memory\n"));
return FALSE;
};

char *pData = reinterpret_cast<char*>(GlobalLock(hGlobal));
if (!pData)
{
TRACE(_T("Load (file): Error locking memory\n"));
GlobalFree(hGlobal);
return FALSE;
};

TRY
{
file.Read(pData,dwSize);
}
CATCH(CFileException, e);
{
TRACE(_T("Load (file): An exception occured while reading the file %s\n"),
szFileName);
GlobalFree(hGlobal);
e->Delete();
file.Close();
return FALSE;
}
END_CATCH
GlobalUnlock(hGlobal);
file.Close();

BOOL bRetValue = Load(hGlobal,dwSize);
GlobalFree(hGlobal);
return bRetValue;
}

BOOL CPictureEx::Load(LPCTSTR szResourceName, LPCTSTR szResourceType)
{
ASSERT(szResourceName);
ASSERT(szResourceType);

HRSRC hPicture = FindResource(AfxGetResourceHandle(),szResourceName,szResourceType);
HGLOBAL hResData;
if (!hPicture || !(hResData = LoadResource(AfxGetResourceHandle(),hPicture)))
{
TRACE(_T("Load (resource): Error loading resource %s\n"),szResourceName);
return FALSE;
};
DWORD dwSize = SizeofResource(AfxGetResourceHandle(),hPicture);

// hResData is not the real HGLOBAL (we cant lock it)
// lets make it real

HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
if (!hGlobal)
{
TRACE(_T("Load (resource): Error allocating memory\n"));
FreeResource(hResData);
return FALSE;
};

char *pDest = reinterpret_cast<char *> (GlobalLock(hGlobal));
char *pSrc = reinterpret_cast<char *> (LockResource(hResData));
if (!pSrc || !pDest)
{
TRACE(_T("Load (resource): Error locking memory\n"));
GlobalFree(hGlobal);
FreeResource(hResData);
return FALSE;
};
CopyMemory(pDest,pSrc,dwSize);
FreeResource(hResData);
GlobalUnlock(hGlobal);

BOOL bRetValue = Load(hGlobal,dwSize);
GlobalFree(hGlobal);
return bRetValue;
}

void CPictureEx::ResetDataPointer()
{
// skip header and logical screen descriptor
m_nCurrOffset =
sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;
}

BOOL CPictureEx::SkipNextGraphicBlock()
{
if (!m_pRawData) return FALSE;

// GIF header + LSDescriptor [+ GCT] [+ Control block] + Data

enum GIFBlockTypes nBlock;

nBlock = GetNextBlock();

while ((nBlock != BLOCK_CONTROLEXT) &&
     (nBlock != BLOCK_IMAGE) &&
     (nBlock != BLOCK_PLAINTEXT) &&
     (nBlock != BLOCK_UNKNOWN) &&
     (nBlock != BLOCK_TRAILER) )

[1] [2] [3]

【相关文章】

暂无