drawdib.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "vfw.h"
#include "wine/debug.h"

Include dependency graph for drawdib.c:

Go to the source code of this file.

Classes
struct	tagWINE_HDD

Macros
#define	CHANGED(x)   (whdd->x != x)

Typedefs
typedef struct tagWINE_HDD	WINE_HDD

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msvideo)
static int	num_colours (const BITMAPINFOHEADER *lpbi)
static WINE_HDD *	MSVIDEO_GetHddPtr (HDRAWDIB hd)
HDRAWDIB VFWAPI	DrawDibOpen (void)
BOOL VFWAPI	DrawDibClose (HDRAWDIB hdd)
BOOL VFWAPI	DrawDibEnd (HDRAWDIB hdd)
BOOL VFWAPI	DrawDibBegin (HDRAWDIB hdd, HDC hdc, INT dxDst, INT dyDst, LPBITMAPINFOHEADER lpbi, INT dxSrc, INT dySrc, UINT wFlags)
BOOL VFWAPI	DrawDibDraw (HDRAWDIB hdd, HDC hdc, INT xDst, INT yDst, INT dxDst, INT dyDst, LPBITMAPINFOHEADER lpbi, LPVOID lpBits, INT xSrc, INT ySrc, INT dxSrc, INT dySrc, UINT wFlags)
BOOL VFWAPI	DrawDibStart (HDRAWDIB hdd, DWORD rate)
BOOL VFWAPI	DrawDibStop (HDRAWDIB hdd)
BOOL VFWAPI	DrawDibChangePalette (HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
BOOL VFWAPI	DrawDibSetPalette (HDRAWDIB hdd, HPALETTE hpal)
LPVOID VFWAPI	DrawDibGetBuffer (HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
HPALETTE VFWAPI	DrawDibGetPalette (HDRAWDIB hdd)
UINT VFWAPI	DrawDibRealize (HDRAWDIB hdd, HDC hdc, BOOL fBackground)
BOOL VFWAPI	DrawDibTime (HDRAWDIB hdd, LPDRAWDIBTIME lpddtime)
DWORD VFWAPI	DrawDibProfileDisplay (LPBITMAPINFOHEADER lpbi)

Variables
static WINE_HDD *	HDD_FirstHdd
static UINT_PTR	HDD_HandleRef = 1

Macro Definition Documentation

CHANGED

#define CHANGED

(

x

)

(whdd->x != x)

Typedef Documentation

WINE_HDD

typedef struct tagWINE_HDD WINE_HDD

Function Documentation

DrawDibBegin()

BOOL VFWAPI DrawDibBegin	(	HDRAWDIB	hdd,
		HDC	hdc,
		INT	dxDst,
		INT	dyDst,
		LPBITMAPINFOHEADER	lpbi,
		INT	dxSrc,
		INT	dySrc,
		UINT	wFlags
	)

Definition at line 175 of file drawdib.c.

{
    BOOL ret = TRUE;
    WINE_HDD *whdd;
 
    TRACE("(%p,%p,%d,%d,%p,%d,%d,0x%08x)\n",
          hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, wFlags);
 
    TRACE("lpbi: %d,%d/%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
          lpbi->biSize, lpbi->biWidth, lpbi->biHeight, lpbi->biPlanes,
          lpbi->biBitCount, lpbi->biCompression, lpbi->biSizeImage,
          lpbi->biXPelsPerMeter, lpbi->biYPelsPerMeter, lpbi->biClrUsed,
          lpbi->biClrImportant);
 
    if (wFlags & ~(DDF_BUFFER))
        FIXME("wFlags == 0x%08x not handled\n", wFlags & ~(DDF_BUFFER));
 
    whdd = MSVIDEO_GetHddPtr(hdd);
    if (!whdd) return FALSE;
 
    if (whdd->begun) DrawDibEnd(hdd);
 
    if (lpbi->biCompression) 
    {
        DWORD size = 0;
 
        whdd->hic = ICOpen(ICTYPE_VIDEO, lpbi->biCompression, ICMODE_DECOMPRESS);
        if (!whdd->hic) 
        {
            WARN("Could not open IC. biCompression == 0x%08x\n", lpbi->biCompression);
            ret = FALSE;
        }
 
        if (ret) 
        {
            size = ICDecompressGetFormat(whdd->hic, lpbi, NULL);
            if (size == ICERR_UNSUPPORTED) 
            {
                WARN("Codec doesn't support GetFormat, giving up.\n");
                ret = FALSE;
            }
        }
 
        if (ret) 
        {
            whdd->lpbiOut = HeapAlloc(GetProcessHeap(), 0, size);
 
            if (ICDecompressGetFormat(whdd->hic, lpbi, whdd->lpbiOut) != ICERR_OK)
                ret = FALSE;
        }
 
        if (ret) 
        {
            /* FIXME: Use Ex functions if available? */
            if (ICDecompressBegin(whdd->hic, lpbi, whdd->lpbiOut) != ICERR_OK)
                ret = FALSE;
            
            TRACE("biSizeImage == %d\n", whdd->lpbiOut->biSizeImage);
            TRACE("biCompression == %d\n", whdd->lpbiOut->biCompression);
            TRACE("biBitCount == %d\n", whdd->lpbiOut->biBitCount);
        }
    }
    else 
    {
        DWORD dwSize;
        /* No compression */
        TRACE("Not compressed!\n");
        if (lpbi->biHeight <= 0)
        {
            /* we don't draw inverted DIBs */
            TRACE("detected inverted DIB\n");
            ret = FALSE;
        }
        else
        {
            dwSize = lpbi->biSize + num_colours(lpbi)*sizeof(RGBQUAD);
            whdd->lpbiOut = HeapAlloc(GetProcessHeap(), 0, dwSize);
            memcpy(whdd->lpbiOut, lpbi, dwSize);
        }
    }
 
    if (ret) 
    {
        /*whdd->lpvbuf = HeapAlloc(GetProcessHeap(), 0, whdd->lpbiOut->biSizeImage);*/
 
        whdd->hMemDC = CreateCompatibleDC(hdc);
        TRACE("Creating: %d, %p\n", whdd->lpbiOut->biSize, whdd->lpvbits);
        whdd->hDib = CreateDIBSection(whdd->hMemDC, (BITMAPINFO *)whdd->lpbiOut, DIB_RGB_COLORS, &(whdd->lpvbits), 0, 0);
        if (whdd->hDib) 
        {
            TRACE("Created: %p,%p\n", whdd->hDib, whdd->lpvbits);
        }
        else
        {
            ret = FALSE;
            TRACE("Error: %d\n", GetLastError());
        }
        whdd->hOldDib = SelectObject(whdd->hMemDC, whdd->hDib);
    }
 
    if (ret) 
    {
        whdd->hdc = hdc;
        whdd->dxDst = dxDst;
        whdd->dyDst = dyDst;
        whdd->lpbi = HeapAlloc(GetProcessHeap(), 0, lpbi->biSize);
        memcpy(whdd->lpbi, lpbi, lpbi->biSize);
        whdd->dxSrc = dxSrc;
        whdd->dySrc = dySrc;
        whdd->begun = TRUE;
        whdd->hpal = 0;
    } 
    else 
    {
        if (whdd->hic)
            ICClose(whdd->hic);
        HeapFree(GetProcessHeap(), 0, whdd->lpbiOut);
        whdd->lpbiOut = NULL;
    }
 
    return ret;
}

Referenced by DrawDibDraw().

DrawDibChangePalette()

BOOL VFWAPI DrawDibChangePalette	(	HDRAWDIB	hdd,
		int	iStart,
		int	iLen,
		LPPALETTEENTRY	lppe
	)

Definition at line 432 of file drawdib.c.

{
    FIXME("(%p, 0x%08x, 0x%08x, %p), stub\n", hdd, iStart, iLen, lppe);
    return TRUE;
}

DrawDibClose()

BOOL VFWAPI DrawDibClose

(

HDRAWDIB

hdd

)

Definition at line 101 of file drawdib.c.

{
    WINE_HDD* whdd = MSVIDEO_GetHddPtr(hdd);
    WINE_HDD** p;
 
    TRACE("(%p)\n", hdd);
 
    if (!whdd) return FALSE;
 
    if (whdd->begun) DrawDibEnd(hdd);
 
    for (p = &HDD_FirstHdd; *p != NULL; p = &((*p)->next))
    {
        if (*p == whdd)
        {
            *p = whdd->next;
            break;
        }
    }
 
    HeapFree(GetProcessHeap(), 0, whdd);
 
    return TRUE;
}

Referenced by test_DrawDib_sizeimage().

DrawDibDraw()

BOOL VFWAPI DrawDibDraw	(	HDRAWDIB	hdd,
		HDC	hdc,
		INT	xDst,
		INT	yDst,
		INT	dxDst,
		INT	dyDst,
		LPBITMAPINFOHEADER	lpbi,
		LPVOID	lpBits,
		INT	xSrc,
		INT	ySrc,
		INT	dxSrc,
		INT	dySrc,
		UINT	wFlags
	)

Definition at line 308 of file drawdib.c.

{
    WINE_HDD *whdd;
    BOOL ret;
    int reopen = 0;
 
    TRACE("(%p,%p,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08x)\n",
          hdd, hdc, xDst, yDst, dxDst, dyDst, lpbi, lpBits, xSrc, ySrc, dxSrc, dySrc, wFlags);
 
    whdd = MSVIDEO_GetHddPtr(hdd);
    if (!whdd) return FALSE;
 
    TRACE("whdd=%p\n", whdd);
 
    if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME | DDF_UPDATE | DDF_DONTDRAW | DDF_BACKGROUNDPAL))
        FIXME("wFlags == 0x%08x not handled\n", wFlags);
 
    if (!lpBits) 
    {
        /* Undocumented? */
        lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(num_colours(lpbi)*sizeof(RGBQUAD));
    }
 
 
#define CHANGED(x) (whdd->x != x)
 
    /* Check if anything changed from the parameters passed and our struct.
     * If anything changed we need to run DrawDibBegin again to ensure we
     * can support the changes.
     */
    if (!whdd->begun)
        reopen = 1;
    else if (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc))
        reopen = 2;
    else if (!(wFlags & DDF_SAME_DRAW))
    {
        if (CHANGED(lpbi) && memcmp(lpbi, whdd->lpbi, sizeof(*lpbi))) reopen = 3;
        else if (CHANGED(dxSrc)) reopen = 4;
        else if (CHANGED(dySrc)) reopen = 5;
        else if (CHANGED(dxDst)) reopen = 6;
        else if (CHANGED(dyDst)) reopen = 7;
    }
    if (reopen)
    {
        TRACE("Something changed (reason %d)!\n", reopen);
        ret = DrawDibBegin(hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, 0);
        if (!ret)
            return ret;
    }
 
#undef CHANGED
 
    /* If source dimensions are not specified derive them from bitmap header */
    if (dxSrc == -1 && dySrc == -1)
    {
        dxSrc = lpbi->biWidth;
        dySrc = lpbi->biHeight;
    }
    /* If destination dimensions are not specified derive them from source */
    if (dxDst == -1 && dyDst == -1)
    {
        dxDst = dxSrc;
        dyDst = dySrc;
    }
 
    if (!(wFlags & DDF_UPDATE)) 
    {
        if (lpbi->biCompression) 
        {
            DWORD flags = 0;
 
            TRACE("Compression == 0x%08x\n", lpbi->biCompression);
 
            if (wFlags & DDF_NOTKEYFRAME)
                flags |= ICDECOMPRESS_NOTKEYFRAME;
 
            ICDecompress(whdd->hic, flags, lpbi, lpBits, whdd->lpbiOut, whdd->lpvbits);
        }
        else
        {
            /* BI_RGB: lpbi->biSizeImage isn't reliable */
            DWORD biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
            memcpy(whdd->lpvbits, lpBits, biSizeImage);
        }
    }
    if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
    {
        if ((wFlags & DDF_BACKGROUNDPAL) && ! (wFlags & DDF_SAME_HDC))
         SelectPalette(hdc, whdd->hpal, TRUE);
        else
         SelectPalette(hdc, whdd->hpal, FALSE);
    }
 
    ret = StretchBlt(whdd->hdc, xDst, yDst, dxDst, dyDst, whdd->hMemDC, xSrc, ySrc, dxSrc, dySrc, SRCCOPY);
    TRACE("Painting %dx%d at %d,%d from %dx%d at %d,%d -> %d\n",
          dxDst, dyDst, xDst, yDst, dxSrc, dySrc, xSrc, ySrc, ret);
 
    return ret;
}

Referenced by test_DrawDib_sizeimage().

DrawDibEnd()

BOOL VFWAPI DrawDibEnd

(

HDRAWDIB

hdd

)

Definition at line 129 of file drawdib.c.

{
    BOOL ret = TRUE;
    WINE_HDD *whdd = MSVIDEO_GetHddPtr(hdd);
 
    TRACE("(%p)\n", hdd);
 
    if (!whdd) return FALSE;
 
    whdd->hpal = 0; /* Do not free this */
    whdd->hdc = 0;
    HeapFree(GetProcessHeap(), 0, whdd->lpbi);
    whdd->lpbi = NULL;
    HeapFree(GetProcessHeap(), 0, whdd->lpbiOut);
    whdd->lpbiOut = NULL;
 
    whdd->begun = FALSE;
 
    /*if (whdd->lpvbits)
      HeapFree(GetProcessHeap(), 0, whdd->lpvbuf);*/
 
    if (whdd->hMemDC) 
    {
        SelectObject(whdd->hMemDC, whdd->hOldDib);
        DeleteDC(whdd->hMemDC);
        whdd->hMemDC = 0;
    }
 
    if (whdd->hDib) DeleteObject(whdd->hDib);
    whdd->hDib = 0;
 
    if (whdd->hic) 
    {
        ICDecompressEnd(whdd->hic);
        ICClose(whdd->hic);
        whdd->hic = 0;
    }
 
    whdd->lpvbits = NULL;
 
    return ret;
}

Referenced by DrawDibBegin(), and DrawDibClose().

DrawDibGetBuffer()

LPVOID VFWAPI DrawDibGetBuffer	(	HDRAWDIB	hdd,
		LPBITMAPINFOHEADER	lpbi,
		DWORD	dwSize,
		DWORD	dwFlags
	)

Definition at line 464 of file drawdib.c.

{
    FIXME("(%p, %p, 0x%08x, 0x%08x), stub\n", hdd, lpbi, dwSize, dwFlags);
    return NULL;
}

DrawDibGetPalette()

HPALETTE VFWAPI DrawDibGetPalette

(

HDRAWDIB

hdd

)

Definition at line 473 of file drawdib.c.

{
    WINE_HDD *whdd;
 
    TRACE("(%p)\n", hdd);
 
    whdd = MSVIDEO_GetHddPtr(hdd);
    if (!whdd) return FALSE;
 
    return whdd->hpal;
}

DrawDibOpen()

HDRAWDIB VFWAPI DrawDibOpen

(

void

)

Definition at line 80 of file drawdib.c.

{
    WINE_HDD*   whdd;
 
    TRACE("(void)\n");
    
    whdd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_HDD));
    TRACE("=> %p\n", whdd);
 
    while (MSVIDEO_GetHddPtr((HDRAWDIB)HDD_HandleRef) != NULL) HDD_HandleRef++;
    whdd->hSelf = (HDRAWDIB)HDD_HandleRef++;
 
    whdd->next = HDD_FirstHdd;
    HDD_FirstHdd = whdd;
 
    return whdd->hSelf;
}

Referenced by test_DrawDib_sizeimage().

DrawDibProfileDisplay()

DWORD VFWAPI DrawDibProfileDisplay

(

LPBITMAPINFOHEADER

lpbi

)

Definition at line 527 of file drawdib.c.

{
    FIXME("(%p) stub\n", lpbi);
 
    return PD_CAN_DRAW_DIB;
}

DrawDibRealize()

UINT VFWAPI DrawDibRealize	(	HDRAWDIB	hdd,
		HDC	hdc,
		BOOL	fBackground
	)

Definition at line 488 of file drawdib.c.

{
    WINE_HDD *whdd;
    UINT ret = 0;
 
    FIXME("(%p, %p, %d), stub\n", hdd, hdc, fBackground);
 
    whdd = MSVIDEO_GetHddPtr(hdd);
    if (!whdd) return FALSE;
 
    if (!whdd->begun)
    {
        ret = 0;
        goto out;
    }
 
    if (!whdd->hpal)
        whdd->hpal = CreateHalftonePalette(hdc);
 
    SelectPalette(hdc, whdd->hpal, fBackground);
    ret = RealizePalette(hdc);
 
 out:
    TRACE("=> %u\n", ret);
    return ret;
}

DrawDibSetPalette()

BOOL VFWAPI DrawDibSetPalette	(	HDRAWDIB	hdd,
		HPALETTE	hpal
	)

Definition at line 441 of file drawdib.c.

{
    WINE_HDD *whdd;
 
    TRACE("(%p, %p)\n", hdd, hpal);
 
    whdd = MSVIDEO_GetHddPtr(hdd);
    if (!whdd) return FALSE;
 
    whdd->hpal = hpal;
 
    if (whdd->begun) 
    {
        SelectPalette(whdd->hdc, hpal, 0);
        RealizePalette(whdd->hdc);
    }
 
    return TRUE;
}

DrawDibStart()

BOOL VFWAPI DrawDibStart	(	HDRAWDIB	hdd,
		DWORD	rate
	)

Definition at line 416 of file drawdib.c.

                                                   {
    FIXME("(%p, %d), stub\n", hdd, rate);
    return TRUE;
}

DrawDibStop()

BOOL VFWAPI DrawDibStop

(

HDRAWDIB

hdd

)

Definition at line 424 of file drawdib.c.

                                      {
    FIXME("(%p), stub\n", hdd);
    return TRUE;
}

DrawDibTime()

BOOL VFWAPI DrawDibTime	(	HDRAWDIB	hdd,
		LPDRAWDIBTIME	lpddtime
	)

Definition at line 518 of file drawdib.c.

{
    FIXME("(%p, %p) stub\n", hdd, lpddtime);
    return FALSE;
}

MSVIDEO_GetHddPtr()

static WINE_HDD * MSVIDEO_GetHddPtr ( HDRAWDIB  hd )

static

Definition at line 67 of file drawdib.c.

{
    WINE_HDD*   hdd;
 
    for (hdd = HDD_FirstHdd; hdd != NULL && hdd->hSelf != hd; hdd = hdd->next);
    return hdd;
}

Referenced by DrawDibBegin(), DrawDibClose(), DrawDibDraw(), DrawDibEnd(), DrawDibGetPalette(), DrawDibOpen(), DrawDibRealize(), and DrawDibSetPalette().

num_colours()

static int num_colours ( const BITMAPINFOHEADER *  lpbi )

static

Definition at line 56 of file drawdib.c.

{
    if(lpbi->biClrUsed)
        return lpbi->biClrUsed;
    if(lpbi->biBitCount<=8)
        return 1<<lpbi->biBitCount;
    return 0;
}

Referenced by DrawDibBegin(), and DrawDibDraw().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msvideo

)

Variable Documentation

HDD_FirstHdd

WINE_HDD* HDD_FirstHdd

static

Definition at line 65 of file drawdib.c.

Referenced by DrawDibClose(), DrawDibOpen(), and MSVIDEO_GetHddPtr().

HDD_HandleRef

UINT_PTR HDD_HandleRef = 1

static

Definition at line 75 of file drawdib.c.

Referenced by DrawDibOpen().