//************************************************************************
PDIB CDib::LoadDibFromFile(LPCSTR lpFileName, HPALETTE hPal, BOOL bMapToLevels, BOOL fDecodeRLE)
//************************************************************************
{
PDIB pHTdib;
PDIB pdib = new CDib();
if (!pdib)
return(NULL);
if (!pdib->LoadFromFile(lpFileName, fDecodeRLE))
{
delete pdib;
return(NULL);
}
if (bMapToLevels)
{
pdib->ConvertToLevels();
}
else
if (hPal)
{
if ( pHTdib = pdib->HalftoneDIB( hPal ) )
{
delete pdib;
pdib = pHTdib;
}
else
pdib->MapToPalette( hPal );
}
return(pdib);
}
PDIB CDib::LoadDibFromResource(HINSTANCE hInstance, LPCSTR lpResource, HPALETTE hPal, BOOL bMapToLevels, BOOL fDecodeRLE)
/***********************************************************************/
{
PDIB pHTdib;
PDIB pdib = new CDib();
if (!pdib)
return(NULL);
if (!pdib->LoadFromResource(hInstance, lpResource, fDecodeRLE))
{
delete pdib;
return(NULL);
}
if (bMapToLevels)
{
pdib->ConvertToLevels();
}
else
if (hPal)
{
if ( pHTdib = pdib->HalftoneDIB( hPal ) )
{
delete pdib;
pdib = pHTdib;
}
else
pdib->MapToPalette( hPal );
}
return(pdib);
}
//************************************************************************
PDIB CDib::GetDib(BOOL fDecodeRLE)
//************************************************************************
{
if ((GetCompression() == BI_RLE8) && fDecodeRLE)
{
DWORD dwSize = (long)GetWidthBytes() * (long)abs(GetHeight());
LPTR lp = AllocX(dwSize, GMEM_ZEROINIT );
if (!lp)
return(NULL);
PDIB pDib = new CDib(this, lp, FALSE);
if (!pDib)
{
FreeUp(lp);
return(NULL);
}
DecodeRLE(lp);
pDib->SetCompression(BI_RGB);
pDib->SetSizeImage(dwSize);
return(pDib);
}
else
{
AddRef();
return(this);
}
}
//***************************************************************************
static long AVIDraw(PINSTINFO pi, ICDRAW FAR *lpicd, LONG cbicd)
//***************************************************************************
{
UINT wFlags;
wFlags = DDF_SAME_HDC;
if ((lpicd->dwFlags & ICDRAW_NULLFRAME) || !lpicd->lpData)
{
if (lpicd->dwFlags & ICDRAW_UPDATE)
wFlags |= DDF_UPDATE;
else
return ICERR_OK;
}
if (lpicd->dwFlags & ICDRAW_PREROLL)
wFlags |= DDF_DONTDRAW;
if (lpicd->dwFlags & ICDRAW_HURRYUP)
wFlags |= DDF_HURRYUP;
// if ( lpMyDrawDibProc )
// {
// CDib MyDib( (LPBITMAPINFOHEADER)lpicd->lpFormat, ((LPBITMAPINFO)lpicd->lpFormat)->bmiColors, (LPTR)lpicd->lpData );
// (*lpMyDrawDibProc)( &MyDib );
// }
#ifdef UNUSED
LPSCENE lpScene = CScene::GetScene(GetParent(GetFocus()));
if ( lpScene )
{
PDIB lpDib;
lpScene->GetDIBs( NULL, &lpDib, NULL );
if ( lpDib )
{
CDib MyDib( (LPBITMAPINFOHEADER)lpicd->lpFormat, ((LPBITMAPINFO)lpicd->lpFormat)->bmiColors, (LPTR)lpicd->lpData );
lpDib->DibBlt( &MyDib, 100/*dstLeft*/, 100/*dstTop*/, 100/*dstWidth*/, 100/*dstHeight*/,
100/*srcLeft*/, 100/*srcTop*/, 100/*srcWidth*/, 100/*srcHeight*/,
YES/*bTransparent*/, NULL/*lpRGB*/, NULL/*lpLut*/, NULL/*hPal*/ );
}
}
#endif
if (!DrawDibDraw(pi->hdd, pi->hdc, pi->xDst, pi->yDst, pi->dxDst, pi->dyDst,
(LPBITMAPINFOHEADER)lpicd->lpFormat, lpicd->lpData, pi->xSrc, pi->ySrc,
pi->dxSrc, pi->dySrc, wFlags))
{
if (wFlags & DDF_UPDATE)
return ICERR_CANTUPDATE;
else
return ICERR_UNSUPPORTED;
}
// if ( lpMyDrawDCProc )
// (*lpMyDrawDCProc)( pi->hdc );
TestDrawDCProc( pi->hdc );
return ICERR_OK;
}
void LcD3D_IBLock(PDIB & pIB, INT nSize, void* pIdx)
{
void* p;
if( FAILED( pIB->Lock( 0, 0, &p, 0 )))
return;
memcpy(p, pIdx, nSize);
pIB->Unlock();
}
//************************************************************************
CDib::CDib(PDIB pdib, LPTR lp, BOOL fCopyBits)
//************************************************************************
{
m_bmiHeader = *pdib->GetInfoHeader();
hmemcpy( m_rgbQuad, pdib->GetColors(), sizeof(m_rgbQuad));
m_lp = lp;
if (fCopyBits)
hmemcpy(m_lp, pdib->GetPtr(), pdib->GetSizeImage());
m_iRefCount = 0;
AddRef();
}
//************************************************************************
void CDib::CopyColorTable( PDIB pdibSrc )
//************************************************************************
{
m_bmiHeader.biClrUsed = pdibSrc->m_bmiHeader.biClrUsed;
m_bmiHeader.biClrImportant = pdibSrc->m_bmiHeader.biClrImportant;
hmemcpy( m_rgbQuad, pdibSrc->GetColors(), sizeof(m_rgbQuad));
}
//************************************************************************
BOOL CDib::Create( PDIB pdib )
//************************************************************************
{
DWORD dwSizeImage;
dwSizeImage = pdib->GetSizeImage();
if ( !(m_lp = AllocX( dwSizeImage + 1024, GMEM_ZEROINIT )) )
{
return FALSE;
}
m_bmiHeader = *pdib->GetInfoHeader();
hmemcpy( m_rgbQuad, pdib->GetColors(), sizeof(m_rgbQuad));
hmemcpy(m_lp, pdib->GetPtr(), pdib->GetSizeImage());
return TRUE;
}
//************************************************************************
BOOL CGBScene::GetDisplaySize(LPINT lpWidth, LPINT lpHeight)
//************************************************************************
{
PDIB pDib = NULL;
if (GetOffScreen())
pDib = GetOffScreen()->GetWritableDIB();
else
if (GetToon())
pDib = GetToon()->GetWinGDib();
if (pDib)
{
*lpWidth = pDib->GetWidth();
*lpHeight = abs(pDib->GetHeight());
return(TRUE);
}
else
{
*lpWidth = 0;
*lpHeight = 0;
return(FALSE);
}
}
// Note we only support 8bpp DIBs here, and..
// there is no regard for color table matching between the DIBs
//************************************************************************
void CDib::DibBlt(PDIB pdibDst, int dstLeft, int dstTop, int dstWidth, int dstHeight,
int srcLeft, int srcTop, int srcWidth, int srcHeight,
BOOL bTransparent, LPRGBTRIPLE lpRGB, LPTR lpLut, HPALETTE hPal )
//************************************************************************
{
HPTR pSrc, pDst;
int iScanS, iScanD, iOverrun;
if ( !pdibDst )
return;
if ( GetBitCount() != 8 )
return;
if ( pdibDst->GetBitCount() != 8 )
return;
// Check the coordinate bounds, to avoid an out of range pointer
if ( srcLeft < 0 ) { dstLeft -= srcLeft; srcWidth += srcLeft; dstWidth += srcLeft; srcLeft = 0; }
if ( srcTop < 0 ) { dstTop -= srcTop; srcHeight += srcTop; dstHeight += srcTop; srcTop = 0; }
if ( dstLeft < 0 ) { srcLeft -= dstLeft; srcWidth += dstLeft; dstWidth += dstLeft; dstLeft = 0; }
if ( dstTop < 0 ) { srcTop -= dstTop; srcHeight += dstTop; dstHeight += dstTop; dstTop = 0; }
if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0 )
return;
if ( srcLeft - GetWidth() >= 0 ) return;
if ( srcTop - abs(GetHeight()) >= 0 ) return;
if ( dstLeft - pdibDst->GetWidth() >= 0 ) return;
if ( dstTop - abs(pdibDst->GetHeight()) >= 0 ) return;
if ( (iOverrun = srcLeft + srcWidth - GetWidth()) > 0 ) { srcWidth -= iOverrun; dstWidth -= iOverrun; }
if ( (iOverrun = srcTop + srcHeight - abs(GetHeight())) > 0 ) { srcHeight -= iOverrun; dstHeight -= iOverrun; }
if ( (iOverrun = dstLeft + dstWidth - pdibDst->GetWidth()) > 0 ) { dstWidth -= iOverrun; srcWidth -= iOverrun; }
if ( (iOverrun = dstTop + dstHeight - abs(pdibDst->GetHeight())) > 0 ) { dstHeight -= iOverrun; srcHeight -= iOverrun; }
if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0 )
return;
// Get pointers to the start points in the source and destination
if ( !(pSrc = GetXY( srcLeft, srcTop )) )
return;
if ( !(pDst = pdibDst->GetXY( dstLeft, dstTop )) )
return;
// Get the scan line widths of each DIB.
iScanS = GetWidthBytes();
iScanD = pdibDst->GetWidthBytes();
// Upside down DIBs have to move backwards
if ( GetHeight() > 0 )
iScanS = -iScanS;
if ( pdibDst->GetHeight() > 0 )
iScanD = -iScanD;
if ( !bTransparent )
{ // Copy the lines.
while ( --srcHeight >= 0 )
{
hmemcpy( pDst, pSrc, srcWidth );
pSrc += iScanS;
pDst += iScanD;
}
}
else
if (lpRGB)
{ // Copy lines with transparency mask
WORD src, dst, wMini;
BYTE dstPixel, srcColor, red, green, blue;
int iSinc, iDinc, iCount;
LPRGBQUAD pTable = GetColors();
if (lpLut)
{
wMini = RGB3toMiniRGB(lpRGB->rgbtRed, lpRGB->rgbtGreen, lpRGB->rgbtBlue);
srcColor = lpLut[wMini];
}
else
if (hPal)
{
srcColor = (BYTE)GetNearestPaletteIndex( hPal, RGB(lpRGB->rgbtRed, lpRGB->rgbtGreen, lpRGB->rgbtBlue) );
}
else
srcColor = 0;
iSinc = iScanS - srcWidth; // Source increment value
iDinc = iScanD - srcWidth; // Destination increment value
while ( --srcHeight >= 0 )
{
iCount = srcWidth; // Number of pixels to scan.
while ( --iCount >= 0 )
{
src = (WORD)(*pSrc++);
// Copy pixel only if it isn't transparent.
if (src == 0)
pDst++;
else
if (src == 255)
*pDst++ = srcColor;
else
{
if (src > 127)
++src;
dst = 256-src;
dstPixel = *pDst;
red = (BYTE)((((WORD)lpRGB->rgbtRed * src) + ((WORD)pTable[dstPixel].rgbRed * dst)) >> 8);
green = (BYTE)((((WORD)lpRGB->rgbtGreen * src) + ((WORD)pTable[dstPixel].rgbGreen * dst)) >> 8);
blue = (BYTE)((((WORD)lpRGB->rgbtBlue * src) + ((WORD)pTable[dstPixel].rgbBlue * dst)) >> 8);
if (lpLut)
{
wMini = RGB3toMiniRGB(red, green, blue);
*pDst++ = lpLut[wMini];
}
else
if (hPal)
{
*pDst++ = (BYTE)GetNearestPaletteIndex( hPal, RGB(red, green, blue) );
}
else
{
pDst++;
}
}
}
pSrc += iSinc;
pDst += iDinc;
}
}
else
{ // Copy lines with transparency.
BOOL CAliasApp::AntiAliasDib(PDIB pForeDib, PDIB pCompDib)
{
#ifndef CPO
if (pForeDib->GetHeight() != pCompDib->GetHeight() ||
pForeDib->GetWidth() != pCompDib->GetWidth())
{
MessageBox(NULL, "Bitmaps are different sizes", "Error", MB_ICONSTOP|MB_OK);
return(FALSE);
}
if (pForeDib->GetBitCount() != 24 ||
pCompDib->GetBitCount() != 24)
{
MessageBox(NULL, "Bitmaps must both be 24-bits", "Error", MB_ICONSTOP|MB_OK);
return(FALSE);
}
RGBS rgb;
BOOL fColor;
LPTR lpFore = pForeDib->GetPtr();
if (FALSE)
rgb.red = rgb.green = rgb.blue = 148;
else
rgb = *((LPRGB)pForeDib->GetXY(0, 0));
BYTE r = rgb.red;
BYTE g = rgb.green;
BYTE b = rgb.blue;
fColor = ((r == 255 && g == 0 && b == 0) || // red
(r == 0 && g == 255 && b == 0) || // green
(r == 0 && g == 0 && b == 255) || // blue
(r == 0 && g == 255 && b == 255) || // cyan
(r == 255 && g == 0 && b == 255) || // magenta
(r == 255 && g == 255 && b == 0)); // yellow
if (!fColor)
{
m_rgbTrans.red = 255;
m_rgbTrans.green = 0;
m_rgbTrans.blue = 255;
}
else
{
m_rgbTrans = rgb;
}
#endif
LPTR lpComp = pCompDib->GetPtr();
UINT uWidthBytes = pCompDib->GetWidthBytes();
int iHeight = abs(pCompDib->GetHeight());
while (--iHeight >= 0)
{
int iWidth = pCompDib->GetWidth();
LPRGB lpC = (LPRGB)lpComp;
m_Quantize.CountFrequencies((LPRGBTRIPLE)lpComp, iWidth);
#ifndef CPO
LPRGB lpF = (LPRGB)lpFore;
while (--iWidth >= 0)
{
if (lpF->red != r || lpF->green != g || lpF->blue != b)
{
*lpF++ = *lpC++;
}
else
{
if (!fColor)
{
lpF->red = 255;
lpF->green = 0;
lpF->blue = 255;
}
++lpF;
++lpC;
}
}
lpFore += uWidthBytes;
#endif
lpComp += uWidthBytes;
}
return(TRUE);
}
//************************************************************************
void SpeedCheck( LPOFFSCREEN lpOffScreen, PDIB pdib )
//************************************************************************
{
#ifdef UNUSED
RGBQUAD rgb1, rgb2;
if (!lpOffScreen)
return;
HDC hdc;
if ( !(hdc = GetDC(NULL)) )
return;
WORD wNumEntries;
GetObject( GetApp()->m_hPal, sizeof(WORD), (LPSTR)&wNumEntries );
PALETTEENTRY sEntries[256], pEntries[256];
GetPaletteEntries( GetApp()->m_hPal, 0, wNumEntries, pEntries );
GetSystemPaletteEntries( hdc, 0, 256, sEntries );
ReleaseDC( NULL, hdc );
if ( wNumEntries != 256 )
{
Debug( "GetApp()->m_hPal only has %d entries\n", wNumEntries );
}
// Compare the app's palette with the system palette
int i;
for ( i=0; i<256; i++ )
{
if ( pEntries[i].peRed != sEntries[i].peRed ||
pEntries[i].peBlue != sEntries[i].peBlue ||
pEntries[i].peGreen != sEntries[i].peGreen )
// pEntries[i].peFlags != sEntries[i].peFlags )
{
Debug( "GetApp()->m_hPal compare with syspal; entry %d (%d,%d,%d) (%d,%d,%d)\n", i,
pEntries[i].peRed, pEntries[i].peGreen, pEntries[i].peBlue,
sEntries[i].peRed, sEntries[i].peGreen, sEntries[i].peBlue );
// break;
}
}
PDIB pdibr, pdibw;
LPWORD lpIndices;
// Compare the system palette with the WRITABLE offscreen
if ( pdibw = lpOffScreen->GetWritableDIB() )
{
RGBQUAD FAR *lprgbQuad = pdibw->GetColors();
for ( i=0; i<256; i++ )
{
rgb1 = lprgbQuad[i];
if ( rgb1.rgbRed != sEntries[i].peRed ||
rgb1.rgbGreen != sEntries[i].peGreen ||
rgb1.rgbBlue != sEntries[i].peBlue )
{
Debug( "OS writable compare with syspal; entry %d (%d,%d,%d) (%d,%d,%d)\n", i,
rgb1.rgbRed, rgb1.rgbGreen, rgb1.rgbBlue,
sEntries[i].peRed, sEntries[i].peGreen, sEntries[i].peBlue );
// break;
}
}
}
// Compare the READONLY offscreen with the WRITABLE offscreen
if ( (pdibr = lpOffScreen->GetReadOnlyDIB()) &&
(pdibw = lpOffScreen->GetWritableDIB()) )
{
RGBQUAD FAR *lprQuad = pdibr->GetColors();
RGBQUAD FAR *lpwQuad = pdibw->GetColors();
for ( i=0; i<256; i++ )
{
rgb1 = lprQuad[i];
rgb2 = lpwQuad[i];
if ( rgb1.rgbRed != rgb2.rgbRed ||
rgb1.rgbGreen != rgb2.rgbGreen ||
rgb1.rgbBlue != rgb2.rgbBlue )
{
Debug( "OS readonly compare with OS writable; entry %d (%d,%d,%d) (%d,%d,%d)\n", i,
rgb1.rgbRed, rgb1.rgbGreen, rgb1.rgbBlue,
rgb2.rgbRed, rgb2.rgbGreen, rgb2.rgbBlue );
// break;
}
}
}
// Compare the WRITABLE offscreen with a passed DIB
if ( (pdibw = lpOffScreen->GetWritableDIB()) && pdib )
{
RGBQUAD FAR *lpQuad = pdib->GetColors();
RGBQUAD FAR *lpwQuad = pdibw->GetColors();
for ( i=0; i<256; i++ )
{
rgb1 = lpwQuad[i];
rgb2 = lpQuad[i];
if ( rgb1.rgbRed != rgb2.rgbRed ||
rgb1.rgbGreen != rgb2.rgbGreen ||
rgb1.rgbBlue != rgb2.rgbBlue )
{
Debug( "OS writable compare with passed dib; entry %d (%d,%d,%d) (%d,%d,%d)\n", i,
rgb1.rgbRed, rgb1.rgbGreen, rgb1.rgbBlue,
rgb2.rgbRed, rgb2.rgbGreen, rgb2.rgbBlue );
// break;
}
}
}
// See if the WRITABLE offscreen is set to indices
if ( pdibw = lpOffScreen->GetWritableDIB() )
{
lpIndices = (LPWORD)pdibw->GetColors();
for ( i=0; i<256; i++ )
{
if ( lpIndices[i] != (WORD)i )
{
// Debug( "OS writable not indices; entry %d (%d)\n", i, lpIndices[i] );
// break;
}
}
}
// See if the READONLY offscreen is set to indices
if ( pdibr = lpOffScreen->GetReadOnlyDIB() )
{
lpIndices = (LPWORD)pdibr->GetColors();
for ( i=0; i<256; i++ )
{
if ( lpIndices[i] != (WORD)i )
{
// Debug( "OS readonly not indices; entry %d (%d)\n", i, lpIndices[i] );
// break;
}
}
}
#endif
}
