static bool convert_file_icon(const HICON icon, Bmp& bmp) {
static IWICImagingFactory* img_factory = 0;
if (!img_factory) {
// In VS 2011 beta, clsid has to be changed to CLSID_WICImagingFactory1 (from CLSID_WICImagingFactory)
if (!SUCCEEDED(::CoInitialize(0)) || !SUCCEEDED(::CoCreateInstance(CLSID_WICImagingFactory1, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&img_factory)))) {
return false;
}
}
IWICBitmap* pBitmap = 0;
IWICFormatConverter* pConverter = 0;
UINT cx = 0, cy = 0;
if (SUCCEEDED(img_factory->CreateBitmapFromHICON(icon, &pBitmap))) {
if (SUCCEEDED(img_factory->CreateFormatConverter(&pConverter))) {
if (SUCCEEDED(pConverter->Initialize(pBitmap, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, 0, 0.0f, WICBitmapPaletteTypeCustom))) {
if (SUCCEEDED(pConverter->GetSize(&cx, &cy))) {
const UINT stride = cx * sizeof(DWORD);
const UINT buf_size = cy * stride;
Byte* buf = new Byte[buf_size];
pConverter->CopyPixels(0, stride, buf_size, buf);
bmp.load_bits_only(buf, buf_size, cx, -(int)cy);
delete [] buf;
}
}
pConverter->Release();
}
pBitmap->Release();
}
return true;
}
HRESULT ConvertBitmapSource( RECT rcDest, IWICBitmapSource*& pToRenderBitmapSource )
{
HRESULT hr = S_OK;
IWICBitmapScaler* pScaler = nullptr;
WICPixelFormatGUID pxformat;
IWICFormatConverter* pConverter = nullptr;
pToRenderBitmapSource = nullptr;
// Get the client Rect
//RECT rcClient = rcDest;
//hr = GetClientRect(hWnd, &rcClient) ? S_OK: E_FAIL;
if( SUCCEEDED( hr ) )
{
// Create a BitmapScaler
hr = g_UserImageFactoryInst.m_pIWICFactory->CreateBitmapScaler( &pScaler );
//hr = IWICImagingFactory_CreateBitmapScaler( g_UserImageFactoryInst.m_pIWICFactory, &pScaler );
// Initialize the bitmap scaler from the original bitmap map bits
if( SUCCEEDED( hr ) )
{
pScaler->Initialize( g_UserImageFactoryInst.m_pOriginalBitmapSource,
rcDest.right - rcDest.left,
rcDest.bottom - rcDest.top,
WICBitmapInterpolationModeFant );
}
//hr = IWICBitmapScaler_GetPixelFormat( pScaler, &pxformat );
hr = pScaler->GetPixelFormat( &pxformat );
// Format convert the bitmap into 32bppBGR, a convenient
// pixel format for GDI rendering
if( SUCCEEDED( hr ) )
{
//hr = IWICImagingFactory_CreateFormatConverter( g_UserImageFactoryInst.m_pIWICFactory, &pConverter );
hr = g_UserImageFactoryInst.m_pIWICFactory->CreateFormatConverter( &pConverter );
// Format convert to 32bppBGR
if( SUCCEEDED( hr ) )
{
hr = pConverter->Initialize( static_cast<IWICBitmapSource*>( pScaler ), // Input bitmap to convert
GUID_WICPixelFormat32bppBGR, // &GUID_WICPixelFormat32bppBGR,
WICBitmapDitherTypeNone, // Specified dither patterm
NULL, // Specify a particular palette
0.f, // Alpha threshold
WICBitmapPaletteTypeCustom ); // Palette translation type
// Store the converted bitmap as ppToRenderBitmapSource
if( SUCCEEDED( hr ) )
pConverter->QueryInterface( IID_IWICBitmapSource, reinterpret_cast<void**>( &pToRenderBitmapSource ) );
}
SAFE_RELEASE( pConverter );
}
SAFE_RELEASE( pScaler );
}
return hr;
}
HRESULT Game::LoadBitmapFromFile(LPCTSTR strFileName, ID2D1Bitmap** ppBitmap)
{
HRESULT hr;
IWICBitmapDecoder *pDecoder = NULL;
IWICBitmapFrameDecode *pSource = NULL;
IWICFormatConverter *pConverter = NULL;
hr = pWICFactory->CreateDecoderFromFilename(strFileName, NULL, GENERIC_READ, WICDecodeMetadataCacheOnLoad, &pDecoder);
if (SUCCEEDED(hr))
{
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr))
{
hr = pWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(pSource, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.f, WICBitmapPaletteTypeMedianCut);
}
if (SUCCEEDED(hr))
{
hr = pRT->CreateBitmapFromWicBitmap(pConverter, NULL, ppBitmap);
}
SafeRelease(&pDecoder);
SafeRelease(&pSource);
SafeRelease(&pConverter);
return hr;
}
bool WICImageLoader::processImage(IWICBitmapDecoder* pDecoder)
{
HRESULT hr = E_FAIL;
IWICBitmapFrameDecode* pFrame = NULL;
if(NULL != pDecoder)
{
hr = pDecoder->GetFrame(0, &pFrame);
}
if(SUCCEEDED(hr))
{
hr = pFrame->GetPixelFormat(&_format);
}
IWICFormatConverter* pConv = NULL;
if(SUCCEEDED(hr))
{
hr = convertFormatIfRequired(pFrame, &pConv);
}
if(SUCCEEDED(hr))
{
_bpp = getBitsPerPixel(_format);
if(NULL != pConv)
{
hr = pConv->GetSize((UINT*)&_width, (UINT*)&_height);
}
else
{
hr = pFrame->GetSize((UINT*)&_width, (UINT*)&_height);
}
}
assert(_bpp > 0);
assert(_width > 0 && _height > 0);
if(SUCCEEDED(hr))
{
size_t rowPitch = (_width * _bpp + 7) / 8;
_dataLen = rowPitch * _height;
_data = new (std::nothrow) BYTE[_dataLen];
if(NULL != pConv)
{
hr = pConv->CopyPixels(NULL, static_cast<UINT>(rowPitch), static_cast<UINT>(_dataLen), _data);
}
else
{
hr = pFrame->CopyPixels(NULL, static_cast<UINT>(rowPitch), static_cast<UINT>(_dataLen), _data);
}
}
SafeRelease(&pFrame);
SafeRelease(&pConv);
return SUCCEEDED(hr);
}
SpriteSheet::SpriteSheet(wchar_t* filename, Graphics* gfx)
{
this->gfx = gfx;
bmp = NULL;
HRESULT hr;
//create a wic factory
IWICImagingFactory *wicFactory = NULL;
hr = CoCreateInstance(
CLSID_WICImagingFactory,
NULL,
CLSCTX_INPROC_SERVER,
IID_IWICImagingFactory,
(LPVOID*)&wicFactory);
//create a decoder
IWICBitmapDecoder *wicDecoder = NULL;
hr = wicFactory->CreateDecoderFromFilename(
filename, // THE FILE NAME
NULL, // the preferred vendor
GENERIC_READ, // we're reading the file, not writing
WICDecodeMetadataCacheOnLoad,
&wicDecoder);
// read a frame from the image
IWICBitmapFrameDecode* wicFrame = NULL;
hr = wicDecoder->GetFrame(0, &wicFrame);
// create a converter
IWICFormatConverter *wicConverter = NULL;
hr = wicFactory->CreateFormatConverter(&wicConverter);
// setup the converter
hr = wicConverter->Initialize(
wicFrame, // frame
GUID_WICPixelFormat32bppPBGRA, // pixel format
WICBitmapDitherTypeNone, // irrelevant
NULL, // no palette needed, irrlevant
0.0, // alpha transparency % irrelevant
WICBitmapPaletteTypeCustom // irrelevant
);
// use the converter to create an D2D1Bitmap
/// ID2D1Bitmap* bmp; // this will be a member variable
hr = gfx->GetRenderTarget()->CreateBitmapFromWicBitmap(
wicConverter, // converter
NULL, // D2D1_BITMAP_PROPERIES
&bmp // destiatnion D2D1 bitmap
);
if (wicFactory) wicFactory->Release();
if (wicDecoder) wicDecoder->Release();
if (wicConverter) wicConverter->Release();
if (wicFrame) wicFrame->Release();
}
//etc. WICConvertBitmapSource
BOOL ConvertWICBitmapFormat(IWICImagingFactory* pWICFactory,REFWICPixelFormatGUID toFormat,IWICBitmapSource* pSrc,IWICBitmapSource** ppDst)
{
IWICFormatConverter* pWICFormatConverter;
if (FAILED(pWICFactory->CreateFormatConverter(&pWICFormatConverter)))
return FALSE;
if (SUCCEEDED(pWICFormatConverter->Initialize(pSrc,toFormat,WICBitmapDitherTypeNone,NULL,.0f,WICBitmapPaletteTypeCustom)))
{
*ppDst = pWICFormatConverter;
return TRUE;
}
return FALSE;
}
HRESULT WICImageLoader::convertFormatIfRequired(IWICBitmapFrameDecode* pFrame, IWICFormatConverter** ppConv)
{
*ppConv = NULL;
if( (memcmp(&_format, &GUID_WICPixelFormat8bppGray, sizeof(WICPixelFormatGUID)) == 0) ||
(memcmp(&_format, &GUID_WICPixelFormat8bppAlpha, sizeof(WICPixelFormatGUID)) == 0) ||
(memcmp(&_format, &GUID_WICPixelFormat24bppRGB, sizeof(WICPixelFormatGUID)) == 0) ||
(memcmp(&_format, &GUID_WICPixelFormat32bppRGBA, sizeof(WICPixelFormatGUID)) == 0))
{
return S_OK;
}
HRESULT hr = E_FAIL;
IWICImagingFactory* pFactory = getWICFactory();
IWICFormatConverter* pConv = NULL;
if(NULL != pFactory)
{
hr = pFactory->CreateFormatConverter(&pConv);
}
WICPixelFormatGUID destFormat = GUID_WICPixelFormat32bppRGBA; // Fallback to RGBA 32-bit format which is supported by all devices
for( size_t i=0; i < _countof(g_WICConvert); ++i )
{
if ( memcmp( &g_WICConvert[i].source, &_format, sizeof(WICPixelFormatGUID) ) == 0 )
{
memcpy( &destFormat, &g_WICConvert[i].target, sizeof(WICPixelFormatGUID) );
break;
}
}
BOOL bCanConv = FALSE;
if(SUCCEEDED(hr))
{
hr = pConv->CanConvert(_format, destFormat, &bCanConv);
}
if(SUCCEEDED(hr) && bCanConv == TRUE)
{
hr = pConv->Initialize(pFrame, destFormat, WICBitmapDitherTypeErrorDiffusion, 0, 0, WICBitmapPaletteTypeCustom);
}
if(SUCCEEDED(hr))
{
memcpy(&_format, &destFormat, sizeof(WICPixelFormatGUID));
*ppConv = pConv;
}
return SUCCEEDED(hr);
}
HRESULT d2d::LoadBitmap (
const wchar_t* filename,
IWICImagingFactory* wic,
ID2D1RenderTarget* rt,
ID2D1Bitmap **bitmap )
{
HRESULT hr = S_OK;
IWICBitmapFrameDecode *frame = nullptr;
IWICBitmapDecoder *decoder = nullptr;
IWICFormatConverter *conv = nullptr;
// 디코더 생성
hr = wic->CreateDecoderFromFilename (
filename,
0,
GENERIC_READ,
WICDecodeMetadataCacheOnDemand,
&decoder );
// 프레임 얻기
if(SUCCEEDED(hr))
hr = decoder->GetFrame (0, &frame);
// 변환기 생성
if(SUCCEEDED(hr))
hr = wic->CreateFormatConverter(&conv);
// 변환기 초기화
if(SUCCEEDED(hr))
hr = conv->Initialize (
frame,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
0,
1.0f,
WICBitmapPaletteTypeCustom );
// 비트맵 생성
if(SUCCEEDED(hr))
hr = rt->CreateBitmapFromWicBitmap (
conv,
bitmap );
// 해제
d2d::SafeRelease(frame);
d2d::SafeRelease(decoder);
d2d::SafeRelease(conv);
// 결과 반환
return hr;
}
//从一个文件加载图片
ID2D1Bitmap* d2d::CreateBitmapFromFile(wstring strFileName)
{
IWICBitmapDecoder *pDecoder = nullptr;
HRESULT hr = m_pWICFactory->CreateDecoderFromFilename(strFileName.c_str(), NULL, GENERIC_READ,
WICDecodeMetadataCacheOnLoad, //enum WICDecodeOptions
&pDecoder);
if (FAILED(hr))
{
return nullptr;
}
// Create the initial frame.
IWICBitmapFrameDecode *pSource = nullptr;
hr = pDecoder->GetFrame(0, &pSource);
if (FAILED(hr))
{
return nullptr;
}
//转换器
IWICFormatConverter *pConverter = nullptr;
hr = m_pWICFactory->CreateFormatConverter(&pConverter);
if (FAILED(hr))
{
return nullptr;
}
hr = pConverter->Initialize(pSource, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone,
NULL, 0.f, WICBitmapPaletteTypeMedianCut);
if (FAILED(hr))
{
return nullptr;
}
// Create a Direct2D bitmap from the WIC bitmap.
ID2D1Bitmap* picBitmap = nullptr;
hr = m_pRenderTarget->CreateBitmapFromWicBitmap(pConverter, NULL, &picBitmap);
if (FAILED(hr))
{
return nullptr;
}
SafeRelease(pDecoder);
SafeRelease(pSource);
SafeRelease(pConverter);
return picBitmap;
}
BitmapWrapperD2D::BitmapWrapperD2D(bitmap bmp)
{
IWICBitmap* wic = 0;
Graphics::locator.getfactory()->CreateBitmapFromMemory(
bmp.width(), bmp.height(),
GUID_WICPixelFormat32bppBGRA,
4 * bmp.width(),
bmp.length(),
(BYTE*)bmp.data(),
&wic);
if (wic != 0)
{
IWICFormatConverter* converter = nullptr;
IWICBitmap* temp = nullptr;
int result = Graphics::locator.getfactory()->CreateFormatConverter(&converter);
if (result == 0)
{
converter->Initialize(wic,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone, 0, 0.f,
WICBitmapPaletteTypeMedianCut);
Graphics::locator.getfactory()->CreateBitmapFromSource(converter, WICBitmapNoCache, &temp);
converter->Release();
}
wic->Release();
ID2D1BitmapRenderTarget* target = Graphics::locator.gettarget();
if (target)
{
target->CreateBitmapFromWicBitmap(temp, &source);
temp->Release();
temp = nullptr;
}
else
{
source = nullptr;
}
}
else
{
source = nullptr;
}
}
// =========================================================
// Load the specified bitmap from file into D2D bitmap
// =========================================================
BOOL Loader::LoadBitmapFromFile(LPCWSTR filename, const Graphics* graphicsWrapper, ID2D1Bitmap** ppBitmap)
{
if (!isInitialized)
return FALSE;
HRESULT hr;
IWICBitmapDecoder *pDecoder = NULL;
IWICBitmapFrameDecode *pSource = NULL;
IWICFormatConverter *pConverter = NULL;
hr = pFactory->CreateDecoderFromFilename(filename, NULL, GENERIC_READ, WICDecodeMetadataCacheOnDemand, &pDecoder);
CHECK(failedDecoder);
hr = pDecoder->GetFrame(0, &pSource);
CHECK(failedGetFrame);
hr = pFactory->CreateFormatConverter(&pConverter);
CHECK(failedConverter);
hr = pConverter->Initialize(pSource, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.0, WICBitmapPaletteTypeMedianCut);
CHECK(failedConversion);
hr = graphicsWrapper->pRenderTarget->CreateBitmapFromWicBitmap(pSource, ppBitmap);
CHECK(failedBitmap);
return TRUE;
failedBitmap:
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to create bitmap.\n");
failedConversion:
pConverter->Release();
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to initialise format converter.\n");
failedConverter:
pSource->Release();
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to create format converter.\n");
failedGetFrame:
pDecoder->Release();
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to get frame 0 from source bitmap.\n");
failedDecoder:
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to create bitmap decoder.\n");
return FALSE;
}
STDMETHODIMP BaseFrameEncode::Commit()
{
HRESULT result = S_OK;
IWICBitmapScaler *scaler = NULL;
IWICFormatConverter *formatConverter = NULL;
result = S_OK;
// Create a scaler to match the requested width and height
if (SUCCEEDED(result))
{
result = factory->CreateBitmapScaler(&scaler);
}
if (SUCCEEDED(result))
{
result = scaler->Initialize(destSource, destWidth, destHeight, WICBitmapInterpolationModeFant);
}
// Create a format converter to output into the proper format
if (SUCCEEDED(result))
{
result = factory->CreateFormatConverter(&formatConverter);
}
if (SUCCEEDED(result))
{
result = formatConverter->Initialize(scaler, destPixelFormat, WICBitmapDitherTypeErrorDiffusion,
destPalette, 50.0, WICBitmapPaletteTypeCustom);
}
// Cleanup
if (formatConverter)
{
destSource->Release();
destSource = formatConverter;
}
return result;
}
void GL::Image::load(const unsigned char *buf, size_t bufSize)
{
if (CoInitializeEx(NULL, COINIT_MULTITHREADED) != S_OK) {
// bad!
return;
}
IStream *stream = SHCreateMemStream((const BYTE*)buf, (UINT)bufSize);
if (stream != NULL) {
IWICImagingFactory *pFactory;
if (CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (LPVOID*)&pFactory) == S_OK) {
IWICBitmapDecoder *pDecoder;
if (pFactory->CreateDecoderFromStream(stream, &CLSID_WICPngDecoder, WICDecodeMetadataCacheOnDemand, &pDecoder) == S_OK) {
IWICBitmapFrameDecode *frame;
if (pDecoder->GetFrame(0, &frame) == S_OK) {
UINT w, h;
if (frame->GetSize(&w, &h) == S_OK) {
width_ = w;
height_ = h;
}
IWICFormatConverter *formatConverter;
if (pFactory->CreateFormatConverter(&formatConverter) == S_OK) {
if (formatConverter->Initialize(frame, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, nullptr, 0.0, WICBitmapPaletteTypeCustom) == S_OK) {
unsigned char *pixels = new unsigned char[w * h * 4];
if (formatConverter->CopyPixels(0, w * 4, w * h * 4, pixels) == S_OK) {
loadTextureData_(pixels);
}
delete[] pixels;
}
formatConverter->Release();
}
}
pDecoder->Release();
}
pFactory->Release();
}
stream->Release();
}
CoUninitialize();
}
pair<imgcontext, size_t> imagecache::createimage(bitmap bmp)
{
size_t id = bmp.id();
if (temp[imgcon][id] || cache[imgcon][id])
{
return make_pair(imgcon, id);
}
else
{
IWICBitmap* wic = 0;
imgfactory->CreateBitmapFromMemory(
bmp.width(), bmp.height(),
GUID_WICPixelFormat32bppBGRA,
4 * bmp.width(),
bmp.length(),
(BYTE*)bmp.data(),
&wic);
if (wic)
{
IWICFormatConverter* spConverter = 0;
int result = imgfactory->CreateFormatConverter(&spConverter);
if (result == 0)
{
spConverter->Initialize(wic,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone, NULL, 0.f,
WICBitmapPaletteTypeMedianCut);
imgfactory->CreateBitmapFromSource(spConverter, WICBitmapNoCache, &temp[imgcon][id]);
spConverter->Release();
}
wic->Release();
}
}
return make_pair(imgcon, id);
}
// =========================================================
// Load the specified bitmap from file into D2D bitmap
// =========================================================
BOOL Loader::LoadBitmapFromResource(LPCWSTR resourceId, LPCWSTR resourceType, const Graphics* graphicsWrapper, ID2D1Bitmap** ppBitmap)
{
if (!isInitialized)
return FALSE;
HRESULT hr;
IWICStream *pStream = NULL;
IWICBitmapDecoder *pDecoder = NULL;
IWICBitmapFrameDecode *pSource = NULL;
IWICFormatConverter *pConverter = NULL;
HRSRC imageResHandle = NULL;
HGLOBAL imageResDataHandle = NULL;
void *pImageFile = NULL;
DWORD imageFileSize = 0;
HMODULE module = GetModuleHandle(0);
// Locate the resource
imageResHandle = FindResource(module, resourceId, resourceType);
if (!imageResHandle)
{
OutputDebugStringA("Loader::LoadBitmapFromResource -> Failed to locate resource.\n");
return FALSE;
}
imageResDataHandle = LoadResource(module, imageResHandle);
if (!imageResDataHandle)
{
OutputDebugStringA("Loader::LoadBitmapFromResource -> Failed to load resource.\n");
return FALSE;
}
// lock resource to get pointer to data
pImageFile = LockResource(imageResDataHandle);
if (!pImageFile)
{
OutputDebugStringA("Loader::LoadBitmapFromResource -> Failed to lock resource for processing.\n");
return FALSE;
}
// get the size of the image
imageFileSize = SizeofResource(module, imageResHandle);
if (!imageFileSize)
{
OutputDebugStringA("Loader::LoadBitmapFromResource -> Failed to obtain size of image resource.\n");
return FALSE;
}
// now that we have everything, we create the stream
hr = pFactory->CreateStream(&pStream);
CHECK(failedCreateStream);
// initialise the stream
hr = pStream->InitializeFromMemory((byte*)pImageFile, imageFileSize);
CHECK(failedStreamInit);
hr = pFactory->CreateDecoderFromStream(pStream, NULL, WICDecodeMetadataCacheOnDemand, &pDecoder);
CHECK(failedDecoder);
hr = pDecoder->GetFrame(0, &pSource);
CHECK(failedGetFrame);
hr = pFactory->CreateFormatConverter(&pConverter);
CHECK(failedConverter);
hr = pConverter->Initialize(pSource, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.0, WICBitmapPaletteTypeMedianCut);
CHECK(failedConversion);
hr = graphicsWrapper->pRenderTarget->CreateBitmapFromWicBitmap(pConverter, ppBitmap);
CHECK(failedBitmap);
return TRUE;
failedBitmap:
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to create bitmap.\n");
failedConversion:
pConverter->Release();
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to initialise format converter.\n");
failedConverter:
pSource->Release();
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to create format converter.\n");
failedGetFrame:
pDecoder->Release();
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to get frame 0 from source bitmap.\n");
failedDecoder:
pStream->Release();
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to create bitmap decoder.\n");
return FALSE;
failedStreamInit:
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to initialize WIC stream.\n");
return FALSE;
failedCreateStream:
OutputDebugStringA("Loader::LoadBitmapFromFile -> Failed to create WIC stream.\n");
return FALSE;
}
HRESULT LoadResourceBitmap(
ID2D1RenderTarget* pRendertarget,
IWICImagingFactory* pIWICFactory,
PCWSTR resourceName,
PCWSTR resourceType,
UINT destinationWidth,
UINT destinationHeight,
ID2D1Bitmap** ppBitmap
)
{
HRESULT hr = S_OK;
IWICBitmapDecoder* pDecoder = NULL;
IWICBitmapFrameDecode* pSource = NULL;
IWICStream* pStream = NULL;
IWICFormatConverter* pConverter = NULL;
IWICBitmapScaler* pScaler = NULL;
HRSRC imageResHandle = NULL;
HGLOBAL imageResDataHandle = NULL;
void* pImageFile = NULL;
DWORD imageFileSize = 0;
// Find the resource then load it
imageResHandle = FindResource(HINST_THISCOMPONENT, resourceName, resourceType);
hr = imageResHandle ? S_OK : E_FAIL;
if (SUCCEEDED(hr))
{
imageResDataHandle = LoadResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageResDataHandle ? S_OK : E_FAIL;
}
// Lock the resource and calculate the image's size
if (SUCCEEDED(hr))
{
// Lock it to get the system memory pointer
pImageFile = LockResource(imageResDataHandle);
hr = pImageFile ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Calculate the size
imageFileSize = SizeofResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageFileSize ? S_OK : E_FAIL;
}
// Create an IWICStream object
if (SUCCEEDED(hr))
{
// Create a WIC stream to map onto the memory
hr = pIWICFactory->CreateStream(&pStream);
}
if (SUCCEEDED(hr))
{
// Initialize the stream with the memory pointer and size
hr = pStream->InitializeFromMemory(
reinterpret_cast<BYTE*>(pImageFile),
imageFileSize
);
}
// Create IWICBitmapDecoder
if (SUCCEEDED(hr))
{
// Create a decoder for the stream
hr = pIWICFactory->CreateDecoderFromStream(
pStream,
NULL,
WICDecodeMetadataCacheOnLoad,
&pDecoder
);
}
// Retrieve a frame from the image and store it in an IWICBitmapFrameDecode object
if (SUCCEEDED(hr))
{
// Create the initial frame
hr = pDecoder->GetFrame(0, &pSource);
}
// Before Direct2D can use the image, it must be converted to the 32bppPBGRA pixel format.
// To convert the image format, use the IWICImagingFactory::CreateFormatConverter method to create an IWICFormatConverter object, then use the IWICFormatConverter object's Initialize method to perform the conversion.
if (SUCCEEDED(hr))
{
// Convert the image format to 32bppPBGRA
// (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
hr = pIWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
// If a new width or height was specified, create and
// IWICBitmapScaler and use it to resize the image.
if (destinationWidth != 0 || destinationHeight != 0)
{
UINT originalWidth;
UINT originalHeight;
hr = pSource->GetSize(&originalWidth, &originalHeight);
if (SUCCEEDED(hr))
{
if (destinationWidth == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationHeight) / static_cast<FLOAT>(originalHeight);
destinationWidth = static_cast<UINT>(scalar * static_cast<FLOAT>(originalWidth));
}
else if (destinationHeight == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationWidth) / static_cast<FLOAT>(originalWidth);
destinationHeight = static_cast<UINT>(scalar * static_cast<FLOAT>(originalHeight));
}
hr = pIWICFactory->CreateBitmapScaler(&pScaler);
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(
pSource,
destinationWidth,
destinationHeight,
WICBitmapInterpolationModeCubic
);
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(
pScaler,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
}
}
}
}
else // use default width and height
{
hr = pConverter->Initialize(
pSource,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
}
}
// Finally, Create an ID2D1Bitmap object, that can be drawn by a render target and used with other Direct2D objects
if (SUCCEEDED(hr))
{
// Create a Direct2D bitmap from the WIC bitmap
hr = pRendertarget->CreateBitmapFromWicBitmap(
pConverter,
NULL,
ppBitmap
);
}
SAFE_RELEASE(pDecoder);
SAFE_RELEASE(pSource);
SAFE_RELEASE(pStream);
SAFE_RELEASE(pConverter);
SAFE_RELEASE(pScaler);
return hr;
}
HRESULT App::LoadResourceBitmap(
ID2D1RenderTarget *pRenderTarget,
IWICImagingFactory *pIWICFactory,
PCWSTR resourceName,
PCWSTR resourceType,
UINT destinationWidth,
UINT destinationHeight,
ID2D1Bitmap **ppBitmap
)
{
IWICBitmapDecoder *pDecoder = NULL;
IWICBitmapFrameDecode *pSource = NULL;
IWICStream *pStream = NULL;
IWICFormatConverter *pConverter = NULL;
IWICBitmapScaler *pScaler = NULL;
HRSRC imageResHandle = NULL;
HGLOBAL imageResDataHandle = NULL;
void *pImageFile = NULL;
DWORD imageFileSize = 0;
// Locate the resource.
imageResHandle = FindResourceW(HINST_THISCOMPONENT, resourceName, resourceType);
HRESULT hr = imageResHandle ? S_OK : E_FAIL;
if (SUCCEEDED(hr))
{
// Load the resource.
imageResDataHandle = LoadResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageResDataHandle ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Lock it to get a system memory pointer.
pImageFile = LockResource(imageResDataHandle);
hr = pImageFile ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Calculate the size.
imageFileSize = SizeofResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageFileSize ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Create a WIC stream to map onto the memory.
hr = pIWICFactory->CreateStream(&pStream);
}
if (SUCCEEDED(hr))
{
// Initialize the stream with the memory pointer and size.
hr = pStream->InitializeFromMemory(
reinterpret_cast<BYTE*>(pImageFile),
imageFileSize
);
}
if (SUCCEEDED(hr))
{
// Create a decoder for the stream.
hr = pIWICFactory->CreateDecoderFromStream(
pStream,
NULL,
WICDecodeMetadataCacheOnLoad,
&pDecoder
);
}
if (SUCCEEDED(hr))
{
// Create the initial frame.
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr))
{
// Convert the image format to 32bppPBGRA
// (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
hr = pIWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
// If a new width or height was specified, create an
// IWICBitmapScaler and use it to resize the image.
if (destinationWidth != 0 || destinationHeight != 0)
{
UINT originalWidth, originalHeight;
hr = pSource->GetSize(&originalWidth, &originalHeight);
if (SUCCEEDED(hr))
{
if (destinationWidth == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationHeight) / static_cast<FLOAT>(originalHeight);
destinationWidth = static_cast<UINT>(scalar * static_cast<FLOAT>(originalWidth));
}
else if (destinationHeight == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationWidth) / static_cast<FLOAT>(originalWidth);
destinationHeight = static_cast<UINT>(scalar * static_cast<FLOAT>(originalHeight));
}
hr = pIWICFactory->CreateBitmapScaler(&pScaler);
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(
pSource,
destinationWidth,
destinationHeight,
WICBitmapInterpolationModeCubic
);
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(
pScaler,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
}
}
}
}
else
{
hr = pConverter->Initialize(
pSource,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
}
}
if (SUCCEEDED(hr))
{
//create a Direct2D bitmap from the WIC bitmap.
hr = pRenderTarget->CreateBitmapFromWicBitmap(
pConverter,
NULL,
ppBitmap
);
}
SafeRelease(&pDecoder);
SafeRelease(&pSource);
SafeRelease(&pStream);
SafeRelease(&pConverter);
SafeRelease(&pScaler);
return hr;
}
bool ResourceManager::LoadFile(ID2D1HwndRenderTarget* renderTarget, wchar_t * filename)
{
HRESULT result;
IWICImagingFactory2* wicFactory;
IWICBitmapDecoder* wicDecoder;
IWICBitmapFrameDecode* wicFrame;
IWICBitmapFlipRotator* wicFlip;
IWICFormatConverter *wicConverter;
Sprite* newSprite;
// WIC의 각종 인터페이스를 사용하기 위한 factory 생성
result = CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&wicFactory));
if (FAILED(result))
return false;
// 파일을 읽고 디코딩 하기 위한 decoder 생성
result = wicFactory->CreateDecoderFromFilename(filename, nullptr, GENERIC_READ, WICDecodeMetadataCacheOnDemand, &wicDecoder);
if (FAILED(result))
return false;
// decoder에서 프레임을 얻어옴, // 일반적인 이미지 파일은 single frame만을 지원하므로 0으로 고정
result = wicDecoder->GetFrame(0, &wicFrame);
if (FAILED(result))
return false;
// 수평으로 뒤집힌 이미지를 얻기 위해 BitmapFlipRotator 생성
result = wicFactory->CreateBitmapFlipRotator(&wicFlip);
if (FAILED(result))
return false;
// wicFrame를 수평으로 뒤집음
wicFlip->Initialize(wicFrame, WICBitmapTransformFlipHorizontal);
// WICBitmap을 D2DBitmap으로 변환시키기 위해 format converter 생성
result = wicFactory->CreateFormatConverter(&wicConverter);
if (FAILED(result))
return false;
// Converter[0]의 Format을 일반 이미지(wicFrame)에 맞춤
result = wicConverter->Initialize(wicFrame, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.0f, WICBitmapPaletteTypeCustom);
if (FAILED(result))
return false;
// 리소스 정보를 저장 할 Sprite 생성
newSprite = new Sprite(renderTarget);
if (!newSprite)
return false;
// WICBitmap을 D2DBitmap으로 변환
//result = renderTarget->CreateBitmapFromWicBitmap(wicConverter, nullptr, &m_Bitmap);
result = renderTarget->CreateBitmapFromWicBitmap(wicConverter, nullptr, newSprite->GetBitmap());
if (FAILED(result))
return false;
ID2D1Bitmap* bitmap = *(newSprite->GetBitmap());
int numberOfFrame = bitmap->GetSize().width / IMAGE_SIZE;
int numberOfAction = bitmap->GetSize().height / IMAGE_SIZE;
newSprite->Initialize(numberOfFrame, numberOfAction);
wchar_t* buffer = new wchar_t[128];
wcscpy_s(buffer, wcslen(filename) + 1, filename);
// 스프라이트 등록
m_Sprites.push_back(newSprite);
m_Filenames.push_back(buffer);
wicConverter->Release();
wicConverter = nullptr;
wicFrame->Release();
wicFrame = nullptr;
wicFlip->Release();
wicFlip = nullptr;
wicDecoder->Release();
wicDecoder = nullptr;
wicFactory->Release();
wicFactory = nullptr;
return true;
}
/// <summary>
/// Load an image from a resource into a buffer
/// </summary>
/// <param name="resourceName">name of image resource to load</param>
/// <param name="resourceType">type of resource to load</param>
/// <param name="nOutputWidth">width (in pixels) of scaled output bitmap</param>
/// <param name="nOutputHeight">height (in pixels) of scaled output bitmap</param>
/// <param name="pOutputBuffer">buffer that will hold the loaded image</param>
/// <returns>S_OK on success, otherwise failure code</returns>
HRESULT CCoordinateMappingBasics::LoadResourceImage(PCWSTR resourceName, PCWSTR resourceType, UINT nOutputWidth, UINT nOutputHeight, RGBQUAD* pOutputBuffer)
{
IWICImagingFactory* pIWICFactory = NULL;
IWICBitmapDecoder* pDecoder = NULL;
IWICBitmapFrameDecode* pSource = NULL;
IWICStream* pStream = NULL;
IWICFormatConverter* pConverter = NULL;
IWICBitmapScaler* pScaler = NULL;
HRSRC imageResHandle = NULL;
HGLOBAL imageResDataHandle = NULL;
void *pImageFile = NULL;
DWORD imageFileSize = 0;
HRESULT hrCoInit = CoInitialize(NULL);
HRESULT hr = hrCoInit;
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (LPVOID*)&pIWICFactory);
}
if (SUCCEEDED(hr))
{
// Locate the resource
imageResHandle = FindResourceW(HINST_THISCOMPONENT, resourceName, resourceType);
hr = imageResHandle ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Load the resource
imageResDataHandle = LoadResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageResDataHandle ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Lock it to get a system memory pointer.
pImageFile = LockResource(imageResDataHandle);
hr = pImageFile ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Calculate the size.
imageFileSize = SizeofResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageFileSize ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Create a WIC stream to map onto the memory.
hr = pIWICFactory->CreateStream(&pStream);
}
if (SUCCEEDED(hr))
{
// Initialize the stream with the memory pointer and size.
hr = pStream->InitializeFromMemory(
reinterpret_cast<BYTE*>(pImageFile),
imageFileSize);
}
if (SUCCEEDED(hr))
{
// Create a decoder for the stream.
hr = pIWICFactory->CreateDecoderFromStream(
pStream,
NULL,
WICDecodeMetadataCacheOnLoad,
&pDecoder);
}
if (SUCCEEDED(hr))
{
// Create the initial frame.
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr))
{
// Convert the image format to 32bppPBGRA
// (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
hr = pIWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
hr = pIWICFactory->CreateBitmapScaler(&pScaler);
}
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(
pSource,
nOutputWidth,
nOutputHeight,
WICBitmapInterpolationModeCubic
);
}
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(
pScaler,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut);
}
UINT width = 0;
UINT height = 0;
if (SUCCEEDED(hr))
{
hr = pConverter->GetSize(&width, &height);
}
// make sure the image scaled correctly so the output buffer is big enough
if (SUCCEEDED(hr))
{
if ((width != nOutputWidth) || (height != nOutputHeight))
{
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
hr = pConverter->CopyPixels(NULL, width * sizeof(RGBQUAD), nOutputWidth * nOutputHeight * sizeof(RGBQUAD), reinterpret_cast<BYTE*>(pOutputBuffer));
}
SafeRelease(pScaler);
SafeRelease(pConverter);
SafeRelease(pSource);
SafeRelease(pDecoder);
SafeRelease(pStream);
SafeRelease(pIWICFactory);
if (SUCCEEDED(hrCoInit))
{
CoUninitialize();
}
return hr;
}
void LoadJPG(wchar_t *pwszJpg, HWND hwnd)
{
IWICImagingFactory *pFactory = NULL;
HRESULT hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFactory));
if (SUCCEEDED(hr)) {
IWICBitmapDecoder *pDecoder = NULL;
hr = pFactory->CreateDecoderFromFilename(pwszJpg, NULL, GENERIC_READ, WICDecodeMetadataCacheOnDemand, &pDecoder);
if (SUCCEEDED(hr)) {
IWICBitmapFrameDecode *pIDecoderFrame = NULL;
hr = pDecoder->GetFrame(0, &pIDecoderFrame);
if (SUCCEEDED(hr)) {
IWICFormatConverter *pFC = NULL;
hr = pFactory->CreateFormatConverter(&pFC);
hr = pFC->Initialize(pIDecoderFrame, GUID_WICPixelFormat24bppBGR, WICBitmapDitherTypeNone, NULL, 0.0, WICBitmapPaletteTypeCustom);
const int nBytesPixel = 3; // GUID_WICPixelFormat24bppBGR 每像素3字节(24bits)
BITMAPINFO bmpInfo;
ZeroMemory(&bmpInfo, sizeof(BITMAPINFO));
bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
hr = pIDecoderFrame->GetSize((UINT*)&bmpInfo.bmiHeader.biWidth, (UINT*)&bmpInfo.bmiHeader.biHeight);
bmpInfo.bmiHeader.biPlanes = 1;
bmpInfo.bmiHeader.biBitCount = 8 * nBytesPixel;
bmpInfo.bmiHeader.biCompression = BI_RGB;
BYTE *pBuf = NULL;
HDC hdc = GetDC(hwnd);
bmpInfo.bmiHeader.biHeight *= -1; // BMP 方向调整
HBITMAP hBmp = CreateDIBSection(hdc, &bmpInfo, DIB_RGB_COLORS, (void**)&pBuf, NULL, 0);
bmpInfo.bmiHeader.biHeight *= -1;
// 计算扫描线
unsigned int cbStride = nBytesPixel * bmpInfo.bmiHeader.biWidth;
unsigned int total = cbStride*bmpInfo.bmiHeader.biHeight;
hr = pFC->CopyPixels(NULL, cbStride, total, pBuf);
// HSL色彩空间变换
DirectX::XMVECTORF32 colorTransofrom = { 1.0f, 1.0f, 1.0f, 1.0f };
if (SUCCEEDED(hr)) {
for (int i = 0; i < bmpInfo.bmiHeader.biHeight; i++) {
for (int j = 0; j < bmpInfo.bmiHeader.biWidth; j++) {
BYTE *pColor = pBuf + cbStride*i + j * nBytesPixel;
DirectX::XMVECTOR colorM = DirectX::PackedVector::XMLoadUByteN4((DirectX::PackedVector::XMUBYTEN4*)pColor);
colorM = DirectX::XMColorRGBToHSL(colorM);
colorM = DirectX::XMColorModulate(colorM, colorTransofrom);
colorM = DirectX::XMColorHSLToRGB(colorM);
DirectX::PackedVector::XMStoreUByteN4((DirectX::PackedVector::XMUBYTEN4*)pColor, colorM);
SetPixel(hdc, j, i, RGB(pColor[2], pColor[1], pColor[0]));
}
}
}
ReleaseDC(hwnd, hdc);
if (SUCCEEDED(hr)) {
MakeMemDC(hBmp, hwnd);
InvalidateRect(hwnd, NULL, TRUE);
}
hr = pFC->Release();
pIDecoderFrame->Release();
}
pDecoder->Release();
}
pFactory->Release();
}
}
HRESULT LoadBitmapFromFile(
PCWSTR uri,
UINT dweight,
UINT dheight,
ID2D1Bitmap **bitmap
)
{
HRESULT hr = S_OK;
IWICImagingFactory* pWICFactory = NULL;
IWICBitmapDecoder* pDecoder = NULL;
IWICBitmapScaler* pScaler = NULL;
IWICBitmapFrameDecode* pSource = NULL;
IWICFormatConverter* pConverter = NULL;
hr = CoCreateInstance(
CLSID_WICImagingFactory,
NULL,
CLSCTX_INPROC_SERVER,
IID_IWICImagingFactory,
(LPVOID*)&pWICFactory);
if (SUCCEEDED(hr))
{
hr = pWICFactory->CreateDecoderFromFilename(
uri,
NULL,
GENERIC_READ,
WICDecodeMetadataCacheOnLoad,
&pDecoder);
}
if (SUCCEEDED(hr))
{
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr))
{
hr = pWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
UINT oWeight, oHeight;
hr = pSource->GetSize(&oWeight, &oHeight);
if (SUCCEEDED(hr))
{
hr = pWICFactory->CreateBitmapScaler(&pScaler);
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(
pSource,
dweight,
dheight,
WICBitmapInterpolationModeCubic);
}
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(
pScaler,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
}
}
}
if (SUCCEEDED(hr))
{
hr = pRT->CreateBitmapFromWicBitmap(pConverter, bitmap);
}
Safe_Release(pWICFactory);
Safe_Release(pDecoder);
Safe_Release(pScaler);
Safe_Release(pSource);
Safe_Release(pConverter);
return hr;
}
// Create a Direct2D bitmap from the specified file name
HRESULT DemoApp::LoadBitmapFromFile(
ID2D1RenderTarget *pRenderTarget,
IWICImagingFactory *pIWICFactory,
PCWSTR uri,
UINT destinationWidth,
UINT destinationHeight,
ID2D1Bitmap **ppBitmap)
{
HRESULT hr = S_OK;
IWICBitmapDecoder *pDecoder = NULL;
IWICBitmapFrameDecode *pSource = NULL;
IWICStream *pStream = NULL;
IWICFormatConverter *pConverter = NULL;
IWICBitmapScaler *pScaler = NULL;
hr = pIWICFactory->CreateDecoderFromFilename(
uri, NULL, GENERIC_READ, WICDecodeMetadataCacheOnLoad, &pDecoder);
if (SUCCEEDED(hr))
{
// Create the initial frame
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr))
{
// Convert the image format to 32bppPBGRA
// (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
hr = pIWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
// If a new width or height was specified, create an
// IWICBitmapScaler and use it to resize the image.
if (destinationWidth != 0 || destinationHeight != 0)
{
UINT originalWidth, originalHeight;
hr = pSource->GetSize(&originalWidth, &originalHeight);
if (SUCCEEDED(hr))
{
if (destinationWidth == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationHeight) / static_cast<FLOAT>(originalHeight);
destinationWidth = static_cast<UINT>(scalar * static_cast<FLOAT>(originalWidth));
}
else if (destinationHeight == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationWidth) / static_cast<FLOAT>(originalWidth);
destinationHeight = static_cast<UINT>(scalar * static_cast<FLOAT>(originalHeight));
}
hr = pIWICFactory->CreateBitmapScaler(&pScaler);
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(
pSource,
destinationWidth,
destinationHeight,
WICBitmapInterpolationModeCubic);
}
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(
pScaler,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut);
}
}
}
else // Don't scale the image.
{
hr = pConverter->Initialize(
pSource,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut);
}
}
if (SUCCEEDED(hr))
{
// Create a Direct2D bitmap from the WIC bitmap.
hr = pRenderTarget->CreateBitmapFromWicBitmap(
pConverter,
NULL,
ppBitmap);
}
SafeRelease(&pDecoder);
SafeRelease(&pSource);
SafeRelease(&pStream);
SafeRelease(&pConverter);
SafeRelease(&pScaler);
return hr;
}
ID2D1Bitmap * BaseButton::LoadBitmap(wchar_t* sz_path)
{
ID2D1Bitmap *p_bmp=NULL;
IWICBitmapDecoder *pDecoder = NULL;
IWICBitmapFrameDecode *pSource = NULL;
IWICStream *pStream = NULL;
IWICFormatConverter *pConverter = NULL;
IWICBitmapScaler *pScaler = NULL;
HRESULT hr;
hr = g_pIWICFactory->CreateDecoderFromFilename(sz_path,NULL,GENERIC_READ,WICDecodeMetadataCacheOnLoad,&pDecoder);
if (SUCCEEDED(hr))
{
// Create the initial frame.
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr))
{
// Convert the image format to 32bppPBGRA
// (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
hr = g_pIWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
// If a new width or height was specified, create an
// IWICBitmapScaler and use it to resize the image.
UINT originalWidth, originalHeight;
hr = pSource->GetSize(&originalWidth, &originalHeight);
}
if (SUCCEEDED(hr))
{
hr =g_pIWICFactory->CreateBitmapScaler(&pScaler);
}
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(pSource,50,30,WICBitmapInterpolationModeCubic);
}
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(pScaler,GUID_WICPixelFormat32bppPBGRA,WICBitmapDitherTypeNone,NULL,0.f,WICBitmapPaletteTypeMedianCut);
}
if (SUCCEEDED(hr))
{
// Create a Direct2D bitmap from the WIC bitmap.
hr =m_pRenderTarget->CreateBitmapFromWicBitmap(pConverter,NULL,&p_bmp);
}
SafeRelease(&pDecoder);
SafeRelease(&pSource);
SafeRelease(&pStream);
SafeRelease(&pConverter);
SafeRelease(&pScaler);
// if (SUCCEEDED(hr))
// {
// return TRUE;
// }
// else
// return FALSE;
return p_bmp;
}
HRESULT YCbCrPixelFormatConverter::ConvertRgbToYCbCr(
/* [in] */ const WICRect *prc,
/* [in] */ UINT cbStride,
/* [in] */ UINT cbPixelsSize,
/* [out] */ BYTE *pbPixels)
{
HRESULT result = S_OK;
//Sanity check
WICPixelFormatGUID srcPixelFormat;
bitmapSource->GetPixelFormat(&srcPixelFormat);
if (srcPixelFormat != GUID_WICPixelFormat32bppBGRA)
{
result = E_UNEXPECTED;
return result;
}
IWICImagingFactory *codecFactory = NULL;
IWICFormatConverter *formatConverter = NULL;
if (SUCCEEDED(result))
{
result = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (LPVOID*) &codecFactory);
}
if (SUCCEEDED(result))
{
result = codecFactory->CreateFormatConverter(&formatConverter);
}
if (SUCCEEDED(result))
{
//We will convert to 24RGB first, since it is easier to convert to YCbCr from there
result = formatConverter->Initialize(bitmapSource,
GUID_WICPixelFormat24bppBGR, WICBitmapDitherTypeSolid, NULL, 1.0, WICBitmapPaletteTypeFixedWebPalette);
}
if (SUCCEEDED(result))
{
result = formatConverter->CopyPixels(prc, cbStride, cbPixelsSize, pbPixels);
}
//Since the two formats have same number of bytes, we will do an inplace conversion
UINT width, height;
if (prc == NULL)
{
if (SUCCEEDED(result))
{
result = bitmapSource->GetSize(&width, &height);
}
}
else
{
width = prc->Width;
height = prc->Height;
}
if (SUCCEEDED(result))
{
//Loop on the data and do the conversion
BYTE *curPos = NULL;
curPos = pbPixels;
for (int i = 0 ; i < height; i++)
{
for (int j = 0; j < width; j++)
{
BYTE R, G ,B;
BYTE Y, Cb, Cr;
B = *curPos;
G = *(curPos+1);
R = *(curPos+2);
//Do the maths
Y = Clamp(0, 255, (0.257*R) + (0.504*G) + (0.098*B) + 16);
Cb = Clamp(0, 255, (-0.148*R) - (0.291*G) + (0.439*B) + 128);
Cr = Clamp(0, 255, (0.439*R) - (0.368*G) - (0.071*B) + 128);
*curPos = Cr;
*(curPos+1) = Cb;
*(curPos+2) = Y;
//Advance to next pixel
curPos += 3;
}
curPos += (cbStride - (width * 3)); //Fast forward remaining part of the stride
}
}
if (formatConverter)
{
formatConverter->Release();
}
if (codecFactory)
{
codecFactory->Release();
}
return result;
}
ID2D1Bitmap* d2d::CreateBitmapFromResource(int idPic, int destinationWidth, int destinationHeight)
{
// Locate the resource.
HRSRC imageResHandle = FindResource(NULL, MAKEINTRESOURCE(idPic), L"PNG");
if (imageResHandle == nullptr)
{
return nullptr;
}
// Load the resource.
HGLOBAL imageResDataHandle = LoadResource(NULL, imageResHandle);
//If hModule is NULL, the system loads the resource from the module that was used to create the current process
HRESULT hr = imageResDataHandle ? S_OK : E_FAIL;
if (FAILED(hr))
{
return nullptr;
}
// Lock it to get a system memory pointer.
void* pImageFile = LockResource(imageResDataHandle);
if (pImageFile == nullptr)
{
return nullptr;
}
// Calculate the size.
DWORD imageFileSize = SizeofResource(NULL, imageResHandle);
if (imageFileSize == 0)
{
return nullptr;
}
// Create a WIC stream to map onto the memory.
IWICStream *pStream = nullptr;
hr = m_pWICFactory->CreateStream(&pStream);
if (FAILED(hr))
{
return nullptr;
}
// Initialize the stream with the memory pointer and size.
hr = pStream->InitializeFromMemory(reinterpret_cast<BYTE*>(pImageFile), imageFileSize);
if (FAILED(hr))
{
return nullptr;
}
// Create a decoder for the stream.
IWICBitmapDecoder *pDecoder = nullptr;
hr = m_pWICFactory->CreateDecoderFromStream(pStream, NULL, WICDecodeMetadataCacheOnLoad, &pDecoder);
if (FAILED(hr))
{
return nullptr;
}
// Create the initial frame.
IWICBitmapFrameDecode *pSource = nullptr;
hr = pDecoder->GetFrame(0, &pSource);
if (FAILED(hr))
{
return nullptr;
}
// Convert the image format to 32bppPBGRA
// (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
IWICFormatConverter *pConverter = NULL;
hr = m_pWICFactory->CreateFormatConverter(&pConverter);
if (FAILED(hr))
{
return nullptr;
}
// If a new width or height was specified, create an
// IWICBitmapScaler and use it to resize the image.
if (destinationWidth != 0 || destinationHeight != 0)
{
UINT originalWidth, originalHeight;
hr = pSource->GetSize(&originalWidth, &originalHeight);
if (SUCCEEDED(hr))
{
if (destinationWidth == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationHeight) / static_cast<FLOAT>(originalHeight);
destinationWidth = static_cast<UINT>(scalar * static_cast<FLOAT>(originalWidth));
}
else if (destinationHeight == 0)
{
FLOAT scalar = static_cast<FLOAT>(destinationWidth) / static_cast<FLOAT>(originalWidth);
destinationHeight = static_cast<UINT>(scalar * static_cast<FLOAT>(originalHeight));
}
IWICBitmapScaler *pScaler = nullptr;
hr = m_pWICFactory->CreateBitmapScaler(&pScaler);
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(pSource,destinationWidth,destinationHeight,WICBitmapInterpolationModeCubic);
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(pScaler,GUID_WICPixelFormat32bppPBGRA,WICBitmapDitherTypeNone,NULL,0.f,WICBitmapPaletteTypeMedianCut);
}
}
SafeRelease(pScaler);
}
}
else
{
hr = pConverter->Initialize(pSource, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.f, WICBitmapPaletteTypeMedianCut);
}
if (FAILED(hr))
{
return nullptr;
}
//create a Direct2D bitmap from the WIC bitmap.
ID2D1Bitmap* resBitmap = nullptr;
hr = m_pRenderTarget->CreateBitmapFromWicBitmap(pConverter, NULL, &resBitmap);
if (FAILED(hr) || resBitmap == nullptr)
{
return nullptr;
}
SafeRelease(pDecoder);
SafeRelease(pSource);
SafeRelease(pStream);
SafeRelease(pConverter);
pokerlog << "CreateBitmapFromResource " << idPic << " OK." << endl;
return resBitmap;
}
HRESULT CRMTexture::Create( std::wstring path )
{
IWICImagingFactory* imageFactory = CRMTextureManager::GetInstance()->GetImageFactory();
IWICBitmapDecoder* bitmapDecoder = nullptr;
HRESULT hr = S_OK;
// 디코더 생성
hr = imageFactory->CreateDecoderFromFilename( path.c_str(), nullptr, GENERIC_READ,
WICDecodeMetadataCacheOnDemand, &bitmapDecoder );
if(FAILED(hr))
return hr;
// 디코더에서 프레임 추출
IWICBitmapFrameDecode* bitmapFrameDecode = nullptr;
hr = bitmapDecoder->GetFrame( 0, &bitmapFrameDecode );
if(FAILED(hr))
{
SafeRelease(bitmapDecoder);
return hr;
}
IWICFormatConverter* formatConverter = nullptr;
// 프레임을 기반으로 컨버터 생성
hr = imageFactory->CreateFormatConverter( &formatConverter );
if(FAILED(hr))
{
SafeRelease(bitmapFrameDecode);
SafeRelease(bitmapDecoder);
return hr;
}
hr = formatConverter->Initialize( bitmapFrameDecode,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone, nullptr, 0.0f,
WICBitmapPaletteTypeCustom );
if(FAILED(hr))
{
SafeRelease(bitmapFrameDecode);
SafeRelease(bitmapDecoder);
}
hr = CRMRender::GetInstance()->GetRenderTarget()->CreateBitmapFromWicBitmap(formatConverter, nullptr, &m_D2D1Bitmap);
if(FAILED(hr))
{
SafeRelease(bitmapFrameDecode);
SafeRelease(bitmapDecoder);
}
m_Width = m_D2D1Bitmap->GetSize().width;
m_Height = m_D2D1Bitmap->GetSize().height;
SafeRelease( bitmapFrameDecode );
SafeRelease( bitmapDecoder );
return hr;
}
HRESULT touchmind::Context::LoadResourceBitmap(ID2D1RenderTarget *pRenderTarget, IWICImagingFactory *pIWICFactory,
PCWSTR resourceName, PCWSTR resourceType, UINT destinationWidth,
UINT destinationHeight, ID2D1Bitmap **ppBitmap) {
#ifdef TOUCHMIND_CONTEXT_DEBUG
LOG_ENTER;
#endif
HRESULT hr = S_OK;
IWICBitmapDecoder *pDecoder = nullptr;
IWICBitmapFrameDecode *pSource = nullptr;
IWICStream *pStream = nullptr;
IWICFormatConverter *pConverter = nullptr;
IWICBitmapScaler *pScaler = nullptr;
HRSRC imageResHandle = nullptr;
HGLOBAL imageResDataHandle = nullptr;
void *pImageFile = nullptr;
DWORD imageFileSize = 0;
imageResHandle = FindResourceW(HINST_THISCOMPONENT, resourceName, resourceType);
hr = imageResHandle ? S_OK : E_FAIL;
if (SUCCEEDED(hr)) {
imageResDataHandle = LoadResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageResDataHandle ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr)) {
pImageFile = LockResource(imageResDataHandle);
hr = pImageFile ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr)) {
imageFileSize = SizeofResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageFileSize ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr)) {
hr = pIWICFactory->CreateStream(&pStream);
#ifdef DEBUG_GPU_RESOURCE
LOG(SEVERITY_LEVEL_INFO) << L"[GPU RESOURCE] IWICStream = [" << std::hex << pStream << L"]" << std::dec;
#endif
}
if (SUCCEEDED(hr)) {
hr = pStream->InitializeFromMemory(reinterpret_cast<BYTE *>(pImageFile), imageFileSize);
}
if (SUCCEEDED(hr)) {
hr = pIWICFactory->CreateDecoderFromStream(pStream, nullptr, WICDecodeMetadataCacheOnLoad, &pDecoder);
#ifdef DEBUG_GPU_RESOURCE
LOG(SEVERITY_LEVEL_INFO) << L"[GPU RESOURCE] IWICBitmapDecoder = [" << std::hex << pDecoder << L"]" << std::dec;
#endif
}
if (SUCCEEDED(hr)) {
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr)) {
hr = pIWICFactory->CreateFormatConverter(&pConverter);
#ifdef DEBUG_GPU_RESOURCE
LOG(SEVERITY_LEVEL_INFO) << L"[GPU RESOURCE] IWICFormatConverter = [" << std::hex << pConverter << L"]" << std::dec;
#endif
}
if (SUCCEEDED(hr)) {
if (destinationWidth != 0 || destinationHeight != 0) {
UINT originalWidth, originalHeight;
hr = pSource->GetSize(&originalWidth, &originalHeight);
if (SUCCEEDED(hr)) {
if (destinationWidth == 0) {
FLOAT scalar = static_cast<FLOAT>(destinationHeight) / static_cast<FLOAT>(originalHeight);
destinationWidth = static_cast<UINT>(scalar * static_cast<FLOAT>(originalWidth));
} else if (destinationHeight == 0) {
FLOAT scalar = static_cast<FLOAT>(destinationWidth) / static_cast<FLOAT>(originalWidth);
destinationHeight = static_cast<UINT>(scalar * static_cast<FLOAT>(originalHeight));
}
hr = pIWICFactory->CreateBitmapScaler(&pScaler);
#ifdef DEBUG_GPU_RESOURCE
LOG(SEVERITY_LEVEL_INFO) << L"[GPU RESOURCE] IWICBitmapScaler = [" << std::hex << pScaler << L"]" << std::dec;
#endif
if (SUCCEEDED(hr)) {
hr = pScaler->Initialize(pSource, destinationWidth, destinationHeight, WICBitmapInterpolationModeCubic);
if (SUCCEEDED(hr)) {
hr = pConverter->Initialize(pScaler, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, nullptr, 0.f,
WICBitmapPaletteTypeMedianCut);
}
}
}
} else {
hr = pConverter->Initialize(pSource, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, nullptr, 0.f,
WICBitmapPaletteTypeMedianCut);
}
}
if (SUCCEEDED(hr)) {
hr = pRenderTarget->CreateBitmapFromWicBitmap(pConverter, nullptr, ppBitmap);
#ifdef DEBUG_OUTPUT_GPU_RESOURCE
LOG(SEVERITY_LEVEL_INFO) << L"[GPU RESOURCE] ID2D1Bitmap = [" << std::hex << *ppBitmap << L"]" << std::dec;
#endif
}
SafeRelease(&pDecoder);
SafeRelease(&pSource);
SafeRelease(&pStream);
SafeRelease(&pConverter);
SafeRelease(&pScaler);
#ifdef TOUCHMIND_CONTEXT_DEBUG
LOG_LEAVE_HRESULT(hr);
#endif
return hr;
}
/// <summary>
/// Load an image from a resource into a buffer
/// </summary>
/// <param name="resourceName">name of image resource to load</param>
/// <param name="resourceType">type of resource to load</param>
/// <param name="cOutputBuffer">size of output buffer, in bytes</param>
/// <param name="outputBuffer">buffer that will hold the loaded image</param>
/// <returns>S_OK on success, otherwise failure code</returns>
HRESULT KinectEasyGrabber::LoadResourceImage(
PCWSTR resourceName,
PCWSTR resourceType,
DWORD cOutputBuffer,
BYTE* outputBuffer
)
{
HRESULT hr = S_OK;
IWICImagingFactory* pIWICFactory = NULL;
IWICBitmapDecoder* pDecoder = NULL;
IWICBitmapFrameDecode* pSource = NULL;
IWICStream* pStream = NULL;
IWICFormatConverter* pConverter = NULL;
IWICBitmapScaler* pScaler = NULL;
HRSRC imageResHandle = NULL;
HGLOBAL imageResDataHandle = NULL;
void *pImageFile = NULL;
DWORD imageFileSize = 0;
hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (LPVOID*)&pIWICFactory);
if ( FAILED(hr) ) return hr;
// Locate the resource.
imageResHandle = FindResourceW(HINST_THISCOMPONENT, resourceName, resourceType);
hr = imageResHandle ? S_OK : E_FAIL;
if (SUCCEEDED(hr))
{
// Load the resource.
imageResDataHandle = LoadResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageResDataHandle ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Lock it to get a system memory pointer.
pImageFile = LockResource(imageResDataHandle);
hr = pImageFile ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Calculate the size.
imageFileSize = SizeofResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageFileSize ? S_OK : E_FAIL;
}
if (SUCCEEDED(hr))
{
// Create a WIC stream to map onto the memory.
hr = pIWICFactory->CreateStream(&pStream);
}
if (SUCCEEDED(hr))
{
// Initialize the stream with the memory pointer and size.
hr = pStream->InitializeFromMemory(
reinterpret_cast<BYTE*>(pImageFile),
imageFileSize
);
}
if (SUCCEEDED(hr))
{
// Create a decoder for the stream.
hr = pIWICFactory->CreateDecoderFromStream(
pStream,
NULL,
WICDecodeMetadataCacheOnLoad,
&pDecoder
);
}
if (SUCCEEDED(hr))
{
// Create the initial frame.
hr = pDecoder->GetFrame(0, &pSource);
}
if (SUCCEEDED(hr))
{
// Convert the image format to 32bppPBGRA
// (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
hr = pIWICFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
hr = pIWICFactory->CreateBitmapScaler(&pScaler);
}
if (SUCCEEDED(hr))
{
hr = pScaler->Initialize(
pSource,
m_colorWidth,
m_colorHeight,
WICBitmapInterpolationModeCubic
);
}
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(
pScaler,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
}
UINT width = 0;
UINT height = 0;
if (SUCCEEDED(hr))
{
hr = pConverter->GetSize(&width, &height);
}
// make sure the output buffer is large enough
if (SUCCEEDED(hr))
{
if ( width*height*cBytesPerPixel > cOutputBuffer )
{
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
hr = pConverter->CopyPixels(NULL, width*cBytesPerPixel, cOutputBuffer, outputBuffer);
}
SafeRelease(pScaler);
SafeRelease(pConverter);
SafeRelease(pSource);
SafeRelease(pDecoder);
SafeRelease(pStream);
SafeRelease(pIWICFactory);
return hr;
}
//@https://msdn.microsoft.com/de-de/library/windows/desktop/dd756686(v=vs.85).aspx
HRESULT BitmapDecoder::LoadBitmapFromFile(ID2D1RenderTarget * pRenderTarget, PCWSTR uri, ID2D1Bitmap ** ppBitmap)
{
IWICImagingFactory* pFactory;
HRESULT hr = CoCreateInstance(CLSID_WICImagingFactory,
NULL,
CLSCTX_INPROC_SERVER,
IID_IWICImagingFactory,
(LPVOID*)&pFactory
);
//IWICStream *pStream = NULL; //?
//IWICBitmapScaler *pScaler = NULL; //?
IWICBitmapDecoder *pDecoder = NULL;
if (SUCCEEDED(hr))
{
hr = pFactory->CreateDecoderFromFilename(uri, NULL, GENERIC_READ, WICDecodeMetadataCacheOnLoad, &pDecoder);
}
IWICBitmapFrameDecode *pSource = NULL;
if (SUCCEEDED(hr))
{
hr = pDecoder->GetFrame(0, &pSource);
}
IWICFormatConverter *pConverter = NULL;
if (SUCCEEDED(hr))
{
hr = pFactory->CreateFormatConverter(&pConverter);
}
if (SUCCEEDED(hr))
{
hr = pConverter->Initialize(
pSource,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
}
if (SUCCEEDED(hr))
{
pRenderTarget->CreateBitmapFromWicBitmap(pConverter, NULL, ppBitmap);
}
if (pDecoder != nullptr)
{
pDecoder->Release();//SafeRelease(&pDecoder);
}
if (pSource != nullptr)
{
pSource->Release();
}
//SafeRelease(&pSource);
// pStream->Release();//SafeRelease(&pStream);
if(pConverter!= nullptr)
{
pConverter->Release();
}
//SafeRelease(&pConverter);
// pScaler->Release();//SafeRelease(&pScaler);
if (pFactory != nullptr)
{
pFactory->Release();
}
return hr;
}
HRESULT ImageLoader::loadImageResource(ID2D1RenderTarget *pRenderTarget, LPCWSTR szName, ID2D1Bitmap **lpOut)
{
HRESULT hr;
HRSRC imageResHandle = NULL;
HGLOBAL imageResDataHandle = NULL;
void *pImageFile = NULL;
DWORD imageFileSize = 0;
IWICBitmapDecoder *pDecoder = NULL;
IWICBitmapFrameDecode *pSource = NULL;
IWICStream *pStream = NULL;
IWICFormatConverter *pConverter;
ID2D1Bitmap *pImage;
imageResHandle = FindResource(HINST_THISCOMPONENT, szName, L"Image");
hr = imageResHandle ? S_OK : E_FAIL;
if (FAILED(hr)) {
goto cleanup;
}
imageResDataHandle = LoadResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageResHandle ? S_OK : E_FAIL;
if (FAILED(hr)) {
goto cleanup;
}
// Lock it to get a system memory pointer.
pImageFile = LockResource(imageResDataHandle);
hr = pImageFile ? S_OK : E_FAIL;
if (FAILED(hr)) {
goto cleanup;
}
imageFileSize = SizeofResource(HINST_THISCOMPONENT, imageResHandle);
hr = imageFileSize ? S_OK : E_FAIL;
if (FAILED(hr)) {
goto cleanup;
}
hr = m_pImagingFactory->CreateStream(&pStream);
if (FAILED(hr)) {
goto cleanup;
}
hr = pStream->InitializeFromMemory(
reinterpret_cast<BYTE*>(pImageFile),
imageFileSize
);
if (FAILED(hr)) {
goto cleanup;
}
hr = m_pImagingFactory->CreateDecoderFromStream(pStream, NULL,
WICDecodeMetadataCacheOnDemand, &pDecoder);
if (FAILED(hr)) {
goto cleanup;
}
hr = pDecoder->GetFrame(0, &pSource);
if (FAILED(hr)) {
goto cleanup;
}
hr = m_pImagingFactory->CreateFormatConverter(&pConverter);
if (FAILED(hr)) {
goto cleanup;
}
hr = pConverter->Initialize(
pSource,
GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherTypeNone,
NULL,
0.f,
WICBitmapPaletteTypeMedianCut
);
if (FAILED(hr)) {
goto cleanup;
}
hr = pRenderTarget->CreateBitmapFromWicBitmap(pConverter, NULL, &pImage);
if (FAILED(hr)) {
goto cleanup;
}
*lpOut = pImage;
cleanup:
SafeRelease(&pConverter);
SafeRelease(&pStream);
SafeRelease(&pDecoder);
SafeRelease(&pSource);
return hr;
}
