mirror of
https://github.com/reactos/reactos.git
synced 2025-04-05 05:01:03 +00:00
[WINDOWSCODECS_WINETEST]
* Import from Wine 1.5.19. svn path=/trunk/; revision=57900
This commit is contained in:
Amine Khaldi
parent
d4129a2e07
commit
0851cf3cdb
14 changed files with 7116 additions and 0 deletions
|
|
@ -87,6 +87,7 @@ add_subdirectory(userenv)
|
|||
add_subdirectory(usp10)
|
||||
add_subdirectory(uxtheme)
|
||||
add_subdirectory(version)
|
||||
add_subdirectory(windowscodecs)
|
||||
add_subdirectory(winhttp)
|
||||
add_subdirectory(wininet)
|
||||
add_subdirectory(winmm)
|
||||
|
|
|
|||
22
rostests/winetests/windowscodecs/CMakeLists.txt
Normal file
22
rostests/winetests/windowscodecs/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
|
||||
add_definitions(-D__ROS_LONG64__)
|
||||
|
||||
list(APPEND SOURCE
|
||||
bitmap.c
|
||||
bmpformat.c
|
||||
converter.c
|
||||
gifformat.c
|
||||
icoformat.c
|
||||
info.c
|
||||
metadata.c
|
||||
palette.c
|
||||
pngformat.c
|
||||
stream.c
|
||||
testlist.c
|
||||
tiffformat.c)
|
||||
|
||||
add_executable(windowscodecs_winetest ${SOURCE})
|
||||
target_link_libraries(windowscodecs_winetest wine)
|
||||
set_module_type(windowscodecs_winetest win32cui)
|
||||
add_importlibs(windowscodecs_winetest windowscodecs ole32 msvcrt kernel32 ntdll)
|
||||
add_cd_file(TARGET version_winetest DESTINATION reactos/bin FOR all)
|
||||
437
rostests/winetests/windowscodecs/bitmap.c
Normal file
437
rostests/winetests/windowscodecs/bitmap.c
Normal file
|
|
@ -0,0 +1,437 @@
|
|||
/*
|
||||
* Copyright 2012 Vincent Povirk for CodeWeavers
|
||||
*
|
||||
* 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 <math.h>
|
||||
|
||||
#define COBJMACROS
|
||||
|
||||
#include "windef.h"
|
||||
#include "objbase.h"
|
||||
#include "wincodec.h"
|
||||
#include "wine/test.h"
|
||||
|
||||
static IWICImagingFactory *factory;
|
||||
|
||||
static void test_createbitmap(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmap *bitmap;
|
||||
IWICPalette *palette;
|
||||
IWICBitmapLock *lock, *lock2;
|
||||
WICBitmapPaletteType palettetype;
|
||||
int i;
|
||||
WICRect rc;
|
||||
const BYTE bitmap_data[27] = {
|
||||
128,128,255, 128,128,128, 128,255,128,
|
||||
128,128,128, 128,128,128, 255,255,255,
|
||||
255,128,128, 255,255,255, 255,255,255};
|
||||
BYTE returned_data[27] = {0};
|
||||
BYTE *lock_buffer=NULL, *base_lock_buffer=NULL;
|
||||
UINT lock_buffer_size=0;
|
||||
UINT lock_buffer_stride=0;
|
||||
WICPixelFormatGUID pixelformat = {0};
|
||||
UINT width=0, height=0;
|
||||
double dpix=10.0, dpiy=10.0;
|
||||
int can_lock_null = 1;
|
||||
|
||||
hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
|
||||
WICBitmapCacheOnLoad, &bitmap);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
|
||||
|
||||
if (FAILED(hr))
|
||||
return;
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
|
||||
|
||||
/* Palette is unavailable until explicitly set */
|
||||
hr = IWICBitmap_CopyPalette(bitmap, palette);
|
||||
ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
|
||||
ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmap_SetPalette(bitmap, palette);
|
||||
ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE);
|
||||
ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmap_CopyPalette(bitmap, palette);
|
||||
ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetType(palette, &palettetype);
|
||||
ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
|
||||
ok(palettetype == WICBitmapPaletteTypeFixedGray256,
|
||||
"expected WICBitmapPaletteTypeFixedGray256, got %x\n", palettetype);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
|
||||
/* pixel data is initially zeroed */
|
||||
hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
|
||||
ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
|
||||
|
||||
for (i=0; i<27; i++)
|
||||
ok(returned_data[i] == 0, "returned_data[%i] == %i\n", i, returned_data[i]);
|
||||
|
||||
/* Invalid lock rects */
|
||||
rc.X = rc.Y = 0;
|
||||
rc.Width = 4;
|
||||
rc.Height = 3;
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
|
||||
ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
|
||||
|
||||
rc.Width = 3;
|
||||
rc.Height = 4;
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
|
||||
ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
|
||||
|
||||
rc.Height = 3;
|
||||
rc.X = 4;
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
|
||||
ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
|
||||
|
||||
rc.X = 0;
|
||||
rc.Y = 4;
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
|
||||
ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
|
||||
|
||||
/* NULL lock rect */
|
||||
hr = IWICBitmap_Lock(bitmap, NULL, WICBitmapLockRead, &lock);
|
||||
ok(hr == S_OK || broken(hr == E_INVALIDARG) /* winxp */, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
/* entire bitmap is locked */
|
||||
hr = IWICBitmapLock_GetSize(lock, &width, &height);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
|
||||
ok(width == 3, "got %d, expected 3\n", width);
|
||||
ok(height == 3, "got %d, expected 3\n", height);
|
||||
|
||||
IWICBitmapLock_Release(lock);
|
||||
}
|
||||
else
|
||||
can_lock_null = 0;
|
||||
|
||||
/* lock with a valid rect */
|
||||
rc.Y = 0;
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
|
||||
ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
|
||||
/* stride is divisible by 4 */
|
||||
ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
|
||||
|
||||
hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
|
||||
/* buffer size does not include padding from the last row */
|
||||
ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
|
||||
ok(lock_buffer != NULL, "got NULL data pointer\n");
|
||||
base_lock_buffer = lock_buffer;
|
||||
|
||||
hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
|
||||
|
||||
hr = IWICBitmapLock_GetSize(lock, &width, &height);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
|
||||
ok(width == 3, "got %d, expected 3\n", width);
|
||||
ok(height == 3, "got %d, expected 3\n", height);
|
||||
|
||||
/* We can have multiple simultaneous read locks */
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
|
||||
ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapLock_GetDataPointer(lock2, &lock_buffer_size, &lock_buffer);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
|
||||
ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
|
||||
ok(lock_buffer == base_lock_buffer, "got %p, expected %p\n", lock_buffer, base_lock_buffer);
|
||||
|
||||
IWICBitmapLock_Release(lock2);
|
||||
}
|
||||
|
||||
if (can_lock_null) /* this hangs on xp/vista */
|
||||
{
|
||||
/* But not a read and a write lock */
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
|
||||
ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
}
|
||||
|
||||
/* But we don't need a write lock to write */
|
||||
if (base_lock_buffer)
|
||||
{
|
||||
for (i=0; i<3; i++)
|
||||
memcpy(base_lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
|
||||
}
|
||||
|
||||
IWICBitmapLock_Release(lock);
|
||||
}
|
||||
|
||||
/* test that the data we wrote is returned by CopyPixels */
|
||||
hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
|
||||
ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
|
||||
|
||||
for (i=0; i<27; i++)
|
||||
ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
|
||||
|
||||
/* try a valid partial rect, and write mode */
|
||||
rc.X = 2;
|
||||
rc.Y = 0;
|
||||
rc.Width = 1;
|
||||
rc.Height = 2;
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
|
||||
ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
if (can_lock_null) /* this hangs on xp/vista */
|
||||
{
|
||||
/* Can't lock again while locked for writing */
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
|
||||
ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
|
||||
ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
}
|
||||
|
||||
hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
|
||||
ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
|
||||
|
||||
hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
|
||||
ok(lock_buffer_size == 15, "got %i, expected 15\n", lock_buffer_size);
|
||||
ok(lock_buffer == base_lock_buffer+6, "got %p, expected %p+6\n", lock_buffer, base_lock_buffer);
|
||||
|
||||
hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
|
||||
|
||||
hr = IWICBitmapLock_GetSize(lock, &width, &height);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
|
||||
ok(width == 1, "got %d, expected 1\n", width);
|
||||
ok(height == 2, "got %d, expected 2\n", height);
|
||||
|
||||
IWICBitmapLock_Release(lock);
|
||||
}
|
||||
|
||||
hr = IWICBitmap_GetPixelFormat(bitmap, &pixelformat);
|
||||
ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
|
||||
|
||||
hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
|
||||
ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
|
||||
ok(dpix == 0.0, "got %f, expected 0.0\n", dpix);
|
||||
ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy);
|
||||
|
||||
hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
|
||||
ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
|
||||
ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
|
||||
ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
|
||||
ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
|
||||
|
||||
hr = IWICBitmap_GetSize(bitmap, &width, &height);
|
||||
ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
|
||||
ok(width == 3, "got %d, expected 3\n", width);
|
||||
ok(height == 3, "got %d, expected 3\n", height);
|
||||
|
||||
IWICBitmap_Release(bitmap);
|
||||
}
|
||||
|
||||
static void test_createbitmapfromsource(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmap *bitmap, *bitmap2;
|
||||
IWICPalette *palette;
|
||||
IWICBitmapLock *lock;
|
||||
int i;
|
||||
WICRect rc;
|
||||
const BYTE bitmap_data[27] = {
|
||||
128,128,255, 128,128,128, 128,255,128,
|
||||
128,128,128, 128,128,128, 255,255,255,
|
||||
255,128,128, 255,255,255, 255,255,255};
|
||||
BYTE returned_data[27] = {0};
|
||||
BYTE *lock_buffer=NULL;
|
||||
UINT lock_buffer_stride=0;
|
||||
UINT lock_buffer_size=0;
|
||||
WICPixelFormatGUID pixelformat = {0};
|
||||
UINT width=0, height=0;
|
||||
double dpix=10.0, dpiy=10.0;
|
||||
UINT count;
|
||||
WICBitmapPaletteType palette_type;
|
||||
|
||||
hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
|
||||
WICBitmapCacheOnLoad, &bitmap);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
|
||||
|
||||
if (FAILED(hr))
|
||||
return;
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
|
||||
ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmap_SetPalette(bitmap, palette);
|
||||
ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
|
||||
rc.X = rc.Y = 0;
|
||||
rc.Width = 3;
|
||||
rc.Height = 3;
|
||||
hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
|
||||
ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
|
||||
ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
|
||||
|
||||
hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
|
||||
ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
|
||||
ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
|
||||
ok(lock_buffer != NULL, "got NULL data pointer\n");
|
||||
|
||||
for (i=0; i<3; i++)
|
||||
memcpy(lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
|
||||
|
||||
IWICBitmapLock_Release(lock);
|
||||
}
|
||||
|
||||
hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
|
||||
ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
|
||||
WICBitmapCacheOnLoad, &bitmap2);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
|
||||
|
||||
IWICBitmap_Release(bitmap);
|
||||
|
||||
if (FAILED(hr)) return;
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
|
||||
|
||||
/* palette isn't copied for non-indexed formats? */
|
||||
hr = IWICBitmap_CopyPalette(bitmap2, palette);
|
||||
ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
|
||||
hr = IWICBitmap_CopyPixels(bitmap2, NULL, 9, 27, returned_data);
|
||||
ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
|
||||
|
||||
for (i=0; i<27; i++)
|
||||
ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
|
||||
|
||||
hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
|
||||
ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
|
||||
|
||||
hr = IWICBitmap_GetResolution(bitmap2, &dpix, &dpiy);
|
||||
ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
|
||||
ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
|
||||
ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
|
||||
|
||||
hr = IWICBitmap_GetSize(bitmap2, &width, &height);
|
||||
ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
|
||||
ok(width == 3, "got %d, expected 3\n", width);
|
||||
ok(height == 3, "got %d, expected 3\n", height);
|
||||
|
||||
IWICBitmap_Release(bitmap2);
|
||||
|
||||
/* Ensure palette is copied for indexed formats */
|
||||
hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat4bppIndexed,
|
||||
WICBitmapCacheOnLoad, &bitmap);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
|
||||
ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmap_SetPalette(bitmap, palette);
|
||||
ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
|
||||
hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
|
||||
WICBitmapCacheOnLoad, &bitmap2);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
|
||||
|
||||
IWICBitmap_Release(bitmap);
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmap_CopyPalette(bitmap2, palette);
|
||||
ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "IWICPalette_GetColorCount failed hr=%x\n", hr);
|
||||
ok(count == 256, "unexpected count %d\n", count);
|
||||
|
||||
hr = IWICPalette_GetType(palette, &palette_type);
|
||||
ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
|
||||
ok(palette_type == WICBitmapPaletteTypeFixedGray256, "unexpected palette type %d\n", palette_type);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
|
||||
hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
|
||||
ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
|
||||
|
||||
hr = IWICBitmap_GetSize(bitmap2, &width, &height);
|
||||
ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
|
||||
ok(width == 3, "got %d, expected 3\n", width);
|
||||
ok(height == 3, "got %d, expected 3\n", height);
|
||||
|
||||
IWICBitmap_Release(bitmap2);
|
||||
}
|
||||
|
||||
START_TEST(bitmap)
|
||||
{
|
||||
HRESULT hr;
|
||||
|
||||
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICImagingFactory, (void**)&factory);
|
||||
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
|
||||
|
||||
test_createbitmap();
|
||||
test_createbitmapfromsource();
|
||||
|
||||
IWICImagingFactory_Release(factory);
|
||||
|
||||
CoUninitialize();
|
||||
}
|
||||
1164
rostests/winetests/windowscodecs/bmpformat.c
Normal file
1164
rostests/winetests/windowscodecs/bmpformat.c
Normal file
File diff suppressed because it is too large
Load diff
518
rostests/winetests/windowscodecs/converter.c
Normal file
518
rostests/winetests/windowscodecs/converter.c
Normal file
|
|
@ -0,0 +1,518 @@
|
|||
/*
|
||||
* Copyright 2009 Vincent Povirk
|
||||
*
|
||||
* 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 <math.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define CONST_VTABLE
|
||||
|
||||
#include "windef.h"
|
||||
#include "objbase.h"
|
||||
#include "wincodec.h"
|
||||
#include "wine/test.h"
|
||||
|
||||
typedef struct bitmap_data {
|
||||
const WICPixelFormatGUID *format;
|
||||
UINT bpp;
|
||||
const BYTE *bits;
|
||||
UINT width;
|
||||
UINT height;
|
||||
double xres;
|
||||
double yres;
|
||||
} bitmap_data;
|
||||
|
||||
typedef struct BitmapTestSrc {
|
||||
IWICBitmapSource IWICBitmapSource_iface;
|
||||
LONG ref;
|
||||
const bitmap_data *data;
|
||||
} BitmapTestSrc;
|
||||
|
||||
static inline BitmapTestSrc *impl_from_IWICBitmapSource(IWICBitmapSource *iface)
|
||||
{
|
||||
return CONTAINING_RECORD(iface, BitmapTestSrc, IWICBitmapSource_iface);
|
||||
}
|
||||
|
||||
static HRESULT WINAPI BitmapTestSrc_QueryInterface(IWICBitmapSource *iface, REFIID iid,
|
||||
void **ppv)
|
||||
{
|
||||
if (!ppv) return E_INVALIDARG;
|
||||
|
||||
if (IsEqualIID(&IID_IUnknown, iid) ||
|
||||
IsEqualIID(&IID_IWICBitmapSource, iid))
|
||||
*ppv = iface;
|
||||
else
|
||||
return E_NOINTERFACE;
|
||||
|
||||
IUnknown_AddRef((IUnknown*)*ppv);
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static ULONG WINAPI BitmapTestSrc_AddRef(IWICBitmapSource *iface)
|
||||
{
|
||||
BitmapTestSrc *This = impl_from_IWICBitmapSource(iface);
|
||||
ULONG ref = InterlockedIncrement(&This->ref);
|
||||
return ref;
|
||||
}
|
||||
|
||||
static ULONG WINAPI BitmapTestSrc_Release(IWICBitmapSource *iface)
|
||||
{
|
||||
BitmapTestSrc *This = impl_from_IWICBitmapSource(iface);
|
||||
ULONG ref = InterlockedDecrement(&This->ref);
|
||||
return ref;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI BitmapTestSrc_GetSize(IWICBitmapSource *iface,
|
||||
UINT *puiWidth, UINT *puiHeight)
|
||||
{
|
||||
BitmapTestSrc *This = impl_from_IWICBitmapSource(iface);
|
||||
*puiWidth = This->data->width;
|
||||
*puiHeight = This->data->height;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI BitmapTestSrc_GetPixelFormat(IWICBitmapSource *iface,
|
||||
WICPixelFormatGUID *pPixelFormat)
|
||||
{
|
||||
BitmapTestSrc *This = impl_from_IWICBitmapSource(iface);
|
||||
memcpy(pPixelFormat, This->data->format, sizeof(GUID));
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI BitmapTestSrc_GetResolution(IWICBitmapSource *iface,
|
||||
double *pDpiX, double *pDpiY)
|
||||
{
|
||||
BitmapTestSrc *This = impl_from_IWICBitmapSource(iface);
|
||||
*pDpiX = This->data->xres;
|
||||
*pDpiY = This->data->yres;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI BitmapTestSrc_CopyPalette(IWICBitmapSource *iface,
|
||||
IWICPalette *pIPalette)
|
||||
{
|
||||
return E_NOTIMPL;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI BitmapTestSrc_CopyPixels(IWICBitmapSource *iface,
|
||||
const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
|
||||
{
|
||||
BitmapTestSrc *This = impl_from_IWICBitmapSource(iface);
|
||||
UINT bytesperrow;
|
||||
UINT srcstride;
|
||||
UINT row_offset;
|
||||
WICRect rc;
|
||||
|
||||
if (!prc)
|
||||
{
|
||||
rc.X = 0;
|
||||
rc.Y = 0;
|
||||
rc.Width = This->data->width;
|
||||
rc.Height = This->data->height;
|
||||
prc = &rc;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (prc->X < 0 || prc->Y < 0 || prc->X+prc->Width > This->data->width || prc->Y+prc->Height > This->data->height)
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
|
||||
bytesperrow = ((This->data->bpp * prc->Width)+7)/8;
|
||||
srcstride = ((This->data->bpp * This->data->width)+7)/8;
|
||||
|
||||
if (cbStride < bytesperrow)
|
||||
return E_INVALIDARG;
|
||||
|
||||
if ((cbStride * prc->Height) > cbBufferSize)
|
||||
return E_INVALIDARG;
|
||||
|
||||
row_offset = prc->X * This->data->bpp;
|
||||
|
||||
if (row_offset % 8 == 0)
|
||||
{
|
||||
UINT row;
|
||||
const BYTE *src;
|
||||
BYTE *dst;
|
||||
|
||||
src = This->data->bits + (row_offset / 8) + prc->Y * srcstride;
|
||||
dst = pbBuffer;
|
||||
for (row=0; row < prc->Height; row++)
|
||||
{
|
||||
memcpy(dst, src, bytesperrow);
|
||||
src += srcstride;
|
||||
dst += cbStride;
|
||||
}
|
||||
return S_OK;
|
||||
}
|
||||
else
|
||||
{
|
||||
ok(0, "bitmap %p was asked to copy pixels not aligned on a byte boundary\n", iface);
|
||||
return E_FAIL;
|
||||
}
|
||||
}
|
||||
|
||||
static const IWICBitmapSourceVtbl BitmapTestSrc_Vtbl = {
|
||||
BitmapTestSrc_QueryInterface,
|
||||
BitmapTestSrc_AddRef,
|
||||
BitmapTestSrc_Release,
|
||||
BitmapTestSrc_GetSize,
|
||||
BitmapTestSrc_GetPixelFormat,
|
||||
BitmapTestSrc_GetResolution,
|
||||
BitmapTestSrc_CopyPalette,
|
||||
BitmapTestSrc_CopyPixels
|
||||
};
|
||||
|
||||
static void CreateTestBitmap(const bitmap_data *data, BitmapTestSrc **This)
|
||||
{
|
||||
*This = HeapAlloc(GetProcessHeap(), 0, sizeof(**This));
|
||||
|
||||
if (*This)
|
||||
{
|
||||
(*This)->IWICBitmapSource_iface.lpVtbl = &BitmapTestSrc_Vtbl;
|
||||
(*This)->ref = 1;
|
||||
(*This)->data = data;
|
||||
}
|
||||
}
|
||||
|
||||
static void DeleteTestBitmap(BitmapTestSrc *This)
|
||||
{
|
||||
ok(This->IWICBitmapSource_iface.lpVtbl == &BitmapTestSrc_Vtbl, "test bitmap %p deleted with incorrect vtable\n", This);
|
||||
ok(This->ref == 1, "test bitmap %p deleted with %i references instead of 1\n", This, This->ref);
|
||||
HeapFree(GetProcessHeap(), 0, This);
|
||||
}
|
||||
|
||||
static void compare_bitmap_data(const struct bitmap_data *expect, IWICBitmapSource *source, const char *name)
|
||||
{
|
||||
BYTE *converted_bits;
|
||||
UINT width, height;
|
||||
double xres, yres;
|
||||
WICRect prc;
|
||||
UINT stride, buffersize;
|
||||
GUID dst_pixelformat;
|
||||
HRESULT hr;
|
||||
|
||||
hr = IWICBitmapSource_GetSize(source, &width, &height);
|
||||
ok(SUCCEEDED(hr), "GetSize(%s) failed, hr=%x\n", name, hr);
|
||||
ok(width == expect->width, "expecting %u, got %u (%s)\n", expect->width, width, name);
|
||||
ok(height == expect->height, "expecting %u, got %u (%s)\n", expect->height, height, name);
|
||||
|
||||
hr = IWICBitmapSource_GetResolution(source, &xres, &yres);
|
||||
ok(SUCCEEDED(hr), "GetResolution(%s) failed, hr=%x\n", name, hr);
|
||||
ok(fabs(xres - expect->xres) < 0.02, "expecting %0.2f, got %0.2f (%s)\n", expect->xres, xres, name);
|
||||
ok(fabs(yres - expect->yres) < 0.02, "expecting %0.2f, got %0.2f (%s)\n", expect->yres, yres, name);
|
||||
|
||||
hr = IWICBitmapSource_GetPixelFormat(source, &dst_pixelformat);
|
||||
ok(SUCCEEDED(hr), "GetPixelFormat(%s) failed, hr=%x\n", name, hr);
|
||||
ok(IsEqualGUID(&dst_pixelformat, expect->format), "got unexpected pixel format (%s)\n", name);
|
||||
|
||||
prc.X = 0;
|
||||
prc.Y = 0;
|
||||
prc.Width = expect->width;
|
||||
prc.Height = expect->height;
|
||||
|
||||
stride = (expect->bpp * expect->width + 7) / 8;
|
||||
buffersize = stride * expect->height;
|
||||
|
||||
converted_bits = HeapAlloc(GetProcessHeap(), 0, buffersize);
|
||||
hr = IWICBitmapSource_CopyPixels(source, &prc, stride, buffersize, converted_bits);
|
||||
ok(SUCCEEDED(hr), "CopyPixels(%s) failed, hr=%x\n", name, hr);
|
||||
if (IsEqualGUID(expect->format, &GUID_WICPixelFormat32bppBGR))
|
||||
{
|
||||
/* ignore the padding byte when comparing data */
|
||||
UINT i;
|
||||
BOOL equal=TRUE;
|
||||
const DWORD *a=(const DWORD*)expect->bits, *b=(const DWORD*)converted_bits;
|
||||
for (i=0; i<(buffersize/4); i++)
|
||||
if ((a[i]&0xffffff) != (b[i]&0xffffff))
|
||||
{
|
||||
equal = FALSE;
|
||||
break;
|
||||
}
|
||||
ok(equal, "unexpected pixel data (%s)\n", name);
|
||||
}
|
||||
else
|
||||
ok(memcmp(expect->bits, converted_bits, buffersize) == 0, "unexpected pixel data (%s)\n", name);
|
||||
|
||||
/* Test with NULL rectangle - should copy the whole bitmap */
|
||||
hr = IWICBitmapSource_CopyPixels(source, NULL, stride, buffersize, converted_bits);
|
||||
ok(SUCCEEDED(hr), "CopyPixels(%s,rc=NULL) failed, hr=%x\n", name, hr);
|
||||
if (IsEqualGUID(expect->format, &GUID_WICPixelFormat32bppBGR))
|
||||
{
|
||||
/* ignore the padding byte when comparing data */
|
||||
UINT i;
|
||||
BOOL equal=TRUE;
|
||||
const DWORD *a=(const DWORD*)expect->bits, *b=(const DWORD*)converted_bits;
|
||||
for (i=0; i<(buffersize/4); i++)
|
||||
if ((a[i]&0xffffff) != (b[i]&0xffffff))
|
||||
{
|
||||
equal = FALSE;
|
||||
break;
|
||||
}
|
||||
ok(equal, "unexpected pixel data with rc=NULL (%s)\n", name);
|
||||
}
|
||||
else
|
||||
ok(memcmp(expect->bits, converted_bits, buffersize) == 0, "unexpected pixel data with rc=NULL (%s)\n", name);
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, converted_bits);
|
||||
}
|
||||
|
||||
static const BYTE bits_24bppBGR[] = {
|
||||
255,0,0, 0,255,0, 0,0,255, 0,0,0,
|
||||
0,255,255, 255,0,255, 255,255,0, 255,255,255};
|
||||
static const struct bitmap_data testdata_24bppBGR = {
|
||||
&GUID_WICPixelFormat24bppBGR, 24, bits_24bppBGR, 4, 2, 96.0, 96.0};
|
||||
|
||||
static const BYTE bits_32bppBGR[] = {
|
||||
255,0,0,80, 0,255,0,80, 0,0,255,80, 0,0,0,80,
|
||||
0,255,255,80, 255,0,255,80, 255,255,0,80, 255,255,255,80};
|
||||
static const struct bitmap_data testdata_32bppBGR = {
|
||||
&GUID_WICPixelFormat32bppBGR, 32, bits_32bppBGR, 4, 2, 96.0, 96.0};
|
||||
|
||||
static const BYTE bits_32bppBGRA[] = {
|
||||
255,0,0,255, 0,255,0,255, 0,0,255,255, 0,0,0,255,
|
||||
0,255,255,255, 255,0,255,255, 255,255,0,255, 255,255,255,255};
|
||||
static const struct bitmap_data testdata_32bppBGRA = {
|
||||
&GUID_WICPixelFormat32bppBGRA, 32, bits_32bppBGRA, 4, 2, 96.0, 96.0};
|
||||
|
||||
static void test_conversion(const struct bitmap_data *src, const struct bitmap_data *dst, const char *name, BOOL todo)
|
||||
{
|
||||
BitmapTestSrc *src_obj;
|
||||
IWICBitmapSource *dst_bitmap;
|
||||
HRESULT hr;
|
||||
|
||||
CreateTestBitmap(src, &src_obj);
|
||||
|
||||
hr = WICConvertBitmapSource(dst->format, &src_obj->IWICBitmapSource_iface, &dst_bitmap);
|
||||
if (todo)
|
||||
todo_wine ok(SUCCEEDED(hr), "WICConvertBitmapSource(%s) failed, hr=%x\n", name, hr);
|
||||
else
|
||||
ok(SUCCEEDED(hr), "WICConvertBitmapSource(%s) failed, hr=%x\n", name, hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
compare_bitmap_data(dst, dst_bitmap, name);
|
||||
|
||||
IWICBitmapSource_Release(dst_bitmap);
|
||||
}
|
||||
|
||||
DeleteTestBitmap(src_obj);
|
||||
}
|
||||
|
||||
static void test_invalid_conversion(void)
|
||||
{
|
||||
BitmapTestSrc *src_obj;
|
||||
IWICBitmapSource *dst_bitmap;
|
||||
HRESULT hr;
|
||||
|
||||
CreateTestBitmap(&testdata_32bppBGRA, &src_obj);
|
||||
|
||||
/* convert to a non-pixel-format GUID */
|
||||
hr = WICConvertBitmapSource(&GUID_VendorMicrosoft, &src_obj->IWICBitmapSource_iface, &dst_bitmap);
|
||||
ok(hr == WINCODEC_ERR_COMPONENTNOTFOUND, "WICConvertBitmapSource returned %x\n", hr);
|
||||
|
||||
DeleteTestBitmap(src_obj);
|
||||
}
|
||||
|
||||
static void test_default_converter(void)
|
||||
{
|
||||
BitmapTestSrc *src_obj;
|
||||
IWICFormatConverter *converter;
|
||||
BOOL can_convert=1;
|
||||
HRESULT hr;
|
||||
|
||||
CreateTestBitmap(&testdata_32bppBGRA, &src_obj);
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICDefaultFormatConverter, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICFormatConverter, (void**)&converter);
|
||||
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICFormatConverter_CanConvert(converter, &GUID_WICPixelFormat32bppBGRA,
|
||||
&GUID_WICPixelFormat32bppBGR, &can_convert);
|
||||
ok(SUCCEEDED(hr), "CanConvert returned %x\n", hr);
|
||||
ok(can_convert, "expected TRUE, got %i\n", can_convert);
|
||||
|
||||
hr = IWICFormatConverter_Initialize(converter, &src_obj->IWICBitmapSource_iface,
|
||||
&GUID_WICPixelFormat32bppBGR, WICBitmapDitherTypeNone, NULL, 0.0,
|
||||
WICBitmapPaletteTypeCustom);
|
||||
ok(SUCCEEDED(hr), "Initialize returned %x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
compare_bitmap_data(&testdata_32bppBGR, (IWICBitmapSource*)converter, "default converter");
|
||||
|
||||
IWICFormatConverter_Release(converter);
|
||||
}
|
||||
|
||||
DeleteTestBitmap(src_obj);
|
||||
}
|
||||
|
||||
static void test_multi_encoder(const struct bitmap_data **srcs, const CLSID* clsid_encoder,
|
||||
const struct bitmap_data **dsts, const CLSID *clsid_decoder, const char *name)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmapEncoder *encoder;
|
||||
BitmapTestSrc *src_obj;
|
||||
HGLOBAL hglobal;
|
||||
IStream *stream;
|
||||
IWICBitmapFrameEncode *frameencode;
|
||||
IPropertyBag2 *options=NULL;
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICBitmapFrameDecode *framedecode;
|
||||
WICPixelFormatGUID pixelformat;
|
||||
int i;
|
||||
|
||||
hr = CoCreateInstance(clsid_encoder, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICBitmapEncoder, (void**)&encoder);
|
||||
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hglobal = GlobalAlloc(GMEM_MOVEABLE, 0);
|
||||
ok(hglobal != NULL, "GlobalAlloc failed\n");
|
||||
if (hglobal)
|
||||
{
|
||||
hr = CreateStreamOnHGlobal(hglobal, TRUE, &stream);
|
||||
ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
|
||||
}
|
||||
|
||||
if (hglobal && SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
|
||||
ok(SUCCEEDED(hr), "Initialize failed, hr=%x\n", hr);
|
||||
|
||||
i=0;
|
||||
while (SUCCEEDED(hr) && srcs[i])
|
||||
{
|
||||
CreateTestBitmap(srcs[i], &src_obj);
|
||||
|
||||
hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &options);
|
||||
ok(SUCCEEDED(hr), "CreateFrame failed, hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapFrameEncode_Initialize(frameencode, options);
|
||||
ok(SUCCEEDED(hr), "Initialize failed, hr=%x\n", hr);
|
||||
|
||||
memcpy(&pixelformat, srcs[i]->format, sizeof(GUID));
|
||||
hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &pixelformat);
|
||||
ok(SUCCEEDED(hr), "SetPixelFormat failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&pixelformat, srcs[i]->format), "SetPixelFormat changed the format\n");
|
||||
|
||||
hr = IWICBitmapFrameEncode_SetSize(frameencode, srcs[i]->width, srcs[i]->height);
|
||||
ok(SUCCEEDED(hr), "SetSize failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapFrameEncode_WriteSource(frameencode, &src_obj->IWICBitmapSource_iface, NULL);
|
||||
ok(SUCCEEDED(hr), "WriteSource failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapFrameEncode_Commit(frameencode);
|
||||
ok(SUCCEEDED(hr), "Commit failed, hr=%x\n", hr);
|
||||
|
||||
IWICBitmapFrameEncode_Release(frameencode);
|
||||
IPropertyBag2_Release(options);
|
||||
}
|
||||
|
||||
DeleteTestBitmap(src_obj);
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapEncoder_Commit(encoder);
|
||||
ok(SUCCEEDED(hr), "Commit failed, hr=%x\n", hr);
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = CoCreateInstance(clsid_decoder, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICBitmapDecoder, (void**)&decoder);
|
||||
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnDemand);
|
||||
ok(SUCCEEDED(hr), "Initialize failed, hr=%x\n", hr);
|
||||
|
||||
i=0;
|
||||
while (SUCCEEDED(hr) && dsts[i])
|
||||
{
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, i, &framedecode);
|
||||
ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
compare_bitmap_data(dsts[i], (IWICBitmapSource*)framedecode, name);
|
||||
|
||||
IWICBitmapFrameDecode_Release(framedecode);
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
}
|
||||
|
||||
IStream_Release(stream);
|
||||
}
|
||||
|
||||
IWICBitmapEncoder_Release(encoder);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_encoder(const struct bitmap_data *src, const CLSID* clsid_encoder,
|
||||
const struct bitmap_data *dst, const CLSID *clsid_decoder, const char *name)
|
||||
{
|
||||
const struct bitmap_data *srcs[2];
|
||||
const struct bitmap_data *dsts[2];
|
||||
|
||||
srcs[0] = src;
|
||||
srcs[1] = NULL;
|
||||
dsts[0] = dst;
|
||||
dsts[1] = NULL;
|
||||
|
||||
test_multi_encoder(srcs, clsid_encoder, dsts, clsid_decoder, name);
|
||||
}
|
||||
|
||||
static const struct bitmap_data *multiple_frames[3] = {
|
||||
&testdata_24bppBGR,
|
||||
&testdata_24bppBGR,
|
||||
NULL};
|
||||
|
||||
START_TEST(converter)
|
||||
{
|
||||
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||||
|
||||
test_conversion(&testdata_32bppBGRA, &testdata_32bppBGR, "BGRA -> BGR", 0);
|
||||
test_conversion(&testdata_32bppBGR, &testdata_32bppBGRA, "BGR -> BGRA", 0);
|
||||
test_conversion(&testdata_32bppBGRA, &testdata_32bppBGRA, "BGRA -> BGRA", 0);
|
||||
test_invalid_conversion();
|
||||
test_default_converter();
|
||||
|
||||
test_encoder(&testdata_32bppBGR, &CLSID_WICBmpEncoder,
|
||||
&testdata_32bppBGR, &CLSID_WICBmpDecoder, "BMP encoder 32bppBGR");
|
||||
|
||||
test_encoder(&testdata_24bppBGR, &CLSID_WICPngEncoder,
|
||||
&testdata_24bppBGR, &CLSID_WICPngDecoder, "PNG encoder 24bppBGR");
|
||||
|
||||
test_encoder(&testdata_24bppBGR, &CLSID_WICTiffEncoder,
|
||||
&testdata_24bppBGR, &CLSID_WICTiffDecoder, "TIFF encoder 24bppBGR");
|
||||
|
||||
test_multi_encoder(multiple_frames, &CLSID_WICTiffEncoder,
|
||||
multiple_frames, &CLSID_WICTiffDecoder, "TIFF encoder multi-frame");
|
||||
|
||||
CoUninitialize();
|
||||
}
|
||||
334
rostests/winetests/windowscodecs/gifformat.c
Normal file
334
rostests/winetests/windowscodecs/gifformat.c
Normal file
|
|
@ -0,0 +1,334 @@
|
|||
/*
|
||||
* 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 <stdio.h>
|
||||
|
||||
#define COBJMACROS
|
||||
|
||||
#include "windef.h"
|
||||
#include "wincodec.h"
|
||||
#include "wine/test.h"
|
||||
|
||||
static const char gif_global_palette[] = {
|
||||
/* LSD */'G','I','F','8','7','a',0x01,0x00,0x01,0x00,0xa1,0x02,0x00,
|
||||
/* palette */0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
|
||||
/* GCE */0x21,0xf9,0x04,0x01,0x05,0x00,0x01,0x00, /* index 1 */
|
||||
/* IMD */0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,
|
||||
0x02,0x02,0x44,0x01,0x00,0x3b
|
||||
};
|
||||
|
||||
/* frame 0, GCE transparent index 1
|
||||
* frame 1, GCE transparent index 2
|
||||
*/
|
||||
static const char gif_global_palette_2frames[] = {
|
||||
/* LSD */'G','I','F','8','9','a',0x01,0x00,0x01,0x00,0xa1,0x02,0x00,
|
||||
/* palette */0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
|
||||
/* GCE */0x21,0xf9,0x04,0x01,0x05,0x00,0x01,0x00, /* index 1 */
|
||||
/* IMD */0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,
|
||||
0x02,0x02,0x44,0x01,0x00,
|
||||
/* GCE */0x21,0xf9,0x04,0x01,0x05,0x00,0x02,0x00, /* index 2 */
|
||||
/* IMD */0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,
|
||||
0x02,0x02,0x44,0x01,0x00,0x3b
|
||||
};
|
||||
|
||||
static const char gif_local_palette[] = {
|
||||
/* LSD */'G','I','F','8','7','a',0x01,0x00,0x01,0x00,0x27,0x02,0x00,
|
||||
/* GCE */0x21,0xf9,0x04,0x01,0x05,0x00,0x01,0x00, /* index 1 */
|
||||
/* IMD */0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x81,
|
||||
/* palette */0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
|
||||
0x02,0x02,0x44,0x01,0x00,0x3b
|
||||
};
|
||||
|
||||
static IWICImagingFactory *factory;
|
||||
|
||||
static const char *debugstr_guid(const GUID *guid)
|
||||
{
|
||||
static char buf[50];
|
||||
|
||||
if (!guid) return "(null)";
|
||||
sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
|
||||
guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
|
||||
guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
|
||||
guid->Data4[5], guid->Data4[6], guid->Data4[7]);
|
||||
return buf;
|
||||
}
|
||||
|
||||
static IWICBitmapDecoder *create_decoder(const void *image_data, UINT image_size)
|
||||
{
|
||||
HGLOBAL hmem;
|
||||
BYTE *data;
|
||||
HRESULT hr;
|
||||
IWICBitmapDecoder *decoder = NULL;
|
||||
IStream *stream;
|
||||
GUID format;
|
||||
|
||||
hmem = GlobalAlloc(0, image_size);
|
||||
data = GlobalLock(hmem);
|
||||
memcpy(data, image_data, image_size);
|
||||
GlobalUnlock(hmem);
|
||||
|
||||
hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
|
||||
ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);
|
||||
ok(hr == S_OK, "CreateDecoderFromStream error %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoder_GetContainerFormat(decoder, &format);
|
||||
ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&format, &GUID_ContainerFormatGif),
|
||||
"wrong container format %s\n", debugstr_guid(&format));
|
||||
|
||||
IStream_Release(stream);
|
||||
|
||||
return decoder;
|
||||
}
|
||||
|
||||
static void test_global_gif_palette(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICBitmapFrameDecode *frame;
|
||||
IWICPalette *palette;
|
||||
GUID format;
|
||||
UINT count, ret;
|
||||
WICColor color[256];
|
||||
|
||||
decoder = create_decoder(gif_global_palette, sizeof(gif_global_palette));
|
||||
ok(decoder != 0, "Failed to load GIF image data\n");
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "CreatePalette error %#x\n", hr);
|
||||
|
||||
/* global palette */
|
||||
hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
|
||||
ok(hr == S_OK, "CopyPalette error %#x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "GetColorCount error %#x\n", hr);
|
||||
ok(count == 4, "expected 4, got %u\n", count);
|
||||
|
||||
hr = IWICPalette_GetColors(palette, count, color, &ret);
|
||||
ok(hr == S_OK, "GetColors error %#x\n", hr);
|
||||
ok(ret == count, "expected %u, got %u\n", count, ret);
|
||||
ok(color[0] == 0xff010203, "expected 0xff010203, got %#x\n", color[0]);
|
||||
ok(color[1] == 0x00040506, "expected 0x00040506, got %#x\n", color[1]);
|
||||
ok(color[2] == 0xff070809, "expected 0xff070809, got %#x\n", color[2]);
|
||||
ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x\n", color[3]);
|
||||
|
||||
/* frame palette */
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
|
||||
ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
|
||||
"wrong pixel format %s\n", debugstr_guid(&format));
|
||||
|
||||
hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
|
||||
ok(hr == S_OK, "CopyPalette error %#x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "GetColorCount error %#x\n", hr);
|
||||
ok(count == 4, "expected 4, got %u\n", count);
|
||||
|
||||
hr = IWICPalette_GetColors(palette, count, color, &ret);
|
||||
ok(hr == S_OK, "GetColors error %#x\n", hr);
|
||||
ok(ret == count, "expected %u, got %u\n", count, ret);
|
||||
ok(color[0] == 0xff010203, "expected 0xff010203, got %#x\n", color[0]);
|
||||
ok(color[1] == 0x00040506, "expected 0x00040506, got %#x\n", color[1]);
|
||||
ok(color[2] == 0xff070809, "expected 0xff070809, got %#x\n", color[2]);
|
||||
ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x\n", color[3]);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
}
|
||||
|
||||
static void test_global_gif_palette_2frames(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICBitmapFrameDecode *frame;
|
||||
IWICPalette *palette;
|
||||
GUID format;
|
||||
UINT count, ret;
|
||||
WICColor color[256];
|
||||
|
||||
decoder = create_decoder(gif_global_palette_2frames, sizeof(gif_global_palette_2frames));
|
||||
ok(decoder != 0, "Failed to load GIF image data\n");
|
||||
|
||||
/* active frame 0, GCE transparent index 1 */
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "CreatePalette error %#x\n", hr);
|
||||
|
||||
/* global palette */
|
||||
hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
|
||||
ok(hr == S_OK, "CopyPalette error %#x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "GetColorCount error %#x\n", hr);
|
||||
ok(count == 4, "expected 4, got %u\n", count);
|
||||
|
||||
hr = IWICPalette_GetColors(palette, count, color, &ret);
|
||||
ok(hr == S_OK, "GetColors error %#x\n", hr);
|
||||
ok(ret == count, "expected %u, got %u\n", count, ret);
|
||||
ok(color[0] == 0xff010203, "expected 0xff010203, got %#x\n", color[0]);
|
||||
ok(color[1] == 0x00040506, "expected 0x00040506, got %#x\n", color[1]);
|
||||
ok(color[2] == 0xff070809, "expected 0xff070809, got %#x\n", color[2]);
|
||||
ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x\n", color[3]);
|
||||
|
||||
/* frame 0 palette */
|
||||
hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
|
||||
ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
|
||||
"wrong pixel format %s\n", debugstr_guid(&format));
|
||||
|
||||
hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
|
||||
ok(hr == S_OK, "CopyPalette error %#x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "GetColorCount error %#x\n", hr);
|
||||
ok(count == 4, "expected 4, got %u\n", count);
|
||||
|
||||
hr = IWICPalette_GetColors(palette, count, color, &ret);
|
||||
ok(hr == S_OK, "GetColors error %#x\n", hr);
|
||||
ok(ret == count, "expected %u, got %u\n", count, ret);
|
||||
ok(color[0] == 0xff010203, "expected 0xff010203, got %#x\n", color[0]);
|
||||
ok(color[1] == 0x00040506, "expected 0x00040506, got %#x\n", color[1]);
|
||||
ok(color[2] == 0xff070809, "expected 0xff070809, got %#x\n", color[2]);
|
||||
ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x\n", color[3]);
|
||||
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
|
||||
/* active frame 1, GCE transparent index 2 */
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 1, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
/* global palette */
|
||||
hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
|
||||
ok(hr == S_OK, "CopyPalette error %#x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "GetColorCount error %#x\n", hr);
|
||||
ok(count == 4, "expected 4, got %u\n", count);
|
||||
|
||||
hr = IWICPalette_GetColors(palette, count, color, &ret);
|
||||
ok(hr == S_OK, "GetColors error %#x\n", hr);
|
||||
ok(ret == count, "expected %u, got %u\n", count, ret);
|
||||
ok(color[0] == 0xff010203, "expected 0xff010203, got %#x\n", color[0]);
|
||||
ok(color[1] == 0xff040506 || broken(color[1] == 0x00040506) /* XP */, "expected 0xff040506, got %#x\n", color[1]);
|
||||
ok(color[2] == 0x00070809 || broken(color[2] == 0xff070809) /* XP */, "expected 0x00070809, got %#x\n", color[2]);
|
||||
ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x\n", color[3]);
|
||||
|
||||
/* frame 1 palette */
|
||||
hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
|
||||
ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
|
||||
"wrong pixel format %s\n", debugstr_guid(&format));
|
||||
|
||||
hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
|
||||
ok(hr == S_OK, "CopyPalette error %#x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "GetColorCount error %#x\n", hr);
|
||||
ok(count == 4, "expected 4, got %u\n", count);
|
||||
|
||||
hr = IWICPalette_GetColors(palette, count, color, &ret);
|
||||
ok(hr == S_OK, "GetColors error %#x\n", hr);
|
||||
ok(ret == count, "expected %u, got %u\n", count, ret);
|
||||
ok(color[0] == 0xff010203, "expected 0xff010203, got %#x\n", color[0]);
|
||||
ok(color[1] == 0xff040506, "expected 0xff040506, got %#x\n", color[1]);
|
||||
ok(color[2] == 0x00070809, "expected 0x00070809, got %#x\n", color[2]);
|
||||
ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x\n", color[3]);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
}
|
||||
|
||||
static void test_local_gif_palette(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICBitmapFrameDecode *frame;
|
||||
IWICPalette *palette;
|
||||
GUID format;
|
||||
UINT count, ret;
|
||||
WICColor color[256];
|
||||
|
||||
decoder = create_decoder(gif_local_palette, sizeof(gif_local_palette));
|
||||
ok(decoder != 0, "Failed to load GIF image data\n");
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "CreatePalette error %#x\n", hr);
|
||||
|
||||
/* global palette */
|
||||
hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
|
||||
ok(hr == WINCODEC_ERR_FRAMEMISSING,
|
||||
"expected WINCODEC_ERR_FRAMEMISSING, got %#x\n", hr);
|
||||
|
||||
/* frame palette */
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
|
||||
ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
|
||||
"wrong pixel format %s\n", debugstr_guid(&format));
|
||||
|
||||
hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
|
||||
ok(hr == S_OK, "CopyPalette error %#x\n", hr);
|
||||
|
||||
hr = IWICPalette_GetColorCount(palette, &count);
|
||||
ok(hr == S_OK, "GetColorCount error %#x\n", hr);
|
||||
ok(count == 4, "expected 4, got %u\n", count);
|
||||
|
||||
hr = IWICPalette_GetColors(palette, count, color, &ret);
|
||||
ok(hr == S_OK, "GetColors error %#x\n", hr);
|
||||
ok(ret == count, "expected %u, got %u\n", count, ret);
|
||||
ok(color[0] == 0xff010203, "expected 0xff010203, got %#x\n", color[0]);
|
||||
ok(color[1] == 0x00040506, "expected 0x00040506, got %#x\n", color[1]);
|
||||
ok(color[2] == 0xff070809, "expected 0xff070809, got %#x\n", color[2]);
|
||||
ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x\n", color[3]);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
}
|
||||
|
||||
START_TEST(gifformat)
|
||||
{
|
||||
HRESULT hr;
|
||||
|
||||
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICImagingFactory, (void **)&factory);
|
||||
ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
|
||||
if (FAILED(hr)) return;
|
||||
|
||||
test_global_gif_palette();
|
||||
test_global_gif_palette_2frames();
|
||||
test_local_gif_palette();
|
||||
|
||||
IWICImagingFactory_Release(factory);
|
||||
CoUninitialize();
|
||||
}
|
||||
166
rostests/winetests/windowscodecs/icoformat.c
Normal file
166
rostests/winetests/windowscodecs/icoformat.c
Normal file
|
|
@ -0,0 +1,166 @@
|
|||
/*
|
||||
* Copyright 2010 Damjan Jovanovic
|
||||
*
|
||||
* 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 <math.h>
|
||||
|
||||
#define COBJMACROS
|
||||
|
||||
#include "windef.h"
|
||||
#include "objbase.h"
|
||||
#include "wincodec.h"
|
||||
#include "wine/test.h"
|
||||
|
||||
static unsigned char testico_bad_icondirentry_size[] = {
|
||||
/* ICONDIR */
|
||||
0, 0, /* reserved */
|
||||
1, 0, /* type */
|
||||
1, 0, /* count */
|
||||
/* ICONDIRENTRY */
|
||||
2, /* width */
|
||||
2, /* height */
|
||||
2, /* colorCount */
|
||||
0, /* reserved */
|
||||
1,0, /* planes */
|
||||
8,0, /* bitCount */
|
||||
(40+2*4+16*16+16*4) & 0xFF,((40+2*4+16*16+16*4) >> 8) & 0xFF,0,0, /* bytesInRes */
|
||||
22,0,0,0, /* imageOffset */
|
||||
/* BITMAPINFOHEADER */
|
||||
40,0,0,0, /* header size */
|
||||
16,0,0,0, /* width */
|
||||
2*16,0,0,0, /* height (XOR+AND rows) */
|
||||
1,0, /* planes */
|
||||
8,0, /* bit count */
|
||||
0,0,0,0, /* compression */
|
||||
0,0,0,0, /* sizeImage */
|
||||
0,0,0,0, /* x pels per meter */
|
||||
0,0,0,0, /* y pels per meter */
|
||||
2,0,0,0, /* clrUsed */
|
||||
0,0,0,0, /* clrImportant */
|
||||
/* palette */
|
||||
0,0,0,0,
|
||||
0xFF,0xFF,0xFF,0,
|
||||
/* XOR mask */
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,
|
||||
0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,
|
||||
0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,
|
||||
0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,
|
||||
0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,
|
||||
0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,
|
||||
0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,
|
||||
0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,
|
||||
0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,
|
||||
0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,
|
||||
0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
/* AND mask */
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0,
|
||||
0,0,0,0
|
||||
};
|
||||
|
||||
static void test_bad_icondirentry_size(void)
|
||||
{
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICImagingFactory *factory;
|
||||
HRESULT hr;
|
||||
IWICStream *icostream;
|
||||
IWICBitmapFrameDecode *framedecode = NULL;
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICImagingFactory, (void**)&factory);
|
||||
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
|
||||
if (FAILED(hr)) return;
|
||||
|
||||
hr = IWICImagingFactory_CreateStream(factory, &icostream);
|
||||
ok(hr == S_OK, "CreateStream failed, hr=%x\n", hr);
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICStream_InitializeFromMemory(icostream, testico_bad_icondirentry_size,
|
||||
sizeof(testico_bad_icondirentry_size));
|
||||
ok(hr == S_OK, "InitializeFromMemory failed, hr=%x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = CoCreateInstance(&CLSID_WICIcoDecoder, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICBitmapDecoder, (void**)&decoder);
|
||||
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)icostream,
|
||||
WICDecodeMetadataCacheOnDemand);
|
||||
ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
|
||||
ok(hr == S_OK, "GetFrame failed, hr=%x\n", hr);
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
UINT width = 0, height = 0;
|
||||
IWICBitmapSource *thumbnail = NULL;
|
||||
|
||||
hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
|
||||
ok(hr == S_OK, "GetFrameSize failed, hr=%x\n", hr);
|
||||
ok(width == 16 && height == 16, "framesize=%ux%u\n", width, height);
|
||||
|
||||
hr = IWICBitmapFrameDecode_GetThumbnail(framedecode, &thumbnail);
|
||||
todo_wine ok(hr == S_OK, "GetThumbnail failed, hr=%x\n", hr);
|
||||
|
||||
if (thumbnail) IWICBitmapSource_Release(thumbnail);
|
||||
IWICBitmapFrameDecode_Release(framedecode);
|
||||
}
|
||||
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
}
|
||||
|
||||
IWICStream_Release(icostream);
|
||||
}
|
||||
|
||||
IWICImagingFactory_Release(factory);
|
||||
}
|
||||
|
||||
START_TEST(icoformat)
|
||||
{
|
||||
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||||
|
||||
test_bad_icondirentry_size();
|
||||
|
||||
CoUninitialize();
|
||||
}
|
||||
549
rostests/winetests/windowscodecs/info.c
Normal file
549
rostests/winetests/windowscodecs/info.c
Normal file
|
|
@ -0,0 +1,549 @@
|
|||
/*
|
||||
* Copyright 2009 Vincent Povirk for CodeWeavers
|
||||
*
|
||||
* 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 <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <math.h>
|
||||
|
||||
#define COBJMACROS
|
||||
|
||||
#include "windef.h"
|
||||
#include "objbase.h"
|
||||
#include "wincodec.h"
|
||||
#include "wincodecsdk.h"
|
||||
#include "wine/test.h"
|
||||
|
||||
#include "initguid.h"
|
||||
DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
|
||||
|
||||
static const char *debugstr_guid(GUID *guid)
|
||||
{
|
||||
static char buf[50];
|
||||
|
||||
if(!guid)
|
||||
return "(null)";
|
||||
|
||||
sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
|
||||
guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
|
||||
guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
|
||||
guid->Data4[5], guid->Data4[6], guid->Data4[7]);
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
static HRESULT get_component_info(const GUID *clsid, IWICComponentInfo **result)
|
||||
{
|
||||
IWICImagingFactory *factory;
|
||||
HRESULT hr;
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICImagingFactory, (void**)&factory);
|
||||
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
|
||||
if (FAILED(hr)) return hr;
|
||||
|
||||
hr = IWICImagingFactory_CreateComponentInfo(factory, clsid, result);
|
||||
|
||||
IWICImagingFactory_Release(factory);
|
||||
|
||||
return hr;
|
||||
}
|
||||
|
||||
static int is_pixelformat(GUID *format)
|
||||
{
|
||||
IWICComponentInfo *info;
|
||||
HRESULT hr;
|
||||
WICComponentType componenttype;
|
||||
|
||||
hr = get_component_info(format, &info);
|
||||
if (FAILED(hr))
|
||||
return FALSE;
|
||||
|
||||
hr = IWICComponentInfo_GetComponentType(info, &componenttype);
|
||||
|
||||
IWICComponentInfo_Release(info);
|
||||
|
||||
return SUCCEEDED(hr) && componenttype == WICPixelFormat;
|
||||
}
|
||||
|
||||
static void test_decoder_info(void)
|
||||
{
|
||||
IWICComponentInfo *info;
|
||||
IWICBitmapDecoderInfo *decoder_info;
|
||||
HRESULT hr;
|
||||
ULONG len;
|
||||
WCHAR value[256];
|
||||
const WCHAR expected_mimetype[] = {'i','m','a','g','e','/','b','m','p',0};
|
||||
const WCHAR expected_extensions[] = {'.','b','m','p',',','.','d','i','b',',','.','r','l','e',0};
|
||||
CLSID clsid;
|
||||
GUID pixelformats[20];
|
||||
UINT num_formats, count;
|
||||
int i;
|
||||
|
||||
hr = get_component_info(&CLSID_WICBmpDecoder, &info);
|
||||
|
||||
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICBitmapDecoderInfo, (void**)&decoder_info);
|
||||
ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetCLSID(decoder_info, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetCLSID failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetCLSID(decoder_info, &clsid);
|
||||
ok(hr == S_OK, "GetCLSID failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&CLSID_WICBmpDecoder, &clsid), "GetCLSID returned wrong result\n");
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetMimeTypes(decoder_info, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetMimeType failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetMimeTypes(decoder_info, 1, NULL, &len);
|
||||
ok(hr == E_INVALIDARG, "GetMimeType failed, hr=%x\n", hr);
|
||||
ok(len == lstrlenW(expected_mimetype)+1, "GetMimeType returned wrong len %i\n", len);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetMimeTypes(decoder_info, len, value, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetMimeType failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetMimeTypes(decoder_info, 0, NULL, &len);
|
||||
ok(hr == S_OK, "GetMimeType failed, hr=%x\n", hr);
|
||||
ok(len == lstrlenW(expected_mimetype)+1, "GetMimeType returned wrong len %i\n", len);
|
||||
|
||||
value[0] = 0;
|
||||
hr = IWICBitmapDecoderInfo_GetMimeTypes(decoder_info, len, value, &len);
|
||||
ok(hr == S_OK, "GetMimeType failed, hr=%x\n", hr);
|
||||
ok(lstrcmpW(value, expected_mimetype) == 0, "GetMimeType returned wrong value %s\n", wine_dbgstr_w(value));
|
||||
ok(len == lstrlenW(expected_mimetype)+1, "GetMimeType returned wrong len %i\n", len);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetMimeTypes(decoder_info, 1, value, &len);
|
||||
ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "GetMimeType failed, hr=%x\n", hr);
|
||||
ok(len == lstrlenW(expected_mimetype)+1, "GetMimeType returned wrong len %i\n", len);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetMimeTypes(decoder_info, 256, value, &len);
|
||||
ok(hr == S_OK, "GetMimeType failed, hr=%x\n", hr);
|
||||
ok(lstrcmpW(value, expected_mimetype) == 0, "GetMimeType returned wrong value %s\n", wine_dbgstr_w(value));
|
||||
ok(len == lstrlenW(expected_mimetype)+1, "GetMimeType returned wrong len %i\n", len);
|
||||
|
||||
num_formats = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoderInfo_GetPixelFormats(decoder_info, 0, NULL, &num_formats);
|
||||
ok(hr == S_OK, "GetPixelFormats failed, hr=%x\n", hr);
|
||||
ok(num_formats < 20 && num_formats > 1, "got %d formats\n", num_formats);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetPixelFormats(decoder_info, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetPixelFormats failed, hr=%x\n", hr);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoderInfo_GetPixelFormats(decoder_info, 0, pixelformats, &count);
|
||||
ok(hr == S_OK, "GetPixelFormats failed, hr=%x\n", hr);
|
||||
ok(count == 0, "got %d formats\n", count);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoderInfo_GetPixelFormats(decoder_info, 1, pixelformats, &count);
|
||||
ok(hr == S_OK, "GetPixelFormats failed, hr=%x\n", hr);
|
||||
ok(count == 1, "got %d formats\n", count);
|
||||
ok(is_pixelformat(&pixelformats[0]), "got invalid pixel format\n");
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoderInfo_GetPixelFormats(decoder_info, num_formats, pixelformats, &count);
|
||||
ok(hr == S_OK, "GetPixelFormats failed, hr=%x\n", hr);
|
||||
ok(count == num_formats, "got %d formats, expected %d\n", count, num_formats);
|
||||
for (i=0; i<num_formats; i++)
|
||||
ok(is_pixelformat(&pixelformats[i]), "got invalid pixel format\n");
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetPixelFormats(decoder_info, num_formats, pixelformats, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetPixelFormats failed, hr=%x\n", hr);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoderInfo_GetPixelFormats(decoder_info, 20, pixelformats, &count);
|
||||
ok(hr == S_OK, "GetPixelFormats failed, hr=%x\n", hr);
|
||||
ok(count == num_formats, "got %d formats, expected %d\n", count, num_formats);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetFileExtensions(decoder_info, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetFileExtensions failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetFileExtensions(decoder_info, 1, NULL, &len);
|
||||
ok(hr == E_INVALIDARG, "GetFileExtensions failed, hr=%x\n", hr);
|
||||
ok(len == lstrlenW(expected_extensions)+1, "GetFileExtensions returned wrong len %i\n", len);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetFileExtensions(decoder_info, len, value, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetFileExtensions failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetFileExtensions(decoder_info, 0, NULL, &len);
|
||||
ok(hr == S_OK, "GetFileExtensions failed, hr=%x\n", hr);
|
||||
ok(len == lstrlenW(expected_extensions)+1, "GetFileExtensions returned wrong len %i\n", len);
|
||||
|
||||
value[0] = 0;
|
||||
hr = IWICBitmapDecoderInfo_GetFileExtensions(decoder_info, len, value, &len);
|
||||
ok(hr == S_OK, "GetFileExtensions failed, hr=%x\n", hr);
|
||||
ok(lstrcmpW(value, expected_extensions) == 0, "GetFileExtensions returned wrong value %s\n", wine_dbgstr_w(value));
|
||||
ok(len == lstrlenW(expected_extensions)+1, "GetFileExtensions returned wrong len %i\n", len);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetFileExtensions(decoder_info, 1, value, &len);
|
||||
ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "GetFileExtensions failed, hr=%x\n", hr);
|
||||
ok(len == lstrlenW(expected_extensions)+1, "GetFileExtensions returned wrong len %i\n", len);
|
||||
|
||||
hr = IWICBitmapDecoderInfo_GetFileExtensions(decoder_info, 256, value, &len);
|
||||
ok(hr == S_OK, "GetFileExtensions failed, hr=%x\n", hr);
|
||||
ok(lstrcmpW(value, expected_extensions) == 0, "GetFileExtensions returned wrong value %s\n", wine_dbgstr_w(value));
|
||||
ok(len == lstrlenW(expected_extensions)+1, "GetFileExtensions returned wrong len %i\n", len);
|
||||
|
||||
IWICBitmapDecoderInfo_Release(decoder_info);
|
||||
|
||||
IWICComponentInfo_Release(info);
|
||||
}
|
||||
|
||||
static void test_pixelformat_info(void)
|
||||
{
|
||||
IWICComponentInfo *info;
|
||||
IWICPixelFormatInfo *pixelformat_info;
|
||||
IWICPixelFormatInfo2 *pixelformat_info2;
|
||||
HRESULT hr;
|
||||
ULONG len, known_len;
|
||||
WCHAR value[256];
|
||||
GUID guid;
|
||||
WICComponentType componenttype;
|
||||
WICPixelFormatNumericRepresentation numericrepresentation;
|
||||
DWORD signing;
|
||||
UINT uiresult;
|
||||
BYTE abbuffer[256];
|
||||
BOOL supportstransparency;
|
||||
|
||||
hr = get_component_info(&GUID_WICPixelFormat32bppBGRA, &info);
|
||||
ok(hr == S_OK, "CreateComponentInfo failed, hr=%x\n", hr);
|
||||
|
||||
if (FAILED(hr))
|
||||
return;
|
||||
|
||||
hr = IWICComponentInfo_GetAuthor(info, 0, NULL, 0);
|
||||
ok(hr == E_INVALIDARG, "GetAuthor failed, hr=%x\n", hr);
|
||||
|
||||
len = 0xdeadbeef;
|
||||
hr = IWICComponentInfo_GetAuthor(info, 0, NULL, &len);
|
||||
ok(hr == S_OK, "GetAuthor failed, hr=%x\n", hr);
|
||||
ok(len < 255 && len > 0, "invalid length 0x%x\n", len);
|
||||
known_len = len;
|
||||
|
||||
memset(value, 0xaa, 256 * sizeof(WCHAR));
|
||||
hr = IWICComponentInfo_GetAuthor(info, len-1, value, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetAuthor failed, hr=%x\n", hr);
|
||||
ok(value[0] = 0xaaaa, "string modified\n");
|
||||
|
||||
len = 0xdeadbeef;
|
||||
memset(value, 0xaa, 256 * sizeof(WCHAR));
|
||||
hr = IWICComponentInfo_GetAuthor(info, known_len-1, value, &len);
|
||||
ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "GetAuthor failed, hr=%x\n", hr);
|
||||
ok(len == known_len, "got length of 0x%x, expected 0x%x\n", len, known_len);
|
||||
ok(value[known_len-1] == 0xaaaa, "string modified past given length\n");
|
||||
ok(value[0] == 0xaaaa, "string modified\n");
|
||||
|
||||
len = 0xdeadbeef;
|
||||
memset(value, 0xaa, 256 * sizeof(WCHAR));
|
||||
hr = IWICComponentInfo_GetAuthor(info, known_len, value, &len);
|
||||
ok(hr == S_OK, "GetAuthor failed, hr=%x\n", hr);
|
||||
ok(len == known_len, "got length of 0x%x, expected 0x%x\n", len, known_len);
|
||||
ok(value[known_len-1] == 0, "string not terminated at expected length\n");
|
||||
ok(value[known_len-2] != 0xaaaa, "string not modified at given length\n");
|
||||
|
||||
len = 0xdeadbeef;
|
||||
memset(value, 0xaa, 256 * sizeof(WCHAR));
|
||||
hr = IWICComponentInfo_GetAuthor(info, known_len+1, value, &len);
|
||||
ok(hr == S_OK, "GetAuthor failed, hr=%x\n", hr);
|
||||
ok(len == known_len, "got length of 0x%x, expected 0x%x\n", len, known_len);
|
||||
ok(value[known_len] == 0xaaaa, "string modified past end\n");
|
||||
ok(value[known_len-1] == 0, "string not terminated at expected length\n");
|
||||
ok(value[known_len-2] != 0xaaaa, "string not modified at given length\n");
|
||||
|
||||
hr = IWICComponentInfo_GetCLSID(info, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetCLSID failed, hr=%x\n", hr);
|
||||
|
||||
memset(&guid, 0xaa, sizeof(guid));
|
||||
hr = IWICComponentInfo_GetCLSID(info, &guid);
|
||||
ok(hr == S_OK, "GetCLSID failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&guid, &GUID_WICPixelFormat32bppBGRA), "unexpected CLSID %s\n", debugstr_guid(&guid));
|
||||
|
||||
hr = IWICComponentInfo_GetComponentType(info, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetComponentType failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICComponentInfo_GetComponentType(info, &componenttype);
|
||||
ok(hr == S_OK, "GetComponentType failed, hr=%x\n", hr);
|
||||
ok(componenttype == WICPixelFormat, "unexpected component type 0x%x\n", componenttype);
|
||||
|
||||
len = 0xdeadbeef;
|
||||
hr = IWICComponentInfo_GetFriendlyName(info, 0, NULL, &len);
|
||||
ok(hr == S_OK, "GetFriendlyName failed, hr=%x\n", hr);
|
||||
ok(len < 255 && len > 0, "invalid length 0x%x\n", len);
|
||||
|
||||
hr = IWICComponentInfo_GetSigningStatus(info, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetSigningStatus failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICComponentInfo_GetSigningStatus(info, &signing);
|
||||
ok(hr == S_OK, "GetSigningStatus failed, hr=%x\n", hr);
|
||||
ok(signing == WICComponentSigned, "unexpected signing status 0x%x\n", signing);
|
||||
|
||||
len = 0xdeadbeef;
|
||||
hr = IWICComponentInfo_GetSpecVersion(info, 0, NULL, &len);
|
||||
ok(hr == S_OK, "GetSpecVersion failed, hr=%x\n", hr);
|
||||
ok(len == 0, "invalid length 0x%x\n", len); /* spec version does not apply to pixel formats */
|
||||
|
||||
memset(&guid, 0xaa, sizeof(guid));
|
||||
hr = IWICComponentInfo_GetVendorGUID(info, &guid);
|
||||
ok(hr == S_OK, "GetVendorGUID failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&guid, &GUID_VendorMicrosoft) ||
|
||||
broken(IsEqualGUID(&guid, &GUID_NULL)) /* XP */, "unexpected GUID %s\n", debugstr_guid(&guid));
|
||||
|
||||
len = 0xdeadbeef;
|
||||
hr = IWICComponentInfo_GetVersion(info, 0, NULL, &len);
|
||||
ok(hr == S_OK, "GetVersion failed, hr=%x\n", hr);
|
||||
ok(len == 0, "invalid length 0x%x\n", len); /* version does not apply to pixel formats */
|
||||
|
||||
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo, (void**)&pixelformat_info);
|
||||
ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = IWICPixelFormatInfo_GetBitsPerPixel(pixelformat_info, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetBitsPerPixel failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICPixelFormatInfo_GetBitsPerPixel(pixelformat_info, &uiresult);
|
||||
ok(hr == S_OK, "GetBitsPerPixel failed, hr=%x\n", hr);
|
||||
ok(uiresult == 32, "unexpected bpp %i\n", uiresult);
|
||||
|
||||
hr = IWICPixelFormatInfo_GetChannelCount(pixelformat_info, &uiresult);
|
||||
ok(hr == S_OK, "GetChannelCount failed, hr=%x\n", hr);
|
||||
ok(uiresult == 4, "unexpected channel count %i\n", uiresult);
|
||||
|
||||
hr = IWICPixelFormatInfo_GetChannelMask(pixelformat_info, 0, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetChannelMask failed, hr=%x\n", hr);
|
||||
|
||||
uiresult = 0xdeadbeef;
|
||||
hr = IWICPixelFormatInfo_GetChannelMask(pixelformat_info, 0, 0, NULL, &uiresult);
|
||||
ok(hr == S_OK, "GetChannelMask failed, hr=%x\n", hr);
|
||||
ok(uiresult == 4, "unexpected length %i\n", uiresult);
|
||||
|
||||
memset(abbuffer, 0xaa, sizeof(abbuffer));
|
||||
hr = IWICPixelFormatInfo_GetChannelMask(pixelformat_info, 0, known_len, abbuffer, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetChannelMask failed, hr=%x\n", hr);
|
||||
ok(abbuffer[0] == 0xaa, "buffer modified\n");
|
||||
|
||||
uiresult = 0xdeadbeef;
|
||||
memset(abbuffer, 0xaa, sizeof(abbuffer));
|
||||
hr = IWICPixelFormatInfo_GetChannelMask(pixelformat_info, 0, 3, abbuffer, &uiresult);
|
||||
ok(hr == E_INVALIDARG, "GetChannelMask failed, hr=%x\n", hr);
|
||||
ok(abbuffer[0] == 0xaa, "buffer modified\n");
|
||||
ok(uiresult == 4, "unexpected length %i\n", uiresult);
|
||||
|
||||
memset(abbuffer, 0xaa, sizeof(abbuffer));
|
||||
hr = IWICPixelFormatInfo_GetChannelMask(pixelformat_info, 0, 4, abbuffer, &uiresult);
|
||||
ok(hr == S_OK, "GetChannelMask failed, hr=%x\n", hr);
|
||||
ok(*((ULONG*)abbuffer) == 0xff, "unexpected mask 0x%x\n", *((ULONG*)abbuffer));
|
||||
ok(uiresult == 4, "unexpected length %i\n", uiresult);
|
||||
|
||||
memset(abbuffer, 0xaa, sizeof(abbuffer));
|
||||
hr = IWICPixelFormatInfo_GetChannelMask(pixelformat_info, 0, 5, abbuffer, &uiresult);
|
||||
ok(hr == S_OK, "GetChannelMask failed, hr=%x\n", hr);
|
||||
ok(*((ULONG*)abbuffer) == 0xff, "unexpected mask 0x%x\n", *((ULONG*)abbuffer));
|
||||
ok(abbuffer[4] == 0xaa, "buffer modified past actual length\n");
|
||||
ok(uiresult == 4, "unexpected length %i\n", uiresult);
|
||||
|
||||
memset(&guid, 0xaa, sizeof(guid));
|
||||
hr = IWICPixelFormatInfo_GetFormatGUID(pixelformat_info, &guid);
|
||||
ok(hr == S_OK, "GetFormatGUID failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&guid, &GUID_WICPixelFormat32bppBGRA), "unexpected GUID %s\n", debugstr_guid(&guid));
|
||||
|
||||
IWICPixelFormatInfo_Release(pixelformat_info);
|
||||
}
|
||||
|
||||
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo2, (void**)&pixelformat_info2);
|
||||
|
||||
if (FAILED(hr))
|
||||
win_skip("IWICPixelFormatInfo2 not supported\n");
|
||||
else
|
||||
{
|
||||
hr = IWICPixelFormatInfo2_GetNumericRepresentation(pixelformat_info2, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetNumericRepresentation failed, hr=%x\n", hr);
|
||||
|
||||
numericrepresentation = 0xdeadbeef;
|
||||
hr = IWICPixelFormatInfo2_GetNumericRepresentation(pixelformat_info2, &numericrepresentation);
|
||||
ok(hr == S_OK, "GetNumericRepresentation failed, hr=%x\n", hr);
|
||||
ok(numericrepresentation == WICPixelFormatNumericRepresentationUnsignedInteger, "unexpected numeric representation %i\n", numericrepresentation);
|
||||
|
||||
hr = IWICPixelFormatInfo2_SupportsTransparency(pixelformat_info2, NULL);
|
||||
ok(hr == E_INVALIDARG, "SupportsTransparency failed, hr=%x\n", hr);
|
||||
|
||||
supportstransparency = 0xdeadbeef;
|
||||
hr = IWICPixelFormatInfo2_SupportsTransparency(pixelformat_info2, &supportstransparency);
|
||||
ok(hr == S_OK, "SupportsTransparency failed, hr=%x\n", hr);
|
||||
ok(supportstransparency == 1, "unexpected value %i\n", supportstransparency);
|
||||
|
||||
IWICPixelFormatInfo2_Release(pixelformat_info2);
|
||||
}
|
||||
|
||||
IWICComponentInfo_Release(info);
|
||||
}
|
||||
|
||||
static void test_reader_info(void)
|
||||
{
|
||||
IWICImagingFactory *factory;
|
||||
IWICComponentInfo *info;
|
||||
IWICMetadataReaderInfo *reader_info;
|
||||
HRESULT hr;
|
||||
CLSID clsid;
|
||||
GUID container_formats[10];
|
||||
UINT count, size;
|
||||
WICMetadataPattern *patterns;
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICImagingFactory, (void**)&factory);
|
||||
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
|
||||
if (FAILED(hr)) return;
|
||||
|
||||
hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICUnknownMetadataReader, &info);
|
||||
ok(hr == S_OK, "CreateComponentInfo failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICMetadataReaderInfo, (void**)&reader_info);
|
||||
ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetCLSID failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, &clsid);
|
||||
ok(hr == S_OK, "GetCLSID failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&CLSID_WICUnknownMetadataReader, &clsid), "GetCLSID returned wrong result\n");
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetMetadataFormat(reader_info, &clsid);
|
||||
ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&GUID_MetadataFormatUnknown, &clsid), "GetMetadataFormat returned wrong result\n");
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetContainerFormats failed, hr=%x\n", hr);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, &count);
|
||||
todo_wine
|
||||
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
|
||||
todo_wine
|
||||
ok(count == 0, "unexpected count %d\n", count);
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_ContainerFormatPng,
|
||||
0, NULL, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetPatterns failed, hr=%x\n", hr);
|
||||
|
||||
count = size = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_ContainerFormatPng,
|
||||
0, NULL, &count, &size);
|
||||
todo_wine
|
||||
ok(hr == WINCODEC_ERR_COMPONENTNOTFOUND || broken(hr == S_OK) /* Windows XP */,
|
||||
"GetPatterns failed, hr=%x\n", hr);
|
||||
ok(count == 0xdeadbeef, "unexpected count %d\n", count);
|
||||
ok(size == 0xdeadbeef, "unexpected size %d\n", size);
|
||||
|
||||
IWICMetadataReaderInfo_Release(reader_info);
|
||||
|
||||
IWICComponentInfo_Release(info);
|
||||
|
||||
hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICXMPStructMetadataReader, &info);
|
||||
todo_wine
|
||||
ok(hr == S_OK, "CreateComponentInfo failed, hr=%x\n", hr);
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
IWICImagingFactory_Release(factory);
|
||||
return;
|
||||
}
|
||||
|
||||
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICMetadataReaderInfo, (void**)&reader_info);
|
||||
ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetCLSID failed, hr=%x\n", hr);
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, &clsid);
|
||||
ok(hr == S_OK, "GetCLSID failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&CLSID_WICXMPStructMetadataReader, &clsid), "GetCLSID returned wrong result\n");
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetMetadataFormat(reader_info, &clsid);
|
||||
ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
|
||||
ok(IsEqualGUID(&GUID_MetadataFormatXMPStruct, &clsid), "GetMetadataFormat returned wrong result\n");
|
||||
|
||||
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "GetContainerFormats failed, hr=%x\n", hr);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, &count);
|
||||
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
|
||||
ok(count >= 2, "unexpected count %d\n", count);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 1, container_formats, &count);
|
||||
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
|
||||
ok(count == 1, "unexpected count %d\n", count);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 10, container_formats, &count);
|
||||
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
|
||||
ok(count == min(count, 10), "unexpected count %d\n", count);
|
||||
|
||||
count = size = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_ContainerFormatPng,
|
||||
0, NULL, &count, &size);
|
||||
ok(hr == WINCODEC_ERR_COMPONENTNOTFOUND || broken(hr == S_OK) /* Windows XP */,
|
||||
"GetPatterns failed, hr=%x\n", hr);
|
||||
ok(count == 0xdeadbeef, "unexpected count %d\n", count);
|
||||
ok(size == 0xdeadbeef, "unexpected size %d\n", size);
|
||||
|
||||
count = size = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_MetadataFormatXMP,
|
||||
0, NULL, &count, &size);
|
||||
ok(hr == S_OK, "GetPatterns failed, hr=%x\n", hr);
|
||||
ok(count == 1, "unexpected count %d\n", count);
|
||||
ok(size > sizeof(WICMetadataPattern), "unexpected size %d\n", size);
|
||||
|
||||
if (hr == S_OK)
|
||||
{
|
||||
patterns = HeapAlloc(GetProcessHeap(), 0, size);
|
||||
|
||||
count = size = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_MetadataFormatXMP,
|
||||
size-1, patterns, &count, &size);
|
||||
ok(hr == S_OK, "GetPatterns failed, hr=%x\n", hr);
|
||||
ok(count == 1, "unexpected count %d\n", count);
|
||||
ok(size > sizeof(WICMetadataPattern), "unexpected size %d\n", size);
|
||||
|
||||
count = size = 0xdeadbeef;
|
||||
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_MetadataFormatXMP,
|
||||
size, patterns, &count, &size);
|
||||
ok(hr == S_OK, "GetPatterns failed, hr=%x\n", hr);
|
||||
ok(count == 1, "unexpected count %d\n", count);
|
||||
ok(size == sizeof(WICMetadataPattern) + patterns->Length * 2, "unexpected size %d\n", size);
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, patterns);
|
||||
}
|
||||
|
||||
IWICMetadataReaderInfo_Release(reader_info);
|
||||
|
||||
IWICComponentInfo_Release(info);
|
||||
|
||||
IWICImagingFactory_Release(factory);
|
||||
}
|
||||
|
||||
START_TEST(info)
|
||||
{
|
||||
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||||
|
||||
test_decoder_info();
|
||||
test_reader_info();
|
||||
test_pixelformat_info();
|
||||
|
||||
CoUninitialize();
|
||||
}
|
||||
1811
rostests/winetests/windowscodecs/metadata.c
Normal file
1811
rostests/winetests/windowscodecs/metadata.c
Normal file
File diff suppressed because it is too large
Load diff
553
rostests/winetests/windowscodecs/palette.c
Normal file
553
rostests/winetests/windowscodecs/palette.c
Normal file
|
|
@ -0,0 +1,553 @@
|
|||
/*
|
||||
* 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 COBJMACROS
|
||||
|
||||
#include "windef.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();
|
||||
}
|
||||
490
rostests/winetests/windowscodecs/pngformat.c
Normal file
490
rostests/winetests/windowscodecs/pngformat.c
Normal file
|
|
@ -0,0 +1,490 @@
|
|||
/*
|
||||
* Copyright 2012 Dmitry Timoshkov
|
||||
* Copyright 2012 Hans Leidekker for CodeWeavers
|
||||
*
|
||||
* 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 <stdio.h>
|
||||
|
||||
#define COBJMACROS
|
||||
|
||||
#include "windef.h"
|
||||
#include "wincodec.h"
|
||||
#include "wine/test.h"
|
||||
|
||||
/* 1x1 pixel PNG image */
|
||||
static const char png_no_color_profile[] = {
|
||||
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
|
||||
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
|
||||
0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, 0xde, 0x00, 0x00, 0x00,
|
||||
0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b,
|
||||
0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49,
|
||||
0x4d, 0x45, 0x07, 0xdc, 0x0b, 0x0e, 0x0e, 0x22, 0x17, 0x10, 0xd8, 0xde,
|
||||
0x3b, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41, 0x54, 0x08, 0xd7, 0x63,
|
||||
0xf8, 0xff, 0xff, 0x3f, 0x00, 0x05, 0xfe, 0x02, 0xfe, 0xdc, 0xcc, 0x59,
|
||||
0xe7, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60,
|
||||
0x82
|
||||
};
|
||||
|
||||
/* 1x1 pixel PNG image with embedded sRGB profile */
|
||||
static const char png_color_profile[] = {
|
||||
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
|
||||
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
|
||||
0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, 0xde, 0x00, 0x00, 0x0a,
|
||||
0x43, 0x69, 0x43, 0x43, 0x50, 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6f,
|
||||
0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x78, 0xda, 0x9d, 0x53, 0x77, 0x58,
|
||||
0x93, 0xf7, 0x16, 0x3e, 0xdf, 0xf7, 0x65, 0x0f, 0x56, 0x42, 0xd8, 0xf0,
|
||||
0xb1, 0x97, 0x6c, 0x81, 0x00, 0x22, 0x23, 0xac, 0x08, 0xc8, 0x10, 0x59,
|
||||
0xa2, 0x10, 0x92, 0x00, 0x61, 0x84, 0x10, 0x12, 0x40, 0xc5, 0x85, 0x88,
|
||||
0x0a, 0x56, 0x14, 0x15, 0x11, 0x9c, 0x48, 0x55, 0xc4, 0x82, 0xd5, 0x0a,
|
||||
0x48, 0x9d, 0x88, 0xe2, 0xa0, 0x28, 0xb8, 0x67, 0x41, 0x8a, 0x88, 0x5a,
|
||||
0x8b, 0x55, 0x5c, 0x38, 0xee, 0x1f, 0xdc, 0xa7, 0xb5, 0x7d, 0x7a, 0xef,
|
||||
0xed, 0xed, 0xfb, 0xd7, 0xfb, 0xbc, 0xe7, 0x9c, 0xe7, 0xfc, 0xce, 0x79,
|
||||
0xcf, 0x0f, 0x80, 0x11, 0x12, 0x26, 0x91, 0xe6, 0xa2, 0x6a, 0x00, 0x39,
|
||||
0x52, 0x85, 0x3c, 0x3a, 0xd8, 0x1f, 0x8f, 0x4f, 0x48, 0xc4, 0xc9, 0xbd,
|
||||
0x80, 0x02, 0x15, 0x48, 0xe0, 0x04, 0x20, 0x10, 0xe6, 0xcb, 0xc2, 0x67,
|
||||
0x05, 0xc5, 0x00, 0x00, 0xf0, 0x03, 0x79, 0x78, 0x7e, 0x74, 0xb0, 0x3f,
|
||||
0xfc, 0x01, 0xaf, 0x6f, 0x00, 0x02, 0x00, 0x70, 0xd5, 0x2e, 0x24, 0x12,
|
||||
0xc7, 0xe1, 0xff, 0x83, 0xba, 0x50, 0x26, 0x57, 0x00, 0x20, 0x91, 0x00,
|
||||
0xe0, 0x22, 0x12, 0xe7, 0x0b, 0x01, 0x90, 0x52, 0x00, 0xc8, 0x2e, 0x54,
|
||||
0xc8, 0x14, 0x00, 0xc8, 0x18, 0x00, 0xb0, 0x53, 0xb3, 0x64, 0x0a, 0x00,
|
||||
0x94, 0x00, 0x00, 0x6c, 0x79, 0x7c, 0x42, 0x22, 0x00, 0xaa, 0x0d, 0x00,
|
||||
0xec, 0xf4, 0x49, 0x3e, 0x05, 0x00, 0xd8, 0xa9, 0x93, 0xdc, 0x17, 0x00,
|
||||
0xd8, 0xa2, 0x1c, 0xa9, 0x08, 0x00, 0x8d, 0x01, 0x00, 0x99, 0x28, 0x47,
|
||||
0x24, 0x02, 0x40, 0xbb, 0x00, 0x60, 0x55, 0x81, 0x52, 0x2c, 0x02, 0xc0,
|
||||
0xc2, 0x00, 0xa0, 0xac, 0x40, 0x22, 0x2e, 0x04, 0xc0, 0xae, 0x01, 0x80,
|
||||
0x59, 0xb6, 0x32, 0x47, 0x02, 0x80, 0xbd, 0x05, 0x00, 0x76, 0x8e, 0x58,
|
||||
0x90, 0x0f, 0x40, 0x60, 0x00, 0x80, 0x99, 0x42, 0x2c, 0xcc, 0x00, 0x20,
|
||||
0x38, 0x02, 0x00, 0x43, 0x1e, 0x13, 0xcd, 0x03, 0x20, 0x4c, 0x03, 0xa0,
|
||||
0x30, 0xd2, 0xbf, 0xe0, 0xa9, 0x5f, 0x70, 0x85, 0xb8, 0x48, 0x01, 0x00,
|
||||
0xc0, 0xcb, 0x95, 0xcd, 0x97, 0x4b, 0xd2, 0x33, 0x14, 0xb8, 0x95, 0xd0,
|
||||
0x1a, 0x77, 0xf2, 0xf0, 0xe0, 0xe2, 0x21, 0xe2, 0xc2, 0x6c, 0xb1, 0x42,
|
||||
0x61, 0x17, 0x29, 0x10, 0x66, 0x09, 0xe4, 0x22, 0x9c, 0x97, 0x9b, 0x23,
|
||||
0x13, 0x48, 0xe7, 0x03, 0x4c, 0xce, 0x0c, 0x00, 0x00, 0x1a, 0xf9, 0xd1,
|
||||
0xc1, 0xfe, 0x38, 0x3f, 0x90, 0xe7, 0xe6, 0xe4, 0xe1, 0xe6, 0x66, 0xe7,
|
||||
0x6c, 0xef, 0xf4, 0xc5, 0xa2, 0xfe, 0x6b, 0xf0, 0x6f, 0x22, 0x3e, 0x21,
|
||||
0xf1, 0xdf, 0xfe, 0xbc, 0x8c, 0x02, 0x04, 0x00, 0x10, 0x4e, 0xcf, 0xef,
|
||||
0xda, 0x5f, 0xe5, 0xe5, 0xd6, 0x03, 0x70, 0xc7, 0x01, 0xb0, 0x75, 0xbf,
|
||||
0x6b, 0xa9, 0x5b, 0x00, 0xda, 0x56, 0x00, 0x68, 0xdf, 0xf9, 0x5d, 0x33,
|
||||
0xdb, 0x09, 0xa0, 0x5a, 0x0a, 0xd0, 0x7a, 0xf9, 0x8b, 0x79, 0x38, 0xfc,
|
||||
0x40, 0x1e, 0x9e, 0xa1, 0x50, 0xc8, 0x3c, 0x1d, 0x1c, 0x0a, 0x0b, 0x0b,
|
||||
0xed, 0x25, 0x62, 0xa1, 0xbd, 0x30, 0xe3, 0x8b, 0x3e, 0xff, 0x33, 0xe1,
|
||||
0x6f, 0xe0, 0x8b, 0x7e, 0xf6, 0xfc, 0x40, 0x1e, 0xfe, 0xdb, 0x7a, 0xf0,
|
||||
0x00, 0x71, 0x9a, 0x40, 0x99, 0xad, 0xc0, 0xa3, 0x83, 0xfd, 0x71, 0x61,
|
||||
0x6e, 0x76, 0xae, 0x52, 0x8e, 0xe7, 0xcb, 0x04, 0x42, 0x31, 0x6e, 0xf7,
|
||||
0xe7, 0x23, 0xfe, 0xc7, 0x85, 0x7f, 0xfd, 0x8e, 0x29, 0xd1, 0xe2, 0x34,
|
||||
0xb1, 0x5c, 0x2c, 0x15, 0x8a, 0xf1, 0x58, 0x89, 0xb8, 0x50, 0x22, 0x4d,
|
||||
0xc7, 0x79, 0xb9, 0x52, 0x91, 0x44, 0x21, 0xc9, 0x95, 0xe2, 0x12, 0xe9,
|
||||
0x7f, 0x32, 0xf1, 0x1f, 0x96, 0xfd, 0x09, 0x93, 0x77, 0x0d, 0x00, 0xac,
|
||||
0x86, 0x4f, 0xc0, 0x4e, 0xb6, 0x07, 0xb5, 0xcb, 0x6c, 0xc0, 0x7e, 0xee,
|
||||
0x01, 0x02, 0x8b, 0x0e, 0x58, 0xd2, 0x76, 0x00, 0x40, 0x7e, 0xf3, 0x2d,
|
||||
0x8c, 0x1a, 0x0b, 0x91, 0x00, 0x10, 0x67, 0x34, 0x32, 0x79, 0xf7, 0x00,
|
||||
0x00, 0x93, 0xbf, 0xf9, 0x8f, 0x40, 0x2b, 0x01, 0x00, 0xcd, 0x97, 0xa4,
|
||||
0xe3, 0x00, 0x00, 0xbc, 0xe8, 0x18, 0x5c, 0xa8, 0x94, 0x17, 0x4c, 0xc6,
|
||||
0x08, 0x00, 0x00, 0x44, 0xa0, 0x81, 0x2a, 0xb0, 0x41, 0x07, 0x0c, 0xc1,
|
||||
0x14, 0xac, 0xc0, 0x0e, 0x9c, 0xc1, 0x1d, 0xbc, 0xc0, 0x17, 0x02, 0x61,
|
||||
0x06, 0x44, 0x40, 0x0c, 0x24, 0xc0, 0x3c, 0x10, 0x42, 0x06, 0xe4, 0x80,
|
||||
0x1c, 0x0a, 0xa1, 0x18, 0x96, 0x41, 0x19, 0x54, 0xc0, 0x3a, 0xd8, 0x04,
|
||||
0xb5, 0xb0, 0x03, 0x1a, 0xa0, 0x11, 0x9a, 0xe1, 0x10, 0xb4, 0xc1, 0x31,
|
||||
0x38, 0x0d, 0xe7, 0xe0, 0x12, 0x5c, 0x81, 0xeb, 0x70, 0x17, 0x06, 0x60,
|
||||
0x18, 0x9e, 0xc2, 0x18, 0xbc, 0x86, 0x09, 0x04, 0x41, 0xc8, 0x08, 0x13,
|
||||
0x61, 0x21, 0x3a, 0x88, 0x11, 0x62, 0x8e, 0xd8, 0x22, 0xce, 0x08, 0x17,
|
||||
0x99, 0x8e, 0x04, 0x22, 0x61, 0x48, 0x34, 0x92, 0x80, 0xa4, 0x20, 0xe9,
|
||||
0x88, 0x14, 0x51, 0x22, 0xc5, 0xc8, 0x72, 0xa4, 0x02, 0xa9, 0x42, 0x6a,
|
||||
0x91, 0x5d, 0x48, 0x23, 0xf2, 0x2d, 0x72, 0x14, 0x39, 0x8d, 0x5c, 0x40,
|
||||
0xfa, 0x90, 0xdb, 0xc8, 0x20, 0x32, 0x8a, 0xfc, 0x8a, 0xbc, 0x47, 0x31,
|
||||
0x94, 0x81, 0xb2, 0x51, 0x03, 0xd4, 0x02, 0x75, 0x40, 0xb9, 0xa8, 0x1f,
|
||||
0x1a, 0x8a, 0xc6, 0xa0, 0x73, 0xd1, 0x74, 0x34, 0x0f, 0x5d, 0x80, 0x96,
|
||||
0xa2, 0x6b, 0xd1, 0x1a, 0xb4, 0x1e, 0x3d, 0x80, 0xb6, 0xa2, 0xa7, 0xd1,
|
||||
0x4b, 0xe8, 0x75, 0x74, 0x00, 0x7d, 0x8a, 0x8e, 0x63, 0x80, 0xd1, 0x31,
|
||||
0x0e, 0x66, 0x8c, 0xd9, 0x61, 0x5c, 0x8c, 0x87, 0x45, 0x60, 0x89, 0x58,
|
||||
0x1a, 0x26, 0xc7, 0x16, 0x63, 0xe5, 0x58, 0x35, 0x56, 0x8f, 0x35, 0x63,
|
||||
0x1d, 0x58, 0x37, 0x76, 0x15, 0x1b, 0xc0, 0x9e, 0x61, 0xef, 0x08, 0x24,
|
||||
0x02, 0x8b, 0x80, 0x13, 0xec, 0x08, 0x5e, 0x84, 0x10, 0xc2, 0x6c, 0x82,
|
||||
0x90, 0x90, 0x47, 0x58, 0x4c, 0x58, 0x43, 0xa8, 0x25, 0xec, 0x23, 0xb4,
|
||||
0x12, 0xba, 0x08, 0x57, 0x09, 0x83, 0x84, 0x31, 0xc2, 0x27, 0x22, 0x93,
|
||||
0xa8, 0x4f, 0xb4, 0x25, 0x7a, 0x12, 0xf9, 0xc4, 0x78, 0x62, 0x3a, 0xb1,
|
||||
0x90, 0x58, 0x46, 0xac, 0x26, 0xee, 0x21, 0x1e, 0x21, 0x9e, 0x25, 0x5e,
|
||||
0x27, 0x0e, 0x13, 0x5f, 0x93, 0x48, 0x24, 0x0e, 0xc9, 0x92, 0xe4, 0x4e,
|
||||
0x0a, 0x21, 0x25, 0x90, 0x32, 0x49, 0x0b, 0x49, 0x6b, 0x48, 0xdb, 0x48,
|
||||
0x2d, 0xa4, 0x53, 0xa4, 0x3e, 0xd2, 0x10, 0x69, 0x9c, 0x4c, 0x26, 0xeb,
|
||||
0x90, 0x6d, 0xc9, 0xde, 0xe4, 0x08, 0xb2, 0x80, 0xac, 0x20, 0x97, 0x91,
|
||||
0xb7, 0x90, 0x0f, 0x90, 0x4f, 0x92, 0xfb, 0xc9, 0xc3, 0xe4, 0xb7, 0x14,
|
||||
0x3a, 0xc5, 0x88, 0xe2, 0x4c, 0x09, 0xa2, 0x24, 0x52, 0xa4, 0x94, 0x12,
|
||||
0x4a, 0x35, 0x65, 0x3f, 0xe5, 0x04, 0xa5, 0x9f, 0x32, 0x42, 0x99, 0xa0,
|
||||
0xaa, 0x51, 0xcd, 0xa9, 0x9e, 0xd4, 0x08, 0xaa, 0x88, 0x3a, 0x9f, 0x5a,
|
||||
0x49, 0x6d, 0xa0, 0x76, 0x50, 0x2f, 0x53, 0x87, 0xa9, 0x13, 0x34, 0x75,
|
||||
0x9a, 0x25, 0xcd, 0x9b, 0x16, 0x43, 0xcb, 0xa4, 0x2d, 0xa3, 0xd5, 0xd0,
|
||||
0x9a, 0x69, 0x67, 0x69, 0xf7, 0x68, 0x2f, 0xe9, 0x74, 0xba, 0x09, 0xdd,
|
||||
0x83, 0x1e, 0x45, 0x97, 0xd0, 0x97, 0xd2, 0x6b, 0xe8, 0x07, 0xe9, 0xe7,
|
||||
0xe9, 0x83, 0xf4, 0x77, 0x0c, 0x0d, 0x86, 0x0d, 0x83, 0xc7, 0x48, 0x62,
|
||||
0x28, 0x19, 0x6b, 0x19, 0x7b, 0x19, 0xa7, 0x18, 0xb7, 0x19, 0x2f, 0x99,
|
||||
0x4c, 0xa6, 0x05, 0xd3, 0x97, 0x99, 0xc8, 0x54, 0x30, 0xd7, 0x32, 0x1b,
|
||||
0x99, 0x67, 0x98, 0x0f, 0x98, 0x6f, 0x55, 0x58, 0x2a, 0xf6, 0x2a, 0x7c,
|
||||
0x15, 0x91, 0xca, 0x12, 0x95, 0x3a, 0x95, 0x56, 0x95, 0x7e, 0x95, 0xe7,
|
||||
0xaa, 0x54, 0x55, 0x73, 0x55, 0x3f, 0xd5, 0x79, 0xaa, 0x0b, 0x54, 0xab,
|
||||
0x55, 0x0f, 0xab, 0x5e, 0x56, 0x7d, 0xa6, 0x46, 0x55, 0xb3, 0x50, 0xe3,
|
||||
0xa9, 0x09, 0xd4, 0x16, 0xab, 0xd5, 0xa9, 0x1d, 0x55, 0xbb, 0xa9, 0x36,
|
||||
0xae, 0xce, 0x52, 0x77, 0x52, 0x8f, 0x50, 0xcf, 0x51, 0x5f, 0xa3, 0xbe,
|
||||
0x5f, 0xfd, 0x82, 0xfa, 0x63, 0x0d, 0xb2, 0x86, 0x85, 0x46, 0xa0, 0x86,
|
||||
0x48, 0xa3, 0x54, 0x63, 0xb7, 0xc6, 0x19, 0x8d, 0x21, 0x16, 0xc6, 0x32,
|
||||
0x65, 0xf1, 0x58, 0x42, 0xd6, 0x72, 0x56, 0x03, 0xeb, 0x2c, 0x6b, 0x98,
|
||||
0x4d, 0x62, 0x5b, 0xb2, 0xf9, 0xec, 0x4c, 0x76, 0x05, 0xfb, 0x1b, 0x76,
|
||||
0x2f, 0x7b, 0x4c, 0x53, 0x43, 0x73, 0xaa, 0x66, 0xac, 0x66, 0x91, 0x66,
|
||||
0x9d, 0xe6, 0x71, 0xcd, 0x01, 0x0e, 0xc6, 0xb1, 0xe0, 0xf0, 0x39, 0xd9,
|
||||
0x9c, 0x4a, 0xce, 0x21, 0xce, 0x0d, 0xce, 0x7b, 0x2d, 0x03, 0x2d, 0x3f,
|
||||
0x2d, 0xb1, 0xd6, 0x6a, 0xad, 0x66, 0xad, 0x7e, 0xad, 0x37, 0xda, 0x7a,
|
||||
0xda, 0xbe, 0xda, 0x62, 0xed, 0x72, 0xed, 0x16, 0xed, 0xeb, 0xda, 0xef,
|
||||
0x75, 0x70, 0x9d, 0x40, 0x9d, 0x2c, 0x9d, 0xf5, 0x3a, 0x6d, 0x3a, 0xf7,
|
||||
0x75, 0x09, 0xba, 0x36, 0xba, 0x51, 0xba, 0x85, 0xba, 0xdb, 0x75, 0xcf,
|
||||
0xea, 0x3e, 0xd3, 0x63, 0xeb, 0x79, 0xe9, 0x09, 0xf5, 0xca, 0xf5, 0x0e,
|
||||
0xe9, 0xdd, 0xd1, 0x47, 0xf5, 0x6d, 0xf4, 0xa3, 0xf5, 0x17, 0xea, 0xef,
|
||||
0xd6, 0xef, 0xd1, 0x1f, 0x37, 0x30, 0x34, 0x08, 0x36, 0x90, 0x19, 0x6c,
|
||||
0x31, 0x38, 0x63, 0xf0, 0xcc, 0x90, 0x63, 0xe8, 0x6b, 0x98, 0x69, 0xb8,
|
||||
0xd1, 0xf0, 0x84, 0xe1, 0xa8, 0x11, 0xcb, 0x68, 0xba, 0x91, 0xc4, 0x68,
|
||||
0xa3, 0xd1, 0x49, 0xa3, 0x27, 0xb8, 0x26, 0xee, 0x87, 0x67, 0xe3, 0x35,
|
||||
0x78, 0x17, 0x3e, 0x66, 0xac, 0x6f, 0x1c, 0x62, 0xac, 0x34, 0xde, 0x65,
|
||||
0xdc, 0x6b, 0x3c, 0x61, 0x62, 0x69, 0x32, 0xdb, 0xa4, 0xc4, 0xa4, 0xc5,
|
||||
0xe4, 0xbe, 0x29, 0xcd, 0x94, 0x6b, 0x9a, 0x66, 0xba, 0xd1, 0xb4, 0xd3,
|
||||
0x74, 0xcc, 0xcc, 0xc8, 0x2c, 0xdc, 0xac, 0xd8, 0xac, 0xc9, 0xec, 0x8e,
|
||||
0x39, 0xd5, 0x9c, 0x6b, 0x9e, 0x61, 0xbe, 0xd9, 0xbc, 0xdb, 0xfc, 0x8d,
|
||||
0x85, 0xa5, 0x45, 0x9c, 0xc5, 0x4a, 0x8b, 0x36, 0x8b, 0xc7, 0x96, 0xda,
|
||||
0x96, 0x7c, 0xcb, 0x05, 0x96, 0x4d, 0x96, 0xf7, 0xac, 0x98, 0x56, 0x3e,
|
||||
0x56, 0x79, 0x56, 0xf5, 0x56, 0xd7, 0xac, 0x49, 0xd6, 0x5c, 0xeb, 0x2c,
|
||||
0xeb, 0x6d, 0xd6, 0x57, 0x6c, 0x50, 0x1b, 0x57, 0x9b, 0x0c, 0x9b, 0x3a,
|
||||
0x9b, 0xcb, 0xb6, 0xa8, 0xad, 0x9b, 0xad, 0xc4, 0x76, 0x9b, 0x6d, 0xdf,
|
||||
0x14, 0xe2, 0x14, 0x8f, 0x29, 0xd2, 0x29, 0xf5, 0x53, 0x6e, 0xda, 0x31,
|
||||
0xec, 0xfc, 0xec, 0x0a, 0xec, 0x9a, 0xec, 0x06, 0xed, 0x39, 0xf6, 0x61,
|
||||
0xf6, 0x25, 0xf6, 0x6d, 0xf6, 0xcf, 0x1d, 0xcc, 0x1c, 0x12, 0x1d, 0xd6,
|
||||
0x3b, 0x74, 0x3b, 0x7c, 0x72, 0x74, 0x75, 0xcc, 0x76, 0x6c, 0x70, 0xbc,
|
||||
0xeb, 0xa4, 0xe1, 0x34, 0xc3, 0xa9, 0xc4, 0xa9, 0xc3, 0xe9, 0x57, 0x67,
|
||||
0x1b, 0x67, 0xa1, 0x73, 0x9d, 0xf3, 0x35, 0x17, 0xa6, 0x4b, 0x90, 0xcb,
|
||||
0x12, 0x97, 0x76, 0x97, 0x17, 0x53, 0x6d, 0xa7, 0x8a, 0xa7, 0x6e, 0x9f,
|
||||
0x7a, 0xcb, 0x95, 0xe5, 0x1a, 0xee, 0xba, 0xd2, 0xb5, 0xd3, 0xf5, 0xa3,
|
||||
0x9b, 0xbb, 0x9b, 0xdc, 0xad, 0xd9, 0x6d, 0xd4, 0xdd, 0xcc, 0x3d, 0xc5,
|
||||
0x7d, 0xab, 0xfb, 0x4d, 0x2e, 0x9b, 0x1b, 0xc9, 0x5d, 0xc3, 0x3d, 0xef,
|
||||
0x41, 0xf4, 0xf0, 0xf7, 0x58, 0xe2, 0x71, 0xcc, 0xe3, 0x9d, 0xa7, 0x9b,
|
||||
0xa7, 0xc2, 0xf3, 0x90, 0xe7, 0x2f, 0x5e, 0x76, 0x5e, 0x59, 0x5e, 0xfb,
|
||||
0xbd, 0x1e, 0x4f, 0xb3, 0x9c, 0x26, 0x9e, 0xd6, 0x30, 0x6d, 0xc8, 0xdb,
|
||||
0xc4, 0x5b, 0xe0, 0xbd, 0xcb, 0x7b, 0x60, 0x3a, 0x3e, 0x3d, 0x65, 0xfa,
|
||||
0xce, 0xe9, 0x03, 0x3e, 0xc6, 0x3e, 0x02, 0x9f, 0x7a, 0x9f, 0x87, 0xbe,
|
||||
0xa6, 0xbe, 0x22, 0xdf, 0x3d, 0xbe, 0x23, 0x7e, 0xd6, 0x7e, 0x99, 0x7e,
|
||||
0x07, 0xfc, 0x9e, 0xfb, 0x3b, 0xfa, 0xcb, 0xfd, 0x8f, 0xf8, 0xbf, 0xe1,
|
||||
0x79, 0xf2, 0x16, 0xf1, 0x4e, 0x05, 0x60, 0x01, 0xc1, 0x01, 0xe5, 0x01,
|
||||
0xbd, 0x81, 0x1a, 0x81, 0xb3, 0x03, 0x6b, 0x03, 0x1f, 0x04, 0x99, 0x04,
|
||||
0xa5, 0x07, 0x35, 0x05, 0x8d, 0x05, 0xbb, 0x06, 0x2f, 0x0c, 0x3e, 0x15,
|
||||
0x42, 0x0c, 0x09, 0x0d, 0x59, 0x1f, 0x72, 0x93, 0x6f, 0xc0, 0x17, 0xf2,
|
||||
0x1b, 0xf9, 0x63, 0x33, 0xdc, 0x67, 0x2c, 0x9a, 0xd1, 0x15, 0xca, 0x08,
|
||||
0x9d, 0x15, 0x5a, 0x1b, 0xfa, 0x30, 0xcc, 0x26, 0x4c, 0x1e, 0xd6, 0x11,
|
||||
0x8e, 0x86, 0xcf, 0x08, 0xdf, 0x10, 0x7e, 0x6f, 0xa6, 0xf9, 0x4c, 0xe9,
|
||||
0xcc, 0xb6, 0x08, 0x88, 0xe0, 0x47, 0x6c, 0x88, 0xb8, 0x1f, 0x69, 0x19,
|
||||
0x99, 0x17, 0xf9, 0x7d, 0x14, 0x29, 0x2a, 0x32, 0xaa, 0x2e, 0xea, 0x51,
|
||||
0xb4, 0x53, 0x74, 0x71, 0x74, 0xf7, 0x2c, 0xd6, 0xac, 0xe4, 0x59, 0xfb,
|
||||
0x67, 0xbd, 0x8e, 0xf1, 0x8f, 0xa9, 0x8c, 0xb9, 0x3b, 0xdb, 0x6a, 0xb6,
|
||||
0x72, 0x76, 0x67, 0xac, 0x6a, 0x6c, 0x52, 0x6c, 0x63, 0xec, 0x9b, 0xb8,
|
||||
0x80, 0xb8, 0xaa, 0xb8, 0x81, 0x78, 0x87, 0xf8, 0x45, 0xf1, 0x97, 0x12,
|
||||
0x74, 0x13, 0x24, 0x09, 0xed, 0x89, 0xe4, 0xc4, 0xd8, 0xc4, 0x3d, 0x89,
|
||||
0xe3, 0x73, 0x02, 0xe7, 0x6c, 0x9a, 0x33, 0x9c, 0xe4, 0x9a, 0x54, 0x96,
|
||||
0x74, 0x63, 0xae, 0xe5, 0xdc, 0xa2, 0xb9, 0x17, 0xe6, 0xe9, 0xce, 0xcb,
|
||||
0x9e, 0x77, 0x3c, 0x59, 0x35, 0x59, 0x90, 0x7c, 0x38, 0x85, 0x98, 0x12,
|
||||
0x97, 0xb2, 0x3f, 0xe5, 0x83, 0x20, 0x42, 0x50, 0x2f, 0x18, 0x4f, 0xe5,
|
||||
0xa7, 0x6e, 0x4d, 0x1d, 0x13, 0xf2, 0x84, 0x9b, 0x85, 0x4f, 0x45, 0xbe,
|
||||
0xa2, 0x8d, 0xa2, 0x51, 0xb1, 0xb7, 0xb8, 0x4a, 0x3c, 0x92, 0xe6, 0x9d,
|
||||
0x56, 0x95, 0xf6, 0x38, 0xdd, 0x3b, 0x7d, 0x43, 0xfa, 0x68, 0x86, 0x4f,
|
||||
0x46, 0x75, 0xc6, 0x33, 0x09, 0x4f, 0x52, 0x2b, 0x79, 0x91, 0x19, 0x92,
|
||||
0xb9, 0x23, 0xf3, 0x4d, 0x56, 0x44, 0xd6, 0xde, 0xac, 0xcf, 0xd9, 0x71,
|
||||
0xd9, 0x2d, 0x39, 0x94, 0x9c, 0x94, 0x9c, 0xa3, 0x52, 0x0d, 0x69, 0x96,
|
||||
0xb4, 0x2b, 0xd7, 0x30, 0xb7, 0x28, 0xb7, 0x4f, 0x66, 0x2b, 0x2b, 0x93,
|
||||
0x0d, 0xe4, 0x79, 0xe6, 0x6d, 0xca, 0x1b, 0x93, 0x87, 0xca, 0xf7, 0xe4,
|
||||
0x23, 0xf9, 0x73, 0xf3, 0xdb, 0x15, 0x6c, 0x85, 0x4c, 0xd1, 0xa3, 0xb4,
|
||||
0x52, 0xae, 0x50, 0x0e, 0x16, 0x4c, 0x2f, 0xa8, 0x2b, 0x78, 0x5b, 0x18,
|
||||
0x5b, 0x78, 0xb8, 0x48, 0xbd, 0x48, 0x5a, 0xd4, 0x33, 0xdf, 0x66, 0xfe,
|
||||
0xea, 0xf9, 0x23, 0x0b, 0x82, 0x16, 0x7c, 0xbd, 0x90, 0xb0, 0x50, 0xb8,
|
||||
0xb0, 0xb3, 0xd8, 0xb8, 0x78, 0x59, 0xf1, 0xe0, 0x22, 0xbf, 0x45, 0xbb,
|
||||
0x16, 0x23, 0x8b, 0x53, 0x17, 0x77, 0x2e, 0x31, 0x5d, 0x52, 0xba, 0x64,
|
||||
0x78, 0x69, 0xf0, 0xd2, 0x7d, 0xcb, 0x68, 0xcb, 0xb2, 0x96, 0xfd, 0x50,
|
||||
0xe2, 0x58, 0x52, 0x55, 0xf2, 0x6a, 0x79, 0xdc, 0xf2, 0x8e, 0x52, 0x83,
|
||||
0xd2, 0xa5, 0xa5, 0x43, 0x2b, 0x82, 0x57, 0x34, 0x95, 0xa9, 0x94, 0xc9,
|
||||
0xcb, 0x6e, 0xae, 0xf4, 0x5a, 0xb9, 0x63, 0x15, 0x61, 0x95, 0x64, 0x55,
|
||||
0xef, 0x6a, 0x97, 0xd5, 0x5b, 0x56, 0x7f, 0x2a, 0x17, 0x95, 0x5f, 0xac,
|
||||
0x70, 0xac, 0xa8, 0xae, 0xf8, 0xb0, 0x46, 0xb8, 0xe6, 0xe2, 0x57, 0x4e,
|
||||
0x5f, 0xd5, 0x7c, 0xf5, 0x79, 0x6d, 0xda, 0xda, 0xde, 0x4a, 0xb7, 0xca,
|
||||
0xed, 0xeb, 0x48, 0xeb, 0xa4, 0xeb, 0x6e, 0xac, 0xf7, 0x59, 0xbf, 0xaf,
|
||||
0x4a, 0xbd, 0x6a, 0x41, 0xd5, 0xd0, 0x86, 0xf0, 0x0d, 0xad, 0x1b, 0xf1,
|
||||
0x8d, 0xe5, 0x1b, 0x5f, 0x6d, 0x4a, 0xde, 0x74, 0xa1, 0x7a, 0x6a, 0xf5,
|
||||
0x8e, 0xcd, 0xb4, 0xcd, 0xca, 0xcd, 0x03, 0x35, 0x61, 0x35, 0xed, 0x5b,
|
||||
0xcc, 0xb6, 0xac, 0xdb, 0xf2, 0xa1, 0x36, 0xa3, 0xf6, 0x7a, 0x9d, 0x7f,
|
||||
0x5d, 0xcb, 0x56, 0xfd, 0xad, 0xab, 0xb7, 0xbe, 0xd9, 0x26, 0xda, 0xd6,
|
||||
0xbf, 0xdd, 0x77, 0x7b, 0xf3, 0x0e, 0x83, 0x1d, 0x15, 0x3b, 0xde, 0xef,
|
||||
0x94, 0xec, 0xbc, 0xb5, 0x2b, 0x78, 0x57, 0x6b, 0xbd, 0x45, 0x7d, 0xf5,
|
||||
0x6e, 0xd2, 0xee, 0x82, 0xdd, 0x8f, 0x1a, 0x62, 0x1b, 0xba, 0xbf, 0xe6,
|
||||
0x7e, 0xdd, 0xb8, 0x47, 0x77, 0x4f, 0xc5, 0x9e, 0x8f, 0x7b, 0xa5, 0x7b,
|
||||
0x07, 0xf6, 0x45, 0xef, 0xeb, 0x6a, 0x74, 0x6f, 0x6c, 0xdc, 0xaf, 0xbf,
|
||||
0xbf, 0xb2, 0x09, 0x6d, 0x52, 0x36, 0x8d, 0x1e, 0x48, 0x3a, 0x70, 0xe5,
|
||||
0x9b, 0x80, 0x6f, 0xda, 0x9b, 0xed, 0x9a, 0x77, 0xb5, 0x70, 0x5a, 0x2a,
|
||||
0x0e, 0xc2, 0x41, 0xe5, 0xc1, 0x27, 0xdf, 0xa6, 0x7c, 0x7b, 0xe3, 0x50,
|
||||
0xe8, 0xa1, 0xce, 0xc3, 0xdc, 0xc3, 0xcd, 0xdf, 0x99, 0x7f, 0xb7, 0xf5,
|
||||
0x08, 0xeb, 0x48, 0x79, 0x2b, 0xd2, 0x3a, 0xbf, 0x75, 0xac, 0x2d, 0xa3,
|
||||
0x6d, 0xa0, 0x3d, 0xa1, 0xbd, 0xef, 0xe8, 0x8c, 0xa3, 0x9d, 0x1d, 0x5e,
|
||||
0x1d, 0x47, 0xbe, 0xb7, 0xff, 0x7e, 0xef, 0x31, 0xe3, 0x63, 0x75, 0xc7,
|
||||
0x35, 0x8f, 0x57, 0x9e, 0xa0, 0x9d, 0x28, 0x3d, 0xf1, 0xf9, 0xe4, 0x82,
|
||||
0x93, 0xe3, 0xa7, 0x64, 0xa7, 0x9e, 0x9d, 0x4e, 0x3f, 0x3d, 0xd4, 0x99,
|
||||
0xdc, 0x79, 0xf7, 0x4c, 0xfc, 0x99, 0x6b, 0x5d, 0x51, 0x5d, 0xbd, 0x67,
|
||||
0x43, 0xcf, 0x9e, 0x3f, 0x17, 0x74, 0xee, 0x4c, 0xb7, 0x5f, 0xf7, 0xc9,
|
||||
0xf3, 0xde, 0xe7, 0x8f, 0x5d, 0xf0, 0xbc, 0x70, 0xf4, 0x22, 0xf7, 0x62,
|
||||
0xdb, 0x25, 0xb7, 0x4b, 0xad, 0x3d, 0xae, 0x3d, 0x47, 0x7e, 0x70, 0xfd,
|
||||
0xe1, 0x48, 0xaf, 0x5b, 0x6f, 0xeb, 0x65, 0xf7, 0xcb, 0xed, 0x57, 0x3c,
|
||||
0xae, 0x74, 0xf4, 0x4d, 0xeb, 0x3b, 0xd1, 0xef, 0xd3, 0x7f, 0xfa, 0x6a,
|
||||
0xc0, 0xd5, 0x73, 0xd7, 0xf8, 0xd7, 0x2e, 0x5d, 0x9f, 0x79, 0xbd, 0xef,
|
||||
0xc6, 0xec, 0x1b, 0xb7, 0x6e, 0x26, 0xdd, 0x1c, 0xb8, 0x25, 0xba, 0xf5,
|
||||
0xf8, 0x76, 0xf6, 0xed, 0x17, 0x77, 0x0a, 0xee, 0x4c, 0xdc, 0x5d, 0x7a,
|
||||
0x8f, 0x78, 0xaf, 0xfc, 0xbe, 0xda, 0xfd, 0xea, 0x07, 0xfa, 0x0f, 0xea,
|
||||
0x7f, 0xb4, 0xfe, 0xb1, 0x65, 0xc0, 0x6d, 0xe0, 0xf8, 0x60, 0xc0, 0x60,
|
||||
0xcf, 0xc3, 0x59, 0x0f, 0xef, 0x0e, 0x09, 0x87, 0x9e, 0xfe, 0x94, 0xff,
|
||||
0xd3, 0x87, 0xe1, 0xd2, 0x47, 0xcc, 0x47, 0xd5, 0x23, 0x46, 0x23, 0x8d,
|
||||
0x8f, 0x9d, 0x1f, 0x1f, 0x1b, 0x0d, 0x1a, 0xbd, 0xf2, 0x64, 0xce, 0x93,
|
||||
0xe1, 0xa7, 0xb2, 0xa7, 0x13, 0xcf, 0xca, 0x7e, 0x56, 0xff, 0x79, 0xeb,
|
||||
0x73, 0xab, 0xe7, 0xdf, 0xfd, 0xe2, 0xfb, 0x4b, 0xcf, 0x58, 0xfc, 0xd8,
|
||||
0xf0, 0x0b, 0xf9, 0x8b, 0xcf, 0xbf, 0xae, 0x79, 0xa9, 0xf3, 0x72, 0xef,
|
||||
0xab, 0xa9, 0xaf, 0x3a, 0xc7, 0x23, 0xc7, 0x1f, 0xbc, 0xce, 0x79, 0x3d,
|
||||
0xf1, 0xa6, 0xfc, 0xad, 0xce, 0xdb, 0x7d, 0xef, 0xb8, 0xef, 0xba, 0xdf,
|
||||
0xc7, 0xbd, 0x1f, 0x99, 0x28, 0xfc, 0x40, 0xfe, 0x50, 0xf3, 0xd1, 0xfa,
|
||||
0x63, 0xc7, 0xa7, 0xd0, 0x4f, 0xf7, 0x3e, 0xe7, 0x7c, 0xfe, 0xfc, 0x2f,
|
||||
0xf7, 0x84, 0xf3, 0xfb, 0x80, 0x39, 0x25, 0x11, 0x00, 0x00, 0x00, 0x09,
|
||||
0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13,
|
||||
0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d,
|
||||
0x45, 0x07, 0xdc, 0x0b, 0x0e, 0x0e, 0x25, 0x16, 0x28, 0x9e, 0x78, 0x6a,
|
||||
0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8,
|
||||
0xff, 0xff, 0x3f, 0x00, 0x05, 0xfe, 0x02, 0xfe, 0xdc, 0xcc, 0x59, 0xe7,
|
||||
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
|
||||
};
|
||||
|
||||
static IWICImagingFactory *factory;
|
||||
|
||||
static const char *debugstr_guid(const GUID *guid)
|
||||
{
|
||||
static char buf[50];
|
||||
|
||||
if (!guid) return "(null)";
|
||||
sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
|
||||
guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
|
||||
guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
|
||||
guid->Data4[5], guid->Data4[6], guid->Data4[7]);
|
||||
return buf;
|
||||
}
|
||||
|
||||
static IWICBitmapDecoder *create_decoder(const void *image_data, UINT image_size)
|
||||
{
|
||||
HGLOBAL hmem;
|
||||
BYTE *data;
|
||||
HRESULT hr;
|
||||
IWICBitmapDecoder *decoder = NULL;
|
||||
IStream *stream;
|
||||
GUID format;
|
||||
|
||||
hmem = GlobalAlloc(0, image_size);
|
||||
data = GlobalLock(hmem);
|
||||
memcpy(data, image_data, image_size);
|
||||
GlobalUnlock(hmem);
|
||||
|
||||
hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
|
||||
ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);
|
||||
ok(hr == S_OK, "CreateDecoderFromStream error %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoder_GetContainerFormat(decoder, &format);
|
||||
ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&format, &GUID_ContainerFormatPng),
|
||||
"wrong container format %s\n", debugstr_guid(&format));
|
||||
|
||||
IStream_Release(stream);
|
||||
|
||||
return decoder;
|
||||
}
|
||||
|
||||
static void test_color_contexts(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICBitmapFrameDecode *frame;
|
||||
IWICColorContext *context;
|
||||
WICColorContextType type;
|
||||
UINT count, colorspace, size;
|
||||
BYTE *buffer;
|
||||
|
||||
decoder = create_decoder(png_no_color_profile, sizeof(png_no_color_profile));
|
||||
ok(decoder != 0, "Failed to load PNG image data\n");
|
||||
|
||||
/* global color context */
|
||||
hr = IWICBitmapDecoder_GetColorContexts(decoder, 0, NULL, NULL);
|
||||
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "GetColorContexts error %#x\n", hr);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoder_GetColorContexts(decoder, 0, NULL, &count);
|
||||
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "GetColorContexts error %#x\n", hr);
|
||||
ok(count == 0xdeadbeef, "unexpected count %u\n", count);
|
||||
|
||||
/* frame color context */
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, &count);
|
||||
ok(hr == S_OK, "GetColorContexts error %#x\n", hr);
|
||||
ok(!count, "unexpected count %u\n", count);
|
||||
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
|
||||
decoder = create_decoder(png_color_profile, sizeof(png_color_profile));
|
||||
ok(decoder != 0, "Failed to load PNG image data\n");
|
||||
|
||||
/* global color context */
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoder_GetColorContexts(decoder, 0, NULL, &count);
|
||||
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "GetColorContexts error %#x\n", hr);
|
||||
ok(count == 0xdeadbeef, "unexpected count %u\n", count);
|
||||
|
||||
/* frame color context */
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
count = 0xdeadbeef;
|
||||
hr = IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, &count);
|
||||
ok(hr == S_OK, "GetColorContexts error %#x\n", hr);
|
||||
ok(count == 1, "unexpected count %u\n", count);
|
||||
|
||||
hr = IWICImagingFactory_CreateColorContext(factory, NULL);
|
||||
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreateColorContext(factory, &context);
|
||||
ok(hr == S_OK, "CreateColorContext error %#x\n", hr);
|
||||
|
||||
hr = IWICColorContext_GetType(context, NULL);
|
||||
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
|
||||
|
||||
type = 0xdeadbeef;
|
||||
hr = IWICColorContext_GetType(context, &type);
|
||||
ok(hr == S_OK, "GetType error %#x\n", hr);
|
||||
ok(type == WICColorContextUninitialized, "unexpected type %u\n", type);
|
||||
|
||||
hr = IWICColorContext_GetProfileBytes(context, 0, NULL, NULL);
|
||||
ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetProfileBytes error %#x\n", hr);
|
||||
|
||||
size = 0;
|
||||
hr = IWICColorContext_GetProfileBytes(context, 0, NULL, &size);
|
||||
ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetProfileBytes error %#x\n", hr);
|
||||
ok(!size, "unexpected size %u\n", size);
|
||||
|
||||
hr = IWICColorContext_GetExifColorSpace(context, NULL);
|
||||
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
|
||||
|
||||
colorspace = 0xdeadbeef;
|
||||
hr = IWICColorContext_GetExifColorSpace(context, &colorspace);
|
||||
ok(hr == S_OK, "GetExifColorSpace error %#x\n", hr);
|
||||
ok(colorspace == 0xffffffff, "unexpected color space %u\n", colorspace);
|
||||
|
||||
hr = IWICColorContext_InitializeFromExifColorSpace(context, 0);
|
||||
ok(hr == S_OK, "InitializeFromExifColorSpace error %#x\n", hr);
|
||||
|
||||
hr = IWICColorContext_InitializeFromExifColorSpace(context, 1);
|
||||
ok(hr == S_OK, "InitializeFromExifColorSpace error %#x\n", hr);
|
||||
|
||||
hr = IWICColorContext_InitializeFromExifColorSpace(context, 2);
|
||||
ok(hr == S_OK, "InitializeFromExifColorSpace error %#x\n", hr);
|
||||
|
||||
colorspace = 0xdeadbeef;
|
||||
hr = IWICColorContext_GetExifColorSpace(context, &colorspace);
|
||||
ok(hr == S_OK, "GetExifColorSpace error %#x\n", hr);
|
||||
ok(colorspace == 2, "unexpected color space %u\n", colorspace);
|
||||
|
||||
size = 0;
|
||||
hr = IWICColorContext_GetProfileBytes(context, 0, NULL, &size);
|
||||
ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetProfileBytes error %#x\n", hr);
|
||||
ok(!size, "unexpected size %u\n", size);
|
||||
|
||||
type = 0xdeadbeef;
|
||||
hr = IWICColorContext_GetType(context, &type);
|
||||
ok(hr == S_OK, "GetType error %#x\n", hr);
|
||||
ok(type == WICColorContextExifColorSpace, "unexpected type %u\n", type);
|
||||
|
||||
hr = IWICBitmapFrameDecode_GetColorContexts(frame, count, &context, &count);
|
||||
ok(hr == WINCODEC_ERR_WRONGSTATE, "GetColorContexts error %#x\n", hr);
|
||||
|
||||
IWICColorContext_Release(context);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreateColorContext(factory, &context);
|
||||
ok(hr == S_OK, "CreateColorContext error %#x\n", hr);
|
||||
|
||||
count = 1;
|
||||
hr = IWICBitmapFrameDecode_GetColorContexts(frame, count, &context, &count);
|
||||
ok(hr == S_OK, "GetColorContexts error %#x\n", hr);
|
||||
|
||||
hr = IWICColorContext_GetProfileBytes(context, 0, NULL, NULL);
|
||||
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
|
||||
|
||||
size = 0;
|
||||
hr = IWICColorContext_GetProfileBytes(context, 0, NULL, &size);
|
||||
ok(hr == S_OK, "GetProfileBytes error %#x\n", hr);
|
||||
ok(size, "unexpected size %u\n", size);
|
||||
|
||||
buffer = HeapAlloc(GetProcessHeap(), 0, size);
|
||||
hr = IWICColorContext_GetProfileBytes(context, size, buffer, &size);
|
||||
ok(hr == S_OK, "GetProfileBytes error %#x\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, buffer);
|
||||
|
||||
type = 0xdeadbeef;
|
||||
hr = IWICColorContext_GetType(context, &type);
|
||||
ok(hr == S_OK, "GetType error %#x\n", hr);
|
||||
ok(type == WICColorContextProfile, "unexpected type %u\n", type);
|
||||
|
||||
colorspace = 0xdeadbeef;
|
||||
hr = IWICColorContext_GetExifColorSpace(context, &colorspace);
|
||||
ok(hr == S_OK, "GetExifColorSpace error %#x\n", hr);
|
||||
ok(colorspace == 0xffffffff, "unexpected color space %u\n", colorspace);
|
||||
|
||||
hr = IWICColorContext_InitializeFromExifColorSpace(context, 1);
|
||||
ok(hr == WINCODEC_ERR_WRONGSTATE, "InitializeFromExifColorSpace error %#x\n", hr);
|
||||
|
||||
IWICColorContext_Release(context);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
}
|
||||
|
||||
START_TEST(pngformat)
|
||||
{
|
||||
HRESULT hr;
|
||||
|
||||
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICImagingFactory, (void **)&factory);
|
||||
ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
|
||||
if (FAILED(hr)) return;
|
||||
|
||||
test_color_contexts();
|
||||
|
||||
IWICImagingFactory_Release(factory);
|
||||
CoUninitialize();
|
||||
}
|
||||
744
rostests/winetests/windowscodecs/stream.c
Normal file
744
rostests/winetests/windowscodecs/stream.c
Normal file
|
|
@ -0,0 +1,744 @@
|
|||
/*
|
||||
* Copyright 2009 Tony Wasserka
|
||||
*
|
||||
* 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 "wine/test.h"
|
||||
|
||||
#define COBJMACROS
|
||||
#include "wincodec.h"
|
||||
|
||||
static void test_StreamOnMemory(void)
|
||||
{
|
||||
IWICImagingFactory *pFactory;
|
||||
IWICStream *pStream, *pBufStream;
|
||||
const BYTE CmpMem[] = {
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
||||
};
|
||||
const BYTE CmpMemOverlap[] = {
|
||||
0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
||||
};
|
||||
const BYTE ZeroMem[10] = {0};
|
||||
BYTE Memory[64], MemBuf[64];
|
||||
LARGE_INTEGER LargeNull, LargeInt, SeekPos;
|
||||
ULARGE_INTEGER uLargeNull, uNewPos;
|
||||
ULONG uBytesRead, uBytesWritten;
|
||||
HRESULT hr;
|
||||
STATSTG Stats;
|
||||
|
||||
LargeNull.QuadPart = 0;
|
||||
uLargeNull.QuadPart = 0;
|
||||
SeekPos.QuadPart = 5;
|
||||
|
||||
memcpy(Memory, CmpMem, sizeof(CmpMem));
|
||||
|
||||
CoInitialize(NULL);
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&pFactory);
|
||||
if(FAILED(hr)) {
|
||||
skip("CoCreateInstance returned with %#x, expected %#x\n", hr, S_OK);
|
||||
return;
|
||||
}
|
||||
|
||||
hr = IWICImagingFactory_CreateStream(pFactory, &pStream);
|
||||
ok(hr == S_OK, "CreateStream returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(FAILED(hr)) {
|
||||
skip("Failed to create stream\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* InitializeFromMemory */
|
||||
hr = IWICStream_InitializeFromMemory(pStream, NULL, sizeof(Memory)); /* memory = NULL */
|
||||
ok(hr == E_INVALIDARG, "InitializeFromMemory returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
|
||||
hr = IWICStream_InitializeFromMemory(pStream, Memory, 0); /* size = 0 */
|
||||
ok(hr == S_OK, "InitializeFromMemory returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
hr = IWICStream_InitializeFromMemory(pStream, Memory, sizeof(Memory)); /* stream already initialized */
|
||||
ok(hr == WINCODEC_ERR_WRONGSTATE, "InitializeFromMemory returned with %#x, expected %#x\n", hr, WINCODEC_ERR_WRONGSTATE);
|
||||
|
||||
/* recreate stream */
|
||||
IWICStream_Release(pStream);
|
||||
hr = IWICImagingFactory_CreateStream(pFactory, &pStream);
|
||||
ok(hr == S_OK, "CreateStream failed with %#x\n", hr);
|
||||
|
||||
hr = IWICStream_InitializeFromMemory(pStream, Memory, sizeof(Memory));
|
||||
ok(hr == S_OK, "InitializeFromMemory returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
/* IWICStream does not maintain an independent copy of the backing memory buffer. */
|
||||
memcpy(Memory, ZeroMem, sizeof(ZeroMem));
|
||||
hr = IWICStream_Read(pStream, MemBuf, sizeof(ZeroMem), &uBytesRead);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == sizeof(ZeroMem), "Read %u bytes\n", uBytesRead);
|
||||
ok(memcmp(MemBuf, ZeroMem, sizeof(ZeroMem)) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Write(pStream, CmpMem, sizeof(CmpMem), &uBytesWritten);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
/* Seek */
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
LargeInt.u.HighPart = 1;
|
||||
LargeInt.u.LowPart = 0;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pStream, LargeInt, STREAM_SEEK_SET, &uNewPos);
|
||||
ok(hr == HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW), "Seek returned with %#x, expected %#x\n", hr, HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW));
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
LargeInt.QuadPart = sizeof(Memory) + 10;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pStream, LargeInt, STREAM_SEEK_SET, &uNewPos);
|
||||
ok(hr == E_INVALIDARG, "Seek returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
LargeInt.QuadPart = 1;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pStream, LargeInt, STREAM_SEEK_END, &uNewPos);
|
||||
ok(hr == E_INVALIDARG, "Seek returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
LargeInt.QuadPart = -1;
|
||||
hr = IWICStream_Seek(pStream, LargeInt, STREAM_SEEK_END, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == sizeof(Memory) - 1, "bSeek cursor moved to position (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart);
|
||||
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, &uNewPos); /* reset seek pointer */
|
||||
LargeInt.QuadPart = -(LONGLONG)sizeof(Memory) - 5;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pStream, LargeInt, STREAM_SEEK_END, &uNewPos);
|
||||
ok(hr == HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW),
|
||||
"Seek returned with %#x, expected %#x\n", hr, HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW));
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0); /* remains unchanged */
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
|
||||
/* Read */
|
||||
hr = IWICStream_Read(pStream, MemBuf, 12, &uBytesRead);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 12, "Read %u bytes, expected %u\n", uBytesRead, 12);
|
||||
ok(memcmp(MemBuf, CmpMem, 12) == 0, "Read returned invalid data!\n");
|
||||
|
||||
/* check whether the seek pointer has moved correctly */
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesRead, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesRead);
|
||||
}
|
||||
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Read(pStream, Memory, 10, &uBytesRead); /* source = dest */
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 10, "Read %u bytes, expected %u\n", uBytesRead, 10);
|
||||
ok(memcmp(Memory, CmpMem, uBytesRead) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
|
||||
IWICStream_Seek(pStream, SeekPos, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Read(pStream, Memory, 10, &uBytesRead); /* source and dest overlap */
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 10, "Read %u bytes, expected %u\n", uBytesRead, 10);
|
||||
ok(memcmp(Memory, CmpMemOverlap, uBytesRead) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
|
||||
memcpy(Memory, CmpMem, sizeof(CmpMem));
|
||||
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Read(pStream, Memory, sizeof(Memory) + 10, &uBytesRead); /* request too many bytes */
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == sizeof(Memory), "Read %u bytes\n", uBytesRead);
|
||||
ok(memcmp(Memory, CmpMem, uBytesRead) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
|
||||
hr = IWICStream_Read(pStream, NULL, 1, &uBytesRead); /* destination buffer = NULL */
|
||||
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
|
||||
hr = IWICStream_Read(pStream, MemBuf, 0, &uBytesRead); /* read 0 bytes */
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
hr = IWICStream_Read(pStream, NULL, 0, &uBytesRead);
|
||||
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
|
||||
hr = IWICStream_Read(pStream, NULL, 0, NULL);
|
||||
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
|
||||
hr = IWICStream_Read(pStream, MemBuf, 1, NULL);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
ZeroMemory(MemBuf, sizeof(MemBuf));
|
||||
hr = IWICStream_Read(pStream, MemBuf, sizeof(Memory) + 10, &uBytesRead);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == sizeof(Memory), "Read %u bytes\n", uBytesRead);
|
||||
ok(memcmp(Memory, CmpMem, 64) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
|
||||
/* Write */
|
||||
MemBuf[0] = CmpMem[0] + 1;
|
||||
MemBuf[1] = CmpMem[1] + 1;
|
||||
MemBuf[2] = CmpMem[2] + 1;
|
||||
hr = IWICStream_Write(pStream, MemBuf, 3, &uBytesWritten);
|
||||
ok(hr == S_OK, "Write returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesWritten == 3, "Wrote %u bytes, expected %u\n", uBytesWritten, 3);
|
||||
ok(memcmp(MemBuf, Memory, 3) == 0, "Wrote returned invalid data!\n"); /* make sure we're writing directly */
|
||||
|
||||
/* check whether the seek pointer has moved correctly */
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesWritten, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesWritten);
|
||||
}
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Write(pStream, MemBuf, 0, &uBytesWritten);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
/* Restore the original contents of the memory stream. */
|
||||
hr = IWICStream_Write(pStream, CmpMem, sizeof(CmpMem), &uBytesWritten);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
/* Source and destination overlap. */
|
||||
hr = IWICStream_Write(pStream, Memory + 5, 10, &uBytesWritten);
|
||||
ok(hr == S_OK, "Write returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesWritten == 10, "Wrote %u bytes, expected %u\n", uBytesWritten, 10);
|
||||
ok(memcmp(CmpMemOverlap, Memory, sizeof(CmpMemOverlap)) == 0, "Wrote returned invalid data!\n");
|
||||
}
|
||||
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
uBytesWritten = 0xdeadbeef;
|
||||
hr = IWICStream_Write(pStream, NULL, 3, &uBytesWritten);
|
||||
ok(hr == E_INVALIDARG, "Write returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
uBytesWritten = 0xdeadbeef;
|
||||
hr = IWICStream_Write(pStream, NULL, 0, &uBytesWritten);
|
||||
ok(hr == E_INVALIDARG, "Write returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
uBytesWritten = 0xdeadbeef;
|
||||
hr = IWICStream_Write(pStream, CmpMem, sizeof(Memory) + 10, &uBytesWritten);
|
||||
ok(hr == STG_E_MEDIUMFULL, "Write returned with %#x, expected %#x\n", hr, STG_E_MEDIUMFULL);
|
||||
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
|
||||
/* SetSize */
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = sizeof(Memory) + 10;
|
||||
hr = IWICStream_SetSize(pStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = sizeof(Memory);
|
||||
hr = IWICStream_SetSize(pStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = sizeof(Memory) - 10;
|
||||
hr = IWICStream_SetSize(pStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = 0;
|
||||
hr = IWICStream_SetSize(pStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.QuadPart = -10;
|
||||
hr = IWICStream_SetSize(pStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
/* CopyTo */
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = 5;
|
||||
hr = IWICStream_CopyTo(pStream, NULL, uNewPos, NULL, NULL);
|
||||
ok(hr == E_NOTIMPL, "CopyTo returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICImagingFactory_CreateStream(pFactory, &pBufStream);
|
||||
ok(hr == S_OK, "CreateStream failed with %#x\n", hr);
|
||||
|
||||
hr = IWICStream_InitializeFromMemory(pBufStream, Memory, sizeof(Memory));
|
||||
ok(hr == S_OK, "InitializeFromMemory returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
hr = IWICStream_CopyTo(pStream, (IStream*)pBufStream, uNewPos, NULL, NULL);
|
||||
ok(hr == E_NOTIMPL, "CopyTo returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
IWICStream_Release(pBufStream);
|
||||
|
||||
|
||||
/* Commit */
|
||||
hr = IWICStream_Commit(pStream, STGC_DEFAULT);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pStream, STGC_OVERWRITE);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pStream, STGC_ONLYIFCURRENT);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pStream, STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pStream, STGC_CONSOLIDATE);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
/* Revert */
|
||||
IWICStream_Write(pStream, &MemBuf[5], 6, NULL);
|
||||
hr = IWICStream_Revert(pStream);
|
||||
ok(hr == E_NOTIMPL, "Revert returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
memcpy(Memory, CmpMem, sizeof(Memory));
|
||||
|
||||
|
||||
/* LockRegion/UnlockRegion */
|
||||
hr = IWICStream_LockRegion(pStream, uLargeNull, uLargeNull, 0);
|
||||
ok(hr == E_NOTIMPL, "LockRegion returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_UnlockRegion(pStream, uLargeNull, uLargeNull, 0);
|
||||
ok(hr == E_NOTIMPL, "UnlockRegion returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
/* Stat */
|
||||
hr = IWICStream_Stat(pStream, NULL, 0);
|
||||
ok(hr == E_INVALIDARG, "Stat returned %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
|
||||
hr = IWICStream_Stat(pStream, &Stats, 0);
|
||||
ok(hr == S_OK, "Stat returned %#x, expected %#x\n", hr, S_OK);
|
||||
ok(Stats.pwcsName == NULL, "Stat returned name %p, expected %p\n", Stats.pwcsName, NULL);
|
||||
ok(Stats.type == STGTY_STREAM, "Stat returned type %d, expected %d\n", Stats.type, STGTY_STREAM);
|
||||
ok(Stats.cbSize.u.HighPart == 0 && Stats.cbSize.u.LowPart == sizeof(Memory), "Stat returned size (%u;%u)\n", Stats.cbSize.u.HighPart, Stats.cbSize.u.LowPart);
|
||||
ok(Stats.mtime.dwHighDateTime == 0 && Stats.mtime.dwLowDateTime == 0, "Stat returned mtime (%u;%u), expected (%u;%u)\n", Stats.mtime.dwHighDateTime, Stats.mtime.dwLowDateTime, 0, 0);
|
||||
ok(Stats.ctime.dwHighDateTime == 0 && Stats.ctime.dwLowDateTime == 0, "Stat returned ctime (%u;%u), expected (%u;%u)\n", Stats.ctime.dwHighDateTime, Stats.ctime.dwLowDateTime, 0, 0);
|
||||
ok(Stats.atime.dwHighDateTime == 0 && Stats.atime.dwLowDateTime == 0, "Stat returned atime (%u;%u), expected (%u;%u)\n", Stats.atime.dwHighDateTime, Stats.atime.dwLowDateTime, 0, 0);
|
||||
ok(Stats.grfMode == 0, "Stat returned access mode %d, expected %d\n", Stats.grfMode, 0);
|
||||
ok(Stats.grfLocksSupported == 0, "Stat returned supported locks %#x, expected %#x\n", Stats.grfLocksSupported, 0);
|
||||
ok(Stats.grfStateBits == 0, "Stat returned state bits %#x, expected %#x\n", Stats.grfStateBits, 0);
|
||||
|
||||
|
||||
/* Clone */
|
||||
hr = IWICStream_Clone(pStream, (IStream**)&pBufStream);
|
||||
ok(hr == E_NOTIMPL, "UnlockRegion returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
IWICStream_Release(pStream);
|
||||
IWICImagingFactory_Release(pFactory);
|
||||
CoUninitialize();
|
||||
}
|
||||
|
||||
static void test_StreamOnStreamRange(void)
|
||||
{
|
||||
IWICImagingFactory *pFactory;
|
||||
IWICStream *pStream, *pSubStream;
|
||||
IStream *CopyStream;
|
||||
const BYTE CmpMem[] = {
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
||||
};
|
||||
BYTE Memory[64], MemBuf[64];
|
||||
LARGE_INTEGER LargeNull, LargeInt;
|
||||
ULARGE_INTEGER uLargeNull, uNewPos, uSize;
|
||||
ULONG uBytesRead, uBytesWritten;
|
||||
HRESULT hr;
|
||||
STATSTG Stats;
|
||||
|
||||
LargeNull.QuadPart = 0;
|
||||
uLargeNull.QuadPart = 0;
|
||||
|
||||
memcpy(Memory, CmpMem, sizeof(CmpMem));
|
||||
|
||||
CoInitialize(NULL);
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&pFactory);
|
||||
if(FAILED(hr)) {
|
||||
skip("CoCreateInstance returned with %#x, expected %#x\n", hr, S_OK);
|
||||
return;
|
||||
}
|
||||
|
||||
hr = IWICImagingFactory_CreateStream(pFactory, &pStream);
|
||||
ok(hr == S_OK, "CreateStream returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(FAILED(hr)) {
|
||||
skip("Failed to create stream\n");
|
||||
return;
|
||||
}
|
||||
|
||||
hr = IWICStream_InitializeFromMemory(pStream, Memory, sizeof(Memory));
|
||||
ok(hr == S_OK, "InitializeFromMemory returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
hr = IWICImagingFactory_CreateStream(pFactory, &pSubStream);
|
||||
ok(hr == S_OK, "CreateStream returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
uNewPos.QuadPart = 20;
|
||||
uSize.QuadPart = 20;
|
||||
hr = IWICStream_InitializeFromIStreamRegion(pSubStream, (IStream*)pStream, uNewPos, uSize);
|
||||
ok(hr == S_OK, "InitializeFromIStreamRegion returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(FAILED(hr)) {
|
||||
skip("InitializeFromIStreamRegion unimplemented\n");
|
||||
IWICStream_Release(pSubStream);
|
||||
IWICStream_Release(pStream);
|
||||
IWICImagingFactory_Release(pFactory);
|
||||
CoUninitialize();
|
||||
return;
|
||||
}
|
||||
|
||||
/* Seek */
|
||||
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_END, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 20, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 20);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
LargeInt.u.HighPart = 1;
|
||||
LargeInt.u.LowPart = 0;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_SET, &uNewPos);
|
||||
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "Seek returned with %#x, expected %#x\n", hr, WINCODEC_ERR_VALUEOUTOFRANGE);
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
LargeInt.QuadPart = 30;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_SET, &uNewPos);
|
||||
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "Seek returned with %#x, expected %#x\n", hr, WINCODEC_ERR_VALUEOUTOFRANGE);
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
LargeInt.QuadPart = 1;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_END, &uNewPos);
|
||||
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "Seek returned with %#x, expected %#x\n", hr, WINCODEC_ERR_VALUEOUTOFRANGE);
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
LargeInt.QuadPart = -1;
|
||||
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_END, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 19, "bSeek cursor moved to position (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart);
|
||||
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, &uNewPos); /* reset seek pointer */
|
||||
LargeInt.QuadPart = -25;
|
||||
uNewPos.u.HighPart = 0xdeadbeef;
|
||||
uNewPos.u.LowPart = 0xdeadbeef;
|
||||
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_END, &uNewPos);
|
||||
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE,
|
||||
"Seek returned with %#x, expected %#x\n", hr, HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW));
|
||||
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
|
||||
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0); /* remains unchanged */
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
|
||||
/* Read */
|
||||
hr = IWICStream_Read(pSubStream, MemBuf, 12, &uBytesRead);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 12, "Read %u bytes, expected %u\n", uBytesRead, 12);
|
||||
ok(memcmp(MemBuf, CmpMem+20, 12) == 0, "Read returned invalid data!\n");
|
||||
|
||||
/* check whether the seek pointer has moved correctly */
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesRead, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesRead);
|
||||
}
|
||||
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Read(pSubStream, Memory, 10, &uBytesRead); /* source = dest */
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 10, "Read %u bytes, expected %u\n", uBytesRead, 10);
|
||||
ok(memcmp(Memory, CmpMem+20, uBytesRead) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Read(pSubStream, Memory, 30, &uBytesRead); /* request too many bytes */
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 20, "Read %u bytes\n", uBytesRead);
|
||||
ok(memcmp(Memory, CmpMem+20, uBytesRead) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
uBytesRead = 0xdeadbeef;
|
||||
hr = IWICStream_Read(pSubStream, NULL, 1, &uBytesRead); /* destination buffer = NULL */
|
||||
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uBytesRead == 0xdeadbeef, "Expected uBytesRead to be unchanged, got %u\n", uBytesRead);
|
||||
|
||||
hr = IWICStream_Read(pSubStream, MemBuf, 0, &uBytesRead); /* read 0 bytes */
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
uBytesRead = 0xdeadbeef;
|
||||
hr = IWICStream_Read(pSubStream, NULL, 0, &uBytesRead);
|
||||
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uBytesRead == 0xdeadbeef, "Expected uBytesRead to be unchanged, got %u\n", uBytesRead);
|
||||
|
||||
hr = IWICStream_Read(pSubStream, NULL, 0, NULL);
|
||||
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
|
||||
hr = IWICStream_Read(pSubStream, MemBuf, 1, NULL);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
ZeroMemory(MemBuf, sizeof(MemBuf));
|
||||
hr = IWICStream_Read(pSubStream, MemBuf, 30, &uBytesRead);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 20, "Read %u bytes\n", uBytesRead);
|
||||
ok(memcmp(Memory, CmpMem+20, 20) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
|
||||
/* Write */
|
||||
MemBuf[0] = CmpMem[0] + 1;
|
||||
MemBuf[1] = CmpMem[1] + 1;
|
||||
MemBuf[2] = CmpMem[2] + 1;
|
||||
hr = IWICStream_Write(pSubStream, MemBuf, 3, &uBytesWritten);
|
||||
ok(hr == S_OK, "Write returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesWritten == 3, "Wrote %u bytes, expected %u\n", uBytesWritten, 3);
|
||||
ok(memcmp(MemBuf, Memory+20, 3) == 0, "Wrote returned invalid data!\n"); /* make sure we're writing directly */
|
||||
|
||||
/* check whether the seek pointer has moved correctly */
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesWritten, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesWritten);
|
||||
}
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
hr = IWICStream_Write(pSubStream, MemBuf, 0, &uBytesWritten);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
uBytesWritten = 0xdeadbeef;
|
||||
hr = IWICStream_Write(pSubStream, NULL, 3, &uBytesWritten);
|
||||
ok(hr == E_INVALIDARG, "Write returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
uBytesWritten = 0xdeadbeef;
|
||||
hr = IWICStream_Write(pSubStream, NULL, 0, &uBytesWritten);
|
||||
ok(hr == E_INVALIDARG, "Write returned with %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
hr = IWICStream_Write(pSubStream, CmpMem, 30, &uBytesWritten);
|
||||
ok(hr == S_OK, "Write returned with %#x, expected %#x\n", hr, STG_E_MEDIUMFULL);
|
||||
ok(uBytesWritten == 20, "Wrote %u bytes, expected %u\n", uBytesWritten, 0);
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesWritten, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesWritten);
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
|
||||
|
||||
/* SetSize */
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = sizeof(Memory) + 10;
|
||||
hr = IWICStream_SetSize(pSubStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = sizeof(Memory);
|
||||
hr = IWICStream_SetSize(pSubStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = sizeof(Memory) - 10;
|
||||
hr = IWICStream_SetSize(pSubStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = 0;
|
||||
hr = IWICStream_SetSize(pSubStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
uNewPos.QuadPart = -10;
|
||||
hr = IWICStream_SetSize(pSubStream, uNewPos);
|
||||
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
/* CopyTo */
|
||||
uNewPos.u.HighPart = 0;
|
||||
uNewPos.u.LowPart = 30;
|
||||
hr = IWICStream_CopyTo(pSubStream, NULL, uNewPos, NULL, NULL);
|
||||
ok(hr == E_NOTIMPL, "CopyTo returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = CreateStreamOnHGlobal(NULL, TRUE, &CopyStream);
|
||||
ok(hr == S_OK, "CreateStream failed with %#x\n", hr);
|
||||
|
||||
hr = IWICStream_CopyTo(pSubStream, CopyStream, uNewPos, NULL, NULL);
|
||||
ok(hr == E_NOTIMPL, "CopyTo returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
IStream_Release(CopyStream);
|
||||
|
||||
|
||||
/* Commit */
|
||||
hr = IWICStream_Commit(pSubStream, STGC_DEFAULT);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pSubStream, STGC_OVERWRITE);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pSubStream, STGC_ONLYIFCURRENT);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pSubStream, STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_Commit(pSubStream, STGC_CONSOLIDATE);
|
||||
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
/* Revert */
|
||||
IWICStream_Write(pSubStream, &MemBuf[5], 6, NULL);
|
||||
hr = IWICStream_Revert(pSubStream);
|
||||
ok(hr == E_NOTIMPL, "Revert returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
memcpy(Memory, CmpMem, sizeof(Memory));
|
||||
|
||||
|
||||
/* LockRegion/UnlockRegion */
|
||||
hr = IWICStream_LockRegion(pSubStream, uLargeNull, uLargeNull, 0);
|
||||
ok(hr == E_NOTIMPL, "LockRegion returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
hr = IWICStream_UnlockRegion(pSubStream, uLargeNull, uLargeNull, 0);
|
||||
ok(hr == E_NOTIMPL, "UnlockRegion returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
/* Stat */
|
||||
hr = IWICStream_Stat(pSubStream, NULL, 0);
|
||||
ok(hr == E_INVALIDARG, "Stat returned %#x, expected %#x\n", hr, E_INVALIDARG);
|
||||
|
||||
hr = IWICStream_Stat(pSubStream, &Stats, 0);
|
||||
ok(hr == S_OK, "Stat returned %#x, expected %#x\n", hr, S_OK);
|
||||
ok(Stats.pwcsName == NULL, "Stat returned name %p, expected %p\n", Stats.pwcsName, NULL);
|
||||
ok(Stats.type == STGTY_STREAM, "Stat returned type %d, expected %d\n", Stats.type, STGTY_STREAM);
|
||||
ok(Stats.cbSize.u.HighPart == 0 && Stats.cbSize.u.LowPart == 20, "Stat returned size (%u;%u)\n", Stats.cbSize.u.HighPart, Stats.cbSize.u.LowPart);
|
||||
ok(Stats.mtime.dwHighDateTime == 0 && Stats.mtime.dwLowDateTime == 0, "Stat returned mtime (%u;%u), expected (%u;%u)\n", Stats.mtime.dwHighDateTime, Stats.mtime.dwLowDateTime, 0, 0);
|
||||
ok(Stats.ctime.dwHighDateTime == 0 && Stats.ctime.dwLowDateTime == 0, "Stat returned ctime (%u;%u), expected (%u;%u)\n", Stats.ctime.dwHighDateTime, Stats.ctime.dwLowDateTime, 0, 0);
|
||||
ok(Stats.atime.dwHighDateTime == 0 && Stats.atime.dwLowDateTime == 0, "Stat returned atime (%u;%u), expected (%u;%u)\n", Stats.atime.dwHighDateTime, Stats.atime.dwLowDateTime, 0, 0);
|
||||
ok(Stats.grfMode == 0, "Stat returned access mode %d, expected %d\n", Stats.grfMode, 0);
|
||||
ok(Stats.grfLocksSupported == 0, "Stat returned supported locks %#x, expected %#x\n", Stats.grfLocksSupported, 0);
|
||||
ok(Stats.grfStateBits == 0, "Stat returned state bits %#x, expected %#x\n", Stats.grfStateBits, 0);
|
||||
|
||||
|
||||
/* Clone */
|
||||
hr = IWICStream_Clone(pSubStream, &CopyStream);
|
||||
ok(hr == E_NOTIMPL, "Clone returned %#x, expected %#x\n", hr, E_NOTIMPL);
|
||||
|
||||
|
||||
IWICStream_Release(pSubStream);
|
||||
|
||||
|
||||
/* Recreate, this time larger than the original. */
|
||||
hr = IWICImagingFactory_CreateStream(pFactory, &pSubStream);
|
||||
ok(hr == S_OK, "CreateStream returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
uNewPos.QuadPart = 48;
|
||||
uSize.QuadPart = 32;
|
||||
hr = IWICStream_InitializeFromIStreamRegion(pSubStream, (IStream*)pStream, uNewPos, uSize);
|
||||
ok(hr == S_OK, "InitializeFromMemory returned with %#x, expected %#x\n", hr, S_OK);
|
||||
|
||||
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_END, &uNewPos);
|
||||
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 16, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 16);
|
||||
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
hr = IWICStream_Read(pSubStream, Memory, 48, &uBytesRead);
|
||||
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
|
||||
if(SUCCEEDED(hr)) {
|
||||
ok(uBytesRead == 16, "Read %u bytes\n", uBytesRead);
|
||||
ok(memcmp(Memory, CmpMem+48, uBytesRead) == 0, "Read returned invalid data!\n");
|
||||
}
|
||||
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
|
||||
uBytesWritten = 0xdeadbeef;
|
||||
hr = IWICStream_Write(pSubStream, CmpMem, 32, &uBytesWritten);
|
||||
ok(hr == STG_E_MEDIUMFULL, "Write returned with %#x, expected %#x\n", hr, STG_E_MEDIUMFULL);
|
||||
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
|
||||
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
|
||||
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
|
||||
|
||||
|
||||
IWICStream_Release(pSubStream);
|
||||
IWICStream_Release(pStream);
|
||||
IWICImagingFactory_Release(pFactory);
|
||||
CoUninitialize();
|
||||
}
|
||||
|
||||
START_TEST(stream)
|
||||
{
|
||||
test_StreamOnMemory();
|
||||
test_StreamOnStreamRange();
|
||||
}
|
||||
35
rostests/winetests/windowscodecs/testlist.c
Normal file
35
rostests/winetests/windowscodecs/testlist.c
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
/* Automatically generated file; DO NOT EDIT!! */
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
|
||||
#define STANDALONE
|
||||
#include "wine/test.h"
|
||||
|
||||
extern void func_bitmap(void);
|
||||
extern void func_bmpformat(void);
|
||||
extern void func_converter(void);
|
||||
extern void func_gifformat(void);
|
||||
extern void func_icoformat(void);
|
||||
extern void func_info(void);
|
||||
extern void func_metadata(void);
|
||||
extern void func_palette(void);
|
||||
extern void func_pngformat(void);
|
||||
extern void func_stream(void);
|
||||
extern void func_tiffformat(void);
|
||||
|
||||
const struct test winetest_testlist[] =
|
||||
{
|
||||
{ "bitmap", func_bitmap },
|
||||
{ "bmpformat", func_bmpformat },
|
||||
{ "converter", func_converter },
|
||||
{ "gifformat", func_gifformat },
|
||||
{ "icoformat", func_icoformat },
|
||||
{ "info", func_info },
|
||||
{ "metadata", func_metadata },
|
||||
{ "palette", func_palette },
|
||||
{ "pngformat", func_pngformat },
|
||||
{ "stream", func_stream },
|
||||
{ "tiffformat", func_tiffformat },
|
||||
{ 0, 0 }
|
||||
};
|
||||
292
rostests/winetests/windowscodecs/tiffformat.c
Normal file
292
rostests/winetests/windowscodecs/tiffformat.c
Normal file
|
|
@ -0,0 +1,292 @@
|
|||
/*
|
||||
* 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 <stdio.h>
|
||||
|
||||
#define COBJMACROS
|
||||
|
||||
#include "windef.h"
|
||||
#include "wincodec.h"
|
||||
#include "wine/test.h"
|
||||
|
||||
#define IFD_BYTE 1
|
||||
#define IFD_ASCII 2
|
||||
#define IFD_SHORT 3
|
||||
#define IFD_LONG 4
|
||||
#define IFD_RATIONAL 5
|
||||
#define IFD_SBYTE 6
|
||||
#define IFD_UNDEFINED 7
|
||||
#define IFD_SSHORT 8
|
||||
#define IFD_SLONG 9
|
||||
#define IFD_SRATIONAL 10
|
||||
#define IFD_FLOAT 11
|
||||
#define IFD_DOUBLE 12
|
||||
|
||||
#include "pshpack2.h"
|
||||
struct IFD_entry
|
||||
{
|
||||
SHORT id;
|
||||
SHORT type;
|
||||
ULONG count;
|
||||
LONG value;
|
||||
};
|
||||
|
||||
struct IFD_rational
|
||||
{
|
||||
LONG numerator;
|
||||
LONG denominator;
|
||||
};
|
||||
|
||||
static const struct tiff_1bpp_data
|
||||
{
|
||||
USHORT byte_order;
|
||||
USHORT version;
|
||||
ULONG dir_offset;
|
||||
USHORT number_of_entries;
|
||||
struct IFD_entry entry[13];
|
||||
ULONG next_IFD;
|
||||
struct IFD_rational res;
|
||||
BYTE pixel_data[4];
|
||||
} tiff_1bpp_data =
|
||||
{
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
'M' | 'M' << 8,
|
||||
#else
|
||||
'I' | 'I' << 8,
|
||||
#endif
|
||||
42,
|
||||
FIELD_OFFSET(struct tiff_1bpp_data, number_of_entries),
|
||||
13,
|
||||
{
|
||||
{ 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
|
||||
{ 0x100, IFD_LONG, 1, 1 }, /* IMAGEWIDTH */
|
||||
{ 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
|
||||
{ 0x102, IFD_SHORT, 1, 1 }, /* BITSPERSAMPLE */
|
||||
{ 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
|
||||
{ 0x106, IFD_SHORT, 1, 1 }, /* PHOTOMETRIC */
|
||||
{ 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_1bpp_data, pixel_data) }, /* STRIPOFFSETS */
|
||||
{ 0x115, IFD_SHORT, 1, 1 }, /* SAMPLESPERPIXEL */
|
||||
{ 0x116, IFD_LONG, 1, 1 }, /* ROWSPERSTRIP */
|
||||
{ 0x117, IFD_LONG, 1, 1 }, /* STRIPBYTECOUNT */
|
||||
{ 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1bpp_data, res) },
|
||||
{ 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1bpp_data, res) },
|
||||
{ 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
|
||||
},
|
||||
0,
|
||||
{ 900, 3 },
|
||||
{ 0x11, 0x22, 0x33, 0 }
|
||||
};
|
||||
#include "poppack.h"
|
||||
|
||||
static IWICImagingFactory *factory;
|
||||
|
||||
static const char *debugstr_guid(const GUID *guid)
|
||||
{
|
||||
static char buf[50];
|
||||
|
||||
if (!guid) return "(null)";
|
||||
sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
|
||||
guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
|
||||
guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
|
||||
guid->Data4[5], guid->Data4[6], guid->Data4[7]);
|
||||
return buf;
|
||||
}
|
||||
|
||||
static IStream *create_stream(const void *data, int data_size)
|
||||
{
|
||||
HRESULT hr;
|
||||
IStream *stream;
|
||||
HGLOBAL hdata;
|
||||
void *locked_data;
|
||||
|
||||
hdata = GlobalAlloc(GMEM_MOVEABLE, data_size);
|
||||
ok(hdata != 0, "GlobalAlloc failed\n");
|
||||
if (!hdata) return NULL;
|
||||
|
||||
locked_data = GlobalLock(hdata);
|
||||
memcpy(locked_data, data, data_size);
|
||||
GlobalUnlock(hdata);
|
||||
|
||||
hr = CreateStreamOnHGlobal(hdata, TRUE, &stream);
|
||||
ok(hr == S_OK, "CreateStreamOnHGlobal failed, hr=%x\n", hr);
|
||||
|
||||
return stream;
|
||||
}
|
||||
|
||||
static IWICBitmapDecoder *create_decoder(const void *image_data, UINT image_size)
|
||||
{
|
||||
HRESULT hr;
|
||||
IStream *stream;
|
||||
IWICBitmapDecoder *decoder = NULL;
|
||||
GUID guid;
|
||||
|
||||
stream = create_stream(image_data, image_size);
|
||||
|
||||
hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);
|
||||
ok(hr == S_OK, "CreateDecoderFromStream error %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guid);
|
||||
ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&guid, &GUID_ContainerFormatTiff), "container format is not TIFF\n");
|
||||
|
||||
IStream_Release(stream);
|
||||
|
||||
return decoder;
|
||||
}
|
||||
|
||||
static void test_tiff_palette(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICBitmapFrameDecode *frame;
|
||||
IWICPalette *palette;
|
||||
GUID format;
|
||||
|
||||
decoder = create_decoder(&tiff_1bpp_data, sizeof(tiff_1bpp_data));
|
||||
ok(decoder != 0, "Failed to load TIFF image data\n");
|
||||
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
|
||||
ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
|
||||
ok(IsEqualGUID(&format, &GUID_WICPixelFormatBlackWhite),
|
||||
"got wrong format %s\n", debugstr_guid(&format));
|
||||
|
||||
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
||||
ok(hr == S_OK, "CreatePalette error %#x\n", hr);
|
||||
hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
|
||||
ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE,
|
||||
"expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %#x\n", hr);
|
||||
|
||||
IWICPalette_Release(palette);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
}
|
||||
|
||||
static void test_QueryCapability(void)
|
||||
{
|
||||
HRESULT hr;
|
||||
IStream *stream;
|
||||
IWICBitmapDecoder *decoder;
|
||||
IWICBitmapFrameDecode *frame;
|
||||
static const DWORD exp_caps = WICBitmapDecoderCapabilityCanDecodeAllImages |
|
||||
WICBitmapDecoderCapabilityCanDecodeSomeImages |
|
||||
WICBitmapDecoderCapabilityCanEnumerateMetadata;
|
||||
static const DWORD exp_caps_xp = WICBitmapDecoderCapabilityCanDecodeAllImages |
|
||||
WICBitmapDecoderCapabilityCanDecodeSomeImages;
|
||||
DWORD capability;
|
||||
LARGE_INTEGER pos;
|
||||
ULARGE_INTEGER cur_pos;
|
||||
UINT frame_count;
|
||||
|
||||
stream = create_stream(&tiff_1bpp_data, sizeof(tiff_1bpp_data));
|
||||
if (!stream) return;
|
||||
|
||||
hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatTiff, NULL, &decoder);
|
||||
ok(hr == S_OK, "CreateDecoder error %#x\n", hr);
|
||||
|
||||
frame_count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
|
||||
ok(hr == S_OK || broken(hr == E_POINTER) /* XP */, "GetFrameCount error %#x\n", hr);
|
||||
ok(frame_count == 0, "expected 0, got %u\n", frame_count);
|
||||
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == WINCODEC_ERR_FRAMEMISSING || broken(hr == E_POINTER) /* XP */, "expected WINCODEC_ERR_FRAMEMISSING, got %#x\n", hr);
|
||||
|
||||
pos.QuadPart = 4;
|
||||
hr = IStream_Seek(stream, pos, SEEK_SET, NULL);
|
||||
ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
|
||||
|
||||
capability = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoder_QueryCapability(decoder, stream, &capability);
|
||||
ok(hr == S_OK, "QueryCapability error %#x\n", hr);
|
||||
ok(capability == exp_caps || capability == exp_caps_xp,
|
||||
"expected %#x, got %#x\n", exp_caps, capability);
|
||||
|
||||
frame_count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
|
||||
ok(hr == S_OK, "GetFrameCount error %#x\n", hr);
|
||||
ok(frame_count == 1, "expected 1, got %u\n", frame_count);
|
||||
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
|
||||
pos.QuadPart = 0;
|
||||
hr = IStream_Seek(stream, pos, SEEK_CUR, &cur_pos);
|
||||
ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
|
||||
ok(cur_pos.QuadPart > 4 && cur_pos.QuadPart < sizeof(tiff_1bpp_data),
|
||||
"current stream pos is at %x/%x\n", cur_pos.u.LowPart, cur_pos.u.HighPart);
|
||||
|
||||
hr = IWICBitmapDecoder_QueryCapability(decoder, stream, &capability);
|
||||
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnDemand);
|
||||
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
|
||||
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
|
||||
hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);
|
||||
todo_wine
|
||||
ok(hr == WINCODEC_ERR_COMPONENTNOTFOUND, "expected WINCODEC_ERR_COMPONENTNOTFOUND, got %#x\n", hr);
|
||||
|
||||
pos.QuadPart = 0;
|
||||
hr = IStream_Seek(stream, pos, SEEK_SET, NULL);
|
||||
ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
|
||||
|
||||
hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);
|
||||
ok(hr == S_OK, "CreateDecoderFromStream error %#x\n", hr);
|
||||
|
||||
frame_count = 0xdeadbeef;
|
||||
hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
|
||||
ok(hr == S_OK, "GetFrameCount error %#x\n", hr);
|
||||
ok(frame_count == 1, "expected 1, got %u\n", frame_count);
|
||||
|
||||
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
||||
ok(hr == S_OK, "GetFrame error %#x\n", hr);
|
||||
IWICBitmapFrameDecode_Release(frame);
|
||||
|
||||
hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnDemand);
|
||||
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
|
||||
|
||||
hr = IWICBitmapDecoder_QueryCapability(decoder, stream, &capability);
|
||||
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
|
||||
|
||||
IWICBitmapDecoder_Release(decoder);
|
||||
IStream_Release(stream);
|
||||
}
|
||||
|
||||
START_TEST(tiffformat)
|
||||
{
|
||||
HRESULT hr;
|
||||
|
||||
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
||||
|
||||
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
|
||||
&IID_IWICImagingFactory, (void **)&factory);
|
||||
ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
|
||||
if (FAILED(hr)) return;
|
||||
|
||||
test_tiff_palette();
|
||||
test_QueryCapability();
|
||||
|
||||
IWICImagingFactory_Release(factory);
|
||||
CoUninitialize();
|
||||
}
|
||||
Loading…
Reference in a new issue