Problems in bitblt (in x11drv)

[David Albrecht]

Sorry about the resend, but I used an old copy of the source
inadvertently.

I'm new to wine and relatively new to windows programming being mostly
a unix hack.  Just for yucks I thought I'd get a relatively simple app
emu48 to work.  Turns out emu48 is not so simple (multi-threaded,
etc.).  First task towards functionality is to get the boot up display
to look right and a BitBlt didn't seem to be functioning correctly.

Much investigation later it turns out that in the file dib.c:

/* if the source bitmap is 8bpp or less, we're supposed to use the
     * DC's palette for color conversion (not the DIB color table) */

is NOT true at least not for my case where the DC containing the
bitmap has one palette and the colormap for the bitmap is not the
same.  If I disable the hPalette tests as I did below and always use
the DIB colormap it boots up with the correct display
otherwise the color mapping  doesn't match the DIB bits and I get
garbage.

if (dib.dsBm.bmBitsPixel <= 8) {
      HPALETTE hPalette = GetCurrentObject( physDevSrc->hdc, OBJ_PAL
);
      if (/*!hPalette || (hPalette ==
GetStockObject(DEFAULT_PALETTE))*/1) {
    /* HACK: no palette has been set in the source DC,
     * use the DIB colormap instead - this is necessary in some
     * cases since we need to do depth conversion in some places
     * where real Windows can just copy data straight over */
    colorMap = physBitmap->colorMap;
    nColorMap = physBitmap->nColorMap;

} else {
    colorMap = X11DRV_DIB_BuildColorMap( physDevSrc, (WORD)-1,
                         dib.dsBm.bmBitsPixel,
                         (BITMAPINFO*)&dib.dsBmih,
                         &nColorMap );
    if (colorMap) aColorMap = TRUE;
      }
    }

Not knowing the full ramifications of this code I thought I'd pass
this along so that someone more familiar with it can reassess
it.

The DC and bitmap are created thusly (nLcdDoubled == 2):

#define B 0x00000000
#define W 0x00FFFFFF
#define I 0xFFFFFFFF
static struct
{
    BITMAPINFOHEADER Lcd_bmih;
    DWORD dwColor[64];
} bmiLcd =
{
    {0x28,0/*x*/,0/*y*/,1,8,BI_RGB,0,0,0,64,0},
    {
    	W,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,
    	B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,
    	I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,
    	I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I
    }
};
VOID CreateLcdBitmap(VOID)
{
    // create LCD bitmap
    _ASSERT(nLcdDoubled == 1 || nLcdDoubled == 2 || nLcdDoubled == 4);
    bmiLcd.Lcd_bmih.biWidth = LCD1_ROW * nLcdDoubled;
    bmiLcd.Lcd_bmih.biHeight = -64 * nLcdDoubled;
    hLcdDC = CreateCompatibleDC(hWindowDC);
    _ASSERT(hLcdDC != NULL);
    hLcdBitmap = CreateDIBSection(hLcdDC, 
(BITMAPINFO*)&bmiLcd,DIB_RGB_COLORS, (LPVOID*)&pbyLcd, NULL, 0);
    _ASSERT(hLcdBitmap != NULL);
    hOldLcdBitmap = SelectObject(hLcdDC, hLcdBitmap);
    _ASSERT(hPalette != NULL);
    SelectPalette(hLcdDC, hPalette, FALSE);	// set palette for LCD DC
    RealizePalette(hLcdDC);					// realize palette
    UpdateContrast(Chipset.contrast);
}
In the new source update contrast doesn't do a SetDIBColorTable
it just plays with the pattern used to write to the dib.
static DWORD Pattern[16];

VOID UpdateContrast(BYTE byContrast)
{
    DWORD c = byContrast;
    DWORD b = byContrast + 0x20;
    if (bmiLcd.dwColor[b] == 0xFFFFFFFF) b = 0;

_ASSERT(nLcdDoubled == 1 || nLcdDoubled == 2 || nLcdDoubled == 4);

if (nLcdDoubled == 1)
    {
    	WORD i,j;
    	for (i=0; i<16; ++i)
    	{
    		Pattern[i] = 0;
    		for (j=8; j>0; j>>=1)
    		{
    			Pattern[i] = (Pattern[i] << 8) | ((i&j) ? c : b);
    		}
    	}
    	return;
    }

c = (c<<8) | c;
    b = (b<<8) | b;

if (nLcdDoubled == 2)
    {
    	Pattern[0] = (b<<16)|b;
    	Pattern[1] = (b<<16)|c;
    	Pattern[2] = (c<<16)|b;
    	Pattern[3] = (c<<16)|c;
    	return;
    }

c = (c<<16) | c;
    b = (b<<16) | b;

if (nLcdDoubled == 4)
    {
    	Pattern[0] = b;
    	Pattern[1] = c;
    }
    return;
}
The BitBlt:
static BYTE Buf[36];

VOID UpdateMainDisplay(VOID)
{
    UINT  x, y, nLines;
    DWORD d = Chipset.start1;
    BYTE *p = pbyLcd;

#if defined DEBUG_DISPLAY
    {
    	TCHAR buffer[256];
    	wsprintf(buffer,_T("%.5lx: Update Main Display\n"),Chipset.pc);
    	OutputDebugString(buffer);
    }
    #endif

_ASSERT(nLcdDoubled == 1 || nLcdDoubled == 2 || nLcdDoubled == 4);
    if (!Chipset.dispon)
    {
    	nLines = 64;
    	ZeroMemory(pbyLcd, LCD1_ROW * nLcdDoubled * nLines * nLcdDoubled);
    }
    else
    {
    	nLines = LINES(Chipset.lcounter);	// main display lines
    	if (nLcdDoubled == 4)
    	{
    		for (y = 0; y < nLines; ++y)
    		{
    			Npeek(Buf,d,36);
    			for (x=0; x<36; x++)
    			{
    				*(((DWORD*)p)++)=Pattern[Buf[x]&1];
    				*(((DWORD*)p)++)=Pattern[(Buf[x]>>1) & 1];
    				*(((DWORD*)p)++)=Pattern[(Buf[x]>>2) & 1];
    				*(((DWORD*)p)++)=Pattern[(Buf[x]>>3) & 1];
    			}
    			CopyMemory(p, p-LCD3_ROW, LCD3_ROW);
    			p+=LCD3_ROW;
    			CopyMemory(p, p-LCD3_ROW*2, LCD3_ROW*2);
    			p+=LCD3_ROW*2;
    			d+=Chipset.width;
    		}
    	}
    	if (nLcdDoubled == 2)
    	{
    		for (y = 0; y < nLines; ++y)
    		{
    			Npeek(Buf,d,36);
    			for (x=0; x<36; x++)
    			{
    				*(((DWORD*)p)++)=Pattern[Buf[x]&3];
    				*(((DWORD*)p)++)=Pattern[Buf[x]>>2];
    			}
    			CopyMemory(p, p-LCD2_ROW, LCD2_ROW);
    			p+=LCD2_ROW;
    			d+=Chipset.width;
    		}
    	}
    	if (nLcdDoubled == 1)
    	{
    		for (y = 0; y < nLines; ++y)
    		{
    			Npeek(Buf,d,36);
    			for (x=0; x<36; x++) *(((DWORD*)p)++)=Pattern[Buf[x]];
    			d+=Chipset.width;
    		}
    	}
    }
    EnterCriticalSection(&csGDILock);		// solving NT GDI problems
    {
    	BitBlt(hWindowDC, nLcdX, nLcdY, 131*nLcdDoubled, nLines*nLcdDoubled,
    		   hLcdDC, Chipset.boffset*nLcdDoubled, 0, SRCCOPY);
    	GdiFlush();
    }
    LeaveCriticalSection(&csGDILock);
    return;
}

As emu48 still doesn't work I'll probably have more things I find in
likely much different areas later.

Dave