/*! \param dib Valid CLDIB
* \return Initialized HBITMAP; NULL on failure.
*/
HBITMAP dib_to_hbm(CLDIB *dib)
{
if(dib == NULL)
return NULL;
HDC hdc = GetDC(NULL);
BYTE *hbmD;
HBITMAP hbm= CreateDIBSection(hdc, dib_get_info(dib),
DIB_RGB_COLORS, (void**)&hbmD, NULL, 0);
// while the following _should_ work, it sometimes doesn't
// for some inexplicable reason.
//SetDIBits(hdc, hbm, 0, dib_get_height(dib),
// dib_get_img(dib), dib_get_info(dib), DIB_RGB_COLORS);
ReleaseDC(NULL, hdc);
if(hbm == NULL)
return NULL;
// so we're doing it manually
memcpy(hbmD, dib_get_img(dib), dib_get_size_img(dib));
// PONDER: palette?
return hbm;
}
/*! Prepares the work dib for export, i.e. converts to the final
bitdepth, compresses the data and fills in \a gr._gfxRec.
*/
bool grit_prep_gfx(GritRec *gr)
{
lprintf(LOG_STATUS, "Graphics preparation.\n");
int srcB= dib_get_bpp(gr->_dib); // should be 8 or 16 by now
int srcP= dib_get_pitch(gr->_dib);
int srcS= dib_get_size_img(gr->_dib);
BYTE *srcD= dib_get_img(gr->_dib);
int dstB= gr->gfxBpp;
// # dst bytes, with # src pixels as 'width'
int dstS= dib_align(srcS*8/srcB, dstB);
dstS= ALIGN4(dstS);
BYTE *dstD= (BYTE*)malloc(dstS);
if(dstD == NULL)
{
lprintf(LOG_ERROR, " Can't allocate graphics data.\n");
return false;
}
// Convert to final bitdepth
// NOTE: do not use dib_convert here, because of potential
// problems with padding
// NOTE: we're already at 8 or 16 bpp here, with 16 bpp already
// accounted for. Only have to do 8->1,2,4
// TODO: offset
if(srcB == 8 && srcB != dstB)
{
lprintf(LOG_STATUS, " Bitpacking: %d -> %d.\n", srcB, dstB);
data_bit_pack(dstD, srcD, srcS, srcB, dstB, 0);
}
else
memcpy(dstD, srcD, dstS);
RECORD rec= { 1, dstS, dstD };
if( BYTE_ORDER == BIG_ENDIAN && gr->gfxBpp > 8 )
data_byte_rev(rec.data, rec.data, rec_size(&rec), gr->gfxBpp/8);
// attach and compress graphics
grit_compress(&rec, &rec, gr->gfxCompression);
rec_alias(&gr->_gfxRec, &rec);
lprintf(LOG_STATUS, "Graphics preparation complete.\n");
return true;
}
/*! This basically does two things. First, create a bitmap from the
designated area of the source bitmap. Then, converts it 8 or
16 bpp, depending on \a gr.gfxBpp. Conversion to lower bpp is
done later, when it's more convenient. The resultant bitmap is
put into \a gr._dib, and will be used in later preparation.
*/
bool grit_prep_work_dib(GritRec *gr)
{
int ii, nn;
RGBQUAD *rgb;
lprintf(LOG_STATUS, "Work-DIB creation.\n");
// --- resize ---
CLDIB *dib= dib_copy(gr->srcDib,
gr->areaLeft, gr->areaTop, gr->areaRight, gr->areaBottom,
false);
if(dib == NULL)
{
lprintf(LOG_ERROR, " Work-DIB creation failed.\n");
return false;
}
// ... that's it? Yeah, looks like.
// --- resample (to 8 or 16) ---
//
int dibB= dib_get_bpp(dib);
// Convert to 16bpp, but ONLY for bitmaps
if( gr->gfxBpp == 16 && gr->gfxMode != GRIT_GFX_TILE )
{
if(dibB != 16)
{
lprintf(LOG_WARNING, " converting from %d bpp to %d bpp.\n",
dibB, gr->gfxBpp);
CLDIB *dib2= dib_convert_copy(dib, 16, 0);
// If paletted src AND -pT AND NOT -gT[!]
// use trans color pal[T]
//# PONDER: did I fix this right?
if(dibB <= 8 && gr->palHasAlpha && !gr->gfxHasAlpha)
{
rgb= &dib_get_pal(dib)[gr->palAlphaId];
lprintf(LOG_WARNING,
" pal->true-color conversion with transp pal-id option.\n"
" using color %02X%02X%02X",
rgb->rgbRed, rgb->rgbGreen, rgb->rgbBlue);
gr->gfxHasAlpha= true;
gr->gfxAlphaColor= *rgb;
}
dib_free(dib);
if(dib2 == NULL)
{
lprintf(LOG_ERROR, "prep: Bpp conversion failed.\n");
return false;
}
dib= dib2;
}
// --- Dealing with 16bpp images ---
// Modes:
// 555 | GBA | swap R_B
// 555+A=1 | NDS | swap R_B + add NDS_ALPHA
// 555+A | NDS, transp | swap R_B + NDS_ALPHA if !trans-clr
// src-pal + -pT -> NDS, transp
// Swap palette bRGB to bBGR
// And resolve -gT
nn= dib_get_size_img(dib)/2;
WORD *dibD2= (WORD*)dib_get_img(dib);
// Single transparent color
if(gr->gfxHasAlpha)
{
rgb= &gr->gfxAlphaColor;
WORD clr= RGB16(rgb->rgbBlue, rgb->rgbGreen, rgb->rgbRed), wd;
lprintf(LOG_STATUS,
" converting to: 16bpp BGR, alpha=1, except for 0x%04X.\n",
clr);
for(ii=0; ii<nn; ii++)
{
wd= swap_rgb16(dibD2[ii]);
dibD2[ii]= (wd == clr ? wd : wd | NDS_ALPHA);
}
}
else if(gr->gfxMode == GRIT_GFX_BMP_A)
{
lprintf(LOG_STATUS, "converting to: 16bpp BGR, alpha=1.\n");
for(ii=0; ii<nn; ii++)
dibD2[ii]= swap_rgb16(dibD2[ii]) | NDS_ALPHA;
}
else
{
lprintf(LOG_STATUS, "converting to: 16bpp, BGR.\n");
for(ii=0; ii<nn; ii++)
dibD2[ii]= swap_rgb16(dibD2[ii]);
}
}
else if(dibB != 8) // otherwise, convert to 8bpp
{
lprintf(LOG_WARNING, " converting from %d bpp to %d bpp.\n",
dibB, gr->gfxBpp);
if(!dib_convert(dib, 8, 0))
{
dib_free(dib);
lprintf(LOG_ERROR, " Bpp conversion failed.\n");
return false;
}
}
// Palette transparency additions.
if(dib_get_bpp(dib)==8)
{
// If gfx-trans && !pal-trans:
// Find gfx-trans in palette and use that
if(gr->gfxHasAlpha && !gr->palHasAlpha)
{
rgb= &gr->gfxAlphaColor;
RGBQUAD *pal= dib_get_pal(dib);
lprintf(LOG_WARNING,
" tru/pal -> pal conversion with transp color option.\n"
" looking for color %02X%02X%02X in palette.\n",
rgb->rgbRed, rgb->rgbGreen, rgb->rgbBlue);
uint ii_min= 0, dist, dist_min;
dist_min= rgb_dist(rgb, &pal[0]);
for(ii=1; ii<256; ii++)
{
dist= rgb_dist(rgb, &pal[ii]);
if(dist < dist_min)
{
ii_min= ii;
dist_min= dist;
}
}
// HACK: count 'match' only if average error is < +/-14
if(dist_min < 576)
{
gr->palHasAlpha= true;
gr->palAlphaId= ii_min;
}
}
// Swap alpha and pixels palette entry
if(gr->palHasAlpha)
{
lprintf(LOG_STATUS, " Palette transparency: pal[%d].\n",
gr->palAlphaId);
BYTE *imgD= dib_get_img(dib);
nn= dib_get_size_img(dib);
for(ii=0; ii<nn; ii++)
{
if(imgD[ii] == 0)
imgD[ii]= gr->palAlphaId;
else if(imgD[ii] == gr->palAlphaId)
imgD[ii]= 0;
}
RGBQUAD tmp, *pal= dib_get_pal(dib);
SWAP3(pal[0], pal[gr->palAlphaId], tmp);
}
// TODO: Palette merging.
if(gr->palIsShared)
{
lprintf(LOG_STATUS, " Palette merging\n");
nn= dib_pal_reduce(dib, &gr->shared->palRec);
if(nn>PAL_MAX)
lprintf(LOG_WARNING, " New palette exceeds 256. Truncating.\n");
}
}
dib_free(gr->_dib);
gr->_dib= dib;
lprintf(LOG_STATUS, "Work-DIB creation complete: %dx%d@%d.\n",
dib_get_width(gr->_dib), dib_get_height(gr->_dib),
dib_get_bpp(gr->_dib));
return true;
}
