wine-commits May 2011

wine-commits@winehq.org

2 participants
945 discussions

Huw Davies : gdi32: Add support for 8 bpp brushes.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: c4576b4a9445b87e775fc3a80dc6f8a22bf91c65 URL: http://source.winehq.org/git/wine.git/?a=commit;h=c4576b4a9445b87e775fc3a80… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 14:36:55 2011 +0100 gdi32: Add support for 8 bpp brushes. --- dlls/gdi32/dibdrv/primitives.c | 139 ++++++++++++++++++++++++++++++++++++++++ 1 files changed, 139 insertions(+), 0 deletions(-) diff --git a/dlls/gdi32/dibdrv/primitives.c b/dlls/gdi32/dibdrv/primitives.c index 9622098..f2738ba 100644 --- a/dlls/gdi32/dibdrv/primitives.c +++ b/dlls/gdi32/dibdrv/primitives.c @@ -18,6 +18,8 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <assert.h> + #include "gdi_private.h" #include "dibdrv.h" @@ -402,6 +404,27 @@ static BOOL convert_to_8888(dib_info *dst, const dib_info *src, const RECT *src_ break; } + case 8: + { + BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel; + for(y = src_rect->top; y < src_rect->bottom; y++) + { + dst_pixel = dst_start; + src_pixel = src_start; + for(x = src_rect->left; x < src_rect->right; x++) + { + RGBQUAD rgb; + src_val = *src_pixel++; + if(src_val >= src->color_table_size) src_val = src->color_table_size - 1; + rgb = src->color_table[src_val]; + *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue; + } + dst_start += dst->stride / 4; + src_start += src->stride; + } + break; + } + default: FIXME("Unsupported conversion: %d -> 8888\n", src->bit_count); return FALSE; @@ -474,6 +497,29 @@ static BOOL convert_to_32(dib_info *dst, const dib_info *src, const RECT *src_re break; } + case 8: + { + BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel; + for(y = src_rect->top; y < src_rect->bottom; y++) + { + dst_pixel = dst_start; + src_pixel = src_start; + for(x = src_rect->left; x < src_rect->right; x++) + { + RGBQUAD rgb; + src_val = *src_pixel++; + if(src_val >= src->color_table_size) src_val = src->color_table_size - 1; + rgb = src->color_table[src_val]; + *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) | + put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) | + put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len); + } + dst_start += dst->stride / 4; + src_start += src->stride; + } + break; + } + default: FIXME("Unsupported conversion: %d -> 32\n", src->bit_count); return FALSE; @@ -544,6 +590,29 @@ static BOOL convert_to_555(dib_info *dst, const dib_info *src, const RECT *src_r break; } + case 8: + { + BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel; + for(y = src_rect->top; y < src_rect->bottom; y++) + { + dst_pixel = dst_start; + src_pixel = src_start; + for(x = src_rect->left; x < src_rect->right; x++) + { + RGBQUAD rgb; + src_val = *src_pixel++; + if(src_val >= src->color_table_size) src_val = src->color_table_size - 1; + rgb = src->color_table[src_val]; + *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) | + ((rgb.rgbGreen << 2) & 0x03e0) | + ((rgb.rgbBlue >> 3) & 0x001f); + } + dst_start += dst->stride / 2; + src_start += src->stride; + } + break; + } + default: FIXME("Unsupported conversion: %d -> 555\n", src->bit_count); return FALSE; @@ -617,6 +686,29 @@ static BOOL convert_to_16(dib_info *dst, const dib_info *src, const RECT *src_re break; } + case 8: + { + BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel; + for(y = src_rect->top; y < src_rect->bottom; y++) + { + dst_pixel = dst_start; + src_pixel = src_start; + for(x = src_rect->left; x < src_rect->right; x++) + { + RGBQUAD rgb; + src_val = *src_pixel++; + if(src_val >= src->color_table_size) src_val = src->color_table_size - 1; + rgb = src->color_table[src_val]; + *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) | + put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) | + put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len); + } + dst_start += dst->stride / 2; + src_start += src->stride; + } + break; + } + default: FIXME("Unsupported conversion: %d -> 16\n", src->bit_count); return FALSE; @@ -625,6 +717,14 @@ static BOOL convert_to_16(dib_info *dst, const dib_info *src, const RECT *src_re return TRUE; } +static inline BOOL color_tables_match(const dib_info *d1, const dib_info *d2) +{ + assert(d1->color_table_size && d2->color_table_size); + + if(d1->color_table_size != d2->color_table_size) return FALSE; + return !memcmp(d1->color_table, d2->color_table, d1->color_table_size * sizeof(d1->color_table[0])); +} + static BOOL convert_to_8(dib_info *dst, const dib_info *src, const RECT *src_rect) { BYTE *dst_start = dst->bits, *dst_pixel; @@ -690,6 +790,45 @@ static BOOL convert_to_8(dib_info *dst, const dib_info *src, const RECT *src_rec break; } + case 8: + { + BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel; + + if(color_tables_match(dst, src)) + { + if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width) + memcpy(dst->bits, src_start, (src_rect->bottom - src_rect->top) * src->stride); + else + { + for(y = src_rect->top; y < src_rect->bottom; y++) + { + memcpy(dst_start, src_start, src_rect->right - src_rect->left); + dst_start += dst->stride; + src_start += src->stride; + } + } + } + else + { + for(y = src_rect->top; y < src_rect->bottom; y++) + { + dst_pixel = dst_start; + src_pixel = src_start; + for(x = src_rect->left; x < src_rect->right; x++) + { + RGBQUAD rgb; + src_val = *src_pixel++; + if(src_val >= src->color_table_size) src_val = src->color_table_size - 1; + rgb = src->color_table[src_val]; + *dst_pixel++ = colorref_to_pixel_colortable(dst, RGB(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue)); + } + dst_start += dst->stride; + src_start += src->stride; + } + } + break; + } + default: FIXME("Unsupported conversion: %d -> 8\n", src->bit_count); return FALSE;

1 0

Huw Davies : gdi32/tests: Add tests for 8 bpp dibs.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: 64a34a33b1fca508956760e8097e31586f114e38 URL: http://source.winehq.org/git/wine.git/?a=commit;h=64a34a33b1fca508956760e80… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 14:29:49 2011 +0100 gdi32/tests: Add tests for 8 bpp dibs. --- dlls/gdi32/tests/dib.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 58 insertions(+), 0 deletions(-) diff --git a/dlls/gdi32/tests/dib.c b/dlls/gdi32/tests/dib.c index 75519b6..bb30215 100644 --- a/dlls/gdi32/tests/dib.c +++ b/dlls/gdi32/tests/dib.c @@ -178,6 +178,32 @@ static const char *sha1_graphics_r4g4b4[] = NULL }; +static const char *sha1_graphics_8[] = +{ + "41728d7ff2bb425b5fc06521adeabf6cc73136f3", + "512246d4886ab889a090b167ba194577cb95272e", + "921e852d4564cb9e5ac15ff68b5207bebea871d1", + "9636b0ebefc443ea11949ccd28f6ca454277dd41", + "aa9050da55e6b6957c60b7d603fce539cb5c0048", + "e2b93aca15fb1233ac09a713dced1f4cd950b1e4", + "3e3a603fc26cc305aa27f88da7d2a3b0073877d8", + "390b2bf70daba36310683f46af9cd50b9a061396", + "82d21737e9a7247397a6c983a9b6d9a0452dd74d", + "2a8460af91675e01cbe9384eb6cd3eb2cb420960", + "1af53b1218ee9844fcda891b836d42f6b2f66bd5", + "da1cc34a9d9b779fc7849e03e214096026506464", + "5ba8f99ca034666effa556748c49a0f5a015125f", + "b67ba2f55659c75ac72c1112494461bb3086e1a4", + "73e2859ce849f756f954718ce3c90f02e31712b6", + "196d832d283bf642d2e481e5452ca175f7902761", + "9552f48b88982633a44001227abb847dae4d06b0", + "cfc67c325c7cdf96d90af9b3cceb8d0504cbb3b0", + "1f13ea0034db4b0ffa4ddcff9664fd892058f9cd", + "3caf512cfddfd463d0750cfe3cadb58548eb2ae8", + "4e5e7d5fd64818b2b3d3e793c88f603b699d2f0f", + NULL +}; + static inline DWORD get_stride(BITMAPINFO *bmi) { return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3; @@ -800,6 +826,38 @@ todo_wine SelectObject(mem_dc, orig_bm); DeleteObject(dib); + /* 8 */ + trace("8\n"); + bmi->bmiHeader.biBitCount = 8; + bmi->bmiHeader.biCompression = BI_RGB; + bmi->bmiHeader.biClrUsed = 5; + bmi->bmiColors[0].rgbRed = 0xff; + bmi->bmiColors[0].rgbGreen = 0xff; + bmi->bmiColors[0].rgbBlue = 0xff; + bmi->bmiColors[1].rgbRed = 0; + bmi->bmiColors[1].rgbGreen = 0; + bmi->bmiColors[1].rgbBlue = 0; + bmi->bmiColors[2].rgbRed = 0xff; + bmi->bmiColors[2].rgbGreen = 0; + bmi->bmiColors[2].rgbBlue = 0; + bmi->bmiColors[3].rgbRed = 0; + bmi->bmiColors[3].rgbGreen = 0xff; + bmi->bmiColors[3].rgbBlue = 0; + bmi->bmiColors[4].rgbRed = 0; + bmi->bmiColors[4].rgbGreen = 0; + bmi->bmiColors[4].rgbBlue = 0xff; + + dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0); + ok(dib != NULL, "ret NULL\n"); + + orig_bm = SelectObject(mem_dc, dib); + + sha1 = sha1_graphics_8; + draw_graphics(mem_dc, bmi, bits, &sha1); + + SelectObject(mem_dc, orig_bm); + DeleteObject(dib); + DeleteDC(mem_dc); }

1 0

Huw Davies : gdi32: Add support for 8 bpp dibs.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: 30f26b3bcadf1fcc35a15f024570e10ceab08d5f URL: http://source.winehq.org/git/wine.git/?a=commit;h=30f26b3bcadf1fcc35a15f024… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 14:26:02 2011 +0100 gdi32: Add support for 8 bpp dibs. --- dlls/gdi32/dibdrv/dc.c | 4 + dlls/gdi32/dibdrv/dibdrv.h | 1 + dlls/gdi32/dibdrv/primitives.c | 182 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 187 insertions(+), 0 deletions(-) diff --git a/dlls/gdi32/dibdrv/dc.c b/dlls/gdi32/dibdrv/dc.c index d6023b0..850fbc3 100644 --- a/dlls/gdi32/dibdrv/dc.c +++ b/dlls/gdi32/dibdrv/dc.c @@ -114,6 +114,10 @@ static BOOL init_dib_info(dib_info *dib, const BITMAPINFOHEADER *bi, const DWORD dib->funcs = &funcs_16; break; + case 8: + dib->funcs = &funcs_8; + break; + default: TRACE("bpp %d not supported, will forward to graphics driver.\n", dib->bit_count); return FALSE; diff --git a/dlls/gdi32/dibdrv/dibdrv.h b/dlls/gdi32/dibdrv/dibdrv.h index a330d0a..56d08b3 100644 --- a/dlls/gdi32/dibdrv/dibdrv.h +++ b/dlls/gdi32/dibdrv/dibdrv.h @@ -49,6 +49,7 @@ extern const primitive_funcs funcs_8888 DECLSPEC_HIDDEN; extern const primitive_funcs funcs_32 DECLSPEC_HIDDEN; extern const primitive_funcs funcs_555 DECLSPEC_HIDDEN; extern const primitive_funcs funcs_16 DECLSPEC_HIDDEN; +extern const primitive_funcs funcs_8 DECLSPEC_HIDDEN; extern const primitive_funcs funcs_null DECLSPEC_HIDDEN; extern void calc_and_xor_masks(INT rop, DWORD color, DWORD *and, DWORD *xor) DECLSPEC_HIDDEN; diff --git a/dlls/gdi32/dibdrv/primitives.c b/dlls/gdi32/dibdrv/primitives.c index 8ff95fa..9622098 100644 --- a/dlls/gdi32/dibdrv/primitives.c +++ b/dlls/gdi32/dibdrv/primitives.c @@ -35,6 +35,11 @@ static inline WORD *get_pixel_ptr_16(const dib_info *dib, int x, int y) return (WORD *)((BYTE*)dib->bits + y * dib->stride + x * 2); } +static inline BYTE *get_pixel_ptr_8(const dib_info *dib, int x, int y) +{ + return (BYTE*)dib->bits + y * dib->stride + x; +} + static inline void do_rop_32(DWORD *ptr, DWORD and, DWORD xor) { *ptr = (*ptr & and) ^ xor; @@ -45,6 +50,11 @@ static inline void do_rop_16(WORD *ptr, WORD and, WORD xor) *ptr = (*ptr & and) ^ xor; } +static inline void do_rop_8(BYTE *ptr, BYTE and, BYTE xor) +{ + *ptr = (*ptr & and) ^ xor; +} + static void solid_rects_32(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor) { DWORD *ptr, *start; @@ -73,6 +83,20 @@ static void solid_rects_16(const dib_info *dib, int num, const RECT *rc, DWORD a } } +static void solid_rects_8(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor) +{ + BYTE *ptr, *start; + int x, y, i; + + for(i = 0; i < num; i++, rc++) + { + start = get_pixel_ptr_8(dib, rc->left, rc->top); + for(y = rc->top; y < rc->bottom; y++, start += dib->stride) + for(x = rc->left, ptr = start; x < rc->right; x++) + do_rop_8(ptr++, and, xor); + } +} + static void solid_rects_null(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor) { return; @@ -194,6 +218,52 @@ static void pattern_rects_16(const dib_info *dib, int num, const RECT *rc, const } } +static void pattern_rects_8(const dib_info *dib, int num, const RECT *rc, const POINT *origin, + const dib_info *brush, void *and_bits, void *xor_bits) +{ + BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr; + int x, y, i; + POINT offset; + + for(i = 0; i < num; i++, rc++) + { + offset = calc_brush_offset(rc, brush, origin); + + start = get_pixel_ptr_8(dib, rc->left, rc->top); + start_and = (BYTE*)and_bits + offset.y * brush->stride; + start_xor = (BYTE*)xor_bits + offset.y * brush->stride; + + for(y = rc->top; y < rc->bottom; y++, start += dib->stride) + { + and_ptr = start_and + offset.x; + xor_ptr = start_xor + offset.x; + + for(x = rc->left, ptr = start; x < rc->right; x++) + { + do_rop_8(ptr++, *and_ptr++, *xor_ptr++); + if(and_ptr == start_and + brush->width) + { + and_ptr = start_and; + xor_ptr = start_xor; + } + } + + offset.y++; + if(offset.y == brush->height) + { + start_and = and_bits; + start_xor = xor_bits; + offset.y = 0; + } + else + { + start_and += brush->stride; + start_xor += brush->stride; + } + } + } +} + static void pattern_rects_null(const dib_info *dib, int num, const RECT *rc, const POINT *origin, const dib_info *brush, void *and_bits, void *xor_bits) { @@ -235,6 +305,37 @@ static DWORD colorref_to_pixel_555(const dib_info *dib, COLORREF color) return ( ((color >> 19) & 0x1f) | ((color >> 6) & 0x03e0) | ((color << 7) & 0x7c00) ); } +static DWORD colorref_to_pixel_colortable(const dib_info *dib, COLORREF color) +{ + int i, best_index = 0; + RGBQUAD rgb; + DWORD diff, best_diff = 0xffffffff; + + rgb.rgbRed = GetRValue(color); + rgb.rgbGreen = GetGValue(color); + rgb.rgbBlue = GetBValue(color); + + for(i = 0; i < dib->color_table_size; i++) + { + RGBQUAD *cur = dib->color_table + i; + diff = (rgb.rgbRed - cur->rgbRed) * (rgb.rgbRed - cur->rgbRed) + + (rgb.rgbGreen - cur->rgbGreen) * (rgb.rgbGreen - cur->rgbGreen) + + (rgb.rgbBlue - cur->rgbBlue) * (rgb.rgbBlue - cur->rgbBlue); + + if(diff == 0) + { + best_index = i; + break; + } + + if(diff < best_diff) + { + best_diff = diff; + best_index = i; + } + } + return best_index; +} static DWORD colorref_to_pixel_null(const dib_info *dib, COLORREF color) { @@ -524,6 +625,79 @@ static BOOL convert_to_16(dib_info *dst, const dib_info *src, const RECT *src_re return TRUE; } +static BOOL convert_to_8(dib_info *dst, const dib_info *src, const RECT *src_rect) +{ + BYTE *dst_start = dst->bits, *dst_pixel; + INT x, y; + DWORD src_val; + + switch(src->bit_count) + { + case 32: + { + DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel; + + if(src->funcs == &funcs_8888) + { + for(y = src_rect->top; y < src_rect->bottom; y++) + { + dst_pixel = dst_start; + src_pixel = src_start; + for(x = src_rect->left; x < src_rect->right; x++) + { + src_val = *src_pixel++; + *dst_pixel++ = colorref_to_pixel_colortable(dst, ((src_val >> 16) & 0x0000ff) | + ( src_val & 0x00ff00) | + ((src_val << 16) & 0xff0000) ); + } + dst_start += dst->stride; + src_start += src->stride / 4; + } + } + else + { + FIXME("Unsupported conversion: 32 -> 8\n"); + return FALSE; + } + break; + } + + case 16: + { + WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel; + if(src->funcs == &funcs_555) + { + for(y = src_rect->top; y < src_rect->bottom; y++) + { + dst_pixel = dst_start; + src_pixel = src_start; + for(x = src_rect->left; x < src_rect->right; x++) + { + src_val = *src_pixel++; + *dst_pixel++ = colorref_to_pixel_colortable(dst, ((src_val >> 7) & 0x0000f8) | ((src_val >> 12) & 0x000007) | + ((src_val << 6) & 0x00f800) | ((src_val << 1) & 0x000700) | + ((src_val << 19) & 0xf80000) | ((src_val << 14) & 0x070000) ); + } + dst_start += dst->stride; + src_start += src->stride / 2; + } + } + else + { + FIXME("Unsupported conversion: 16 -> 8\n"); + return FALSE; + } + break; + } + + default: + FIXME("Unsupported conversion: %d -> 8\n", src->bit_count); + return FALSE; + + } + return TRUE; +} + static BOOL convert_to_null(dib_info *dst, const dib_info *src, const RECT *src_rect) { return TRUE; @@ -561,6 +735,14 @@ const primitive_funcs funcs_16 = convert_to_16 }; +const primitive_funcs funcs_8 = +{ + solid_rects_8, + pattern_rects_8, + colorref_to_pixel_colortable, + convert_to_8 +}; + const primitive_funcs funcs_null = { solid_rects_null,

1 0

Huw Davies : gdi32: Add support for colour tables.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: a44aa8a95426c38ba1badeff0082973a809e2138 URL: http://source.winehq.org/git/wine.git/?a=commit;h=a44aa8a95426c38ba1badeff0… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 14:17:20 2011 +0100 gdi32: Add support for colour tables. --- dlls/gdi32/dibdrv/dc.c | 65 ++++++++++++++++++++++++++++++++++++------ dlls/gdi32/dibdrv/dibdrv.h | 2 +- dlls/gdi32/dibdrv/objects.c | 4 ++- dlls/gdi32/gdi_private.h | 3 ++ 4 files changed, 62 insertions(+), 12 deletions(-) diff --git a/dlls/gdi32/dibdrv/dc.c b/dlls/gdi32/dibdrv/dc.c index 07227a1..d6023b0 100644 --- a/dlls/gdi32/dibdrv/dc.c +++ b/dlls/gdi32/dibdrv/dc.c @@ -63,7 +63,8 @@ static void init_bit_fields(dib_info *dib, const DWORD *bit_fields) calc_shift_and_len(dib->blue_mask, &dib->blue_shift, &dib->blue_len); } -static BOOL init_dib_info(dib_info *dib, const BITMAPINFOHEADER *bi, const DWORD *bit_fields, void *bits) +static BOOL init_dib_info(dib_info *dib, const BITMAPINFOHEADER *bi, const DWORD *bit_fields, + RGBQUAD *color_table, int color_table_size, void *bits) { static const DWORD bit_fields_888[3] = {0xff0000, 0x00ff00, 0x0000ff}; static const DWORD bit_fields_555[3] = {0x7c00, 0x03e0, 0x001f}; @@ -118,13 +119,26 @@ static BOOL init_dib_info(dib_info *dib, const BITMAPINFOHEADER *bi, const DWORD return FALSE; } + if(color_table) + { + dib->color_table = HeapAlloc(GetProcessHeap(), 0, color_table_size * sizeof(dib->color_table[0])); + if(!dib->color_table) return FALSE; + dib->color_table_size = color_table_size; + memcpy(dib->color_table, color_table, color_table_size * sizeof(color_table[0])); + } + else + { + dib->color_table = NULL; + dib->color_table_size = 0; + } + return TRUE; } -BOOL init_dib_info_from_packed(dib_info *dib, const BITMAPINFOHEADER *bi, WORD usage) +BOOL init_dib_info_from_packed(dib_info *dib, const BITMAPINFOHEADER *bi, WORD usage, HPALETTE palette) { DWORD *masks = NULL; - RGBQUAD *color_table = NULL; + RGBQUAD *color_table = NULL, pal_table[256]; BYTE *ptr = (BYTE*)bi + bi->biSize; int num_colors = bi->biClrUsed; @@ -135,17 +149,37 @@ BOOL init_dib_info_from_packed(dib_info *dib, const BITMAPINFOHEADER *bi, WORD u } if(!num_colors && bi->biBitCount <= 8) num_colors = 1 << bi->biBitCount; - if(num_colors) color_table = (RGBQUAD*)ptr; - if(usage == DIB_PAL_COLORS) - ptr += num_colors * sizeof(WORD); - else - ptr += num_colors * sizeof(*color_table); + if(num_colors) + { + if(usage == DIB_PAL_COLORS) + { + PALETTEENTRY entries[256]; + const WORD *index = (const WORD*) ptr; + UINT i, count = GetPaletteEntries( palette, 0, num_colors, entries ); + for (i = 0; i < num_colors; i++, index++) + { + PALETTEENTRY *entry = &entries[*index % count]; + pal_table[i].rgbRed = entry->peRed; + pal_table[i].rgbGreen = entry->peGreen; + pal_table[i].rgbBlue = entry->peBlue; + pal_table[i].rgbReserved = 0; + } + color_table = pal_table; + ptr += num_colors * sizeof(WORD); + } + else + { + color_table = (RGBQUAD*)ptr; + ptr += num_colors * sizeof(*color_table); + } + } - return init_dib_info(dib, bi, masks, ptr); + return init_dib_info(dib, bi, masks, color_table, num_colors, ptr); } static void clear_dib_info(dib_info *dib) { + dib->color_table = NULL; dib->bits = NULL; } @@ -156,6 +190,8 @@ static void clear_dib_info(dib_info *dib) */ void free_dib_info(dib_info *dib, BOOL free_bits) { + HeapFree(GetProcessHeap(), 0, dib->color_table); + dib->color_table = NULL; if(free_bits) { HeapFree(GetProcessHeap(), 0, dib->bits); @@ -176,6 +212,14 @@ void copy_dib_color_info(dib_info *dst, const dib_info *src) dst->green_shift = src->green_shift; dst->blue_shift = src->blue_shift; dst->funcs = src->funcs; + dst->color_table_size = src->color_table_size; + dst->color_table = NULL; + if(dst->color_table_size) + { + int size = dst->color_table_size * sizeof(dst->color_table[0]); + dst->color_table = HeapAlloc(GetProcessHeap(), 0, size); + memcpy(dst->color_table, src->color_table, size); + } } /************************************************************** @@ -239,7 +283,8 @@ static HBITMAP CDECL dibdrv_SelectBitmap( PHYSDEV dev, HBITMAP bitmap ) clear_dib_info(&pdev->brush_dib); pdev->brush_and_bits = pdev->brush_xor_bits = NULL; - if(!init_dib_info(&pdev->dib, &bmp->dib->dsBmih, bmp->dib->dsBitfields, bmp->dib->dsBm.bmBits)) + if(!init_dib_info(&pdev->dib, &bmp->dib->dsBmih, bmp->dib->dsBitfields, + bmp->color_table, bmp->nb_colors, bmp->dib->dsBm.bmBits)) pdev->defer |= DEFER_FORMAT; GDI_ReleaseObj( bitmap ); diff --git a/dlls/gdi32/dibdrv/dibdrv.h b/dlls/gdi32/dibdrv/dibdrv.h index a8e1dd9..a330d0a 100644 --- a/dlls/gdi32/dibdrv/dibdrv.h +++ b/dlls/gdi32/dibdrv/dibdrv.h @@ -54,7 +54,7 @@ extern const primitive_funcs funcs_null DECLSPEC_HIDDEN; extern void calc_and_xor_masks(INT rop, DWORD color, DWORD *and, DWORD *xor) DECLSPEC_HIDDEN; extern void update_brush_rop( dibdrv_physdev *pdev, INT rop ) DECLSPEC_HIDDEN; extern void reset_dash_origin(dibdrv_physdev *pdev) DECLSPEC_HIDDEN; -extern BOOL init_dib_info_from_packed(dib_info *dib, const BITMAPINFOHEADER *bi, WORD usage) DECLSPEC_HIDDEN; +extern BOOL init_dib_info_from_packed(dib_info *dib, const BITMAPINFOHEADER *bi, WORD usage, HPALETTE pal) DECLSPEC_HIDDEN; extern void free_dib_info(dib_info *dib, BOOL free_bits) DECLSPEC_HIDDEN; extern void free_pattern_brush(dibdrv_physdev *pdev) DECLSPEC_HIDDEN; extern void copy_dib_color_info(dib_info *dst, const dib_info *src) DECLSPEC_HIDDEN; diff --git a/dlls/gdi32/dibdrv/objects.c b/dlls/gdi32/dibdrv/objects.c index ebe94c0..ce6e710 100644 --- a/dlls/gdi32/dibdrv/objects.c +++ b/dlls/gdi32/dibdrv/objects.c @@ -1117,9 +1117,11 @@ HBRUSH CDECL dibdrv_SelectBrush( PHYSDEV dev, HBRUSH hbrush ) { BITMAPINFOHEADER *bi = GlobalLock((HGLOBAL)logbrush.lbHatch); dib_info orig_dib; + WORD usage = LOWORD(logbrush.lbColor); + HPALETTE pal = (usage == DIB_PAL_COLORS) ? GetCurrentObject(dev->hdc, OBJ_PAL) : NULL; if(!bi) return NULL; - if(init_dib_info_from_packed(&orig_dib, bi, LOWORD(logbrush.lbColor))) + if(init_dib_info_from_packed(&orig_dib, bi, usage, pal)) { copy_dib_color_info(&pdev->brush_dib, &pdev->dib); if(convert_dib(&pdev->brush_dib, &orig_dib)) diff --git a/dlls/gdi32/gdi_private.h b/dlls/gdi32/gdi_private.h index 0f59f48..9a188ee 100644 --- a/dlls/gdi32/gdi_private.h +++ b/dlls/gdi32/gdi_private.h @@ -89,6 +89,9 @@ typedef struct int red_shift, green_shift, blue_shift; int red_len, green_len, blue_len; + RGBQUAD *color_table; + DWORD color_table_size; + const struct primitive_funcs *funcs; } dib_info;

1 0

Huw Davies : gdi32/tests: Add tests for non-standard BI_BITFIELD dibs.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: 6ff7cb8ff6dc16293a4b81057a1733ff79f43a56 URL: http://source.winehq.org/git/wine.git/?a=commit;h=6ff7cb8ff6dc16293a4b81057… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 13:54:46 2011 +0100 gdi32/tests: Add tests for non-standard BI_BITFIELD dibs. --- dlls/gdi32/tests/dib.c | 98 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 98 insertions(+), 0 deletions(-) diff --git a/dlls/gdi32/tests/dib.c b/dlls/gdi32/tests/dib.c index 5c341d5..75519b6 100644 --- a/dlls/gdi32/tests/dib.c +++ b/dlls/gdi32/tests/dib.c @@ -100,6 +100,32 @@ static const char *sha1_graphics_a8r8g8b8[] = NULL }; +static const char *sha1_graphics_a8b8g8r8[] = +{ + "a3cadd34d95d3d5cc23344f69aab1c2e55935fcf", + "e0bc877697093ed440e125154e247ca9d65e933c", + "c6d7faf5a502299f99d59eef3f7650bd63dbe108", + "9d8c05c3ebd786e7d052418e905a80a64bf7853d", + "3da12af0a810fd993fa3dbe23328a4fcd2b6c92a", + "b91c8f21cc4d7994abc551feff5b6927d267a9db", + "d49dd2c6a37e975b6dc3d201ccc217a788b30284", + "ca6753f9eb44529cf8c67cd6abcd4ed1ef758904", + "18c3ae944e0afb6c43c21cde093ddb22a27611e4", + "b753ebb39d90210cc717f57b53dd439f7de6b077", + "38c017dd1fff26b492a57e09f3ce2c4370faf225", + "94368cea5033b435454daa56d55546310675131e", + "bf57a6a37fb107d29ed3d45695919887abcb7902", + "3db0f8bcca3d94920aa57be6321202b8c3c08822", + "1f1fc165a4dae7ba118ddccb58a279bfe3876b0a", + "66da15b6780a4ca3b3d2eb1d1dba4e30f7b74964", + "42fefefe4435570fa8038ec759140c66c76570e9", + "3369889a67d6c79a24ee15f7d14374f9995215e4", + "4851c5b7d5bc18590e787c0c218a592ef504e738", + "9aa506e3df33e0d5298755aa4144e10eb4b5adcf", + "abdf003699364fe45fab7dc61e67c606d0063b40", + NULL +}; + static const char *sha1_graphics_r5g5b5[] = { "2a2ab8b3c019e70b788ade028b0e9e53ffc529ae", @@ -126,6 +152,32 @@ static const char *sha1_graphics_r5g5b5[] = NULL }; +static const char *sha1_graphics_r4g4b4[] = +{ + "2a2ab8b3c019e70b788ade028b0e9e53ffc529ae", + "cfa0ab83ee93283ad914c3748f0532da1697af1d", + "8bd18697d1ef27492805667a0bc956343ac08667", + "e8501c830321584474654f90e40eaf27dc21e6a8", + "d95ab10fcfb8447b41742e89f1ae8cd297a32fc4", + "821177710961d2cb5f7e7dfc0e06e767b6042753", + "667124365ffadeea1d8791bedda77a0c7b898de8", + "c9f23e684b600dea17575b4b17175fbd9106c3a9", + "7678876e50eae35d1eaa096aae25afaa0b864bf3", + "fb52b0c373a5f2a60b981604b120962942d2447a", + "5ab8dd07436681d762fa04ad7c6d71291c488924", + "0167981d9e1490a2ebd396ff7582f0943aa8e1b8", + "115a6bd382410a4a1d3c1fa71d8bf02536863e38", + "65c6d1228e3b6d63d42647f14217bc1658b70d9a", + "25fcb75aa687aac35b8f72640889fe92413e00c5", + "dbc8d66b419880108793db91c05766c0c6efd86d", + "6092ccbab6b6e073c6ac8244d122f2cfc453aa38", + "32b6e0aa79b7e96cd0ab2da167f6463c011023a8", + "d591232bbc2592462c819a9486750f64180518fd", + "0e183a4c30b3da345129cffe33fe0fc593d8666b", + "f14d9a4bd8a365b7c8f068a0dad481b6eb2b178b", + NULL +}; + static inline DWORD get_stride(BITMAPINFO *bmi) { return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3; @@ -679,6 +731,29 @@ static void test_simple_graphics(void) SelectObject(mem_dc, orig_bm); DeleteObject(dib); + /* a8b8g8r8 - bitfields. */ + trace("a8b8g8r8 - bitfields\n"); + bmi->bmiHeader.biBitCount = 32; + bmi->bmiHeader.biCompression = BI_BITFIELDS; + bit_fields[0] = 0x0000ff; + bit_fields[1] = 0x00ff00; + bit_fields[2] = 0xff0000; + + dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0); + ok(dib != NULL, "ret NULL\n"); + ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n"); + ok(ds.dsBitfields[0] == 0x0000ff, "got %08x\n", ds.dsBitfields[0]); + ok(ds.dsBitfields[1] == 0x00ff00, "got %08x\n", ds.dsBitfields[1]); + ok(ds.dsBitfields[2] == 0xff0000, "got %08x\n", ds.dsBitfields[2]); + ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression); + + orig_bm = SelectObject(mem_dc, dib); + + sha1 = sha1_graphics_a8b8g8r8; + draw_graphics(mem_dc, bmi, bits, &sha1); + + SelectObject(mem_dc, orig_bm); + DeleteObject(dib); /* r5g5b5 */ trace("555\n"); @@ -702,6 +777,29 @@ todo_wine SelectObject(mem_dc, orig_bm); DeleteObject(dib); + /* r4g4b4 */ + trace("444\n"); + bmi->bmiHeader.biBitCount = 16; + bmi->bmiHeader.biCompression = BI_BITFIELDS; + bit_fields[0] = 0x0f00; + bit_fields[1] = 0x00f0; + bit_fields[2] = 0x000f; + dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0); + ok(dib != NULL, "ret NULL\n"); + ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n"); + ok(ds.dsBitfields[0] == 0x0f00, "got %08x\n", ds.dsBitfields[0]); + ok(ds.dsBitfields[1] == 0x00f0, "got %08x\n", ds.dsBitfields[1]); + ok(ds.dsBitfields[2] == 0x000f, "got %08x\n", ds.dsBitfields[2]); + ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression); + + orig_bm = SelectObject(mem_dc, dib); + + sha1 = sha1_graphics_r4g4b4; + draw_graphics(mem_dc, bmi, bits, &sha1); + + SelectObject(mem_dc, orig_bm); + DeleteObject(dib); + DeleteDC(mem_dc); }

1 0

Huw Davies : gdi32/tests: Add tests for 16 bpp brushes.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: ede526196e486ca097cb6867a2fcc98b8e9faa66 URL: http://source.winehq.org/git/wine.git/?a=commit;h=ede526196e486ca097cb6867a… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 13:48:26 2011 +0100 gdi32/tests: Add tests for 16 bpp brushes. --- dlls/gdi32/tests/dib.c | 37 +++++++++++++++++++++++++++++++++++-- 1 files changed, 35 insertions(+), 2 deletions(-) diff --git a/dlls/gdi32/tests/dib.c b/dlls/gdi32/tests/dib.c index e2fd0ef..5c341d5 100644 --- a/dlls/gdi32/tests/dib.c +++ b/dlls/gdi32/tests/dib.c @@ -93,6 +93,7 @@ static const char *sha1_graphics_a8r8g8b8[] = "b2261353decda2712b83538ab434a49ce21f3172", "ef654fedcb494dae79559f4db8b691ae2d522a3f", "a694872f38e66a7ff471440c3e6a9310ef78328a", + "d7398de15b2837a58a62a701ca1b3384625afec4", "e2a8eef4aeda3a0f6c950075acba38f1f9e0814d", "8b66f14d51ecdeea12bc993302bb9b7d3ec085a1", "7da9dd3d40d44d92deb9883fb7110443c2d5769a", @@ -118,6 +119,7 @@ static const char *sha1_graphics_r5g5b5[] = "449092689226a1172b6086ba1181d6b6d6499f26", "5c636ffadec10fbe440b552fe6436f3dbc607dcf", "4aac89fc18c128eddb69eea658272af53138a1cb", + "9d21bcfdeaf1ca5d47eb823bdefc24d7a95f4f56", "3a50ce21b3563a604b4fc9f247a30f5a981f1ba6", "d7d97e28ed316f6596c737eb83baa5948d86b673", "ecc2991277d7314f55b00e0f284ae3703aeef81e", @@ -286,10 +288,11 @@ static const RECT rectangles[] = {140, 20, 143, 30}, /* width == 3 */ {200, 20, 210, 21}, /* height == 1 */ {200, 30, 210, 32}, /* height == 2 */ - {200, 40, 210, 43} /* height == 3 */ + {200, 40, 210, 43} /* height == 3 */ }; -static const BITMAPINFOHEADER dib_brush_header_32 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 32, BI_RGB, 0, 0, 0, 0, 0}; +static const BITMAPINFOHEADER dib_brush_header_32 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 32, BI_RGB, 0, 0, 0, 0, 0}; +static const BITMAPINFOHEADER dib_brush_header_555 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 16, BI_RGB, 0, 0, 0, 0, 0}; static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits, const char ***sha1) { @@ -525,6 +528,36 @@ static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits, const char ***sh compare_hash(bmi, bits, sha1, "bottom-up dib brush patblt"); memset(bits, 0xcc, dib_size); + /* 555 dib pattern brush */ + + brush_bi->bmiHeader = dib_brush_header_555; + brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER); + memset(brush_bits, 0, 16 * 16 * sizeof(WORD)); + brush_bits[0] = brush_bits[1] = 0xff; + brush_bits[32] = brush_bits[34] = 0x7c; + + dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS); + + SelectObject(hdc, dib_brush); + SetBrushOrgEx(hdc, 1, 1, NULL); + + for(i = 0, y = 10; i < 256; i++) + { + BOOL ret; + + if(!rop_uses_src(rop3[i])) + { + ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]); + ok(ret, "got FALSE for %x\n", rop3[i]); + y += 25; + } + } + compare_hash(bmi, bits, sha1, "top-down 555 dib brush patblt"); + memset(bits, 0xcc, dib_size); + + SelectObject(hdc, orig_brush); + DeleteObject(dib_brush); + SetBrushOrgEx(hdc, 0, 0, NULL); /* Rectangle */

1 0

Huw Davies : gdi32: Add conversion routines to the primitive functions.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: 0a9eae97d27976e72874e2672ec8c3ab5be84b91 URL: http://source.winehq.org/git/wine.git/?a=commit;h=0a9eae97d27976e72874e2672… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 13:41:32 2011 +0100 gdi32: Add conversion routines to the primitive functions. --- dlls/gdi32/dibdrv/dc.c | 51 ++------ dlls/gdi32/dibdrv/dibdrv.h | 1 + dlls/gdi32/dibdrv/objects.c | 12 +-- dlls/gdi32/dibdrv/primitives.c | 307 +++++++++++++++++++++++++++++++++++++++- 4 files changed, 315 insertions(+), 56 deletions(-) Diff: http://source.winehq.org/git/wine.git/?a=commitdiff;h=0a9eae97d27976e72874e…

1 0

Huw Davies : gdi32: Add support for 16 bpp dibs.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: 18a96edf6932f42abca5e327a043ead088c6c8fb URL: http://source.winehq.org/git/wine.git/?a=commit;h=18a96edf6932f42abca5e327a… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 13:10:29 2011 +0100 gdi32: Add support for 16 bpp dibs. --- dlls/gdi32/dibdrv/dc.c | 13 ++++++ dlls/gdi32/dibdrv/dibdrv.h | 2 + dlls/gdi32/dibdrv/primitives.c | 92 +++++++++++++++++++++++++++++++++++++++- dlls/gdi32/tests/dib.c | 32 ++++++++++++++ 4 files changed, 138 insertions(+), 1 deletions(-) diff --git a/dlls/gdi32/dibdrv/dc.c b/dlls/gdi32/dibdrv/dc.c index 6cc1d33..98463b7 100644 --- a/dlls/gdi32/dibdrv/dc.c +++ b/dlls/gdi32/dibdrv/dc.c @@ -66,6 +66,7 @@ static void init_bit_fields(dib_info *dib, const DWORD *bit_fields) static BOOL init_dib_info(dib_info *dib, const BITMAPINFOHEADER *bi, const DWORD *bit_fields, void *bits) { static const DWORD bit_fields_888[3] = {0xff0000, 0x00ff00, 0x0000ff}; + static const DWORD bit_fields_555[3] = {0x7c00, 0x03e0, 0x001f}; dib->bit_count = bi->biBitCount; dib->width = bi->biWidth; @@ -100,6 +101,18 @@ static BOOL init_dib_info(dib_info *dib, const BITMAPINFOHEADER *bi, const DWORD dib->funcs = &funcs_32; break; + case 16: + if(bi->biCompression == BI_RGB) + bit_fields = bit_fields_555; + + init_bit_fields(dib, bit_fields); + + if(dib->red_mask == 0x7c00 && dib->green_mask == 0x03e0 && dib->blue_mask == 0x001f) + dib->funcs = &funcs_555; + else + dib->funcs = &funcs_16; + break; + default: TRACE("bpp %d not supported, will forward to graphics driver.\n", dib->bit_count); return FALSE; diff --git a/dlls/gdi32/dibdrv/dibdrv.h b/dlls/gdi32/dibdrv/dibdrv.h index ccf9f9a..0b5dba3 100644 --- a/dlls/gdi32/dibdrv/dibdrv.h +++ b/dlls/gdi32/dibdrv/dibdrv.h @@ -46,6 +46,8 @@ typedef struct primitive_funcs extern const primitive_funcs funcs_8888 DECLSPEC_HIDDEN; extern const primitive_funcs funcs_32 DECLSPEC_HIDDEN; +extern const primitive_funcs funcs_555 DECLSPEC_HIDDEN; +extern const primitive_funcs funcs_16 DECLSPEC_HIDDEN; extern const primitive_funcs funcs_null DECLSPEC_HIDDEN; extern void calc_and_xor_masks(INT rop, DWORD color, DWORD *and, DWORD *xor) DECLSPEC_HIDDEN; diff --git a/dlls/gdi32/dibdrv/primitives.c b/dlls/gdi32/dibdrv/primitives.c index 6dec478..c1d1597 100644 --- a/dlls/gdi32/dibdrv/primitives.c +++ b/dlls/gdi32/dibdrv/primitives.c @@ -26,11 +26,21 @@ static inline DWORD *get_pixel_ptr_32(const dib_info *dib, int x, int y) return (DWORD *)((BYTE*)dib->bits + y * dib->stride + x * 4); } +static inline WORD *get_pixel_ptr_16(const dib_info *dib, int x, int y) +{ + return (WORD *)((BYTE*)dib->bits + y * dib->stride + x * 2); +} + static inline void do_rop_32(DWORD *ptr, DWORD and, DWORD xor) { *ptr = (*ptr & and) ^ xor; } +static inline void do_rop_16(WORD *ptr, WORD and, WORD xor) +{ + *ptr = (*ptr & and) ^ xor; +} + static void solid_rects_32(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor) { DWORD *ptr, *start; @@ -38,13 +48,27 @@ static void solid_rects_32(const dib_info *dib, int num, const RECT *rc, DWORD a for(i = 0; i < num; i++, rc++) { - start = ptr = get_pixel_ptr_32(dib, rc->left, rc->top); + start = get_pixel_ptr_32(dib, rc->left, rc->top); for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4) for(x = rc->left, ptr = start; x < rc->right; x++) do_rop_32(ptr++, and, xor); } } +static void solid_rects_16(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor) +{ + WORD *ptr, *start; + int x, y, i; + + for(i = 0; i < num; i++, rc++) + { + start = get_pixel_ptr_16(dib, rc->left, rc->top); + for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2) + for(x = rc->left, ptr = start; x < rc->right; x++) + do_rop_16(ptr++, and, xor); + } +} + static void solid_rects_null(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor) { return; @@ -120,6 +144,52 @@ static void pattern_rects_32(const dib_info *dib, int num, const RECT *rc, const } } +static void pattern_rects_16(const dib_info *dib, int num, const RECT *rc, const POINT *origin, + const dib_info *brush, void *and_bits, void *xor_bits) +{ + WORD *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr; + int x, y, i; + POINT offset; + + for(i = 0; i < num; i++, rc++) + { + offset = calc_brush_offset(rc, brush, origin); + + start = get_pixel_ptr_16(dib, rc->left, rc->top); + start_and = (WORD*)and_bits + offset.y * brush->stride / 2; + start_xor = (WORD*)xor_bits + offset.y * brush->stride / 2; + + for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2) + { + and_ptr = start_and + offset.x; + xor_ptr = start_xor + offset.x; + + for(x = rc->left, ptr = start; x < rc->right; x++) + { + do_rop_16(ptr++, *and_ptr++, *xor_ptr++); + if(and_ptr == start_and + brush->width) + { + and_ptr = start_and; + xor_ptr = start_xor; + } + } + + offset.y++; + if(offset.y == brush->height) + { + start_and = and_bits; + start_xor = xor_bits; + offset.y = 0; + } + else + { + start_and += brush->stride / 2; + start_xor += brush->stride / 2; + } + } + } +} + static void pattern_rects_null(const dib_info *dib, int num, const RECT *rc, const POINT *origin, const dib_info *brush, void *and_bits, void *xor_bits) { @@ -156,6 +226,12 @@ static DWORD colorref_to_pixel_masks(const dib_info *dib, COLORREF colour) put_field(b, dib->blue_shift, dib->blue_len); } +static DWORD colorref_to_pixel_555(const dib_info *dib, COLORREF color) +{ + return ( ((color >> 19) & 0x1f) | ((color >> 6) & 0x03e0) | ((color << 7) & 0x7c00) ); +} + + static DWORD colorref_to_pixel_null(const dib_info *dib, COLORREF color) { return 0; @@ -175,6 +251,20 @@ const primitive_funcs funcs_32 = colorref_to_pixel_masks }; +const primitive_funcs funcs_555 = +{ + solid_rects_16, + pattern_rects_16, + colorref_to_pixel_555 +}; + +const primitive_funcs funcs_16 = +{ + solid_rects_16, + pattern_rects_16, + colorref_to_pixel_masks +}; + const primitive_funcs funcs_null = { solid_rects_null, diff --git a/dlls/gdi32/tests/dib.c b/dlls/gdi32/tests/dib.c index 6300398..e2fd0ef 100644 --- a/dlls/gdi32/tests/dib.c +++ b/dlls/gdi32/tests/dib.c @@ -99,6 +99,31 @@ static const char *sha1_graphics_a8r8g8b8[] = NULL }; +static const char *sha1_graphics_r5g5b5[] = +{ + "2a2ab8b3c019e70b788ade028b0e9e53ffc529ae", + "847005cf7371f511bcc837251cde07b1796f6113", + "a8f75743a930843ec14d516cd048b6e0468e5d89", + "d094f51ce9b9daa9c1d9594ea88be2a2db651459", + "cf3928e240c9149788e1635b115a4e5baea0dd8f", + "a9034a905daa91757b4f63345c0e40638cd53ca8", + "15ee915d989e49bb9bab5b834d8f355bd067cd8f", + "99474fecf11df7b7035c35be6b8b697be9889418", + "cbc2898717f97ebb07c0c7cc04abde936dc5b584", + "29c896b591fdf4ddd23e5c0da1818c37e4686d94", + "4b5b275d33c1ebfe5bdc61df2ad125e865b800fa", + "92df731fa1f89550d9d4f7ea36c13f2e57c4b02a", + "420e39ff3bdd04c4b6cc2c98e99cb7993c7a0de5", + "1fabf0fdd046857b1974e31c1c1764fa9d1a762f", + "449092689226a1172b6086ba1181d6b6d6499f26", + "5c636ffadec10fbe440b552fe6436f3dbc607dcf", + "4aac89fc18c128eddb69eea658272af53138a1cb", + "3a50ce21b3563a604b4fc9f247a30f5a981f1ba6", + "d7d97e28ed316f6596c737eb83baa5948d86b673", + "ecc2991277d7314f55b00e0f284ae3703aeef81e", + NULL +}; + static inline DWORD get_stride(BITMAPINFO *bmi) { return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3; @@ -623,6 +648,7 @@ static void test_simple_graphics(void) /* r5g5b5 */ + trace("555\n"); bmi->bmiHeader.biBitCount = 16; bmi->bmiHeader.biCompression = BI_RGB; @@ -635,6 +661,12 @@ static void test_simple_graphics(void) todo_wine ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression); + orig_bm = SelectObject(mem_dc, dib); + + sha1 = sha1_graphics_r5g5b5; + draw_graphics(mem_dc, bmi, bits, &sha1); + + SelectObject(mem_dc, orig_bm); DeleteObject(dib); DeleteDC(mem_dc);

1 0

Huw Davies : gdi32/tests: Make the 32 bpp brush tests sensitive to a nibble swap in the 4 bpp case.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: 68d07efabc71c35e91a77c234953df7657206067 URL: http://source.winehq.org/git/wine.git/?a=commit;h=68d07efabc71c35e91a77c234… Author: Huw Davies <huw(a)codeweavers.com> Date: Fri May 27 13:02:31 2011 +0100 gdi32/tests: Make the 32 bpp brush tests sensitive to a nibble swap in the 4 bpp case. --- dlls/gdi32/tests/dib.c | 5 +++-- 1 files changed, 3 insertions(+), 2 deletions(-) diff --git a/dlls/gdi32/tests/dib.c b/dlls/gdi32/tests/dib.c index 915aec6..6300398 100644 --- a/dlls/gdi32/tests/dib.c +++ b/dlls/gdi32/tests/dib.c @@ -91,8 +91,8 @@ static const char *sha1_graphics_a8r8g8b8[] = "6c530622a025d872a642e8f950867884d7b136cb", "7c07d91b8f68fb31821701b3dcb96de018bf0c66", "b2261353decda2712b83538ab434a49ce21f3172", - "a8b59f25984b066fc6b91cae6bf983a78028ba7f", - "3d95adb85b9673a932ac847a4b5451fa59885f74", + "ef654fedcb494dae79559f4db8b691ae2d522a3f", + "a694872f38e66a7ff471440c3e6a9310ef78328a", "e2a8eef4aeda3a0f6c950075acba38f1f9e0814d", "8b66f14d51ecdeea12bc993302bb9b7d3ec085a1", "7da9dd3d40d44d92deb9883fb7110443c2d5769a", @@ -451,6 +451,7 @@ static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits, const char ***sh memset(brush_bits, 0, 16 * 16 * sizeof(DWORD)); brush_bits[2] = 0xff; brush_bits[6] = 0xff; + brush_bits[14] = 0xff; brush_bits[65] = 0xff; brush_bits[69] = 0xff;

1 0

Alexandre Julliard : msvcp90: Add an msvcp-specific size_t to avoid casts in traces.
by Alexandre Julliard 27 May '11

27 May '11

Module: wine Branch: master Commit: cfad9c3d54f6f299cde85df9dbb0bbc34a673bab URL: http://source.winehq.org/git/wine.git/?a=commit;h=cfad9c3d54f6f299cde85df9d… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Fri May 27 14:56:18 2011 +0200 msvcp90: Add an msvcp-specific size_t to avoid casts in traces. --- dlls/msvcp90/ios.c | 18 ++-- dlls/msvcp90/memory.c | 26 +++--- dlls/msvcp90/msvcp90.h | 19 ++-- dlls/msvcp90/msvcp90_main.c | 2 +- dlls/msvcp90/string.c | 244 +++++++++++++++++++++---------------------- 5 files changed, 153 insertions(+), 156 deletions(-) Diff: http://source.winehq.org/git/wine.git/?a=commitdiff;h=cfad9c3d54f6f299cde85…

1 0

← Newer
1
...
5
6
7
8
9
10
11
...
95
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-commits May 2011