CImage implicitly converting grayscale PNG images to 32bpp ARGB - mfc

Question

I am using the ATL:CImage class to decode png images.
But the images are getting converted to RGBA (4 byte per pixel) images when loaded.
ATL:CImage img;
img.Load((LPCTSTR)("test.png")); // 8bit grayscale
after a successful load the m_nBPP member is 32 (aka 4 byte) and the m_bHasAlphaChannel is true. But they should be 8 and false.
Due to the implicit conversion we need to convert the RGBA back to 8BPP manually. I am processing more than 400 images. So this is a major slow down for the application.
On Visual Studio forum I read that this is an issue in the GDI+ as its implicitly converting all grayscale PNG images to 32bpp ARGB.
Is there a workaround for this?

Answer 1

If you want control, use the Windows Imaging Component. You'll need to create a Decoder and retrieve the image frame(s) you're interested in. PNG support is outlined at PNG Format Overview.
The following sample code opens a grayscale PNG image, and displays information about the media:
#include <windows.h>
#include <wincodec.h>
#pragma comment(lib, "Windowscodecs.lib")
#include <iostream>
int main() {
::CoInitialize( NULL );
Create the factory COM server:
IWICImagingFactory* pFactory = NULL;
HRESULT hr = ::CoCreateInstance( CLSID_WICImagingFactory,
NULL,
CLSCTX_INPROC_SERVER,
IID_IWICImagingFactory,
(void**)&pFactory );
Create a decoder based on the image source:
IWICBitmapDecoder* pDecoder = NULL;
if ( SUCCEEDED( hr ) ) {
hr = pFactory->CreateDecoderFromFilename( L"test.png",
NULL,
GENERIC_READ,
WICDecodeMetadataCacheOnDemand,
&pDecoder );
}
Although PNG files always contain a single image, there are image formats, that allow to store several images in a single file. In general you will have to query the frame count and iterate over all frames, decoding one after another:
UINT frameCount = 0;
if ( SUCCEEDED( hr ) ) {
hr = pDecoder->GetFrameCount( &frameCount );
}
if ( SUCCEEDED( hr ) ) {
std::wcout << L"Framecount: " << frameCount << std::endl;
for ( UINT frameIndex = 0; frameIndex < frameCount; ++frameIndex ) {
std::wcout << std::endl << L"Frame " << frameIndex << L":" << std::endl;
IWICBitmapFrameDecode* pFrame = NULL;
hr = pDecoder->GetFrame( frameIndex, &pFrame );
Dump image dimensions for illustration purposes:
if ( SUCCEEDED( hr ) ) {
UINT width = 0, height = 0;
hr = pFrame->GetSize( &width, &height );
if ( SUCCEEDED( hr ) ) {
std::wcout << L" width: " << width <<
L", height: " << height << std::endl;
}
}
To verify that the image data has not been altered, dump both bpp and channel count information:
if ( SUCCEEDED( hr ) ) {
WICPixelFormatGUID pixelFormat = { 0 };
pFrame->GetPixelFormat( &pixelFormat );
if ( SUCCEEDED( hr ) ) {
// Translate pixelformat to bpp
IWICComponentInfo* pComponentInfo = NULL;
hr = pFactory->CreateComponentInfo( pixelFormat, &pComponentInfo );
IWICPixelFormatInfo* pPixelFormatInfo = NULL;
if ( SUCCEEDED( hr ) ) {
hr = pComponentInfo->QueryInterface( &pPixelFormatInfo );
}
UINT bpp = 0;
if ( SUCCEEDED( hr ) ) {
hr = pPixelFormatInfo->GetBitsPerPixel( &bpp );
}
if ( SUCCEEDED( hr ) ) {
std::wcout << L" bpp: " << bpp << std::endl;
}
UINT channelCount = 0;
if ( SUCCEEDED( hr ) ) {
hr = pPixelFormatInfo->GetChannelCount( &channelCount );
}
if ( SUCCEEDED( hr ) ) {
std::wcout << L" Channel Count: " << channelCount << std::endl;
}
// Cleanup
if ( pPixelFormatInfo != NULL ) { pPixelFormatInfo->Release(); }
if ( pComponentInfo != NULL ) { pComponentInfo->Release(); }
}
}
The remainder is resource cleanup:
// Cleanup
if ( pFrame != NULL ) { pFrame->Release(); }
}
}
// Cleanup
if ( pDecoder != NULL ) { pDecoder->Release(); }
if ( pFactory != NULL ) { pFactory->Release(); }
return 0;
}
Running this code against this image
produces the following output:
Framecount: 1
Frame 0:
width: 50, height: 50
bpp: 8
Channel Count: 1