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; }