// Copyright 2013 Google Inc. All Rights Reserved.

//

// Use of this source code is governed by a BSD-style license

// that can be found in the COPYING file in the root of the source

// tree. An additional intellectual property rights grant can be found

// in the file PATENTS. All contributing project authors may

// be found in the AUTHORS file in the root of the source tree.

// -----------------------------------------------------------------------------

//

// Windows Imaging Component (WIC) decode.

#include "./wicdec.h"

#ifdef HAVE_CONFIG_H

#include "webp/config.h"

#endif

#include <assert.h>

#include <stdio.h>

#include <string.h>

#ifdef HAVE_WINCODEC_H

#ifdef __MINGW32__

#define INITGUID  // Without this GUIDs are declared extern and fail to link

#endif

#define CINTERFACE

#define COBJMACROS

#define _WIN32_IE 0x500  // Workaround bug in shlwapi.h when compiling C++

                         // code with COBJMACROS.

#include <ole2.h>  // CreateStreamOnHGlobal()

#include <shlwapi.h>

#include <windows.h>

#include <wincodec.h>

#include "webp/encode.h"

#include "./imageio_util.h"

#include "./metadata.h"

#define IFS(fn)                                                     \

  do {                                                              \

    if (SUCCEEDED(hr)) {                                            \

      hr = (fn);                                                    \

      if (FAILED(hr)) fprintf(stderr, #fn " failed %08lx\n", hr);   \

    }                                                               \

  } while (0)

// modified version of DEFINE_GUID from guiddef.h.

#define WEBP_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

  static const GUID name = \

      { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }

#ifdef __cplusplus

#define MAKE_REFGUID(x) (x)

#else

#define MAKE_REFGUID(x) &(x)

#endif

typedef struct WICFormatImporter {

  const GUID* pixel_format;

  int bytes_per_pixel;

  int (*import)(WebPPicture* const, const uint8_t* const, int);

} WICFormatImporter;

// From Microsoft SDK 7.0a -- wincodec.h

// Create local copies for compatibility when building against earlier

// versions of the SDK.

WEBP_DEFINE_GUID(GUID_WICPixelFormat24bppBGR_,

                 0x6fddc324, 0x4e03, 0x4bfe,

                 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0c);

WEBP_DEFINE_GUID(GUID_WICPixelFormat24bppRGB_,

                 0x6fddc324, 0x4e03, 0x4bfe,

                 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0d);

WEBP_DEFINE_GUID(GUID_WICPixelFormat32bppBGRA_,

                 0x6fddc324, 0x4e03, 0x4bfe,

                 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0f);

WEBP_DEFINE_GUID(GUID_WICPixelFormat32bppRGBA_,

                 0xf5c7ad2d, 0x6a8d, 0x43dd,

                 0xa7, 0xa8, 0xa2, 0x99, 0x35, 0x26, 0x1a, 0xe9);

WEBP_DEFINE_GUID(GUID_WICPixelFormat64bppBGRA_,

                 0x1562ff7c, 0xd352, 0x46f9,

                 0x97, 0x9e, 0x42, 0x97, 0x6b, 0x79, 0x22, 0x46);

WEBP_DEFINE_GUID(GUID_WICPixelFormat64bppRGBA_,

                 0x6fddc324, 0x4e03, 0x4bfe,

                 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x16);

static HRESULT OpenInputStream(const char* filename, IStream** stream) {

  HRESULT hr = S_OK;

  if (!strcmp(filename, "-")) {

    const uint8_t* data = NULL;

    size_t data_size = 0;

    const int ok = ImgIoUtilReadFile(filename, &data, &data_size);

    if (ok) {

      HGLOBAL image = GlobalAlloc(GMEM_MOVEABLE, data_size);

      if (image != NULL) {

        void* const image_mem = GlobalLock(image);

        if (image_mem != NULL) {

          memcpy(image_mem, data, data_size);

          GlobalUnlock(image);

          IFS(CreateStreamOnHGlobal(image, TRUE, stream));

        } else {

          hr = E_FAIL;

        }

      } else {

        hr = E_OUTOFMEMORY;

      }

      free((void*)data);

    } else {

      hr = E_FAIL;

    }

  } else {

    IFS(SHCreateStreamOnFileA(filename, STGM_READ, stream));

  }

  if (FAILED(hr)) {

    fprintf(stderr, "Error opening input file %s (%08lx)\n", filename, hr);

  }

  return hr;

}

// -----------------------------------------------------------------------------

// Metadata processing

// Stores the first non-zero sized color profile from 'frame' to 'iccp'.

// Returns an HRESULT to indicate success or failure. The caller is responsible

// for freeing 'iccp->bytes' in either case.

static HRESULT ExtractICCP(IWICImagingFactory* const factory,

                           IWICBitmapFrameDecode* const frame,

                           MetadataPayload* const iccp) {

  HRESULT hr = S_OK;

  UINT i, count;

  IWICColorContext** color_contexts;

  IFS(IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, &count));

  if (FAILED(hr) || count == 0) return hr;

  color_contexts = (IWICColorContext**)calloc(count, sizeof(*color_contexts));

  if (color_contexts == NULL) return E_OUTOFMEMORY;

  for (i = 0; SUCCEEDED(hr) && i < count; ++i) {

    IFS(IWICImagingFactory_CreateColorContext(factory, &color_contexts[i]));

  }

  if (SUCCEEDED(hr)) {

    UINT num_color_contexts;

    IFS(IWICBitmapFrameDecode_GetColorContexts(frame,

                                               count, color_contexts,

                                               &num_color_contexts));

    assert(FAILED(hr) || num_color_contexts <= count);

    for (i = 0; SUCCEEDED(hr) && i < num_color_contexts; ++i) {

      WICColorContextType type;

      IFS(IWICColorContext_GetType(color_contexts[i], &type));

      if (SUCCEEDED(hr) && type == WICColorContextProfile) {

        UINT size;

        IFS(IWICColorContext_GetProfileBytes(color_contexts[i],

                                             0, NULL, &size));

        if (SUCCEEDED(hr) && size > 0) {

          iccp->bytes = (uint8_t*)malloc(size);

          if (iccp->bytes == NULL) {

            hr = E_OUTOFMEMORY;

            break;

          }

          iccp->size = size;

          IFS(IWICColorContext_GetProfileBytes(color_contexts[i],

                                               (UINT)iccp->size, iccp->bytes,

                                               &size));

          if (SUCCEEDED(hr) && size != iccp->size) {

            fprintf(stderr, "Warning! ICC profile size (%u) != expected (%u)\n",

                    size, (uint32_t)iccp->size);

            iccp->size = size;

          }

          break;

        }

      }

    }

  }

  for (i = 0; i < count; ++i) {

    if (color_contexts[i] != NULL) IUnknown_Release(color_contexts[i]);

  }

  free(color_contexts);

  return hr;

}

static HRESULT ExtractMetadata(IWICImagingFactory* const factory,

                               IWICBitmapFrameDecode* const frame,

                               Metadata* const metadata) {

  // TODO(jzern): add XMP/EXIF extraction.

  const HRESULT hr = ExtractICCP(factory, frame, &metadata->iccp);

  if (FAILED(hr)) MetadataFree(metadata);

  return hr;

}

// -----------------------------------------------------------------------------

static int HasPalette(GUID pixel_format) {

  return (IsEqualGUID(MAKE_REFGUID(pixel_format),

                      MAKE_REFGUID(GUID_WICPixelFormat1bppIndexed)) ||

          IsEqualGUID(MAKE_REFGUID(pixel_format),

                      MAKE_REFGUID(GUID_WICPixelFormat2bppIndexed)) ||

          IsEqualGUID(MAKE_REFGUID(pixel_format),

                      MAKE_REFGUID(GUID_WICPixelFormat4bppIndexed)) ||

          IsEqualGUID(MAKE_REFGUID(pixel_format),

                      MAKE_REFGUID(GUID_WICPixelFormat8bppIndexed)));

}

static int HasAlpha(IWICImagingFactory* const factory,

                    IWICBitmapDecoder* const decoder,

                    IWICBitmapFrameDecode* const frame,

                    GUID pixel_format) {

  int has_alpha;

  if (HasPalette(pixel_format)) {

    IWICPalette* frame_palette = NULL;

    IWICPalette* global_palette = NULL;

    BOOL frame_palette_has_alpha = FALSE;

    BOOL global_palette_has_alpha = FALSE;

    // A palette may exist at the frame or container level,

    // check IWICPalette::HasAlpha() for both if present.

    if (SUCCEEDED(IWICImagingFactory_CreatePalette(factory, &frame_palette)) &&

        SUCCEEDED(IWICBitmapFrameDecode_CopyPalette(frame, frame_palette))) {

      IWICPalette_HasAlpha(frame_palette, &frame_palette_has_alpha);

    }

    if (SUCCEEDED(IWICImagingFactory_CreatePalette(factory, &global_palette)) &&

        SUCCEEDED(IWICBitmapDecoder_CopyPalette(decoder, global_palette))) {

      IWICPalette_HasAlpha(global_palette, &global_palette_has_alpha);

    }

    has_alpha = frame_palette_has_alpha || global_palette_has_alpha;

    if (frame_palette != NULL) IUnknown_Release(frame_palette);

    if (global_palette != NULL) IUnknown_Release(global_palette);

  } else {

    has_alpha = IsEqualGUID(MAKE_REFGUID(pixel_format),

                            MAKE_REFGUID(GUID_WICPixelFormat32bppRGBA_)) ||

                IsEqualGUID(MAKE_REFGUID(pixel_format),

                            MAKE_REFGUID(GUID_WICPixelFormat32bppBGRA_)) ||

                IsEqualGUID(MAKE_REFGUID(pixel_format),

                            MAKE_REFGUID(GUID_WICPixelFormat64bppRGBA_)) ||

                IsEqualGUID(MAKE_REFGUID(pixel_format),

                            MAKE_REFGUID(GUID_WICPixelFormat64bppBGRA_));

  }

  return has_alpha;

}

int ReadPictureWithWIC(const char* const filename,

                       WebPPicture* const pic, int keep_alpha,

                       Metadata* const metadata) {

  // From Microsoft SDK 6.0a -- ks.h

  // Define a local copy to avoid link errors under mingw.

  WEBP_DEFINE_GUID(GUID_NULL_, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

  static const WICFormatImporter kAlphaFormatImporters[] = {

    { &GUID_WICPixelFormat32bppBGRA_, 4, WebPPictureImportBGRA },

    { &GUID_WICPixelFormat32bppRGBA_, 4, WebPPictureImportRGBA },

    { NULL, 0, NULL },

  };

  static const WICFormatImporter kNonAlphaFormatImporters[] = {

    { &GUID_WICPixelFormat24bppBGR_, 3, WebPPictureImportBGR },

    { &GUID_WICPixelFormat24bppRGB_, 3, WebPPictureImportRGB },

    { NULL, 0, NULL },

  };

  HRESULT hr = S_OK;

  IWICBitmapFrameDecode* frame = NULL;

  IWICFormatConverter* converter = NULL;

  IWICImagingFactory* factory = NULL;

  IWICBitmapDecoder* decoder = NULL;

  IStream* stream = NULL;

  UINT frame_count = 0;

  UINT width = 0, height = 0;

  BYTE* rgb = NULL;

  WICPixelFormatGUID src_pixel_format = GUID_WICPixelFormatUndefined;

  const WICFormatImporter* importer = NULL;

  GUID src_container_format = GUID_NULL_;

  static const GUID* kAlphaContainers[] = {

    &GUID_ContainerFormatBmp,

    &GUID_ContainerFormatPng,

    &GUID_ContainerFormatTiff,

    NULL

  };

  int has_alpha = 0;

  int64_t stride;

  if (filename == NULL || pic == NULL) return 0;

  IFS(CoInitialize(NULL));

  IFS(CoCreateInstance(MAKE_REFGUID(CLSID_WICImagingFactory), NULL,

                       CLSCTX_INPROC_SERVER,

                       MAKE_REFGUID(IID_IWICImagingFactory),

                       (LPVOID*)&factory));

  if (hr == REGDB_E_CLASSNOTREG) {

    fprintf(stderr,

            "Couldn't access Windows Imaging Component (are you running "

            "Windows XP SP3 or newer?). Most formats not available. "

            "Use -s for the available YUV input.\n");

  }

  // Prepare for image decoding.

  IFS(OpenInputStream(filename, &stream));

  IFS(IWICImagingFactory_CreateDecoderFromStream(

          factory, stream, NULL,

          WICDecodeMetadataCacheOnDemand, &decoder));

  IFS(IWICBitmapDecoder_GetFrameCount(decoder, &frame_count));

  if (SUCCEEDED(hr) && frame_count == 0) {

    fprintf(stderr, "No frame found in input file.\n");

    hr = E_FAIL;

  }

  IFS(IWICBitmapDecoder_GetFrame(decoder, 0, &frame));

  IFS(IWICBitmapFrameDecode_GetPixelFormat(frame, &src_pixel_format));

  IFS(IWICBitmapDecoder_GetContainerFormat(decoder, &src_container_format));

  if (SUCCEEDED(hr) && keep_alpha) {

    const GUID** guid;

    for (guid = kAlphaContainers; *guid != NULL; ++guid) {

      if (IsEqualGUID(MAKE_REFGUID(src_container_format),

                      MAKE_REFGUID(**guid))) {

        has_alpha = HasAlpha(factory, decoder, frame, src_pixel_format);

        break;

      }

    }

  }

  // Prepare for pixel format conversion (if necessary).

  IFS(IWICImagingFactory_CreateFormatConverter(factory, &converter));

  for (importer = has_alpha ? kAlphaFormatImporters : kNonAlphaFormatImporters;

       hr == S_OK && importer->import != NULL; ++importer) {

    BOOL can_convert;

    const HRESULT cchr = IWICFormatConverter_CanConvert(

        converter,

        MAKE_REFGUID(src_pixel_format),

        MAKE_REFGUID(*importer->pixel_format),

        &can_convert);

    if (SUCCEEDED(cchr) && can_convert) break;

  }

  if (importer->import == NULL) hr = E_FAIL;

  IFS(IWICFormatConverter_Initialize(converter, (IWICBitmapSource*)frame,

                                     importer->pixel_format,

                                     WICBitmapDitherTypeNone,

                                     NULL, 0.0, WICBitmapPaletteTypeCustom));

  // Decode.

  IFS(IWICFormatConverter_GetSize(converter, &width, &height));

  stride = (int64_t)importer->bytes_per_pixel * width * sizeof(*rgb);

  if (stride != (int)stride ||

      !ImgIoUtilCheckSizeArgumentsOverflow(stride, height)) {

    hr = E_FAIL;

  }

  if (SUCCEEDED(hr)) {

    rgb = (BYTE*)malloc((size_t)stride * height);

    if (rgb == NULL)

      hr = E_OUTOFMEMORY;

  }

  IFS(IWICFormatConverter_CopyPixels(converter, NULL,

                                     (UINT)stride, (UINT)stride * height, rgb));

  // WebP conversion.

  if (SUCCEEDED(hr)) {

    int ok;

    pic->width = width;

    pic->height = height;

    pic->use_argb = 1;    // For WIC, we always force to argb

    ok = importer->import(pic, rgb, (int)stride);

    if (!ok) hr = E_FAIL;

  }

  if (SUCCEEDED(hr)) {

    if (metadata != NULL) {

      hr = ExtractMetadata(factory, frame, metadata);

      if (FAILED(hr)) {

        fprintf(stderr, "Error extracting image metadata using WIC!\n");

      }

    }

  }

  // Cleanup.

  if (converter != NULL) IUnknown_Release(converter);

  if (frame != NULL) IUnknown_Release(frame);

  if (decoder != NULL) IUnknown_Release(decoder);

  if (factory != NULL) IUnknown_Release(factory);

  if (stream != NULL) IUnknown_Release(stream);

  free(rgb);

  return SUCCEEDED(hr);

}

#else  // !HAVE_WINCODEC_H

int ReadPictureWithWIC(const char* const filename,

                       struct WebPPicture* const pic, int keep_alpha,

                       struct Metadata* const metadata) {

  (void)filename;

  (void)pic;

  (void)keep_alpha;

  (void)metadata;

  fprintf(stderr, "Windows Imaging Component (WIC) support not compiled. "

                  "Visual Studio and mingw-w64 builds support WIC. Make sure "

                  "wincodec.h detection is working correctly if using autoconf "

                  "and HAVE_WINCODEC_H is defined before building.\n");

  return 0;

}

#endif  // HAVE_WINCODEC_H

// -----------------------------------------------------------------------------