dlls/windowscodecs/regsvr.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define NONAMELESSUNION
  20 #define NONAMELESSSTRUCT
  21 #define COBJMACROS
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winuser.h"
  29 #include "winreg.h"
  30 #include "winerror.h"
  31
  32 #include "objbase.h"
  33 #include "ocidl.h"
  34 #include "wincodec.h"
  35 #include "wincodecsdk.h"
  36
  37 #include "wine/debug.h"
  38 #include "wine/unicode.h"
  39
  40 #include "wincodecs_private.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  43
  44 /***********************************************************************
  45  *              interface for self-registering
  46  */
  47 struct decoder_pattern
  48 {
  49     DWORD length;    /* 0 for end of list */
  50     DWORD position;
  51     const BYTE *pattern;
  52     const BYTE *mask;
  53     DWORD endofstream;
  54 };
  55
  56 struct regsvr_decoder
  57 {
  58     CLSID const *clsid;         /* NULL for end of list */
  59     LPCSTR author;
  60     LPCSTR friendlyname;
  61     LPCSTR version;
  62     GUID const *vendor;
  63     GUID const *container_format;
  64     LPCSTR mimetypes;
  65     LPCSTR extensions;
  66     GUID const * const *formats;
  67     const struct decoder_pattern *patterns;
  68 };
  69
  70 static HRESULT register_decoders(struct regsvr_decoder const *list);
  71 static HRESULT unregister_decoders(struct regsvr_decoder const *list);
  72
  73 struct regsvr_encoder
  74 {
  75     CLSID const *clsid;         /* NULL for end of list */
  76     LPCSTR author;
  77     LPCSTR friendlyname;
  78     LPCSTR version;
  79     GUID const *vendor;
  80     GUID const *container_format;
  81     LPCSTR mimetypes;
  82     LPCSTR extensions;
  83     GUID const * const *formats;
  84 };
  85
  86 static HRESULT register_encoders(struct regsvr_encoder const *list);
  87 static HRESULT unregister_encoders(struct regsvr_encoder const *list);
  88
  89 struct regsvr_converter
  90 {
  91     CLSID const *clsid;         /* NULL for end of list */
  92     LPCSTR author;
  93     LPCSTR friendlyname;
  94     LPCSTR version;
  95     GUID const *vendor;
  96     GUID const * const *formats;
  97 };
  98
  99 static HRESULT register_converters(struct regsvr_converter const *list);
 100 static HRESULT unregister_converters(struct regsvr_converter const *list);
 101
 102 struct metadata_pattern
 103 {
 104     DWORD position;
 105     DWORD length;
 106     const BYTE *pattern;
 107     const BYTE *mask;
 108     DWORD data_offset;
 109 };
 110
 111 struct reader_containers
 112 {
 113     GUID const *format;
 114     const struct metadata_pattern *patterns;
 115 };
 116
 117 struct regsvr_metadatareader
 118 {
 119     CLSID const *clsid;         /* NULL for end of list */
 120     LPCSTR author;
 121     LPCSTR friendlyname;
 122     LPCSTR version;
 123     LPCSTR specversion;
 124     GUID const *vendor;
 125     GUID const *metadata_format;
 126     DWORD requires_fullstream;
 127     DWORD supports_padding;
 128     DWORD requires_fixedsize;
 129     const struct reader_containers *containers;
 130 };
 131
 132 static HRESULT register_metadatareaders(struct regsvr_metadatareader const *list);
 133 static HRESULT unregister_metadatareaders(struct regsvr_metadatareader const *list);
 134
 135 struct regsvr_pixelformat
 136 {
 137     CLSID const *clsid;         /* NULL for end of list */
 138     LPCSTR author;
 139     LPCSTR friendlyname;
 140     LPCSTR version;
 141     GUID const *vendor;
 142     UINT bitsperpixel;
 143     UINT channelcount;
 144     BYTE const * const *channelmasks;
 145     WICPixelFormatNumericRepresentation numericrepresentation;
 146     UINT supportsalpha;
 147 };
 148
 149 static HRESULT register_pixelformats(struct regsvr_pixelformat const *list);
 150 static HRESULT unregister_pixelformats(struct regsvr_pixelformat const *list);
 151
 152 /***********************************************************************
 153  *              static string constants
 154  */
 155 static const WCHAR clsid_keyname[] = {
 156     'C', 'L', 'S', 'I', 'D', 0 };
 157 static const WCHAR curver_keyname[] = {
 158     'C', 'u', 'r', 'V', 'e', 'r', 0 };
 159 static const WCHAR ips_keyname[] = {
 160     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
 161     0 };
 162 static const WCHAR ips32_keyname[] = {
 163     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
 164     '3', '2', 0 };
 165 static const WCHAR progid_keyname[] = {
 166     'P', 'r', 'o', 'g', 'I', 'D', 0 };
 167 static const WCHAR viprogid_keyname[] = {
 168     'V', 'e', 'r', 's', 'i', 'o', 'n', 'I', 'n', 'd', 'e', 'p',
 169     'e', 'n', 'd', 'e', 'n', 't', 'P', 'r', 'o', 'g', 'I', 'D',
 170     0 };
 171 static const char tmodel_valuename[] = "ThreadingModel";
 172 static const char author_valuename[] = "Author";
 173 static const char friendlyname_valuename[] = "FriendlyName";
 174 static const WCHAR vendor_valuename[] = {'V','e','n','d','o','r',0};
 175 static const WCHAR containerformat_valuename[] = {'C','o','n','t','a','i','n','e','r','F','o','r','m','a','t',0};
 176 static const char version_valuename[] = "Version";
 177 static const char mimetypes_valuename[] = "MimeTypes";
 178 static const char extensions_valuename[] = "FileExtensions";
 179 static const WCHAR formats_keyname[] = {'F','o','r','m','a','t','s',0};
 180 static const WCHAR patterns_keyname[] = {'P','a','t','t','e','r','n','s',0};
 181 static const WCHAR instance_keyname[] = {'I','n','s','t','a','n','c','e',0};
 182 static const WCHAR clsid_valuename[] = {'C','L','S','I','D',0};
 183 static const char length_valuename[] = "Length";
 184 static const char position_valuename[] = "Position";
 185 static const char pattern_valuename[] = "Pattern";
 186 static const char mask_valuename[] = "Mask";
 187 static const char endofstream_valuename[] = "EndOfStream";
 188 static const WCHAR pixelformats_keyname[] = {'P','i','x','e','l','F','o','r','m','a','t','s',0};
 189 static const WCHAR metadataformat_valuename[] = {'M','e','t','a','d','a','t','a','F','o','r','m','a','t',0};
 190 static const char specversion_valuename[] = "SpecVersion";
 191 static const char requiresfullstream_valuename[] = "RequiresFullStream";
 192 static const char supportspadding_valuename[] = "SupportsPadding";
 193 static const char requiresfixedsize_valuename[] = "FixedSize";
 194 static const WCHAR containers_keyname[] = {'C','o','n','t','a','i','n','e','r','s',0};
 195 static const char dataoffset_valuename[] = "DataOffset";
 196 static const char bitsperpixel_valuename[] = "BitLength";
 197 static const char channelcount_valuename[] = "ChannelCount";
 198 static const char numericrepresentation_valuename[] = "NumericRepresentation";
 199 static const char supportstransparency_valuename[] = "SupportsTransparency";
 200 static const WCHAR channelmasks_keyname[] = {'C','h','a','n','n','e','l','M','a','s','k','s',0};
 201
 202 /***********************************************************************
 203  *              register_decoders
 204  */
 205 static HRESULT register_decoders(struct regsvr_decoder const *list)
 206 {
 207     LONG res = ERROR_SUCCESS;
 208     HKEY coclass_key;
 209     WCHAR buf[39];
 210     HKEY decoders_key;
 211     HKEY instance_key;
 212
 213     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
 214                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
 215     if (res == ERROR_SUCCESS)  {
 216         StringFromGUID2(&CATID_WICBitmapDecoders, buf, 39);
 217         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 218                               KEY_READ | KEY_WRITE, NULL, &decoders_key, NULL);
 219         if (res == ERROR_SUCCESS)
 220         {
 221             res = RegCreateKeyExW(decoders_key, instance_keyname, 0, NULL, 0,
 222                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 223             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 224         }
 225         if (res != ERROR_SUCCESS)
 226             RegCloseKey(coclass_key);
 227     }
 228     if (res != ERROR_SUCCESS) goto error_return;
 229
 230     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 231         HKEY clsid_key;
 232         HKEY instance_clsid_key;
 233
 234         StringFromGUID2(list->clsid, buf, 39);
 235         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 236                               KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
 237         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 238
 239         StringFromGUID2(list->clsid, buf, 39);
 240         res = RegCreateKeyExW(instance_key, buf, 0, NULL, 0,
 241                               KEY_READ | KEY_WRITE, NULL, &instance_clsid_key, NULL);
 242         if (res == ERROR_SUCCESS) {
 243             res = RegSetValueExW(instance_clsid_key, clsid_valuename, 0, REG_SZ,
 244                                  (CONST BYTE*)(buf), 78);
 245             RegCloseKey(instance_clsid_key);
 246         }
 247         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 248
 249         if (list->author) {
 250             res = RegSetValueExA(clsid_key, author_valuename, 0, REG_SZ,
 251                                  (CONST BYTE*)(list->author),
 252                                  strlen(list->author) + 1);
 253             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 254         }
 255
 256         if (list->friendlyname) {
 257             res = RegSetValueExA(clsid_key, friendlyname_valuename, 0, REG_SZ,
 258                                  (CONST BYTE*)(list->friendlyname),
 259                                  strlen(list->friendlyname) + 1);
 260             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 261         }
 262
 263         if (list->vendor) {
 264             StringFromGUID2(list->vendor, buf, 39);
 265             res = RegSetValueExW(clsid_key, vendor_valuename, 0, REG_SZ,
 266                                  (CONST BYTE*)(buf), 78);
 267             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 268         }
 269
 270         if (list->container_format) {
 271             StringFromGUID2(list->container_format, buf, 39);
 272             res = RegSetValueExW(clsid_key, containerformat_valuename, 0, REG_SZ,
 273                                  (CONST BYTE*)(buf), 78);
 274             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 275         }
 276
 277         if (list->version) {
 278             res = RegSetValueExA(clsid_key, version_valuename, 0, REG_SZ,
 279                                  (CONST BYTE*)(list->version),
 280                                  strlen(list->version) + 1);
 281             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 282         }
 283
 284         if (list->mimetypes) {
 285             res = RegSetValueExA(clsid_key, mimetypes_valuename, 0, REG_SZ,
 286                                  (CONST BYTE*)(list->mimetypes),
 287                                  strlen(list->mimetypes) + 1);
 288             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 289         }
 290
 291         if (list->extensions) {
 292             res = RegSetValueExA(clsid_key, extensions_valuename, 0, REG_SZ,
 293                                  (CONST BYTE*)(list->extensions),
 294                                  strlen(list->extensions) + 1);
 295             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 296         }
 297
 298         if (list->formats) {
 299             HKEY formats_key;
 300             GUID const * const *format;
 301
 302             res = RegCreateKeyExW(clsid_key, formats_keyname, 0, NULL, 0,
 303                                   KEY_READ | KEY_WRITE, NULL, &formats_key, NULL);
 304             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 305             for (format=list->formats; *format; ++format)
 306             {
 307                 HKEY format_key;
 308                 StringFromGUID2(*format, buf, 39);
 309                 res = RegCreateKeyExW(formats_key, buf, 0, NULL, 0,
 310                                       KEY_READ | KEY_WRITE, NULL, &format_key, NULL);
 311                 if (res != ERROR_SUCCESS) break;
 312                 RegCloseKey(format_key);
 313             }
 314             RegCloseKey(formats_key);
 315             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 316         }
 317
 318         if (list->patterns) {
 319             HKEY patterns_key;
 320             int i;
 321
 322             res = RegCreateKeyExW(clsid_key, patterns_keyname, 0, NULL, 0,
 323                                   KEY_READ | KEY_WRITE, NULL, &patterns_key, NULL);
 324             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 325             for (i=0; list->patterns[i].length; i++)
 326             {
 327                 HKEY pattern_key;
 328                 static const WCHAR int_format[] = {'%','i',0};
 329                 snprintfW(buf, 39, int_format, i);
 330                 res = RegCreateKeyExW(patterns_key, buf, 0, NULL, 0,
 331                                       KEY_READ | KEY_WRITE, NULL, &pattern_key, NULL);
 332                 if (res != ERROR_SUCCESS) break;
 333                 res = RegSetValueExA(pattern_key, length_valuename, 0, REG_DWORD,
 334                                      (CONST BYTE*)(&list->patterns[i].length), 4);
 335                 if (res == ERROR_SUCCESS)
 336                     res = RegSetValueExA(pattern_key, position_valuename, 0, REG_DWORD,
 337                                          (CONST BYTE*)(&list->patterns[i].position), 4);
 338                 if (res == ERROR_SUCCESS)
 339                     res = RegSetValueExA(pattern_key, pattern_valuename, 0, REG_BINARY,
 340                                          list->patterns[i].pattern,
 341                                          list->patterns[i].length);
 342                 if (res == ERROR_SUCCESS)
 343                     res = RegSetValueExA(pattern_key, mask_valuename, 0, REG_BINARY,
 344                                          list->patterns[i].mask,
 345                                          list->patterns[i].length);
 346                 if (res == ERROR_SUCCESS)
 347                     res = RegSetValueExA(pattern_key, endofstream_valuename, 0, REG_DWORD,
 348                                          (CONST BYTE*)&(list->patterns[i].endofstream), 4);
 349                 RegCloseKey(pattern_key);
 350             }
 351             RegCloseKey(patterns_key);
 352             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 353         }
 354
 355     error_close_clsid_key:
 356         RegCloseKey(clsid_key);
 357     }
 358
 359 error_close_coclass_key:
 360     RegCloseKey(instance_key);
 361     RegCloseKey(decoders_key);
 362     RegCloseKey(coclass_key);
 363 error_return:
 364     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 365 }
 366
 367 /***********************************************************************
 368  *              unregister_decoders
 369  */
 370 static HRESULT unregister_decoders(struct regsvr_decoder const *list)
 371 {
 372     LONG res = ERROR_SUCCESS;
 373     HKEY coclass_key;
 374     WCHAR buf[39];
 375     HKEY decoders_key;
 376     HKEY instance_key;
 377
 378     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
 379                         KEY_READ | KEY_WRITE, &coclass_key);
 380     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
 381
 382     if (res == ERROR_SUCCESS)  {
 383         StringFromGUID2(&CATID_WICBitmapDecoders, buf, 39);
 384         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 385                               KEY_READ | KEY_WRITE, NULL, &decoders_key, NULL);
 386         if (res == ERROR_SUCCESS)
 387         {
 388             res = RegCreateKeyExW(decoders_key, instance_keyname, 0, NULL, 0,
 389                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 390             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 391         }
 392         if (res != ERROR_SUCCESS)
 393             RegCloseKey(coclass_key);
 394     }
 395     if (res != ERROR_SUCCESS) goto error_return;
 396
 397     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 398         StringFromGUID2(list->clsid, buf, 39);
 399
 400         res = RegDeleteTreeW(coclass_key, buf);
 401         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 402         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 403
 404         res = RegDeleteTreeW(instance_key, buf);
 405         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 406         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 407     }
 408
 409 error_close_coclass_key:
 410     RegCloseKey(instance_key);
 411     RegCloseKey(decoders_key);
 412     RegCloseKey(coclass_key);
 413 error_return:
 414     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 415 }
 416
 417 /***********************************************************************
 418  *              register_encoders
 419  */
 420 static HRESULT register_encoders(struct regsvr_encoder const *list)
 421 {
 422     LONG res = ERROR_SUCCESS;
 423     HKEY coclass_key;
 424     WCHAR buf[39];
 425     HKEY encoders_key;
 426     HKEY instance_key;
 427
 428     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
 429                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
 430     if (res == ERROR_SUCCESS)  {
 431         StringFromGUID2(&CATID_WICBitmapEncoders, buf, 39);
 432         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 433                               KEY_READ | KEY_WRITE, NULL, &encoders_key, NULL);
 434         if (res == ERROR_SUCCESS)
 435         {
 436             res = RegCreateKeyExW(encoders_key, instance_keyname, 0, NULL, 0,
 437                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 438             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 439         }
 440         if (res != ERROR_SUCCESS)
 441             RegCloseKey(coclass_key);
 442     }
 443     if (res != ERROR_SUCCESS) goto error_return;
 444
 445     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 446         HKEY clsid_key;
 447         HKEY instance_clsid_key;
 448
 449         StringFromGUID2(list->clsid, buf, 39);
 450         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 451                               KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
 452         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 453
 454         StringFromGUID2(list->clsid, buf, 39);
 455         res = RegCreateKeyExW(instance_key, buf, 0, NULL, 0,
 456                               KEY_READ | KEY_WRITE, NULL, &instance_clsid_key, NULL);
 457         if (res == ERROR_SUCCESS) {
 458             res = RegSetValueExW(instance_clsid_key, clsid_valuename, 0, REG_SZ,
 459                                  (CONST BYTE*)(buf), 78);
 460             RegCloseKey(instance_clsid_key);
 461         }
 462         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 463
 464         if (list->author) {
 465             res = RegSetValueExA(clsid_key, author_valuename, 0, REG_SZ,
 466                                  (CONST BYTE*)(list->author),
 467                                  strlen(list->author) + 1);
 468             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 469         }
 470
 471         if (list->friendlyname) {
 472             res = RegSetValueExA(clsid_key, friendlyname_valuename, 0, REG_SZ,
 473                                  (CONST BYTE*)(list->friendlyname),
 474                                  strlen(list->friendlyname) + 1);
 475             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 476         }
 477
 478         if (list->vendor) {
 479             StringFromGUID2(list->vendor, buf, 39);
 480             res = RegSetValueExW(clsid_key, vendor_valuename, 0, REG_SZ,
 481                                  (CONST BYTE*)(buf), 78);
 482             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 483         }
 484
 485         if (list->container_format) {
 486             StringFromGUID2(list->container_format, buf, 39);
 487             res = RegSetValueExW(clsid_key, containerformat_valuename, 0, REG_SZ,
 488                                  (CONST BYTE*)(buf), 78);
 489             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 490         }
 491
 492         if (list->version) {
 493             res = RegSetValueExA(clsid_key, version_valuename, 0, REG_SZ,
 494                                  (CONST BYTE*)(list->version),
 495                                  strlen(list->version) + 1);
 496             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 497         }
 498
 499         if (list->mimetypes) {
 500             res = RegSetValueExA(clsid_key, mimetypes_valuename, 0, REG_SZ,
 501                                  (CONST BYTE*)(list->mimetypes),
 502                                  strlen(list->mimetypes) + 1);
 503             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 504         }
 505
 506         if (list->extensions) {
 507             res = RegSetValueExA(clsid_key, extensions_valuename, 0, REG_SZ,
 508                                  (CONST BYTE*)(list->extensions),
 509                                  strlen(list->extensions) + 1);
 510             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 511         }
 512
 513         if (list->formats) {
 514             HKEY formats_key;
 515             GUID const * const *format;
 516
 517             res = RegCreateKeyExW(clsid_key, formats_keyname, 0, NULL, 0,
 518                                   KEY_READ | KEY_WRITE, NULL, &formats_key, NULL);
 519             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 520             for (format=list->formats; *format; ++format)
 521             {
 522                 HKEY format_key;
 523                 StringFromGUID2(*format, buf, 39);
 524                 res = RegCreateKeyExW(formats_key, buf, 0, NULL, 0,
 525                                       KEY_READ | KEY_WRITE, NULL, &format_key, NULL);
 526                 if (res != ERROR_SUCCESS) break;
 527                 RegCloseKey(format_key);
 528             }
 529             RegCloseKey(formats_key);
 530             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 531         }
 532
 533     error_close_clsid_key:
 534         RegCloseKey(clsid_key);
 535     }
 536
 537 error_close_coclass_key:
 538     RegCloseKey(instance_key);
 539     RegCloseKey(encoders_key);
 540     RegCloseKey(coclass_key);
 541 error_return:
 542     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 543 }
 544
 545 /***********************************************************************
 546  *              unregister_encoders
 547  */
 548 static HRESULT unregister_encoders(struct regsvr_encoder const *list)
 549 {
 550     LONG res = ERROR_SUCCESS;
 551     HKEY coclass_key;
 552     WCHAR buf[39];
 553     HKEY encoders_key;
 554     HKEY instance_key;
 555
 556     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
 557                         KEY_READ | KEY_WRITE, &coclass_key);
 558     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
 559
 560     if (res == ERROR_SUCCESS)  {
 561         StringFromGUID2(&CATID_WICBitmapEncoders, buf, 39);
 562         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 563                               KEY_READ | KEY_WRITE, NULL, &encoders_key, NULL);
 564         if (res == ERROR_SUCCESS)
 565         {
 566             res = RegCreateKeyExW(encoders_key, instance_keyname, 0, NULL, 0,
 567                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 568             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 569         }
 570         if (res != ERROR_SUCCESS)
 571             RegCloseKey(coclass_key);
 572     }
 573     if (res != ERROR_SUCCESS) goto error_return;
 574
 575     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 576         StringFromGUID2(list->clsid, buf, 39);
 577
 578         res = RegDeleteTreeW(coclass_key, buf);
 579         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 580         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 581
 582         res = RegDeleteTreeW(instance_key, buf);
 583         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 584         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 585     }
 586
 587 error_close_coclass_key:
 588     RegCloseKey(instance_key);
 589     RegCloseKey(encoders_key);
 590     RegCloseKey(coclass_key);
 591 error_return:
 592     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 593 }
 594
 595 /***********************************************************************
 596  *              register_converters
 597  */
 598 static HRESULT register_converters(struct regsvr_converter const *list)
 599 {
 600     LONG res = ERROR_SUCCESS;
 601     HKEY coclass_key;
 602     WCHAR buf[39];
 603     HKEY converters_key;
 604     HKEY instance_key;
 605
 606     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
 607                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
 608     if (res == ERROR_SUCCESS)  {
 609         StringFromGUID2(&CATID_WICFormatConverters, buf, 39);
 610         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 611                               KEY_READ | KEY_WRITE, NULL, &converters_key, NULL);
 612         if (res == ERROR_SUCCESS)
 613         {
 614             res = RegCreateKeyExW(converters_key, instance_keyname, 0, NULL, 0,
 615                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 616             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 617         }
 618         if (res != ERROR_SUCCESS)
 619             RegCloseKey(coclass_key);
 620     }
 621     if (res != ERROR_SUCCESS) goto error_return;
 622
 623     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 624         HKEY clsid_key;
 625         HKEY instance_clsid_key;
 626
 627         StringFromGUID2(list->clsid, buf, 39);
 628         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 629                               KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
 630         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 631
 632         StringFromGUID2(list->clsid, buf, 39);
 633         res = RegCreateKeyExW(instance_key, buf, 0, NULL, 0,
 634                               KEY_READ | KEY_WRITE, NULL, &instance_clsid_key, NULL);
 635         if (res == ERROR_SUCCESS) {
 636             res = RegSetValueExW(instance_clsid_key, clsid_valuename, 0, REG_SZ,
 637                                  (CONST BYTE*)(buf), 78);
 638             RegCloseKey(instance_clsid_key);
 639         }
 640         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 641
 642         if (list->author) {
 643             res = RegSetValueExA(clsid_key, author_valuename, 0, REG_SZ,
 644                                  (CONST BYTE*)(list->author),
 645                                  strlen(list->author) + 1);
 646             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 647         }
 648
 649         if (list->friendlyname) {
 650             res = RegSetValueExA(clsid_key, friendlyname_valuename, 0, REG_SZ,
 651                                  (CONST BYTE*)(list->friendlyname),
 652                                  strlen(list->friendlyname) + 1);
 653             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 654         }
 655
 656         if (list->vendor) {
 657             StringFromGUID2(list->vendor, buf, 39);
 658             res = RegSetValueExW(clsid_key, vendor_valuename, 0, REG_SZ,
 659                                  (CONST BYTE*)(buf), 78);
 660             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 661         }
 662
 663         if (list->version) {
 664             res = RegSetValueExA(clsid_key, version_valuename, 0, REG_SZ,
 665                                  (CONST BYTE*)(list->version),
 666                                  strlen(list->version) + 1);
 667             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 668         }
 669
 670         if (list->formats) {
 671             HKEY formats_key;
 672             GUID const * const *format;
 673
 674             res = RegCreateKeyExW(clsid_key, pixelformats_keyname, 0, NULL, 0,
 675                                   KEY_READ | KEY_WRITE, NULL, &formats_key, NULL);
 676             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 677             for (format=list->formats; *format; ++format)
 678             {
 679                 HKEY format_key;
 680                 StringFromGUID2(*format, buf, 39);
 681                 res = RegCreateKeyExW(formats_key, buf, 0, NULL, 0,
 682                                       KEY_READ | KEY_WRITE, NULL, &format_key, NULL);
 683                 if (res != ERROR_SUCCESS) break;
 684                 RegCloseKey(format_key);
 685             }
 686             RegCloseKey(formats_key);
 687             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 688         }
 689
 690     error_close_clsid_key:
 691         RegCloseKey(clsid_key);
 692     }
 693
 694 error_close_coclass_key:
 695     RegCloseKey(instance_key);
 696     RegCloseKey(converters_key);
 697     RegCloseKey(coclass_key);
 698 error_return:
 699     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 700 }
 701
 702 /***********************************************************************
 703  *              unregister_converters
 704  */
 705 static HRESULT unregister_converters(struct regsvr_converter const *list)
 706 {
 707     LONG res = ERROR_SUCCESS;
 708     HKEY coclass_key;
 709     WCHAR buf[39];
 710     HKEY converters_key;
 711     HKEY instance_key;
 712
 713     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
 714                         KEY_READ | KEY_WRITE, &coclass_key);
 715     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
 716
 717     if (res == ERROR_SUCCESS)  {
 718         StringFromGUID2(&CATID_WICFormatConverters, buf, 39);
 719         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 720                               KEY_READ | KEY_WRITE, NULL, &converters_key, NULL);
 721         if (res == ERROR_SUCCESS)
 722         {
 723             res = RegCreateKeyExW(converters_key, instance_keyname, 0, NULL, 0,
 724                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 725             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 726         }
 727         if (res != ERROR_SUCCESS)
 728             RegCloseKey(coclass_key);
 729     }
 730     if (res != ERROR_SUCCESS) goto error_return;
 731
 732     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 733         StringFromGUID2(list->clsid, buf, 39);
 734
 735         res = RegDeleteTreeW(coclass_key, buf);
 736         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 737         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 738
 739         res = RegDeleteTreeW(instance_key, buf);
 740         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 741         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 742     }
 743
 744 error_close_coclass_key:
 745     RegCloseKey(instance_key);
 746     RegCloseKey(converters_key);
 747     RegCloseKey(coclass_key);
 748 error_return:
 749     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 750 }
 751
 752 /***********************************************************************
 753  *              register_metadatareaders
 754  */
 755 static HRESULT register_metadatareaders(struct regsvr_metadatareader const *list)
 756 {
 757     LONG res = ERROR_SUCCESS;
 758     HKEY coclass_key;
 759     WCHAR buf[39];
 760     HKEY readers_key;
 761     HKEY instance_key;
 762
 763     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
 764                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
 765     if (res == ERROR_SUCCESS)  {
 766         StringFromGUID2(&CATID_WICMetadataReader, buf, 39);
 767         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 768                               KEY_READ | KEY_WRITE, NULL, &readers_key, NULL);
 769         if (res == ERROR_SUCCESS)
 770         {
 771             res = RegCreateKeyExW(readers_key, instance_keyname, 0, NULL, 0,
 772                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 773             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 774         }
 775         if (res != ERROR_SUCCESS)
 776             RegCloseKey(coclass_key);
 777     }
 778     if (res != ERROR_SUCCESS) goto error_return;
 779
 780     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 781         HKEY clsid_key;
 782         HKEY instance_clsid_key;
 783
 784         StringFromGUID2(list->clsid, buf, 39);
 785         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 786                               KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
 787         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 788
 789         StringFromGUID2(list->clsid, buf, 39);
 790         res = RegCreateKeyExW(instance_key, buf, 0, NULL, 0,
 791                               KEY_READ | KEY_WRITE, NULL, &instance_clsid_key, NULL);
 792         if (res == ERROR_SUCCESS) {
 793             res = RegSetValueExW(instance_clsid_key, clsid_valuename, 0, REG_SZ,
 794                                  (CONST BYTE*)(buf), 78);
 795             RegCloseKey(instance_clsid_key);
 796         }
 797         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 798
 799         if (list->author) {
 800             res = RegSetValueExA(clsid_key, author_valuename, 0, REG_SZ,
 801                                  (CONST BYTE*)(list->author),
 802                                  strlen(list->author) + 1);
 803             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 804         }
 805
 806         if (list->friendlyname) {
 807             res = RegSetValueExA(clsid_key, friendlyname_valuename, 0, REG_SZ,
 808                                  (CONST BYTE*)(list->friendlyname),
 809                                  strlen(list->friendlyname) + 1);
 810             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 811         }
 812
 813         if (list->vendor) {
 814             StringFromGUID2(list->vendor, buf, 39);
 815             res = RegSetValueExW(clsid_key, vendor_valuename, 0, REG_SZ,
 816                                  (CONST BYTE*)(buf), 78);
 817             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 818         }
 819
 820         if (list->vendor) {
 821             StringFromGUID2(list->metadata_format, buf, 39);
 822             res = RegSetValueExW(clsid_key, metadataformat_valuename, 0, REG_SZ,
 823                                  (CONST BYTE*)(buf), 78);
 824             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 825         }
 826
 827         if (list->version) {
 828             res = RegSetValueExA(clsid_key, version_valuename, 0, REG_SZ,
 829                                  (CONST BYTE*)(list->version),
 830                                  strlen(list->version) + 1);
 831             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 832         }
 833
 834         if (list->specversion) {
 835             res = RegSetValueExA(clsid_key, specversion_valuename, 0, REG_SZ,
 836                                  (CONST BYTE*)(list->version),
 837                                  strlen(list->version) + 1);
 838             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 839         }
 840
 841         res = RegSetValueExA(clsid_key, requiresfullstream_valuename, 0, REG_DWORD,
 842                              (CONST BYTE*)(&list->requires_fullstream), 4);
 843         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 844
 845         res = RegSetValueExA(clsid_key, supportspadding_valuename, 0, REG_DWORD,
 846                              (CONST BYTE*)(&list->supports_padding), 4);
 847         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 848
 849         if (list->requires_fixedsize) {
 850             res = RegSetValueExA(clsid_key, requiresfixedsize_valuename, 0, REG_DWORD,
 851                                  (CONST BYTE*)(&list->requires_fixedsize), 4);
 852             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 853         }
 854
 855         if (list->containers) {
 856             HKEY containers_key;
 857             const struct reader_containers *container;
 858
 859             res = RegCreateKeyExW(clsid_key, containers_keyname, 0, NULL, 0,
 860                                   KEY_READ | KEY_WRITE, NULL, &containers_key, NULL);
 861             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
 862             for (container=list->containers; container->format; ++container)
 863             {
 864                 HKEY format_key;
 865                 int i;
 866                 StringFromGUID2(container->format, buf, 39);
 867                 res = RegCreateKeyExW(containers_key, buf, 0, NULL, 0,
 868                                       KEY_READ | KEY_WRITE, NULL, &format_key, NULL);
 869                 if (res != ERROR_SUCCESS) break;
 870
 871                 for (i=0; container->patterns[i].length; i++)
 872                 {
 873                     HKEY pattern_key;
 874                     static const WCHAR int_format[] = {'%','i',0};
 875                     snprintfW(buf, 39, int_format, i);
 876                     res = RegCreateKeyExW(format_key, buf, 0, NULL, 0,
 877                                           KEY_READ | KEY_WRITE, NULL, &pattern_key, NULL);
 878                     if (res != ERROR_SUCCESS) break;
 879                     res = RegSetValueExA(pattern_key, position_valuename, 0, REG_DWORD,
 880                                          (CONST BYTE*)(&container->patterns[i].position), 4);
 881                     if (res == ERROR_SUCCESS)
 882                         res = RegSetValueExA(pattern_key, pattern_valuename, 0, REG_BINARY,
 883                                              container->patterns[i].pattern,
 884                                              container->patterns[i].length);
 885                     if (res == ERROR_SUCCESS)
 886                         res = RegSetValueExA(pattern_key, mask_valuename, 0, REG_BINARY,
 887                                              container->patterns[i].mask,
 888                                              container->patterns[i].length);
 889                     if (res == ERROR_SUCCESS && container->patterns[i].data_offset)
 890                         res = RegSetValueExA(pattern_key, dataoffset_valuename, 0, REG_DWORD,
 891                                              (CONST BYTE*)&(container->patterns[i].data_offset), 4);
 892                     RegCloseKey(pattern_key);
 893                 }
 894
 895                 RegCloseKey(format_key);
 896             }
 897             RegCloseKey(containers_key);
 898         }
 899
 900     error_close_clsid_key:
 901         RegCloseKey(clsid_key);
 902     }
 903
 904 error_close_coclass_key:
 905     RegCloseKey(instance_key);
 906     RegCloseKey(readers_key);
 907     RegCloseKey(coclass_key);
 908 error_return:
 909     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 910 }
 911
 912 /***********************************************************************
 913  *              unregister_metadatareaders
 914  */
 915 static HRESULT unregister_metadatareaders(struct regsvr_metadatareader const *list)
 916 {
 917     LONG res = ERROR_SUCCESS;
 918     HKEY coclass_key;
 919     WCHAR buf[39];
 920     HKEY readers_key;
 921     HKEY instance_key;
 922
 923     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
 924                         KEY_READ | KEY_WRITE, &coclass_key);
 925     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
 926
 927     if (res == ERROR_SUCCESS)  {
 928         StringFromGUID2(&CATID_WICMetadataReader, buf, 39);
 929         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 930                               KEY_READ | KEY_WRITE, NULL, &readers_key, NULL);
 931         if (res == ERROR_SUCCESS)
 932         {
 933             res = RegCreateKeyExW(readers_key, instance_keyname, 0, NULL, 0,
 934                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 935             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 936         }
 937         if (res != ERROR_SUCCESS)
 938             RegCloseKey(coclass_key);
 939     }
 940     if (res != ERROR_SUCCESS) goto error_return;
 941
 942     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 943         StringFromGUID2(list->clsid, buf, 39);
 944
 945         res = RegDeleteTreeW(coclass_key, buf);
 946         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 947         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 948
 949         res = RegDeleteTreeW(instance_key, buf);
 950         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
 951         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 952     }
 953
 954 error_close_coclass_key:
 955     RegCloseKey(instance_key);
 956     RegCloseKey(readers_key);
 957     RegCloseKey(coclass_key);
 958 error_return:
 959     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
 960 }
 961
 962 /***********************************************************************
 963  *                register_pixelformats
 964  */
 965 static HRESULT register_pixelformats(struct regsvr_pixelformat const *list)
 966 {
 967     LONG res = ERROR_SUCCESS;
 968     HKEY coclass_key;
 969     WCHAR buf[39];
 970     HKEY formats_key;
 971     HKEY instance_key;
 972
 973     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
 974                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
 975     if (res == ERROR_SUCCESS)  {
 976         StringFromGUID2(&CATID_WICPixelFormats, buf, 39);
 977         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 978                               KEY_READ | KEY_WRITE, NULL, &formats_key, NULL);
 979         if (res == ERROR_SUCCESS)
 980         {
 981             res = RegCreateKeyExW(formats_key, instance_keyname, 0, NULL, 0,
 982                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
 983             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 984         }
 985         if (res != ERROR_SUCCESS)
 986             RegCloseKey(coclass_key);
 987     }
 988     if (res != ERROR_SUCCESS) goto error_return;
 989
 990     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
 991         HKEY clsid_key;
 992         HKEY instance_clsid_key;
 993
 994         StringFromGUID2(list->clsid, buf, 39);
 995         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
 996                               KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
 997         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
 998
 999         StringFromGUID2(list->clsid, buf, 39);
1000         res = RegCreateKeyExW(instance_key, buf, 0, NULL, 0,
1001                               KEY_READ | KEY_WRITE, NULL, &instance_clsid_key, NULL);
1002         if (res == ERROR_SUCCESS) {
1003             res = RegSetValueExW(instance_clsid_key, clsid_valuename, 0, REG_SZ,
1004                                  (CONST BYTE*)(buf), 78);
1005             RegCloseKey(instance_clsid_key);
1006         }
1007         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1008
1009         if (list->author) {
1010             res = RegSetValueExA(clsid_key, author_valuename, 0, REG_SZ,
1011                                  (CONST BYTE*)(list->author),
1012                                  strlen(list->author) + 1);
1013             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1014         }
1015
1016         if (list->friendlyname) {
1017             res = RegSetValueExA(clsid_key, friendlyname_valuename, 0, REG_SZ,
1018                                  (CONST BYTE*)(list->friendlyname),
1019                                  strlen(list->friendlyname) + 1);
1020             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1021         }
1022
1023         if (list->vendor) {
1024             StringFromGUID2(list->vendor, buf, 39);
1025             res = RegSetValueExW(clsid_key, vendor_valuename, 0, REG_SZ,
1026                                  (CONST BYTE*)(buf), 78);
1027             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1028         }
1029
1030         if (list->version) {
1031             res = RegSetValueExA(clsid_key, version_valuename, 0, REG_SZ,
1032                                  (CONST BYTE*)(list->version),
1033                                  strlen(list->version) + 1);
1034             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1035         }
1036
1037         res = RegSetValueExA(clsid_key, bitsperpixel_valuename, 0, REG_DWORD,
1038                              (CONST BYTE*)(&list->bitsperpixel), 4);
1039         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1040
1041         res = RegSetValueExA(clsid_key, channelcount_valuename, 0, REG_DWORD,
1042                              (CONST BYTE*)(&list->channelcount), 4);
1043         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1044
1045         res = RegSetValueExA(clsid_key, numericrepresentation_valuename, 0, REG_DWORD,
1046                              (CONST BYTE*)(&list->numericrepresentation), 4);
1047         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1048
1049         res = RegSetValueExA(clsid_key, supportstransparency_valuename, 0, REG_DWORD,
1050                              (CONST BYTE*)(&list->supportsalpha), 4);
1051         if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1052
1053         if (list->channelmasks) {
1054             HKEY masks_key;
1055             UINT i, mask_size;
1056             WCHAR mask_valuename[11];
1057             const WCHAR valuename_format[] = {'%','d',0};
1058
1059             mask_size = (list->bitsperpixel + 7)/8;
1060
1061             res = RegCreateKeyExW(clsid_key, channelmasks_keyname, 0, NULL, 0,
1062                                   KEY_READ | KEY_WRITE, NULL, &masks_key, NULL);
1063             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1064             for (i=0; i < list->channelcount; i++)
1065             {
1066                 sprintfW(mask_valuename, valuename_format, i);
1067                 res = RegSetValueExW(masks_key, mask_valuename, 0, REG_BINARY,
1068                                      list->channelmasks[i], mask_size);
1069                 if (res != ERROR_SUCCESS) break;
1070             }
1071             RegCloseKey(masks_key);
1072             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
1073         }
1074
1075     error_close_clsid_key:
1076         RegCloseKey(clsid_key);
1077     }
1078
1079 error_close_coclass_key:
1080     RegCloseKey(instance_key);
1081     RegCloseKey(formats_key);
1082     RegCloseKey(coclass_key);
1083 error_return:
1084     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
1085 }
1086
1087 /***********************************************************************
1088  *                unregister_pixelformats
1089  */
1090 static HRESULT unregister_pixelformats(struct regsvr_pixelformat const *list)
1091 {
1092     LONG res = ERROR_SUCCESS;
1093     HKEY coclass_key;
1094     WCHAR buf[39];
1095     HKEY formats_key;
1096     HKEY instance_key;
1097
1098     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
1099                         KEY_READ | KEY_WRITE, &coclass_key);
1100     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
1101
1102     if (res == ERROR_SUCCESS)  {
1103         StringFromGUID2(&CATID_WICPixelFormats, buf, 39);
1104         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
1105                               KEY_READ | KEY_WRITE, NULL, &formats_key, NULL);
1106         if (res == ERROR_SUCCESS)
1107         {
1108             res = RegCreateKeyExW(formats_key, instance_keyname, 0, NULL, 0,
1109                               KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
1110             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
1111         }
1112         if (res != ERROR_SUCCESS)
1113             RegCloseKey(coclass_key);
1114     }
1115     if (res != ERROR_SUCCESS) goto error_return;
1116
1117     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
1118         StringFromGUID2(list->clsid, buf, 39);
1119
1120         res = RegDeleteTreeW(coclass_key, buf);
1121         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
1122         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
1123
1124         res = RegDeleteTreeW(instance_key, buf);
1125         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
1126         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
1127     }
1128
1129 error_close_coclass_key:
1130     RegCloseKey(instance_key);
1131     RegCloseKey(formats_key);
1132     RegCloseKey(coclass_key);
1133 error_return:
1134     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
1135 }
1136
1137 /***********************************************************************
1138  *              decoder list
1139  */
1140 static const BYTE mask_all[] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1141
1142 static const BYTE bmp_magic[] = {0x42,0x4d};
1143
1144 static GUID const * const bmp_formats[] = {
1145     &GUID_WICPixelFormat1bppIndexed,
1146     &GUID_WICPixelFormat2bppIndexed,
1147     &GUID_WICPixelFormat4bppIndexed,
1148     &GUID_WICPixelFormat8bppIndexed,
1149     &GUID_WICPixelFormat16bppBGR555,
1150     &GUID_WICPixelFormat16bppBGR565,
1151     &GUID_WICPixelFormat24bppBGR,
1152     &GUID_WICPixelFormat32bppBGR,
1153     &GUID_WICPixelFormat32bppBGRA,
1154     NULL
1155 };
1156
1157 static struct decoder_pattern const bmp_patterns[] = {
1158     {2,0,bmp_magic,mask_all,0},
1159     {0}
1160 };
1161
1162 static const BYTE gif87a_magic[6] = "GIF87a";
1163 static const BYTE gif89a_magic[6] = "GIF89a";
1164
1165 static GUID const * const gif_formats[] = {
1166     &GUID_WICPixelFormat8bppIndexed,
1167     NULL
1168 };
1169
1170 static struct decoder_pattern const gif_patterns[] = {
1171     {6,0,gif87a_magic,mask_all,0},
1172     {6,0,gif89a_magic,mask_all,0},
1173     {0}
1174 };
1175
1176 static const BYTE ico_magic[] = {00,00,01,00};
1177
1178 static GUID const * const ico_formats[] = {
1179     &GUID_WICPixelFormat32bppBGRA,
1180     NULL
1181 };
1182
1183 static struct decoder_pattern const ico_patterns[] = {
1184     {4,0,ico_magic,mask_all,0},
1185     {0}
1186 };
1187
1188 static const BYTE jpeg_magic[] = {0xff, 0xd8};
1189
1190 static GUID const * const jpeg_formats[] = {
1191     &GUID_WICPixelFormat24bppBGR,
1192     &GUID_WICPixelFormat32bppCMYK,
1193     &GUID_WICPixelFormat8bppGray,
1194     NULL
1195 };
1196
1197 static struct decoder_pattern const jpeg_patterns[] = {
1198     {2,0,jpeg_magic,mask_all,0},
1199     {0}
1200 };
1201
1202 static const BYTE png_magic[] = {137,80,78,71,13,10,26,10};
1203
1204 static GUID const * const png_formats[] = {
1205     &GUID_WICPixelFormatBlackWhite,
1206     &GUID_WICPixelFormat2bppGray,
1207     &GUID_WICPixelFormat4bppGray,
1208     &GUID_WICPixelFormat8bppGray,
1209     &GUID_WICPixelFormat16bppGray,
1210     &GUID_WICPixelFormat32bppBGRA,
1211     &GUID_WICPixelFormat64bppRGBA,
1212     &GUID_WICPixelFormat1bppIndexed,
1213     &GUID_WICPixelFormat2bppIndexed,
1214     &GUID_WICPixelFormat4bppIndexed,
1215     &GUID_WICPixelFormat8bppIndexed,
1216     &GUID_WICPixelFormat24bppBGR,
1217     &GUID_WICPixelFormat48bppRGB,
1218     NULL
1219 };
1220
1221 static struct decoder_pattern const png_patterns[] = {
1222     {8,0,png_magic,mask_all,0},
1223     {0}
1224 };
1225
1226 static const BYTE tiff_magic_le[] = {0x49,0x49,42,0};
1227 static const BYTE tiff_magic_be[] = {0x4d,0x4d,0,42};
1228
1229 static GUID const * const tiff_decode_formats[] = {
1230     &GUID_WICPixelFormatBlackWhite,
1231     &GUID_WICPixelFormat4bppGray,
1232     &GUID_WICPixelFormat8bppGray,
1233     &GUID_WICPixelFormat4bppIndexed,
1234     &GUID_WICPixelFormat8bppIndexed,
1235     &GUID_WICPixelFormat24bppBGR,
1236     &GUID_WICPixelFormat32bppBGR,
1237     &GUID_WICPixelFormat32bppBGRA,
1238     &GUID_WICPixelFormat32bppPBGRA,
1239     &GUID_WICPixelFormat48bppRGB,
1240     &GUID_WICPixelFormat64bppRGBA,
1241     &GUID_WICPixelFormat64bppPRGBA,
1242     NULL
1243 };
1244
1245 static struct decoder_pattern const tiff_patterns[] = {
1246     {4,0,tiff_magic_le,mask_all,0},
1247     {4,0,tiff_magic_be,mask_all,0},
1248     {0}
1249 };
1250
1251 static const BYTE tga_footer_magic[18] = "TRUEVISION-XFILE.";
1252
1253 static const BYTE tga_indexed_magic[18] = {0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0};
1254 static const BYTE tga_indexed_mask[18] = {0,0xff,0xf7,0,0,0,0,0,0,0,0,0,0,0,0,0,0xff,0xcf};
1255
1256 static const BYTE tga_truecolor_magic[18] = {0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1257 static const BYTE tga_truecolor_mask[18] = {0,0xff,0xf7,0,0,0,0,0,0,0,0,0,0,0,0,0,0x87,0xc0};
1258
1259 static const BYTE tga_grayscale_magic[18] = {0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0};
1260 static const BYTE tga_grayscale_mask[18] = {0,0xff,0xf7,0,0,0,0,0,0,0,0,0,0,0,0,0,0xff,0xcf};
1261
1262 static GUID const * const tga_formats[] = {
1263     &GUID_WICPixelFormat8bppGray,
1264     &GUID_WICPixelFormat8bppIndexed,
1265     &GUID_WICPixelFormat16bppGray,
1266     &GUID_WICPixelFormat16bppBGR555,
1267     &GUID_WICPixelFormat24bppBGR,
1268     &GUID_WICPixelFormat32bppBGRA,
1269     &GUID_WICPixelFormat32bppPBGRA,
1270     NULL
1271 };
1272
1273 static struct decoder_pattern const tga_patterns[] = {
1274     {18,18,tga_footer_magic,mask_all,1},
1275     {18,0,tga_indexed_magic,tga_indexed_mask,0},
1276     {18,0,tga_truecolor_magic,tga_truecolor_mask,0},
1277     {18,0,tga_grayscale_magic,tga_grayscale_mask,0},
1278     {0}
1279 };
1280
1281 static struct regsvr_decoder const decoder_list[] = {
1282     {   &CLSID_WICBmpDecoder,
1283         "The Wine Project",
1284         "BMP Decoder",
1285         "1.0.0.0",
1286         &GUID_VendorMicrosoft,
1287         &GUID_ContainerFormatBmp,
1288         "image/bmp",
1289         ".bmp,.dib,.rle",
1290         bmp_formats,
1291         bmp_patterns
1292     },
1293     {   &CLSID_WICGifDecoder,
1294         "The Wine Project",
1295         "GIF Decoder",
1296         "1.0.0.0",
1297         &GUID_VendorMicrosoft,
1298         &GUID_ContainerFormatGif,
1299         "image/gif",
1300         ".gif",
1301         gif_formats,
1302         gif_patterns
1303     },
1304     {   &CLSID_WICIcoDecoder,
1305         "The Wine Project",
1306         "ICO Decoder",
1307         "1.0.0.0",
1308         &GUID_VendorMicrosoft,
1309         &GUID_ContainerFormatIco,
1310         "image/vnd.microsoft.icon",
1311         ".ico",
1312         ico_formats,
1313         ico_patterns
1314     },
1315     {   &CLSID_WICJpegDecoder,
1316         "The Wine Project",
1317         "JPEG Decoder",
1318         "1.0.0.0",
1319         &GUID_VendorMicrosoft,
1320         &GUID_ContainerFormatJpeg,
1321         "image/jpeg",
1322         ".jpg;.jpeg;.jfif",
1323         jpeg_formats,
1324         jpeg_patterns
1325     },
1326     {   &CLSID_WICPngDecoder,
1327         "The Wine Project",
1328         "PNG Decoder",
1329         "1.0.0.0",
1330         &GUID_VendorMicrosoft,
1331         &GUID_ContainerFormatPng,
1332         "image/png",
1333         ".png",
1334         png_formats,
1335         png_patterns
1336     },
1337     {   &CLSID_WICTiffDecoder,
1338         "The Wine Project",
1339         "TIFF Decoder",
1340         "1.0.0.0",
1341         &GUID_VendorMicrosoft,
1342         &GUID_ContainerFormatTiff,
1343         "image/tiff",
1344         ".tif;.tiff",
1345         tiff_decode_formats,
1346         tiff_patterns
1347     },
1348     {   &CLSID_WineTgaDecoder,
1349         "The Wine Project",
1350         "TGA Decoder",
1351         "1.0.0.0",
1352         &GUID_VendorWine,
1353         &GUID_WineContainerFormatTga,
1354         "image/x-targa",
1355         ".tga;.tpic",
1356         tga_formats,
1357         tga_patterns
1358     },
1359     { NULL }                    /* list terminator */
1360 };
1361
1362 static GUID const * const bmp_encode_formats[] = {
1363     &GUID_WICPixelFormat16bppBGR555,
1364     &GUID_WICPixelFormat16bppBGR565,
1365     &GUID_WICPixelFormat24bppBGR,
1366     &GUID_WICPixelFormat32bppBGR,
1367     NULL
1368 };
1369
1370 static GUID const * const png_encode_formats[] = {
1371     &GUID_WICPixelFormat24bppBGR,
1372     &GUID_WICPixelFormatBlackWhite,
1373     &GUID_WICPixelFormat2bppGray,
1374     &GUID_WICPixelFormat4bppGray,
1375     &GUID_WICPixelFormat8bppGray,
1376     &GUID_WICPixelFormat16bppGray,
1377     &GUID_WICPixelFormat32bppBGR,
1378     &GUID_WICPixelFormat32bppBGRA,
1379     &GUID_WICPixelFormat48bppRGB,
1380     &GUID_WICPixelFormat64bppRGBA,
1381     NULL
1382 };
1383
1384 static GUID const * const tiff_encode_formats[] = {
1385     &GUID_WICPixelFormatBlackWhite,
1386     &GUID_WICPixelFormat4bppGray,
1387     &GUID_WICPixelFormat8bppGray,
1388     &GUID_WICPixelFormat24bppBGR,
1389     &GUID_WICPixelFormat32bppBGRA,
1390     &GUID_WICPixelFormat32bppPBGRA,
1391     &GUID_WICPixelFormat48bppRGB,
1392     &GUID_WICPixelFormat64bppRGBA,
1393     &GUID_WICPixelFormat64bppPRGBA,
1394     NULL
1395 };
1396
1397 static GUID const * const icns_encode_formats[] = {
1398     &GUID_WICPixelFormat32bppBGRA,
1399     NULL
1400 };
1401
1402 static struct regsvr_encoder const encoder_list[] = {
1403     {   &CLSID_WICBmpEncoder,
1404         "The Wine Project",
1405         "BMP Encoder",
1406         "1.0.0.0",
1407         &GUID_VendorMicrosoft,
1408         &GUID_ContainerFormatBmp,
1409         "image/bmp",
1410         ".bmp,.dib,.rle",
1411         bmp_encode_formats
1412     },
1413     {   &CLSID_WICJpegEncoder,
1414         "The Wine Project",
1415         "JPEG Encoder",
1416         "1.0.0.0",
1417         &GUID_VendorMicrosoft,
1418         &GUID_ContainerFormatJpeg,
1419         "image/jpeg",
1420         ".jpg;.jpeg;.jfif",
1421         jpeg_formats
1422     },
1423     {   &CLSID_WICPngEncoder,
1424         "The Wine Project",
1425         "PNG Encoder",
1426         "1.0.0.0",
1427         &GUID_VendorMicrosoft,
1428         &GUID_ContainerFormatPng,
1429         "image/png",
1430         ".png",
1431         png_encode_formats
1432     },
1433     {   &CLSID_WICTiffEncoder,
1434         "The Wine Project",
1435         "TIFF Encoder",
1436         "1.0.0.0",
1437         &GUID_VendorMicrosoft,
1438         &GUID_ContainerFormatTiff,
1439         "image/tiff",
1440         ".tif;.tiff",
1441         tiff_encode_formats
1442     },
1443     {   &CLSID_WICIcnsEncoder,
1444         "The Wine Project",
1445         "ICNS Encoder",
1446         "1.0.0.0",
1447         &GUID_VendorWine,
1448         NULL, /* no container format guid */
1449         "image/icns",
1450         ".icns",
1451         icns_encode_formats
1452     },
1453     { NULL }                    /* list terminator */
1454 };
1455
1456 static GUID const * const converter_formats[] = {
1457     &GUID_WICPixelFormat1bppIndexed,
1458     &GUID_WICPixelFormat2bppIndexed,
1459     &GUID_WICPixelFormat4bppIndexed,
1460     &GUID_WICPixelFormat8bppIndexed,
1461     &GUID_WICPixelFormatBlackWhite,
1462     &GUID_WICPixelFormat2bppGray,
1463     &GUID_WICPixelFormat4bppGray,
1464     &GUID_WICPixelFormat8bppGray,
1465     &GUID_WICPixelFormat16bppGray,
1466     &GUID_WICPixelFormat16bppBGR555,
1467     &GUID_WICPixelFormat16bppBGR565,
1468     &GUID_WICPixelFormat16bppBGRA5551,
1469     &GUID_WICPixelFormat24bppBGR,
1470     &GUID_WICPixelFormat32bppBGR,
1471     &GUID_WICPixelFormat32bppBGRA,
1472     &GUID_WICPixelFormat32bppPBGRA,
1473     &GUID_WICPixelFormat48bppRGB,
1474     &GUID_WICPixelFormat64bppRGBA,
1475     &GUID_WICPixelFormat32bppCMYK,
1476     NULL
1477 };
1478
1479 static struct regsvr_converter const converter_list[] = {
1480     {   &CLSID_WICDefaultFormatConverter,
1481         "The Wine Project",
1482         "Default Pixel Format Converter",
1483         "1.0.0.0",
1484         &GUID_VendorMicrosoft,
1485         converter_formats
1486     },
1487     { NULL }                    /* list terminator */
1488 };
1489
1490 static const BYTE no_magic[1] = { 0 };
1491 static const BYTE no_mask[1] = { 0 };
1492
1493 static const struct metadata_pattern ifd_metadata_pattern[] = {
1494     { 0, 1, no_magic, no_mask, 0 },
1495     { 0 }
1496 };
1497
1498 static const struct reader_containers ifd_containers[] = {
1499     {
1500         &GUID_ContainerFormatTiff,
1501         ifd_metadata_pattern
1502     },
1503     { NULL } /* list terminator */
1504 };
1505
1506 static struct regsvr_metadatareader const metadatareader_list[] = {
1507     {   &CLSID_WICUnknownMetadataReader,
1508         "The Wine Project",
1509         "Unknown Metadata Reader",
1510         "1.0.0.0",
1511         "1.0.0.0",
1512         &GUID_VendorMicrosoft,
1513         &GUID_MetadataFormatUnknown,
1514         0, 0, 0,
1515         NULL
1516     },
1517     {
1518         &CLSID_WICIfdMetadataReader,
1519         "The Wine Project",
1520         "Ifd Reader",
1521         "1.0.0.0",
1522         "1.0.0.0",
1523         &GUID_VendorMicrosoft,
1524         &GUID_MetadataFormatIfd,
1525         1, 1, 0,
1526         ifd_containers
1527     },
1528     { NULL }                    /* list terminator */
1529 };
1530
1531 static BYTE const channel_mask_1bit[] = { 0x01 };
1532 static BYTE const channel_mask_2bit[] = { 0x03 };
1533 static BYTE const channel_mask_4bit[] = { 0x0f };
1534
1535 static BYTE const channel_mask_8bit[] = { 0xff, 0x00, 0x00, 0x00 };
1536 static BYTE const channel_mask_8bit2[] = { 0x00, 0xff, 0x00, 0x00 };
1537 static BYTE const channel_mask_8bit3[] = { 0x00, 0x00, 0xff, 0x00 };
1538 static BYTE const channel_mask_8bit4[] = { 0x00, 0x00, 0x00, 0xff };
1539
1540 static BYTE const channel_mask_16bit[] = { 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1541 static BYTE const channel_mask_16bit2[] = { 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 };
1542 static BYTE const channel_mask_16bit3[] = { 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 };
1543 static BYTE const channel_mask_16bit4[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff };
1544
1545 static BYTE const channel_mask_5bit[] = { 0x1f, 0x00 };
1546 static BYTE const channel_mask_5bit2[] = { 0xe0, 0x03 };
1547 static BYTE const channel_mask_5bit3[] = { 0x00, 0x7c };
1548 static BYTE const channel_mask_5bit4[] = { 0x00, 0x80 };
1549
1550 static BYTE const channel_mask_BGR565_2[] = { 0xe0, 0x07 };
1551 static BYTE const channel_mask_BGR565_3[] = { 0x00, 0xf8 };
1552
1553 static BYTE const * const channel_masks_1bit[] = { channel_mask_1bit };
1554 static BYTE const * const channel_masks_2bit[] = { channel_mask_2bit };
1555 static BYTE const * const channel_masks_4bit[] = { channel_mask_4bit };
1556 static BYTE const * const channel_masks_8bit[] = { channel_mask_8bit,
1557     channel_mask_8bit2, channel_mask_8bit3, channel_mask_8bit4 };
1558 static BYTE const * const channel_masks_16bit[] = { channel_mask_16bit,
1559     channel_mask_16bit2, channel_mask_16bit3, channel_mask_16bit4};
1560
1561 static BYTE const * const channel_masks_BGRA5551[] = { channel_mask_5bit,
1562     channel_mask_5bit2, channel_mask_5bit3, channel_mask_5bit4 };
1563
1564 static BYTE const * const channel_masks_BGR565[] = { channel_mask_5bit,
1565     channel_mask_BGR565_2, channel_mask_BGR565_3 };
1566
1567 static struct regsvr_pixelformat const pixelformat_list[] = {
1568     {   &GUID_WICPixelFormat1bppIndexed,
1569         "The Wine Project",
1570         "1bpp Indexed",
1571         NULL, /* no version */
1572         &GUID_VendorMicrosoft,
1573         1, /* bitsperpixel */
1574         1, /* channel count */
1575         channel_masks_1bit,
1576         WICPixelFormatNumericRepresentationIndexed,
1577         1
1578     },
1579     {   &GUID_WICPixelFormat2bppIndexed,
1580         "The Wine Project",
1581         "2bpp Indexed",
1582         NULL, /* no version */
1583         &GUID_VendorMicrosoft,
1584         2, /* bitsperpixel */
1585         1, /* channel count */
1586         channel_masks_2bit,
1587         WICPixelFormatNumericRepresentationIndexed,
1588         1
1589     },
1590     {   &GUID_WICPixelFormat4bppIndexed,
1591         "The Wine Project",
1592         "4bpp Indexed",
1593         NULL, /* no version */
1594         &GUID_VendorMicrosoft,
1595         4, /* bitsperpixel */
1596         1, /* channel count */
1597         channel_masks_4bit,
1598         WICPixelFormatNumericRepresentationIndexed,
1599         1
1600     },
1601     {   &GUID_WICPixelFormat8bppIndexed,
1602         "The Wine Project",
1603         "8bpp Indexed",
1604         NULL, /* no version */
1605         &GUID_VendorMicrosoft,
1606         8, /* bitsperpixel */
1607         1, /* channel count */
1608         channel_masks_8bit,
1609         WICPixelFormatNumericRepresentationIndexed,
1610         1
1611     },
1612     {   &GUID_WICPixelFormatBlackWhite,
1613         "The Wine Project",
1614         "Black and White",
1615         NULL, /* no version */
1616         &GUID_VendorMicrosoft,
1617         1, /* bitsperpixel */
1618         1, /* channel count */
1619         channel_masks_1bit,
1620         WICPixelFormatNumericRepresentationUnsignedInteger,
1621         0
1622     },
1623     {   &GUID_WICPixelFormat2bppGray,
1624         "The Wine Project",
1625         "2bpp Grayscale",
1626         NULL, /* no version */
1627         &GUID_VendorMicrosoft,
1628         2, /* bitsperpixel */
1629         1, /* channel count */
1630         channel_masks_2bit,
1631         WICPixelFormatNumericRepresentationUnsignedInteger,
1632         0
1633     },
1634     {   &GUID_WICPixelFormat4bppGray,
1635         "The Wine Project",
1636         "4bpp Grayscale",
1637         NULL, /* no version */
1638         &GUID_VendorMicrosoft,
1639         4, /* bitsperpixel */
1640         1, /* channel count */
1641         channel_masks_4bit,
1642         WICPixelFormatNumericRepresentationUnsignedInteger,
1643         0
1644     },
1645     {   &GUID_WICPixelFormat8bppGray,
1646         "The Wine Project",
1647         "8bpp Grayscale",
1648         NULL, /* no version */
1649         &GUID_VendorMicrosoft,
1650         8, /* bitsperpixel */
1651         1, /* channel count */
1652         channel_masks_8bit,
1653         WICPixelFormatNumericRepresentationUnsignedInteger,
1654         0
1655     },
1656     {   &GUID_WICPixelFormat16bppGray,
1657         "The Wine Project",
1658         "16bpp Grayscale",
1659         NULL, /* no version */
1660         &GUID_VendorMicrosoft,
1661         16, /* bitsperpixel */
1662         1, /* channel count */
1663         channel_masks_16bit,
1664         WICPixelFormatNumericRepresentationUnsignedInteger,
1665         0
1666     },
1667     {   &GUID_WICPixelFormat16bppBGR555,
1668         "The Wine Project",
1669         "16bpp BGR555",
1670         NULL, /* no version */
1671         &GUID_VendorMicrosoft,
1672         16, /* bitsperpixel */
1673         3, /* channel count */
1674         channel_masks_BGRA5551,
1675         WICPixelFormatNumericRepresentationUnsignedInteger,
1676         0
1677     },
1678     {   &GUID_WICPixelFormat16bppBGR565,
1679         "The Wine Project",
1680         "16bpp BGR565",
1681         NULL, /* no version */
1682         &GUID_VendorMicrosoft,
1683         16, /* bitsperpixel */
1684         3, /* channel count */
1685         channel_masks_BGR565,
1686         WICPixelFormatNumericRepresentationUnsignedInteger,
1687         0
1688     },
1689     {   &GUID_WICPixelFormat16bppBGRA5551,
1690         "The Wine Project",
1691         "16bpp BGRA5551",
1692         NULL, /* no version */
1693         &GUID_VendorMicrosoft,
1694         16, /* bitsperpixel */
1695         4, /* channel count */
1696         channel_masks_BGRA5551,
1697         WICPixelFormatNumericRepresentationUnsignedInteger,
1698         1
1699     },
1700     {   &GUID_WICPixelFormat24bppBGR,
1701         "The Wine Project",
1702         "24bpp BGR",
1703         NULL, /* no version */
1704         &GUID_VendorMicrosoft,
1705         24, /* bitsperpixel */
1706         3, /* channel count */
1707         channel_masks_8bit,
1708         WICPixelFormatNumericRepresentationUnsignedInteger,
1709         0
1710     },
1711     {   &GUID_WICPixelFormat32bppBGR,
1712         "The Wine Project",
1713         "32bpp BGR",
1714         NULL, /* no version */
1715         &GUID_VendorMicrosoft,
1716         32, /* bitsperpixel */
1717         3, /* channel count */
1718         channel_masks_8bit,
1719         WICPixelFormatNumericRepresentationUnsignedInteger,
1720         0
1721     },
1722     {   &GUID_WICPixelFormat32bppBGRA,
1723         "The Wine Project",
1724         "32bpp BGRA",
1725         NULL, /* no version */
1726         &GUID_VendorMicrosoft,
1727         32, /* bitsperpixel */
1728         4, /* channel count */
1729         channel_masks_8bit,
1730         WICPixelFormatNumericRepresentationUnsignedInteger,
1731         1
1732     },
1733     {   &GUID_WICPixelFormat32bppPBGRA,
1734         "The Wine Project",
1735         "32bpp PBGRA",
1736         NULL, /* no version */
1737         &GUID_VendorMicrosoft,
1738         32, /* bitsperpixel */
1739         4, /* channel count */
1740         channel_masks_8bit,
1741         WICPixelFormatNumericRepresentationUnsignedInteger,
1742         1
1743     },
1744     {   &GUID_WICPixelFormat48bppRGB,
1745         "The Wine Project",
1746         "48bpp RGB",
1747         NULL, /* no version */
1748         &GUID_VendorMicrosoft,
1749         48, /* bitsperpixel */
1750         3, /* channel count */
1751         channel_masks_16bit,
1752         WICPixelFormatNumericRepresentationUnsignedInteger,
1753         0
1754     },
1755     {   &GUID_WICPixelFormat64bppRGBA,
1756         "The Wine Project",
1757         "64bpp RGBA",
1758         NULL, /* no version */
1759         &GUID_VendorMicrosoft,
1760         64, /* bitsperpixel */
1761         4, /* channel count */
1762         channel_masks_16bit,
1763         WICPixelFormatNumericRepresentationUnsignedInteger,
1764         1
1765     },
1766     {   &GUID_WICPixelFormat64bppPRGBA,
1767         "The Wine Project",
1768         "64bpp PRGBA",
1769         NULL, /* no version */
1770         &GUID_VendorMicrosoft,
1771         64, /* bitsperpixel */
1772         4, /* channel count */
1773         channel_masks_16bit,
1774         WICPixelFormatNumericRepresentationUnsignedInteger,
1775         1
1776     },
1777     {   &GUID_WICPixelFormat32bppCMYK,
1778         "The Wine Project",
1779         "32bpp CMYK",
1780         NULL, /* no version */
1781         &GUID_VendorMicrosoft,
1782         32, /* bitsperpixel */
1783         4, /* channel count */
1784         channel_masks_8bit,
1785         WICPixelFormatNumericRepresentationUnsignedInteger,
1786         0
1787     },
1788     { NULL }                    /* list terminator */
1789 };
1790
1791 struct regsvr_category
1792 {
1793     const CLSID *clsid; /* NULL for end of list */
1794 };
1795
1796 static const struct regsvr_category category_list[] = {
1797     { &CATID_WICBitmapDecoders },
1798     { &CATID_WICBitmapEncoders },
1799     { &CATID_WICFormatConverters },
1800     { &CATID_WICMetadataReader },
1801     { &CATID_WICPixelFormats },
1802     { NULL }
1803 };
1804
1805 static HRESULT register_categories(const struct regsvr_category *list)
1806 {
1807     LONG res;
1808     WCHAR buf[39];
1809     HKEY coclass_key, categories_key, instance_key;
1810
1811     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
1812                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
1813     if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
1814
1815     StringFromGUID2(&CLSID_WICImagingCategories, buf, 39);
1816     res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
1817                           KEY_READ | KEY_WRITE, NULL, &categories_key, NULL);
1818     if (res != ERROR_SUCCESS)
1819     {
1820         RegCloseKey(coclass_key);
1821         return HRESULT_FROM_WIN32(res);
1822     }
1823
1824     res = RegCreateKeyExW(categories_key, instance_keyname, 0, NULL, 0,
1825                           KEY_READ | KEY_WRITE, NULL, &instance_key, NULL);
1826
1827     for (; res == ERROR_SUCCESS && list->clsid; list++)
1828     {
1829         HKEY instance_clsid_key;
1830
1831         StringFromGUID2(list->clsid, buf, 39);
1832         res = RegCreateKeyExW(instance_key, buf, 0, NULL, 0,
1833                               KEY_READ | KEY_WRITE, NULL, &instance_clsid_key, NULL);
1834         if (res == ERROR_SUCCESS)
1835         {
1836             res = RegSetValueExW(instance_clsid_key, clsid_valuename, 0, REG_SZ,
1837                                  (const BYTE *)buf, 78);
1838             RegCloseKey(instance_clsid_key);
1839         }
1840     }
1841
1842     RegCloseKey(instance_key);
1843     RegCloseKey(categories_key);
1844     RegCloseKey(coclass_key);
1845
1846     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
1847 }
1848
1849 static HRESULT unregister_categories(const struct regsvr_category *list)
1850 {
1851     LONG res;
1852     WCHAR buf[39];
1853     HKEY coclass_key, categories_key, instance_key;
1854
1855     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
1856                         KEY_READ | KEY_WRITE, &coclass_key);
1857     if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
1858
1859     StringFromGUID2(&CLSID_WICImagingCategories, buf, 39);
1860     res = RegOpenKeyExW(coclass_key, buf, 0,
1861                         KEY_READ | KEY_WRITE, &categories_key);
1862     if (res != ERROR_SUCCESS)
1863     {
1864         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
1865         RegCloseKey(coclass_key);
1866         return HRESULT_FROM_WIN32(res);
1867     }
1868
1869     res = RegOpenKeyExW(categories_key, instance_keyname, 0,
1870                           KEY_READ | KEY_WRITE, &instance_key);
1871
1872     for (; res == ERROR_SUCCESS && list->clsid; list++)
1873     {
1874         StringFromGUID2(list->clsid, buf, 39);
1875         res = RegDeleteTreeW(instance_key, buf);
1876     }
1877
1878     RegCloseKey(instance_key);
1879     RegCloseKey(categories_key);
1880
1881     StringFromGUID2(&CLSID_WICImagingCategories, buf, 39);
1882     res = RegDeleteTreeW(coclass_key, buf);
1883
1884     RegCloseKey(coclass_key);
1885
1886     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
1887 }
1888
1889 extern HRESULT WINAPI WIC_DllRegisterServer(void) DECLSPEC_HIDDEN;
1890 extern HRESULT WINAPI WIC_DllUnregisterServer(void) DECLSPEC_HIDDEN;
1891
1892 HRESULT WINAPI DllRegisterServer(void)
1893 {
1894     HRESULT hr;
1895
1896     TRACE("\n");
1897
1898     hr = WIC_DllRegisterServer();
1899     if (SUCCEEDED(hr))
1900         hr = register_categories(category_list);
1901     if (SUCCEEDED(hr))
1902         hr = register_decoders(decoder_list);
1903     if (SUCCEEDED(hr))
1904         hr = register_encoders(encoder_list);
1905     if (SUCCEEDED(hr))
1906         hr = register_converters(converter_list);
1907     if (SUCCEEDED(hr))
1908         hr = register_metadatareaders(metadatareader_list);
1909     if (SUCCEEDED(hr))
1910         hr = register_pixelformats(pixelformat_list);
1911     return hr;
1912 }
1913
1914 HRESULT WINAPI DllUnregisterServer(void)
1915 {
1916     HRESULT hr;
1917
1918     TRACE("\n");
1919
1920     hr = WIC_DllUnregisterServer();
1921     if (SUCCEEDED(hr))
1922         hr = unregister_categories(category_list);
1923     if (SUCCEEDED(hr))
1924         hr = unregister_decoders(decoder_list);
1925     if (SUCCEEDED(hr))
1926         hr = unregister_encoders(encoder_list);
1927     if (SUCCEEDED(hr))
1928         hr = unregister_converters(converter_list);
1929     if (SUCCEEDED(hr))
1930         hr = unregister_metadatareaders(metadatareader_list);
1931     if (SUCCEEDED(hr))
1932         hr = unregister_pixelformats(pixelformat_list);
1933     return hr;
1934 }