pngformat.c File Reference

#include "config.h"
#include "wine/port.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "wincodecs_private.h"
#include "wine/debug.h"
#include "wine/library.h"

Include dependency graph for pngformat.c:

Go to the source code of this file.

Macros
#define	NONAMELESSUNION
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)
static ULONG	read_ulong_be (BYTE *data)
static HRESULT	read_png_chunk (IStream *stream, BYTE *type, BYTE **data, ULONG *data_size)
static HRESULT	LoadTextMetadata (IStream *stream, const GUID *preferred_vendor, DWORD persist_options, MetadataItem **items, DWORD *item_count)
HRESULT	PngTextReader_CreateInstance (REFIID iid, void **ppv)
static HRESULT	LoadGamaMetadata (IStream *stream, const GUID *preferred_vendor, DWORD persist_options, MetadataItem **items, DWORD *item_count)
HRESULT	PngGamaReader_CreateInstance (REFIID iid, void **ppv)
static HRESULT	LoadChrmMetadata (IStream *stream, const GUID *preferred_vendor, DWORD persist_options, MetadataItem **items, DWORD *item_count)
HRESULT	PngChrmReader_CreateInstance (REFIID iid, void **ppv)
HRESULT	PngDecoder_CreateInstance (REFIID iid, void **ppv)
HRESULT	PngEncoder_CreateInstance (REFIID iid, void **ppv)

Variables
static const MetadataHandlerVtbl	TextReader_Vtbl
static const MetadataHandlerVtbl	GamaReader_Vtbl
static const MetadataHandlerVtbl	ChrmReader_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 30 of file pngformat.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 29 of file pngformat.c.

Function Documentation

LoadChrmMetadata()

static HRESULT LoadChrmMetadata ( IStream *  stream, const GUID *  preferred_vendor, DWORD  persist_options, MetadataItem **  items, DWORD *  item_count  )

static

Definition at line 222 of file pngformat.c.

{
    HRESULT hr;
    BYTE type[4];
    BYTE *data;
    ULONG data_size;
    static const WCHAR names[8][12] = {
        {'W','h','i','t','e','P','o','i','n','t','X',0},
        {'W','h','i','t','e','P','o','i','n','t','Y',0},
        {'R','e','d','X',0},
        {'R','e','d','Y',0},
        {'G','r','e','e','n','X',0},
        {'G','r','e','e','n','Y',0},
        {'B','l','u','e','X',0},
        {'B','l','u','e','Y',0},
    };
    LPWSTR dyn_names[8] = {0};
    MetadataItem *result;
    int i;
 
    hr = read_png_chunk(stream, type, &data, &data_size);
    if (FAILED(hr)) return hr;
 
    if (data_size < 32)
    {
        HeapFree(GetProcessHeap(), 0, data);
        return E_FAIL;
    }
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem)*8);
    for (i=0; i<8; i++)
    {
        dyn_names[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(lstrlenW(names[i])+1));
        if (!dyn_names[i]) break;
    }
    if (!result || i < 8)
    {
        HeapFree(GetProcessHeap(), 0, result);
        for (i=0; i<8; i++)
            HeapFree(GetProcessHeap(), 0, dyn_names[i]);
        HeapFree(GetProcessHeap(), 0, data);
        return E_OUTOFMEMORY;
    }
 
    for (i=0; i<8; i++)
    {
        PropVariantInit(&result[i].schema);
 
        PropVariantInit(&result[i].id);
        result[i].id.vt = VT_LPWSTR;
        result[i].id.u.pwszVal = dyn_names[i];
        lstrcpyW(dyn_names[i], names[i]);
 
        PropVariantInit(&result[i].value);
        result[i].value.vt = VT_UI4;
        result[i].value.u.ulVal = read_ulong_be(&data[i*4]);
    }
 
    *items = result;
    *item_count = 8;
 
    HeapFree(GetProcessHeap(), 0, data);
 
    return S_OK;
}

LoadGamaMetadata()

static HRESULT LoadGamaMetadata ( IStream *  stream, const GUID *  preferred_vendor, DWORD  persist_options, MetadataItem **  items, DWORD *  item_count  )

static

Definition at line 160 of file pngformat.c.

{
    HRESULT hr;
    BYTE type[4];
    BYTE *data;
    ULONG data_size;
    ULONG gamma;
    static const WCHAR ImageGamma[] = {'I','m','a','g','e','G','a','m','m','a',0};
    LPWSTR name;
    MetadataItem *result;
 
    hr = read_png_chunk(stream, type, &data, &data_size);
    if (FAILED(hr)) return hr;
 
    if (data_size < 4)
    {
        HeapFree(GetProcessHeap(), 0, data);
        return E_FAIL;
    }
 
    gamma = read_ulong_be(data);
 
    HeapFree(GetProcessHeap(), 0, data);
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
    name = HeapAlloc(GetProcessHeap(), 0, sizeof(ImageGamma));
    if (!result || !name)
    {
        HeapFree(GetProcessHeap(), 0, result);
        HeapFree(GetProcessHeap(), 0, name);
        return E_OUTOFMEMORY;
    }
 
    PropVariantInit(&result[0].schema);
    PropVariantInit(&result[0].id);
    PropVariantInit(&result[0].value);
 
    memcpy(name, ImageGamma, sizeof(ImageGamma));
 
    result[0].id.vt = VT_LPWSTR;
    result[0].id.u.pwszVal = name;
    result[0].value.vt = VT_UI4;
    result[0].value.u.ulVal = gamma;
 
    *items = result;
    *item_count = 1;
 
    return S_OK;
}

LoadTextMetadata()

static HRESULT LoadTextMetadata ( IStream *  stream, const GUID *  preferred_vendor, DWORD  persist_options, MetadataItem **  items, DWORD *  item_count  )

static

Definition at line 89 of file pngformat.c.

{
    HRESULT hr;
    BYTE type[4];
    BYTE *data;
    ULONG data_size;
    ULONG name_len, value_len;
    BYTE *name_end_ptr;
    LPSTR name, value;
    MetadataItem *result;
 
    hr = read_png_chunk(stream, type, &data, &data_size);
    if (FAILED(hr)) return hr;
 
    name_end_ptr = memchr(data, 0, data_size);
 
    name_len = name_end_ptr - data;
 
    if (!name_end_ptr || name_len > 79)
    {
        HeapFree(GetProcessHeap(), 0, data);
        return E_FAIL;
    }
 
    value_len = data_size - name_len - 1;
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
    name = HeapAlloc(GetProcessHeap(), 0, name_len + 1);
    value = HeapAlloc(GetProcessHeap(), 0, value_len + 1);
    if (!result || !name || !value)
    {
        HeapFree(GetProcessHeap(), 0, data);
        HeapFree(GetProcessHeap(), 0, result);
        HeapFree(GetProcessHeap(), 0, name);
        HeapFree(GetProcessHeap(), 0, value);
        return E_OUTOFMEMORY;
    }
 
    PropVariantInit(&result[0].schema);
    PropVariantInit(&result[0].id);
    PropVariantInit(&result[0].value);
 
    memcpy(name, data, name_len + 1);
    memcpy(value, name_end_ptr + 1, value_len);
    value[value_len] = 0;
 
    result[0].id.vt = VT_LPSTR;
    result[0].id.u.pszVal = name;
    result[0].value.vt = VT_LPSTR;
    result[0].value.u.pszVal = value;
 
    *items = result;
    *item_count = 1;
 
    HeapFree(GetProcessHeap(), 0, data);
 
    return S_OK;
}

PngChrmReader_CreateInstance()

HRESULT PngChrmReader_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 295 of file pngformat.c.

{
    return MetadataReader_Create(&ChrmReader_Vtbl, iid, ppv);
}

PngDecoder_CreateInstance()

HRESULT PngDecoder_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 2188 of file pngformat.c.

{
    ERR("Trying to load PNG picture, but PNG support is not compiled in.\n");
    return E_FAIL;
}

Referenced by ReadIcoPng().

PngEncoder_CreateInstance()

HRESULT PngEncoder_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 2194 of file pngformat.c.

{
    ERR("Trying to save PNG picture, but PNG support is not compiled in.\n");
    return E_FAIL;
}

PngGamaReader_CreateInstance()

HRESULT PngGamaReader_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 217 of file pngformat.c.

{
    return MetadataReader_Create(&GamaReader_Vtbl, iid, ppv);
}

PngTextReader_CreateInstance()

HRESULT PngTextReader_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 155 of file pngformat.c.

{
    return MetadataReader_Create(&TextReader_Vtbl, iid, ppv);
}

read_png_chunk()

static HRESULT read_png_chunk ( IStream *  stream, BYTE *  type, BYTE **  data, ULONG *  data_size  )

static

Definition at line 48 of file pngformat.c.

{
    BYTE header[8];
    HRESULT hr;
    ULONG bytesread;
 
    hr = IStream_Read(stream, header, 8, &bytesread);
    if (FAILED(hr) || bytesread < 8)
    {
        if (SUCCEEDED(hr))
            hr = E_FAIL;
        return hr;
    }
 
    *data_size = read_ulong_be(&header[0]);
 
    memcpy(type, &header[4], 4);
 
    if (data)
    {
        *data = HeapAlloc(GetProcessHeap(), 0, *data_size);
        if (!*data)
            return E_OUTOFMEMORY;
 
        hr = IStream_Read(stream, *data, *data_size, &bytesread);
 
        if (FAILED(hr) || bytesread < *data_size)
        {
            if (SUCCEEDED(hr))
                hr = E_FAIL;
            HeapFree(GetProcessHeap(), 0, *data);
            *data = NULL;
            return hr;
        }
 
        /* Windows ignores CRC of the chunk */
    }
 
    return S_OK;
}

Referenced by LoadChrmMetadata(), LoadGamaMetadata(), and LoadTextMetadata().

read_ulong_be()

static ULONG read_ulong_be ( BYTE *  data )

inlinestatic

Definition at line 43 of file pngformat.c.

{
    return data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
}

Referenced by LoadChrmMetadata(), LoadGamaMetadata(), and read_png_chunk().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wincodecs

)

Variable Documentation

ChrmReader_Vtbl

const MetadataHandlerVtbl ChrmReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICPngChrmMetadataReader,
    LoadChrmMetadata
}

Definition at line 289 of file pngformat.c.

Referenced by PngChrmReader_CreateInstance().

GamaReader_Vtbl

const MetadataHandlerVtbl GamaReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICPngGamaMetadataReader,
    LoadGamaMetadata
}

Definition at line 211 of file pngformat.c.

Referenced by PngGamaReader_CreateInstance().

TextReader_Vtbl

const MetadataHandlerVtbl TextReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICPngTextMetadataReader,
    LoadTextMetadata
}

Definition at line 149 of file pngformat.c.

Referenced by PngTextReader_CreateInstance().