dlls/windowscodecs/pngformat.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  * Copyright 2016 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define NONAMELESSUNION
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28
  29 #include "wincodecs_private.h"
  30
  31 #include "wine/debug.h"
  32
  33 static inline ULONG read_ulong_be(BYTE* data)
  34 {
  35     return data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
  36 }
  37
  38 static HRESULT LoadTextMetadata(IStream *stream, const GUID *preferred_vendor,
  39     DWORD persist_options, MetadataItem **items, DWORD *item_count)
  40 {
  41     HRESULT hr;
  42     BYTE type[4];
  43     BYTE *data;
  44     ULONG data_size;
  45     ULONG name_len, value_len;
  46     BYTE *name_end_ptr;
  47     LPSTR name, value;
  48     MetadataItem *result;
  49
  50     hr = read_png_chunk(stream, type, &data, &data_size);
  51     if (FAILED(hr)) return hr;
  52
  53     name_end_ptr = memchr(data, 0, data_size);
  54
  55     name_len = name_end_ptr - data;
  56
  57     if (!name_end_ptr || name_len > 79)
  58     {
  59         HeapFree(GetProcessHeap(), 0, data);
  60         return E_FAIL;
  61     }
  62
  63     value_len = data_size - name_len - 1;
  64
  65     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
  66     name = HeapAlloc(GetProcessHeap(), 0, name_len + 1);
  67     value = HeapAlloc(GetProcessHeap(), 0, value_len + 1);
  68     if (!result || !name || !value)
  69     {
  70         HeapFree(GetProcessHeap(), 0, data);
  71         HeapFree(GetProcessHeap(), 0, result);
  72         HeapFree(GetProcessHeap(), 0, name);
  73         HeapFree(GetProcessHeap(), 0, value);
  74         return E_OUTOFMEMORY;
  75     }
  76
  77     PropVariantInit(&result[0].schema);
  78     PropVariantInit(&result[0].id);
  79     PropVariantInit(&result[0].value);
  80
  81     memcpy(name, data, name_len + 1);
  82     memcpy(value, name_end_ptr + 1, value_len);
  83     value[value_len] = 0;
  84
  85     result[0].id.vt = VT_LPSTR;
  86     result[0].id.pszVal = name;
  87     result[0].value.vt = VT_LPSTR;
  88     result[0].value.pszVal = value;
  89
  90     *items = result;
  91     *item_count = 1;
  92
  93     HeapFree(GetProcessHeap(), 0, data);
  94
  95     return S_OK;
  96 }
  97
  98 static const MetadataHandlerVtbl TextReader_Vtbl = {
  99     0,
 100     &CLSID_WICPngTextMetadataReader,
 101     LoadTextMetadata
 102 };
 103
 104 HRESULT PngTextReader_CreateInstance(REFIID iid, void** ppv)
 105 {
 106     return MetadataReader_Create(&TextReader_Vtbl, iid, ppv);
 107 }
 108
 109 static HRESULT LoadGamaMetadata(IStream *stream, const GUID *preferred_vendor,
 110     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 111 {
 112     HRESULT hr;
 113     BYTE type[4];
 114     BYTE *data;
 115     ULONG data_size;
 116     ULONG gamma;
 117     LPWSTR name;
 118     MetadataItem *result;
 119
 120     hr = read_png_chunk(stream, type, &data, &data_size);
 121     if (FAILED(hr)) return hr;
 122
 123     if (data_size < 4)
 124     {
 125         HeapFree(GetProcessHeap(), 0, data);
 126         return E_FAIL;
 127     }
 128
 129     gamma = read_ulong_be(data);
 130
 131     HeapFree(GetProcessHeap(), 0, data);
 132
 133     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
 134     name = HeapAlloc(GetProcessHeap(), 0, sizeof(L"ImageGamma"));
 135     if (!result || !name)
 136     {
 137         HeapFree(GetProcessHeap(), 0, result);
 138         HeapFree(GetProcessHeap(), 0, name);
 139         return E_OUTOFMEMORY;
 140     }
 141
 142     PropVariantInit(&result[0].schema);
 143     PropVariantInit(&result[0].id);
 144     PropVariantInit(&result[0].value);
 145
 146     memcpy(name, L"ImageGamma", sizeof(L"ImageGamma"));
 147
 148     result[0].id.vt = VT_LPWSTR;
 149     result[0].id.pwszVal = name;
 150     result[0].value.vt = VT_UI4;
 151     result[0].value.ulVal = gamma;
 152
 153     *items = result;
 154     *item_count = 1;
 155
 156     return S_OK;
 157 }
 158
 159 static const MetadataHandlerVtbl GamaReader_Vtbl = {
 160     0,
 161     &CLSID_WICPngGamaMetadataReader,
 162     LoadGamaMetadata
 163 };
 164
 165 HRESULT PngGamaReader_CreateInstance(REFIID iid, void** ppv)
 166 {
 167     return MetadataReader_Create(&GamaReader_Vtbl, iid, ppv);
 168 }
 169
 170 static HRESULT LoadChrmMetadata(IStream *stream, const GUID *preferred_vendor,
 171     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 172 {
 173     HRESULT hr;
 174     BYTE type[4];
 175     BYTE *data;
 176     ULONG data_size;
 177     static const WCHAR names[8][12] = {
 178         L"WhitePointX",
 179         L"WhitePointY",
 180         L"RedX",
 181         L"RedY",
 182         L"GreenX",
 183         L"GreenY",
 184         L"BlueX",
 185         L"BlueY",
 186     };
 187     LPWSTR dyn_names[8] = {0};
 188     MetadataItem *result;
 189     int i;
 190
 191     hr = read_png_chunk(stream, type, &data, &data_size);
 192     if (FAILED(hr)) return hr;
 193
 194     if (data_size < 32)
 195     {
 196         HeapFree(GetProcessHeap(), 0, data);
 197         return E_FAIL;
 198     }
 199
 200     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem)*8);
 201     for (i=0; i<8; i++)
 202     {
 203         dyn_names[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(lstrlenW(names[i])+1));
 204         if (!dyn_names[i]) break;
 205     }
 206     if (!result || i < 8)
 207     {
 208         HeapFree(GetProcessHeap(), 0, result);
 209         for (i=0; i<8; i++)
 210             HeapFree(GetProcessHeap(), 0, dyn_names[i]);
 211         HeapFree(GetProcessHeap(), 0, data);
 212         return E_OUTOFMEMORY;
 213     }
 214
 215     for (i=0; i<8; i++)
 216     {
 217         PropVariantInit(&result[i].schema);
 218
 219         PropVariantInit(&result[i].id);
 220         result[i].id.vt = VT_LPWSTR;
 221         result[i].id.pwszVal = dyn_names[i];
 222         lstrcpyW(dyn_names[i], names[i]);
 223
 224         PropVariantInit(&result[i].value);
 225         result[i].value.vt = VT_UI4;
 226         result[i].value.ulVal = read_ulong_be(&data[i*4]);
 227     }
 228
 229     *items = result;
 230     *item_count = 8;
 231
 232     HeapFree(GetProcessHeap(), 0, data);
 233
 234     return S_OK;
 235 }
 236
 237 static const MetadataHandlerVtbl ChrmReader_Vtbl = {
 238     0,
 239     &CLSID_WICPngChrmMetadataReader,
 240     LoadChrmMetadata
 241 };
 242
 243 HRESULT PngChrmReader_CreateInstance(REFIID iid, void** ppv)
 244 {
 245     return MetadataReader_Create(&ChrmReader_Vtbl, iid, ppv);
 246 }
 247
 248 HRESULT PngDecoder_CreateInstance(REFIID iid, void** ppv)
 249 {
 250     HRESULT hr;
 251     struct decoder *decoder;
 252     struct decoder_info decoder_info;
 253
 254     hr = get_unix_decoder(&CLSID_WICPngDecoder, &decoder_info, &decoder);
 255
 256     if (SUCCEEDED(hr))
 257         hr = CommonDecoder_CreateInstance(decoder, &decoder_info, iid, ppv);
 258
 259     return hr;
 260 }
 261
 262 HRESULT PngEncoder_CreateInstance(REFIID iid, void** ppv)
 263 {
 264     HRESULT hr;
 265     struct encoder *encoder;
 266     struct encoder_info encoder_info;
 267
 268     hr = get_unix_encoder(&CLSID_WICPngEncoder, &encoder_info, &encoder);
 269
 270     if (SUCCEEDED(hr))
 271         hr = CommonEncoder_CreateInstance(encoder, &encoder_info, iid, ppv);
 272
 273     return hr;
 274 }