Esempio n. 1
0
//--------------------------------------------------------------------------//
//--------------------------------------------------------------------------//
void CAGSymImage::LoadDIB(const BITMAPINFOHEADER* pHdr, const BYTE* pBits)
{
	Free();

	if (pHdr->biCompression == BI_RGB && (pHdr->biBitCount == 1 || pHdr->biBitCount == 4 || pHdr->biBitCount == 8 || pHdr->biBitCount == 24))
	{
		BITMAPINFOHEADER bi;
		bi = *pHdr;
		bi.biCompression = BI_RGB;

		if (!bi.biSizeImage)
			bi.biSizeImage = DibSizeImage(&bi);
		if (!bi.biClrUsed)
			bi.biClrUsed = DibNumColors(&bi);

		if (m_pDIB = (BITMAPINFOHEADER*)malloc(DibSize(&bi)))
		{
			*m_pDIB = bi;

			if (bi.biClrUsed)
				memcpy((void*)DibColors(m_pDIB), (void*)DibColors(pHdr), DibPaletteSize(pHdr));

			BYTE* pNewBits = (BYTE*)DibPtr(m_pDIB);
			const BYTE* pSrcBits;
			if (pBits)
				pSrcBits = pBits;
			else
				pSrcBits = (BYTE*)(DibColors(pHdr) + bi.biClrUsed);

			memcpy(pNewBits, pSrcBits, bi.biSizeImage);
		}
	}
}
Esempio n. 2
0
/******************************Public*Routine******************************\
* VcdPlyerCaptureImage
*
\**************************************************************************/
BOOL
VcdPlyerCaptureImage(
    LPCSTR szFile
    )
{
    if(pMpegMovie)
    {
        BYTE* lpCurrImage = NULL;

        if(pMpegMovie->GetCurrentImage(&lpCurrImage) == S_OK)
        {
            BITMAPFILEHEADER    hdr;
            HFILE               fh;
            OFSTRUCT            of;
            DWORD               dwSize;
            PDIB                pdib = (PDIB)lpCurrImage;

            fh = OpenFile(szFile,&of,OF_CREATE|OF_READWRITE);

            if(fh == -1)
                return FALSE;

            dwSize = DibSize(pdib);

            hdr.bfType          = BFT_BITMAP;
            hdr.bfSize          = dwSize + sizeof(BITMAPFILEHEADER);
            hdr.bfReserved1     = 0;
            hdr.bfReserved2     = 0;
            hdr.bfOffBits       = (DWORD)sizeof(BITMAPFILEHEADER) + pdib->biSize +
                DibPaletteSize(pdib);

            _lwrite(fh,(LPCSTR)(LPVOID)&hdr,sizeof(BITMAPFILEHEADER));
            _hwrite(fh,(LPCSTR)(LPVOID)pdib,dwSize);

            _lclose(fh);

            CoTaskMemFree(lpCurrImage);

            TCHAR szText[128], szDir[MAX_PATH];
            GetCurrentDirectory(MAX_PATH, szDir);
            wsprintf(szText, TEXT("Captured current image to %s\\%s."), szDir, szFile);
            MessageBox(hwndApp, szText, TEXT("Captured bitmap"), MB_OK);
            return TRUE;
        }
    }

    return FALSE;
}
Esempio n. 3
0
PDIB DibOpenFile(LPSTR szFile)
{
    HFILE               fh;
    DWORD               dwLen;
    DWORD               dwBits;
    PDIB                pdib;
    LPVOID              p;
    long                i, width, height;
    BYTE                *row1, *row2, *temp, *bits;

    fh = open(szFile, O_BINARY | O_RDONLY);

    if (fh == -1)
        return NULL;

    pdib = DibReadBitmapInfo(fh);

    if (!pdib)
       return NULL;
    
    /* How much memory do we need to hold the DIB */

    dwBits = DibWidthBytes(pdib) * pdib->biHeight;
    dwLen  = pdib->biSize + DibPaletteSize(pdib) + dwBits;

    /* Can we get more memory? */

    p = realloc(pdib,dwLen);

    if (!p)
    {
       free(pdib);
       pdib = NULL;
    }
    else
    {
        pdib = (PDIB)p;
    }

    if (pdib)
    {
       /* read in the bits */
       bits = (LPBYTE) pdib + (UINT)pdib->biSize + DibPaletteSize(pdib);
       read(fh, bits, dwBits);
       
       /* Flip the bits to make bitmap top-down */
       width = DibWidthBytes(pdib);
       height = DibHeight(pdib);
       temp = (BYTE *) malloc(width);
       for (i=0; i < height / 2; i++)
       {
          row1 = bits + (height - i - 1) * width; 
          row2 = bits + i * width; 
          memcpy(temp, row1, (size_t) width);
          memcpy(row1, row2, (size_t) width);
          memcpy(row2, temp, (size_t) width);
       }
       free(temp);
    }

    close(fh);

    return pdib;
}