Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-07 15:10:53 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/rostests/winetests/windowscodecs/palette.c
Amine Khaldi 5d69f70bd6 [WINDOWSCODECS_WINETEST] 
* Sync with Wine 1.5.26.

svn path=/trunk/; revision=59072
2013-05-23 16:40:21 +00:00

558 lines
20 KiB
C
Raw Blame History

/*
* Copyright 2009 Vincent Povirk for CodeWeavers
* Copyright 2012 Dmitry Timoshkov
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdarg.h>
#include <assert.h>
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#define COBJMACROS
#include <windef.h>
#include <winbase.h>
#include <objbase.h>
#include <wincodec.h>
#include <wine/test.h>
static void test_custom_palette(void)
{
IWICImagingFactory *factory;
IWICPalette *palette, *palette2;
HRESULT hr;
WICBitmapPaletteType type=0xffffffff;
UINT count=1;
const WICColor initcolors[4]={0xff000000,0xff0000ff,0xffffff00,0xffffffff};
WICColor colors[4];
BOOL boolresult;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return;
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICPalette_GetType(palette, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
hr = IWICPalette_GetColorCount(palette, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
hr = IWICPalette_GetColors(palette, 0, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
hr = IWICPalette_GetColors(palette, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
memcpy(colors, initcolors, sizeof(initcolors));
hr = IWICPalette_InitializeCustom(palette, colors, 4);
ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
hr = IWICPalette_GetType(palette, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
hr = IWICPalette_GetColorCount(palette, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
memset(colors, 0, sizeof(colors));
count = 0;
hr = IWICPalette_GetColors(palette, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
ok(!memcmp(colors, initcolors, sizeof(colors)), "got unexpected palette data\n");
memset(colors, 0, sizeof(colors));
count = 0;
hr = IWICPalette_GetColors(palette, 2, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 2, "expected 2, got %u\n", count);
ok(!memcmp(colors, initcolors, sizeof(WICColor)*2), "got unexpected palette data\n");
count = 0;
hr = IWICPalette_GetColors(palette, 6, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
hr = IWICPalette_HasAlpha(palette, &boolresult);
ok(SUCCEEDED(hr), "HasAlpha failed, hr=%x\n", hr);
ok(!boolresult, "expected FALSE, got TRUE\n");
hr = IWICPalette_IsBlackWhite(palette, &boolresult);
ok(SUCCEEDED(hr), "IsBlackWhite failed, hr=%x\n", hr);
ok(!boolresult, "expected FALSE, got TRUE\n");
hr = IWICPalette_IsGrayscale(palette, &boolresult);
ok(SUCCEEDED(hr), "IsGrayscale failed, hr=%x\n", hr);
ok(!boolresult, "expected FALSE, got TRUE\n");
hr = IWICImagingFactory_CreatePalette(factory, &palette2);
ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
hr = IWICPalette_InitializeFromPalette(palette2, palette);
ok(SUCCEEDED(hr), "InitializeFromPalette failed, hr=%x\n", hr);
type = 0xdeadbeef;
hr = IWICPalette_GetType(palette2, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette2, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
memset(colors, 0, sizeof(colors));
count = 0xdeadbeef;
hr = IWICPalette_GetColors(palette2, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
ok(!memcmp(colors, initcolors, sizeof(colors)), "got unexpected palette data\n");
/* try a palette with some alpha in it */
colors[2] = 0x80ffffff;
hr = IWICPalette_InitializeCustom(palette, colors, 4);
ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
hr = IWICPalette_HasAlpha(palette, &boolresult);
ok(SUCCEEDED(hr), "HasAlpha failed, hr=%x\n", hr);
ok(boolresult, "expected TRUE, got FALSE\n");
/* setting to a 0-color palette is acceptable */
hr = IWICPalette_InitializeCustom(palette, NULL, 0);
ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
type = 0xdeadbeef;
hr = IWICPalette_GetType(palette, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
count = 0xdeadbeef;
hr = IWICPalette_GetColors(palette, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
hr = IWICPalette_InitializeFromPalette(palette2, palette);
ok(SUCCEEDED(hr), "InitializeFromPalette failed, hr=%x\n", hr);
type = 0xdeadbeef;
hr = IWICPalette_GetType(palette2, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette2, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
memset(colors, 0, sizeof(colors));
count = 0xdeadbeef;
hr = IWICPalette_GetColors(palette2, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
/* IWICPalette is paranoid about NULL pointers */
hr = IWICPalette_GetType(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_GetColorCount(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_InitializeCustom(palette, NULL, 4);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_GetColors(palette, 4, NULL, &count);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_GetColors(palette, 4, colors, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_HasAlpha(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_IsBlackWhite(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_IsGrayscale(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_InitializeFromPalette(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
IWICPalette_Release(palette2);
IWICPalette_Release(palette);
}
IWICImagingFactory_Release(factory);
}
static void generate_gray16_palette(DWORD *entries, UINT count)
{
UINT i;
assert(count == 16);
for (i = 0; i < 16; i++)
{
entries[i] = 0xff000000;
entries[i] |= (i << 20) | (i << 16) | (i << 12) | (i << 8) | (i << 4) | i;
}
}
static void generate_gray256_palette(DWORD *entries, UINT count)
{
UINT i;
assert(count == 256);
for (i = 0; i < 256; i++)
{
entries[i] = 0xff000000;
entries[i] |= (i << 16) | (i << 8) | i;
}
}
static void generate_halftone8_palette(DWORD *entries, UINT count, BOOL add_transparent)
{
UINT i;
if (add_transparent)
ok(count == 17, "expected 17, got %u\n", count);
else
ok(count == 16, "expected 16, got %u\n", count);
for (i = 0; i < 8; i++)
{
entries[i] = 0xff000000;
if (i & 1) entries[i] |= 0xff;
if (i & 2) entries[i] |= 0xff00;
if (i & 4) entries[i] |= 0xff0000;
}
for (i = 8; i < 16; i++)
{
static const DWORD halftone[8] = { 0xc0c0c0, 0x808080, 0x800000, 0x008000,
0x000080, 0x808000, 0x800080, 0x008080 };
entries[i] = 0xff000000;
entries[i] |= halftone[i-8];
}
if (add_transparent)
entries[i] = 0;
}
static void generate_halftone27_palette(DWORD *entries, UINT count, BOOL add_transparent)
{
static const BYTE halftone_values[4] = { 0x00,0x80,0xff };
UINT i;
if (add_transparent)
ok(count == 29, "expected 29, got %u\n", count);
else
ok(count == 28, "expected 28, got %u\n", count);
for (i = 0; i < 27; i++)
{
entries[i] = 0xff000000;
entries[i] |= halftone_values[i%3];
entries[i] |= halftone_values[(i/3)%3] << 8;
entries[i] |= halftone_values[(i/9)%3] << 16;
}
entries[i++] = 0xffc0c0c0;
if (add_transparent)
entries[i] = 0;
}
static void generate_halftone64_palette(DWORD *entries, UINT count, BOOL add_transparent)
{
static const BYTE halftone_values[4] = { 0x00,0x55,0xaa,0xff };
UINT i;
if (add_transparent)
ok(count == 73, "expected 73, got %u\n", count);
else
ok(count == 72, "expected 72, got %u\n", count);
for (i = 0; i < 64; i++)
{
entries[i] = 0xff000000;
entries[i] |= halftone_values[i%4];
entries[i] |= halftone_values[(i/4)%4] << 8;
entries[i] |= halftone_values[(i/16)%4] << 16;
}
for (i = 64; i < 72; i++)
{
static const DWORD halftone[8] = { 0xc0c0c0, 0x808080, 0x800000, 0x008000,
0x000080, 0x808000, 0x800080, 0x008080 };
entries[i] = 0xff000000;
entries[i] |= halftone[i-64];
}
if (add_transparent)
entries[i] = 0;
}
static void generate_halftone125_palette(DWORD *entries, UINT count, BOOL add_transparent)
{
static const BYTE halftone_values[5] = { 0x00, 0x40, 0x80, 0xbf, 0xff };
UINT i;
if (add_transparent)
ok(count == 127, "expected 127, got %u\n", count);
else
ok(count == 126, "expected 126, got %u\n", count);
for (i = 0; i < 125; i++)
{
entries[i] = 0xff000000;
entries[i] |= halftone_values[i%5];
entries[i] |= halftone_values[(i/5)%5] << 8;
entries[i] |= halftone_values[(i/25)%5] << 16;
}
entries[i++] = 0xffc0c0c0;
if (add_transparent)
entries[i] = 0;
}
static void generate_halftone216_palette(DWORD *entries, UINT count, BOOL add_transparent)
{
static const BYTE halftone_values[6] = { 0x00,0x33,0x66,0x99,0xcc,0xff };
UINT i;
if (add_transparent)
ok(count == 225, "expected 225, got %u\n", count);
else
ok(count == 224, "expected 224, got %u\n", count);
for (i = 0; i < 216; i++)
{
entries[i] = 0xff000000;
entries[i] |= halftone_values[i%6];
entries[i] |= halftone_values[(i/6)%6] << 8;
entries[i] |= halftone_values[(i/36)%6] << 16;
}
for (i = 216; i < 224; i++)
{
static const DWORD halftone[8] = { 0xc0c0c0, 0x808080, 0x800000, 0x008000,
0x000080, 0x808000, 0x800080, 0x008080 };
entries[i] = 0xff000000;
entries[i] |= halftone[i-216];
}
if (add_transparent)
entries[i] = 0;
}
static void generate_halftone252_palette(DWORD *entries, UINT count, BOOL add_transparent)
{
static const BYTE halftone_values_rb[6] = { 0x00,0x33,0x66,0x99,0xcc,0xff };
static const BYTE halftone_values_g[7] = { 0x00,0x2b,0x55,0x80,0xaa,0xd5,0xff };
UINT i;
if (add_transparent)
ok(count == 253, "expected 253, got %u\n", count);
else
ok(count == 252, "expected 252, got %u\n", count);
for (i = 0; i < 252; i++)
{
entries[i] = 0xff000000;
entries[i] |= halftone_values_rb[i%6];
entries[i] |= halftone_values_g[(i/6)%7] << 8;
entries[i] |= halftone_values_rb[(i/42)%6] << 16;
}
if (add_transparent)
entries[i] = 0;
}
static void generate_halftone256_palette(DWORD *entries, UINT count, BOOL add_transparent)
{
static const BYTE halftone_values_b[4] = { 0x00,0x55,0xaa,0xff };
static const BYTE halftone_values_gr[8] = { 0x00,0x24,0x49,0x6d,0x92,0xb6,0xdb,0xff };
UINT i;
assert(count == 256);
for (i = 0; i < 256; i++)
{
entries[i] = 0xff000000;
entries[i] |= halftone_values_b[i%4];
entries[i] |= halftone_values_gr[(i/4)%8] << 8;
entries[i] |= halftone_values_gr[(i/32)%8] << 16;
}
if (add_transparent)
entries[255] = 0;
}
static void test_predefined_palette(void)
{
static struct test_data
{
WICBitmapPaletteType type;
BOOL is_bw, is_gray;
UINT count;
WICColor color[256];
BOOL add_transparent;
} td[] =
{
{ WICBitmapPaletteTypeFixedBW, 1, 1, 2, { 0xff000000, 0xffffffff } },
{ WICBitmapPaletteTypeFixedBW, 1, 1, 2, { 0xff000000, 0xffffffff }, 1 },
{ WICBitmapPaletteTypeFixedGray4, 0, 1, 4,
{ 0xff000000, 0xff555555, 0xffaaaaaa, 0xffffffff } },
{ WICBitmapPaletteTypeFixedGray4, 0, 1, 4,
{ 0xff000000, 0xff555555, 0xffaaaaaa, 0xffffffff }, 1 },
{ WICBitmapPaletteTypeFixedGray16, 0, 1, 16, { 0 } },
{ WICBitmapPaletteTypeFixedGray16, 0, 1, 16, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedGray256, 0, 1, 256, { 0 } },
{ WICBitmapPaletteTypeFixedGray256, 0, 1, 256, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone8, 0, 0, 16, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone8, 0, 0, 17, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone27, 0, 0, 28, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone27, 0, 0, 29, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone64, 0, 0, 72, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone64, 0, 0, 73, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone125, 0, 0, 126, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone125, 0, 0, 127, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone216, 0, 0, 224, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone216, 0, 0, 225, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone252, 0, 0, 252, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone252, 0, 0, 253, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone256, 0, 0, 256, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone256, 0, 0, 256, { 0 }, 1 }
};
IWICImagingFactory *factory;
IWICPalette *palette;
HRESULT hr;
WICBitmapPaletteType type;
UINT count, i, ret;
BOOL bret;
WICColor color[256];
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void **)&factory);
ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(hr == S_OK, "CreatePalette error %#x\n", hr);
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeCustom, FALSE);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeMedianCut, FALSE);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
hr = IWICPalette_InitializePredefined(palette, 0x0f, FALSE);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
IWICPalette_Release(palette);
for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
{
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(hr == S_OK, "%u: CreatePalette error %#x\n", i, hr);
hr = IWICPalette_InitializePredefined(palette, td[i].type, td[i].add_transparent);
ok(hr == S_OK, "%u: InitializePredefined error %#x\n", i, hr);
bret = -1;
hr = IWICPalette_IsBlackWhite(palette, &bret);
ok(hr == S_OK, "%u: IsBlackWhite error %#x\n", i, hr);
ok(bret == td[i].is_bw ||
broken(td[i].type == WICBitmapPaletteTypeFixedBW && bret != td[i].is_bw), /* XP */
"%u: expected %d, got %d\n",i, td[i].is_bw, bret);
bret = -1;
hr = IWICPalette_IsGrayscale(palette, &bret);
ok(hr == S_OK, "%u: IsGrayscale error %#x\n", i, hr);
ok(bret == td[i].is_gray, "%u: expected %d, got %d\n", i, td[i].is_gray, bret);
type = -1;
hr = IWICPalette_GetType(palette, &type);
ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
ok(type == td[i].type, "%u: expected %#x, got %#x\n", i, td[i].type, type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette, &count);
ok(hr == S_OK, "%u: GetColorCount error %#x\n", i, hr);
ok(count == td[i].count, "%u: expected %u, got %u\n", i, td[i].count, count);
hr = IWICPalette_GetColors(palette, count, color, &ret);
ok(hr == S_OK, "%u: GetColors error %#x\n", i, hr);
ok(ret == count, "%u: expected %u, got %u\n", i, count, ret);
if (ret == td[i].count)
{
UINT j;
if (td[i].type == WICBitmapPaletteTypeFixedGray16)
generate_gray16_palette(td[i].color, td[i].count);
else if (td[i].type == WICBitmapPaletteTypeFixedGray256)
generate_gray256_palette(td[i].color, td[i].count);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone8)
generate_halftone8_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone27)
generate_halftone27_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone64)
generate_halftone64_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone125)
generate_halftone125_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone216)
generate_halftone216_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone252)
generate_halftone252_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone256)
generate_halftone256_palette(td[i].color, td[i].count, td[i].add_transparent);
for (j = 0; j < count; j++)
{
ok(color[j] == td[i].color[j], "%u:[%u]: expected %#x, got %#x\n",
i, j, td[i].color[j], color[j]);
}
}
IWICPalette_Release(palette);
}
IWICImagingFactory_Release(factory);
}
START_TEST(palette)
{
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
test_custom_palette();
test_predefined_palette();
CoUninitialize();
}
Reference in a new issue View git blame Copy permalink