pngformat.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "wincodec.h"
#include "wine/test.h"
#include "shlwapi.h"

Include dependency graph for pngformat.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	PNG_COLOR_TYPE_GRAY   0
#define	PNG_COLOR_TYPE_RGB   2
#define	PNG_COLOR_TYPE_PALETTE   3
#define	PNG_COLOR_TYPE_GRAY_ALPHA   4
#define	PNG_COLOR_TYPE_RGB_ALPHA   6

Functions
static HRESULT	create_decoder (const void *image_data, UINT image_size, IWICBitmapDecoder **decoder)
static WCHAR *	save_profile (BYTE *buffer, UINT size)
static void	test_color_contexts (void)
static void	test_png_palette (void)
static BOOL	is_valid_png_type_depth (int color_type, int bit_depth, BOOL plte)
static void	test_color_formats (void)
static void	test_chunk_size (void)
	START_TEST (pngformat)

Variables
static const char	png_no_color_profile []
static const char	png_color_profile []
static IWICImagingFactory *	factory
static const char	png_PLTE_tRNS []
static const char	png_gray_tRNS []
static const char	png_1x1_data []
static const char	png_8M_tEXt_start []
static const char	png_8M_tEXt_end []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 23 of file pngformat.c.

PNG_COLOR_TYPE_GRAY

#define PNG_COLOR_TYPE_GRAY   0

Definition at line 697 of file pngformat.c.

PNG_COLOR_TYPE_GRAY_ALPHA

#define PNG_COLOR_TYPE_GRAY_ALPHA   4

Definition at line 700 of file pngformat.c.

PNG_COLOR_TYPE_PALETTE

#define PNG_COLOR_TYPE_PALETTE   3

Definition at line 699 of file pngformat.c.

PNG_COLOR_TYPE_RGB

#define PNG_COLOR_TYPE_RGB   2

Definition at line 698 of file pngformat.c.

PNG_COLOR_TYPE_RGB_ALPHA

#define PNG_COLOR_TYPE_RGB_ALPHA   6

Definition at line 701 of file pngformat.c.

Function Documentation

create_decoder()

static HRESULT create_decoder ( const void *  image_data, UINT  image_size, IWICBitmapDecoder **  decoder  )

static

Definition at line 279 of file pngformat.c.

{
    HRESULT hr;
    IStream *stream;
    GUID format;
    LONG refcount;
    ULARGE_INTEGER pos;
    LARGE_INTEGER zero;
 
    *decoder = NULL;
 
    stream = SHCreateMemStream (image_data, image_size);
    ok(stream != NULL, "SHCreateMemStream error\n");
 
    hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, decoder);
    if (hr == S_OK)
    {
        hr = IWICBitmapDecoder_GetContainerFormat(*decoder, &format);
        ok(hr == S_OK, "GetContainerFormat error %#lx\n", hr);
        ok(IsEqualGUID(&format, &GUID_ContainerFormatPng),
           "wrong container format %s\n", wine_dbgstr_guid(&format));
 
        zero.QuadPart = 0;
        IStream_Seek (stream, zero, STREAM_SEEK_CUR, &pos);
        ok(pos.QuadPart < image_size, "seek beyond the end of stream: %I64x >= %x\n",
           pos.QuadPart, image_size);
 
        refcount = IStream_Release(stream);
        ok(refcount > 0, "expected stream refcount > 0\n");
    }
    else
        IStream_Release(stream);
 
    return hr;
}

is_valid_png_type_depth()

static BOOL is_valid_png_type_depth ( int  color_type, int  bit_depth, BOOL  plte  )

static

Definition at line 703 of file pngformat.c.

{
    switch (color_type)
    {
    case PNG_COLOR_TYPE_GRAY:
        return bit_depth == 1 || bit_depth == 2 || bit_depth == 4 || bit_depth == 8 || bit_depth == 16;
 
    case PNG_COLOR_TYPE_RGB:
        return bit_depth == 8 || bit_depth == 16;
 
    case PNG_COLOR_TYPE_PALETTE:
        return (bit_depth == 1 || bit_depth == 2 || bit_depth == 4 || bit_depth == 8) && plte;
 
    case PNG_COLOR_TYPE_GRAY_ALPHA:
        return bit_depth == 8 || bit_depth == 16;
 
    case PNG_COLOR_TYPE_RGB_ALPHA:
        return bit_depth == 8 || bit_depth == 16;
 
    default:
        ok(0, "unknown PNG type %d, depth %d\n", color_type, bit_depth);
        return FALSE;
    }
}

Referenced by test_color_formats().

save_profile()

static WCHAR * save_profile ( BYTE *  buffer, UINT  size  )

static

Definition at line 315 of file pngformat.c.

{
    static const WCHAR tstW[] = {'t','s','t',0};
    WCHAR path[MAX_PATH], filename[MAX_PATH], *ret;
    HANDLE handle;
    DWORD count;
 
    GetTempPathW(MAX_PATH, path);
    GetTempFileNameW(path, tstW, 0, filename);
 
    handle = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
    if (handle == INVALID_HANDLE_VALUE) return NULL;
 
    WriteFile(handle, buffer, size, &count, NULL);
    CloseHandle( handle );
 
    ret = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR));
    lstrcpyW(ret, filename);
    return ret;
}

Referenced by test_color_contexts().

START_TEST()

START_TEST

(

pngformat

)

Definition at line 953 of file pngformat.c.

{
    HRESULT hr;
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
    hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
                          &IID_IWICImagingFactory, (void **)&factory);
    ok(hr == S_OK, "CoCreateInstance error %#lx\n", hr);
    if (FAILED(hr)) return;
 
    test_color_contexts();
    test_png_palette();
    test_color_formats();
    test_chunk_size();
 
    IWICImagingFactory_Release(factory);
    CoUninitialize();
}

test_chunk_size()

static void test_chunk_size ( void  )

static

Definition at line 937 of file pngformat.c.

{
    static char png_8M_tEXt[sizeof(png_8M_tEXt_start) + 0x800000 + sizeof(png_8M_tEXt_end)] = {0};
    HRESULT hr;
    IWICBitmapDecoder *decoder;
 
    memcpy(png_8M_tEXt, png_8M_tEXt_start, sizeof(png_8M_tEXt_start));
    memcpy(png_8M_tEXt + sizeof(png_8M_tEXt) - sizeof(png_8M_tEXt_end), png_8M_tEXt_end, sizeof(png_8M_tEXt_end));
 
    hr = create_decoder(png_8M_tEXt, sizeof(png_8M_tEXt), &decoder);
    ok(hr == S_OK, "Failed to load PNG image data %#lx\n", hr);
    if (hr != S_OK) return;
 
    IWICBitmapDecoder_Release(decoder);
}

Referenced by START_TEST().

test_color_contexts()

static void test_color_contexts ( void  )

static

Definition at line 336 of file pngformat.c.

{
    HRESULT hr;
    IWICBitmapDecoder *decoder;
    IWICBitmapFrameDecode *frame;
    IWICColorContext *context;
    WICColorContextType type;
    UINT count, colorspace, size;
    WCHAR *tmpfile;
    BYTE *buffer;
    BOOL ret;
 
    hr = create_decoder(png_no_color_profile, sizeof(png_no_color_profile), &decoder);
    ok(hr == S_OK, "Failed to load PNG image data %#lx\n", hr);
    if (hr != S_OK) return;
 
    /* global color context */
    hr = IWICBitmapDecoder_GetColorContexts(decoder, 0, NULL, NULL);
    ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "GetColorContexts error %#lx\n", hr);
 
    count = 0xdeadbeef;
    hr = IWICBitmapDecoder_GetColorContexts(decoder, 0, NULL, &count);
    ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "GetColorContexts error %#lx\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 %#lx\n", hr);
 
    hr = IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 
    count = 0xdeadbeef;
    hr = IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, &count);
    ok(hr == S_OK, "GetColorContexts error %#lx\n", hr);
    ok(!count, "unexpected count %u\n", count);
 
    IWICBitmapFrameDecode_Release(frame);
    IWICBitmapDecoder_Release(decoder);
 
    hr = create_decoder(png_color_profile, sizeof(png_color_profile), &decoder);
    ok(hr == S_OK, "Failed to load PNG image data %#lx\n", hr);
    if (hr != S_OK) return;
 
    /* global color context */
    count = 0xdeadbeef;
    hr = IWICBitmapDecoder_GetColorContexts(decoder, 0, NULL, &count);
    ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "GetColorContexts error %#lx\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 %#lx\n", hr);
 
    count = 0xdeadbeef;
    hr = IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, &count);
    ok(hr == S_OK, "GetColorContexts error %#lx\n", hr);
    ok(count == 1, "unexpected count %u\n", count);
 
    hr = IWICImagingFactory_CreateColorContext(factory, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 
    hr = IWICImagingFactory_CreateColorContext(factory, &context);
    ok(hr == S_OK, "CreateColorContext error %#lx\n", hr);
 
    hr = IWICColorContext_GetType(context, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 
    type = 0xdeadbeef;
    hr = IWICColorContext_GetType(context, &type);
    ok(hr == S_OK, "GetType error %#lx\n", hr);
    ok(type == WICColorContextUninitialized, "unexpected type %u\n", type);
 
    hr = IWICColorContext_GetProfileBytes(context, 0, NULL, NULL);
    ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetProfileBytes error %#lx\n", hr);
 
    size = 0;
    hr = IWICColorContext_GetProfileBytes(context, 0, NULL, &size);
    ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetProfileBytes error %#lx\n", hr);
    ok(!size, "unexpected size %u\n", size);
 
    hr = IWICColorContext_GetExifColorSpace(context, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 
    colorspace = 0xdeadbeef;
    hr = IWICColorContext_GetExifColorSpace(context, &colorspace);
    ok(hr == S_OK, "GetExifColorSpace error %#lx\n", hr);
    ok(colorspace == 0xffffffff, "unexpected color space %u\n", colorspace);
 
    hr = IWICColorContext_InitializeFromExifColorSpace(context, 0);
    ok(hr == S_OK, "InitializeFromExifColorSpace error %#lx\n", hr);
 
    hr = IWICColorContext_InitializeFromExifColorSpace(context, 1);
    ok(hr == S_OK, "InitializeFromExifColorSpace error %#lx\n", hr);
 
    hr = IWICColorContext_InitializeFromExifColorSpace(context, 2);
    ok(hr == S_OK, "InitializeFromExifColorSpace error %#lx\n", hr);
 
    colorspace = 0xdeadbeef;
    hr = IWICColorContext_GetExifColorSpace(context, &colorspace);
    ok(hr == S_OK, "GetExifColorSpace error %#lx\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 %#lx\n", hr);
    ok(!size, "unexpected size %u\n", size);
 
    type = 0xdeadbeef;
    hr = IWICColorContext_GetType(context, &type);
    ok(hr == S_OK, "GetType error %#lx\n", hr);
    ok(type == WICColorContextExifColorSpace, "unexpected type %u\n", type);
 
    hr = IWICBitmapFrameDecode_GetColorContexts(frame, count, &context, &count);
    ok(hr == WINCODEC_ERR_WRONGSTATE, "GetColorContexts error %#lx\n", hr);
 
    IWICColorContext_Release(context);
    IWICBitmapFrameDecode_Release(frame);
 
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
    ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
    hr = IWICImagingFactory_CreateColorContext(factory, &context);
    ok(hr == S_OK, "CreateColorContext error %#lx\n", hr);
 
    count = 1;
    hr = IWICBitmapFrameDecode_GetColorContexts(frame, count, &context, &count);
    ok(hr == S_OK, "GetColorContexts error %#lx\n", hr);
 
    hr = IWICColorContext_GetProfileBytes(context, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 
    size = 0;
    hr = IWICColorContext_GetProfileBytes(context, 0, NULL, &size);
    ok(hr == S_OK, "GetProfileBytes error %#lx\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 %#lx\n", hr);
 
    tmpfile = save_profile( buffer, size );
    HeapFree(GetProcessHeap(), 0, buffer);
 
    type = 0xdeadbeef;
    hr = IWICColorContext_GetType(context, &type);
    ok(hr == S_OK, "GetType error %#lx\n", hr);
    ok(type == WICColorContextProfile, "unexpected type %u\n", type);
 
    colorspace = 0xdeadbeef;
    hr = IWICColorContext_GetExifColorSpace(context, &colorspace);
    ok(hr == S_OK, "GetExifColorSpace error %#lx\n", hr);
    ok(colorspace == 0xffffffff, "unexpected color space %u\n", colorspace);
 
    hr = IWICColorContext_InitializeFromExifColorSpace(context, 1);
    ok(hr == WINCODEC_ERR_WRONGSTATE, "InitializeFromExifColorSpace error %#lx\n", hr);
 
    if (tmpfile)
    {
        hr = IWICColorContext_InitializeFromFilename(context, NULL);
        ok(hr == E_INVALIDARG, "InitializeFromFilename error %#lx\n", hr);
 
        hr = IWICColorContext_InitializeFromFilename(context, tmpfile);
        ok(hr == S_OK, "InitializeFromFilename error %#lx\n", hr);
 
        ret = DeleteFileW(tmpfile);
        ok(ret, "DeleteFileW failed %lu\n", GetLastError());
 
        type = 0xdeadbeef;
        hr = IWICColorContext_GetType(context, &type);
        ok(hr == S_OK, "GetType error %#lx\n", hr);
        ok(type == WICColorContextProfile, "unexpected type %u\n", type);
 
        colorspace = 0xdeadbeef;
        hr = IWICColorContext_GetExifColorSpace(context, &colorspace);
        ok(hr == S_OK, "GetExifColorSpace error %#lx\n", hr);
        ok(colorspace == 0xffffffff, "unexpected color space %u\n", colorspace);
 
        hr = IWICColorContext_InitializeFromExifColorSpace(context, 1);
        ok(hr == WINCODEC_ERR_WRONGSTATE, "InitializeFromExifColorSpace error %#lx\n", hr);
 
        size = 0;
        hr = IWICColorContext_GetProfileBytes(context, 0, NULL, &size);
        ok(hr == S_OK, "GetProfileBytes error %#lx\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 %#lx\n", hr);
 
        HeapFree(GetProcessHeap(), 0, buffer);
        HeapFree(GetProcessHeap(), 0, tmpfile);
    }
    IWICColorContext_Release(context);
    IWICBitmapFrameDecode_Release(frame);
    IWICBitmapDecoder_Release(decoder);
}

Referenced by START_TEST().

test_color_formats()

static void test_color_formats ( void  )

static

Definition at line 728 of file pngformat.c.

{
    static const struct
    {
        char bit_depth, color_type;
        const GUID *format;
        const GUID *format_PLTE;
        const GUID *format_PLTE_tRNS;
        BOOL todo;
        BOOL todo_load;
    } td[] =
    {
        /* 2 - PNG_COLOR_TYPE_RGB */
        { 1, PNG_COLOR_TYPE_RGB, NULL, NULL, NULL },
        { 2, PNG_COLOR_TYPE_RGB, NULL, NULL, NULL },
        { 4, PNG_COLOR_TYPE_RGB, NULL, NULL, NULL },
        { 8, PNG_COLOR_TYPE_RGB,
          &GUID_WICPixelFormat24bppBGR, &GUID_WICPixelFormat24bppBGR, &GUID_WICPixelFormat24bppBGR },
        /* libpng refuses to load our test image complaining about extra compressed data,
         * but libpng is still able to load the image with other combination of type/depth
         * making RGB 16 bpp case special for some reason. Therefore todo = TRUE.
         */
        { 16, PNG_COLOR_TYPE_RGB,
          &GUID_WICPixelFormat48bppRGB, &GUID_WICPixelFormat48bppRGB, &GUID_WICPixelFormat48bppRGB, TRUE, TRUE },
        { 24, PNG_COLOR_TYPE_RGB, NULL, NULL, NULL },
        { 32, PNG_COLOR_TYPE_RGB, NULL, NULL, NULL },
        /* 0 - PNG_COLOR_TYPE_GRAY */
        { 1, PNG_COLOR_TYPE_GRAY,
          &GUID_WICPixelFormatBlackWhite, &GUID_WICPixelFormatBlackWhite, &GUID_WICPixelFormat1bppIndexed },
        { 2, PNG_COLOR_TYPE_GRAY,
          &GUID_WICPixelFormat2bppGray, &GUID_WICPixelFormat2bppGray, &GUID_WICPixelFormat2bppIndexed },
        { 4, PNG_COLOR_TYPE_GRAY,
          &GUID_WICPixelFormat4bppGray, &GUID_WICPixelFormat4bppGray, &GUID_WICPixelFormat4bppIndexed },
        { 8, PNG_COLOR_TYPE_GRAY,
          &GUID_WICPixelFormat8bppGray, &GUID_WICPixelFormat8bppGray, &GUID_WICPixelFormat8bppIndexed },
        { 16, PNG_COLOR_TYPE_GRAY,
          &GUID_WICPixelFormat16bppGray, &GUID_WICPixelFormat16bppGray, &GUID_WICPixelFormat64bppRGBA },
        { 24, PNG_COLOR_TYPE_GRAY, NULL, NULL, NULL },
        { 32, PNG_COLOR_TYPE_GRAY, NULL, NULL, NULL },
        /* 3 - PNG_COLOR_TYPE_PALETTE */
        { 1, PNG_COLOR_TYPE_PALETTE,
          &GUID_WICPixelFormat1bppIndexed, &GUID_WICPixelFormat1bppIndexed, &GUID_WICPixelFormat1bppIndexed },
        { 2, PNG_COLOR_TYPE_PALETTE,
          &GUID_WICPixelFormat2bppIndexed, &GUID_WICPixelFormat2bppIndexed, &GUID_WICPixelFormat2bppIndexed },
        { 4, PNG_COLOR_TYPE_PALETTE,
          &GUID_WICPixelFormat4bppIndexed, &GUID_WICPixelFormat4bppIndexed, &GUID_WICPixelFormat4bppIndexed },
        { 8, PNG_COLOR_TYPE_PALETTE,
          &GUID_WICPixelFormat8bppIndexed, &GUID_WICPixelFormat8bppIndexed, &GUID_WICPixelFormat8bppIndexed },
        { 16, PNG_COLOR_TYPE_PALETTE, NULL, NULL, NULL },
        { 24, PNG_COLOR_TYPE_PALETTE, NULL, NULL, NULL },
        { 32, PNG_COLOR_TYPE_PALETTE, NULL, NULL, NULL },
    };
    char buf[sizeof(png_1x1_data)];
    HRESULT hr;
    IWICBitmapDecoder *decoder;
    IWICBitmapFrameDecode *frame;
    GUID format;
    int i, PLTE_off = 0, tRNS_off = 0;
 
    memcpy(buf, png_1x1_data, sizeof(png_1x1_data));
    for (i = 0; i < sizeof(png_1x1_data) - 4; i++)
    {
        if (!memcmp(buf + i, "tRNS", 4))
            tRNS_off = i;
        else if (!memcmp(buf + i, "PLTE", 4))
            PLTE_off = i;
    }
 
    ok(PLTE_off && tRNS_off, "PLTE offset %d, tRNS offset %d\n", PLTE_off, tRNS_off);
    if (!PLTE_off || !tRNS_off) return;
 
    /* In order to test the image data with and without PLTE and tRNS chunks
     * it's been decided to simply sero out the chunk id for testing puposes,
     * and under Windows such images get loaded just fine. But unfortunately
     * libpng refuses to load such images complaining about unknown chunk type.
     * A workaround for this libpng limitation is to mark the "disabled" chunks
     * with tEXt id.
     */
 
    for (i = 0; i < ARRAY_SIZE(td); i++)
    {
        /* with the tRNS and PLTE chunks */
        memcpy(buf, png_1x1_data, sizeof(png_1x1_data));
        buf[24] = td[i].bit_depth;
        buf[25] = td[i].color_type;
 
        hr = create_decoder(buf, sizeof(buf), &decoder);
        if (!is_valid_png_type_depth(td[i].color_type, td[i].bit_depth, TRUE))
            ok(hr == WINCODEC_ERR_UNKNOWNIMAGEFORMAT, "%d: wrong error %#lx\n", i, hr);
        else
            todo_wine_if(td[i].todo_load)
            ok(hr == S_OK, "%d: Failed to load PNG image data (type %d, bpp %d) %#lx\n", i, td[i].color_type, td[i].bit_depth, hr);
        if (hr != S_OK) goto next_1;
 
        hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
        ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
        hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
        ok(hr == S_OK, "GetPixelFormat error %#lx\n", hr);
        todo_wine_if(td[i].todo)
        ok(IsEqualGUID(&format, td[i].format_PLTE_tRNS),
           "PLTE+tRNS: expected %s, got %s (type %d, bpp %d)\n",
            wine_dbgstr_guid(td[i].format_PLTE_tRNS), wine_dbgstr_guid(&format), td[i].color_type, td[i].bit_depth);
 
        IWICBitmapFrameDecode_Release(frame);
        IWICBitmapDecoder_Release(decoder);
 
next_1:
        /* without the tRNS chunk */
        memcpy(buf, png_1x1_data, sizeof(png_1x1_data));
        buf[24] = td[i].bit_depth;
        buf[25] = td[i].color_type;
        memcpy(buf + tRNS_off, "tEXt", 4);
 
        hr = create_decoder(buf, sizeof(buf), &decoder);
        if (!is_valid_png_type_depth(td[i].color_type, td[i].bit_depth, TRUE))
            ok(hr == WINCODEC_ERR_UNKNOWNIMAGEFORMAT, "%d: wrong error %#lx\n", i, hr);
        else
            todo_wine_if(td[i].todo_load)
            ok(hr == S_OK, "%d: Failed to load PNG image data (type %d, bpp %d) %#lx\n", i, td[i].color_type, td[i].bit_depth, hr);
        if (hr != S_OK) goto next_2;
 
        hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
        ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
        hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
        ok(hr == S_OK, "GetPixelFormat error %#lx\n", hr);
        ok(IsEqualGUID(&format, td[i].format_PLTE),
           "PLTE: expected %s, got %s (type %d, bpp %d)\n",
            wine_dbgstr_guid(td[i].format_PLTE), wine_dbgstr_guid(&format), td[i].color_type, td[i].bit_depth);
 
        IWICBitmapFrameDecode_Release(frame);
        IWICBitmapDecoder_Release(decoder);
 
next_2:
        /* without the tRNS and PLTE chunks */
        memcpy(buf, png_1x1_data, sizeof(png_1x1_data));
        buf[24] = td[i].bit_depth;
        buf[25] = td[i].color_type;
        memcpy(buf + PLTE_off, "tEXt", 4);
        memcpy(buf + tRNS_off, "tEXt", 4);
 
        hr = create_decoder(buf, sizeof(buf), &decoder);
        if (!is_valid_png_type_depth(td[i].color_type, td[i].bit_depth, FALSE))
            ok(hr == WINCODEC_ERR_UNKNOWNIMAGEFORMAT, "%d: wrong error %#lx\n", i, hr);
        else
            todo_wine_if(td[i].todo_load)
            ok(hr == S_OK, "%d: Failed to load PNG image data (type %d, bpp %d) %#lx\n", i, td[i].color_type, td[i].bit_depth, hr);
        if (hr != S_OK) goto next_3;
 
        hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
        ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
        hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
        ok(hr == S_OK, "GetPixelFormat error %#lx\n", hr);
        ok(IsEqualGUID(&format, td[i].format),
           "expected %s, got %s (type %d, bpp %d)\n",
            wine_dbgstr_guid(td[i].format), wine_dbgstr_guid(&format), td[i].color_type, td[i].bit_depth);
 
        IWICBitmapFrameDecode_Release(frame);
        IWICBitmapDecoder_Release(decoder);
 
next_3:
        /* without the PLTE chunk */
        memcpy(buf, png_1x1_data, sizeof(png_1x1_data));
        buf[24] = td[i].bit_depth;
        buf[25] = td[i].color_type;
        memcpy(buf + PLTE_off, "tEXt", 4);
 
        hr = create_decoder(buf, sizeof(buf), &decoder);
        if (!is_valid_png_type_depth(td[i].color_type, td[i].bit_depth, FALSE))
            ok(hr == WINCODEC_ERR_UNKNOWNIMAGEFORMAT, "%d: wrong error %#lx\n", i, hr);
        else
            todo_wine_if(td[i].todo_load)
            ok(hr == S_OK, "%d: Failed to load PNG image data (type %d, bpp %d) %#lx\n", i, td[i].color_type, td[i].bit_depth, hr);
        if (hr != S_OK) continue;
 
        hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
        ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
        hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
        ok(hr == S_OK, "GetPixelFormat error %#lx\n", hr);
        todo_wine_if(td[i].todo)
        ok(IsEqualGUID(&format, td[i].format_PLTE_tRNS),
           "tRNS: expected %s, got %s (type %d, bpp %d)\n",
            wine_dbgstr_guid(td[i].format_PLTE_tRNS), wine_dbgstr_guid(&format), td[i].color_type, td[i].bit_depth);
 
        IWICBitmapFrameDecode_Release(frame);
        IWICBitmapDecoder_Release(decoder);
    }
}

Referenced by START_TEST().

test_png_palette()

static void test_png_palette ( void  )

static

Definition at line 553 of file pngformat.c.

{
    HRESULT hr;
    IWICBitmapDecoder *decoder;
    IWICBitmapFrameDecode *frame;
    IWICPalette *palette;
    GUID format;
    UINT count, ret;
    WICColor color[256];
    char *buf;
 
    hr = create_decoder(png_PLTE_tRNS, sizeof(png_PLTE_tRNS), &decoder);
    ok(hr == S_OK, "Failed to load PNG image data %#lx\n", hr);
    if (hr != S_OK) return;
 
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
    ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
    hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
    ok(hr == S_OK, "GetPixelFormat error %#lx\n", hr);
    ok(IsEqualGUID(&format, &GUID_WICPixelFormat1bppIndexed),
       "got wrong format %s\n", wine_dbgstr_guid(&format));
 
    hr = IWICImagingFactory_CreatePalette(factory, &palette);
    ok(hr == S_OK, "CreatePalette error %#lx\n", hr);
    hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
    ok(hr == S_OK, "CopyPalette error %#lx\n", hr);
 
    hr = IWICPalette_GetColorCount(palette, &count);
    ok(hr == S_OK, "GetColorCount error %#lx\n", hr);
    ok(count == 2, "expected 2, got %u\n", count);
 
    hr = IWICPalette_GetColors(palette, 256, color, &ret);
    ok(hr == S_OK, "GetColors error %#lx\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]);
 
    IWICPalette_Release(palette);
    IWICBitmapFrameDecode_Release(frame);
    IWICBitmapDecoder_Release(decoder);
 
    hr = create_decoder(png_gray_tRNS, sizeof(png_gray_tRNS), &decoder);
    ok(hr == S_OK, "Failed to load PNG image data %#lx\n", hr);
    if (hr != S_OK) return;
 
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
    ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
    hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
    ok(hr == S_OK, "GetPixelFormat error %#lx\n", hr);
    ok(IsEqualGUID(&format, &GUID_WICPixelFormat64bppRGBA),
       "got wrong format %s\n", wine_dbgstr_guid(&format));
 
    hr = IWICImagingFactory_CreatePalette(factory, &palette);
    ok(hr == S_OK, "CreatePalette error %#lx\n", hr);
    hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
    ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "CopyPalette error %#lx\n", hr);
 
    IWICPalette_Release(palette);
    IWICBitmapFrameDecode_Release(frame);
    IWICBitmapDecoder_Release(decoder);
 
    /* test 8 bpp grayscale PNG image with tRNS chunk */
    buf = HeapAlloc(GetProcessHeap(), 0, sizeof(png_gray_tRNS));
    memcpy(buf, png_gray_tRNS, sizeof(png_gray_tRNS));
    buf[24] = 8; /* override bit depth */
 
    hr = create_decoder(buf, sizeof(png_gray_tRNS), &decoder);
    ok(hr == S_OK, "Failed to load PNG image data %#lx\n", hr);
    if (hr != S_OK) return;
 
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
    ok(hr == S_OK, "GetFrame error %#lx\n", hr);
 
    hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
    ok(hr == S_OK, "GetPixelFormat error %#lx\n", hr);
    ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
       "got wrong format %s\n", wine_dbgstr_guid(&format));
 
    hr = IWICImagingFactory_CreatePalette(factory, &palette);
    ok(hr == S_OK, "CreatePalette error %#lx\n", hr);
    hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
    ok(hr == S_OK, "CopyPalette error %#lx\n", hr);
 
    hr = IWICPalette_GetColorCount(palette, &count);
    ok(hr == S_OK, "GetColorCount error %#lx\n", hr);
    ok(count == 256, "expected 256, got %u\n", count);
 
    hr = IWICPalette_GetColors(palette, 256, color, &ret);
    ok(hr == S_OK, "GetColors error %#lx\n", hr);
    ok(ret == count, "expected %u, got %u\n", count, ret);
    ok(color[0] == 0x00000000, "expected 0x00000000, got %#x\n", color[0]);
    ok(color[1] == 0xff010101, "expected 0xff010101, got %#x\n", color[1]);
 
    HeapFree(GetProcessHeap(), 0, buf);
    IWICPalette_Release(palette);
    IWICBitmapFrameDecode_Release(frame);
    IWICBitmapDecoder_Release(decoder);
}

Referenced by START_TEST().

Variable Documentation

factory

IWICImagingFactory* factory

static

Definition at line 277 of file pngformat.c.

png_1x1_data

const char png_1x1_data[]

static

Definition at line 655 of file pngformat.c.

Referenced by test_color_formats().

png_8M_tEXt_end

const char png_8M_tEXt_end[]

static

Initial value:

= {
   0x1e,0x13,0xe2,0xc7,
  0x00,0x00,0x00,0x0c,'I','D','A','T',0x78,0x9c,0x63,0x68,0x00,0x00,0x00,0x82,0x00,0x81,0x77,0xcd,0x72,0xb6,
  0x00,0x00,0x00,0x00,'I','E','N','D',0xae,0x42,0x60,0x82
}

Definition at line 931 of file pngformat.c.

Referenced by test_chunk_size().

png_8M_tEXt_start

const char png_8M_tEXt_start[]

static

Initial value:

= {
  0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,
  0x00,0x00,0x00,0x0d,'I','H','D','R',0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x37,0x6e,0xf9,0x24,
  0x00,0x80,0x00,0x08,'t','E','X','t','C','o','m','m','e','n','t',0x00 
}

Definition at line 926 of file pngformat.c.

Referenced by test_chunk_size().

png_color_profile

const char png_color_profile[]

static

Definition at line 45 of file pngformat.c.

Referenced by test_color_contexts().

png_gray_tRNS

const char png_gray_tRNS[]

static

Initial value:

= {
  0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,
  0x00,0x00,0x00,0x0d,'I','H','D','R',0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x10,0x00,0x00,0x00,0x00,0x6a,0xee,0x47,0x16,
  0x00,0x00,0x00,0x02,'t','R','N','S',0x00,0x00,0x76,0x93,0xcd,0x38,
  0x00,0x00,0x00,0x0b,'I','D','A','T',0x78,0x9c,0x63,0x60,0x60,0x00,0x00,0x00,0x03,0x00,0x01,0xb8,0xad,0x3a,0x63,
  0x00,0x00,0x00,0x00,'I','E','N','D',0xae,0x42,0x60,0x82
}

Definition at line 545 of file pngformat.c.

Referenced by test_png_palette().

png_no_color_profile

const char png_no_color_profile[]

static

Initial value:

= {
  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
}

Definition at line 31 of file pngformat.c.

Referenced by test_color_contexts().

png_PLTE_tRNS

const char png_PLTE_tRNS[]

static

Initial value:

= {
  0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,
  0x00,0x00,0x00,0x0d,'I','H','D','R',0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x03,0x00,0x00,0x00,0x25,0xdb,0x56,0xca,
  0x00,0x00,0x00,0x06,'P','L','T','E',0x01,0x02,0x03,0x04,0x05,0x06,0x95,0x53,0x6f,0x48,
  0x00,0x00,0x00,0x02,'t','R','N','S',0xff,0x00,0xe5,0xb7,0x30,0x4a,
  0x00,0x00,0x00,0x0a,'I','D','A','T',0x18,0xd3,0x63,0x68,0x00,0x00,0x00,0x82,0x00,0x81,0xa7,0x01,0xba,0x10,
  0x00,0x00,0x00,0x00,'I','E','N','D',0xae,0x42,0x60,0x82
}

Definition at line 535 of file pngformat.c.

Referenced by test_png_palette().