drawdib.c File Reference

#include <windows.h>
#include <vfw.h>
#include <wincrypt.h>
#include <stdlib.h>
#include <string.h>
#include "wine/test.h"

Include dependency graph for drawdib.c:

Go to the source code of this file.

Macros
#define	WIN32_LEAN_AND_MEAN
#define	WIDTH   16
#define	HEIGHT   12

Functions
static DWORD	get_stride (const BITMAPINFO *bmi)
static DWORD	get_dib_size (const BITMAPINFO *bmi)
static char *	hash_dib (const BITMAPINFO *bmi, const void *bits)
static void	init_bmi (BITMAPINFO *bmi, LONG width, LONG height, DWORD size)
static void	test_DrawDib_sizeimage (void)
	START_TEST (drawdib)

Variables
static HCRYPTPROV	crypt_prov

Macro Definition Documentation

HEIGHT

#define HEIGHT   12

Definition at line 30 of file drawdib.c.

WIDTH

#define WIDTH   16

Definition at line 29 of file drawdib.c.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 19 of file drawdib.c.

Function Documentation

get_dib_size()

static DWORD get_dib_size ( const BITMAPINFO *  bmi )

inlinestatic

Definition at line 39 of file drawdib.c.

{
    return get_stride(bmi) * abs(bmi->bmiHeader.biHeight);
}

Referenced by hash_dib(), and test_DrawDib_sizeimage().

get_stride()

static DWORD get_stride ( const BITMAPINFO *  bmi )

inlinestatic

Definition at line 34 of file drawdib.c.

{
    return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3;
}

Referenced by get_dib_size().

hash_dib()

static char * hash_dib ( const BITMAPINFO *  bmi, const void *  bits  )

static

Definition at line 44 of file drawdib.c.

{
    DWORD dib_size = get_dib_size(bmi);
    HCRYPTHASH hash;
    char *buf;
    BYTE hash_buf[20];
    DWORD hash_size = sizeof(hash_buf);
    int i;
    static const char *hex = "0123456789abcdef";
 
    if(!crypt_prov) return NULL;
 
    if(!CryptCreateHash(crypt_prov, CALG_SHA1, 0, 0, &hash)) return NULL;
 
    CryptHashData(hash, bits, dib_size, 0);
 
    CryptGetHashParam(hash, HP_HASHVAL, NULL, &hash_size, 0);
    if(hash_size != sizeof(hash_buf)) return NULL;
 
    CryptGetHashParam(hash, HP_HASHVAL, hash_buf, &hash_size, 0);
    CryptDestroyHash(hash);
 
    buf = HeapAlloc(GetProcessHeap(), 0, hash_size * 2 + 1);
 
    for(i = 0; i < hash_size; i++)
    {
        buf[i * 2] = hex[hash_buf[i] >> 4];
        buf[i * 2 + 1] = hex[hash_buf[i] & 0xf];
    }
    buf[i * 2] = '\0';
 
    return buf;
}

Referenced by test_DrawDib_sizeimage().

init_bmi()

static void init_bmi ( BITMAPINFO *  bmi, LONG  width, LONG  height, DWORD  size  )

static

Definition at line 78 of file drawdib.c.

{
    memset(bmi, 0, sizeof(*bmi));
    bmi->bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
    bmi->bmiHeader.biWidth       = width;
    bmi->bmiHeader.biHeight      = height;
    bmi->bmiHeader.biPlanes      = 1;
    bmi->bmiHeader.biBitCount    = 32;
    bmi->bmiHeader.biCompression = BI_RGB;
    bmi->bmiHeader.biSizeImage   = size;
}

Referenced by test_DrawDib_sizeimage().

START_TEST()

START_TEST

(

drawdib

)

Definition at line 174 of file drawdib.c.

{
    CryptAcquireContextW(&crypt_prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
    test_DrawDib_sizeimage();
    CryptReleaseContext(crypt_prov, 0);
}

test_DrawDib_sizeimage()

static void test_DrawDib_sizeimage ( void  )

static

Definition at line 90 of file drawdib.c.

{
    const struct {
        LONG width, height;
        DWORD size;
        char hash[41];
    } test_data[] = {
        /* [0] correct size */
        {  WIDTH,   HEIGHT, WIDTH * HEIGHT * sizeof(RGBQUAD), "bc943d5ab024b8b0118d0a80aa283055d39942b8" },
        /* [1] zero size */
        {  WIDTH,   HEIGHT, 0, "bc943d5ab024b8b0118d0a80aa283055d39942b8" },
        /* error patterns */
        {  WIDTH,  -HEIGHT, 0, "" },
        { -WIDTH,   HEIGHT, 0, "" },
        { -WIDTH,  -HEIGHT, 0, "" },
        {      0,        0, 0, "" },
        {      0,   HEIGHT, 0, "" },
        {  WIDTH,        0, 0, "" },
        /* [8] zero size (to compare [9], [10] ) */
        {  WIDTH, HEIGHT/2, 0, "8b75bf6d54a8645380114fe77505ee0699ffffaa" },
        /* [9] insufficient size */
        {  WIDTH, HEIGHT/2, sizeof(RGBQUAD), "8b75bf6d54a8645380114fe77505ee0699ffffaa" },
        /* [10] too much size */
        {  WIDTH, HEIGHT/2, WIDTH * HEIGHT * sizeof(RGBQUAD), "8b75bf6d54a8645380114fe77505ee0699ffffaa" },
    };
    HDC hdc;
    DWORD src_dib_size, dst_dib_size;
    BOOL r;
    HBITMAP dib;
    BITMAPINFO src_info, dst_info;
    RGBQUAD *src_bits = NULL, *dst_bits;
    HDRAWDIB hdd;
    unsigned int i;
 
    hdc = CreateCompatibleDC(NULL);
 
    init_bmi(&dst_info, WIDTH, HEIGHT, 0);
    dib = CreateDIBSection(NULL, &dst_info, DIB_RGB_COLORS, (void **)&dst_bits, NULL, 0);
    dst_dib_size = get_dib_size(&dst_info);
    ok(dib != NULL, "CreateDIBSection failed\n");
    SelectObject(hdc, dib);
 
    init_bmi(&src_info, WIDTH, HEIGHT, 0);
    src_dib_size = get_dib_size(&src_info);
    src_bits = HeapAlloc(GetProcessHeap(), 0, src_dib_size);
    ok(src_bits != NULL, "Can't allocate memory\n");
    memset(src_bits, 0x88, src_dib_size);
 
    hdd = DrawDibOpen();
    ok(hdd != NULL, "DrawDibOpen failed\n");
 
    for (i = 0; i < ARRAY_SIZE(test_data); i++) {
        char *hash;
        memset(dst_bits, 0xff, dst_dib_size);
        init_bmi(&src_info, test_data[i].width, test_data[i].height, test_data[i].size);
        r = DrawDibDraw(hdd, hdc,
                        0, 0, -1, -1, &src_info.bmiHeader, src_bits,
                        0, 0, test_data[i].width, test_data[i].height, 0);
        if (test_data[i].hash[0])
            ok(r, "[%u] DrawDibDraw failed, expected success\n", i);
        else
            ok(!r, "[%u] DrawDibDraw succeeded, expected failed\n", i);
        if (!r || !test_data[i].hash[0])
            continue;
 
        hash = hash_dib(&dst_info, dst_bits);
        if (!hash) {
            win_skip("This platform doesn't support SHA-1 hash\n");
            continue;
        }
        ok(strcmp(hash, test_data[i].hash) == 0,
           "[%u] got %s, expected %s\n",
           i, hash, test_data[i].hash);
        HeapFree(GetProcessHeap(), 0, hash);
    }
 
    r = DrawDibClose(hdd);
    ok(r, "DrawDibClose failed\n");
 
    HeapFree(GetProcessHeap(), 0, src_bits);
 
    DeleteDC(hdc);
}

Referenced by START_TEST().

Variable Documentation

crypt_prov

HCRYPTPROV crypt_prov

static

Definition at line 32 of file drawdib.c.

Referenced by hash_dib(), and START_TEST().