961 lines
20 KiB
C++
961 lines
20 KiB
C++
|
//
|
||
|
|
// Simple test program for imaging library
|
||
|
|
//
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <stdarg.h>
|
||
|
|
#include <windows.h>
|
||
|
|
#include <objbase.h>
|
||
|
|
#include <urlmon.h>
|
||
|
|
#include <commdlg.h>
|
||
|
|
|
||
|
|
#include <imaging.h>
|
||
|
|
#include <initguid.h>
|
||
|
|
#include <imgguids.h>
|
||
|
|
|
||
|
|
CHAR* programName; // program name
|
||
|
|
HINSTANCE appInstance; // handle to the application instance
|
||
|
|
HWND hwndMain; // handle to application's main window
|
||
|
|
IImagingFactory* imgfact; // pointer to IImageingFactory object
|
||
|
|
IImage* curimage; // pointer to IImage object
|
||
|
|
CHAR curFilename[MAX_PATH]; // current image filename
|
||
|
|
IImageDecoder *decoder;
|
||
|
|
IBitmapImage *bitmap;
|
||
|
|
ImageInfo imageinfo;
|
||
|
|
BOOL hastimedimension, loopingset, viewagain;
|
||
|
|
UINT numframes, lastsuccframe, currentframe, delay;
|
||
|
|
INT loopcount;
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Display an error message dialog
|
||
|
|
//
|
||
|
|
|
||
|
|
BOOL
|
||
|
|
CheckHRESULT(
|
||
|
|
HRESULT hr,
|
||
|
|
INT line
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
return TRUE;
|
||
|
|
|
||
|
|
CHAR buf[1024];
|
||
|
|
|
||
|
|
sprintf(buf, "Error on line %d: 0x%x\n", line, hr);
|
||
|
|
MessageBoxA(hwndMain, buf, programName, MB_OK);
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
#define CHECKHR(hr) CheckHRESULT(hr, __LINE__)
|
||
|
|
#define LASTWIN32HRESULT HRESULT_FROM_WIN32(GetLastError())
|
||
|
|
|
||
|
|
#if DBG
|
||
|
|
#define VERBOSE(args) printf args
|
||
|
|
#else
|
||
|
|
#define VERBOSE(args)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Helper class to convert ANSI strings to Unicode strings
|
||
|
|
//
|
||
|
|
|
||
|
|
inline BOOL
|
||
|
|
UnicodeToAnsiStr(
|
||
|
|
const WCHAR* unicodeStr,
|
||
|
|
CHAR* ansiStr,
|
||
|
|
INT ansiSize
|
||
|
|
)
|
||
|
|
{
|
||
|
|
return WideCharToMultiByte(
|
||
|
|
CP_ACP,
|
||
|
|
0,
|
||
|
|
unicodeStr,
|
||
|
|
-1,
|
||
|
|
ansiStr,
|
||
|
|
ansiSize,
|
||
|
|
NULL,
|
||
|
|
NULL) > 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline BOOL
|
||
|
|
AnsiToUnicodeStr(
|
||
|
|
const CHAR* ansiStr,
|
||
|
|
WCHAR* unicodeStr,
|
||
|
|
INT unicodeSize
|
||
|
|
)
|
||
|
|
{
|
||
|
|
return MultiByteToWideChar(
|
||
|
|
CP_ACP,
|
||
|
|
0,
|
||
|
|
ansiStr,
|
||
|
|
-1,
|
||
|
|
unicodeStr,
|
||
|
|
unicodeSize) > 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
class UnicodeStrFromAnsi
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
UnicodeStrFromAnsi(const CHAR* ansiStr)
|
||
|
|
{
|
||
|
|
if (ansiStr == NULL)
|
||
|
|
{
|
||
|
|
valid = TRUE;
|
||
|
|
unicodeStr = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// NOTE: we only handle strings with length < MAX_PATH.
|
||
|
|
|
||
|
|
valid = AnsiToUnicodeStr(ansiStr, buf, MAX_PATH);
|
||
|
|
unicodeStr = valid ? buf : NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL IsValid() const
|
||
|
|
{
|
||
|
|
return valid;
|
||
|
|
}
|
||
|
|
|
||
|
|
operator WCHAR*()
|
||
|
|
{
|
||
|
|
return unicodeStr;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
BOOL valid;
|
||
|
|
WCHAR* unicodeStr;
|
||
|
|
WCHAR buf[MAX_PATH];
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Convert current image to a bitmap image
|
||
|
|
//
|
||
|
|
|
||
|
|
IBitmapImage*
|
||
|
|
ConvertImageToBitmap(
|
||
|
|
IImage* image,
|
||
|
|
INT width = 0,
|
||
|
|
INT height = 0,
|
||
|
|
PixelFormatID pixfmt = PIXFMT_DONTCARE,
|
||
|
|
InterpolationHint hint = INTERP_DEFAULT
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if (!image)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
HRESULT hr;
|
||
|
|
IBitmapImage* bmp;
|
||
|
|
|
||
|
|
hr = image->QueryInterface(IID_IBitmapImage, (VOID**) &bmp);
|
||
|
|
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
SIZE size;
|
||
|
|
PixelFormatID fmt;
|
||
|
|
|
||
|
|
// Current image is already a bitmap image and
|
||
|
|
// its dimension and pixel format are already as expected
|
||
|
|
|
||
|
|
hr = bmp->GetSize(&size);
|
||
|
|
if (!CHECKHR(hr))
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
hr = bmp->GetPixelFormatID(&fmt);
|
||
|
|
if (!CHECKHR(hr))
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
if ((width == 0 || size.cx == width) &&
|
||
|
|
(height == 0 || size.cy == height) &&
|
||
|
|
(pixfmt == PIXFMT_DONTCARE || pixfmt == fmt))
|
||
|
|
{
|
||
|
|
return bmp;
|
||
|
|
}
|
||
|
|
|
||
|
|
bmp->Release();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Convert the current image to a bitmap image
|
||
|
|
|
||
|
|
if (width == 0 && height == 0)
|
||
|
|
{
|
||
|
|
ImageInfo imageInfo;
|
||
|
|
hr = image->GetImageInfo(&imageInfo);
|
||
|
|
|
||
|
|
// If the source image is scalable, then compute
|
||
|
|
// the appropriate pixel dimension for the bitmap
|
||
|
|
|
||
|
|
if (SUCCEEDED(hr) && (imageInfo.Flags & IMGFLAG_SCALABLE))
|
||
|
|
{
|
||
|
|
width = (INT) (96.0 * imageInfo.Width / imageInfo.Xdpi + 0.5);
|
||
|
|
height = (INT) (96.0 * imageInfo.Height / imageInfo.Ydpi + 0.5);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
hr = imgfact->CreateBitmapFromImage(
|
||
|
|
image,
|
||
|
|
width,
|
||
|
|
height,
|
||
|
|
pixfmt,
|
||
|
|
hint,
|
||
|
|
&bmp);
|
||
|
|
|
||
|
|
return SUCCEEDED(hr) ? bmp : NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Get pixel format strings
|
||
|
|
//
|
||
|
|
|
||
|
|
const CHAR*
|
||
|
|
GetPixelFormatStr(
|
||
|
|
PixelFormatID pixfmt
|
||
|
|
)
|
||
|
|
{
|
||
|
|
switch (pixfmt)
|
||
|
|
{
|
||
|
|
case PIXFMT_8BPP_INDEXED: return "8bpp indexed";
|
||
|
|
case PIXFMT_16BPP_GRAYSCALE: return "16bpp grayscale";
|
||
|
|
case PIXFMT_16BPP_RGB555: return "16bpp RGB 5-5-5";
|
||
|
|
case PIXFMT_16BPP_RGB565: return "16bpp RGB 5-6-5";
|
||
|
|
case PIXFMT_16BPP_ARGB1555: return "16bpp ARGB 1-5-5-5";
|
||
|
|
case PIXFMT_24BPP_RGB: return "24bpp RGB";
|
||
|
|
case PIXFMT_32BPP_RGB: return "32bpp RGB";
|
||
|
|
case PIXFMT_32BPP_ARGB: return "32bpp ARGB";
|
||
|
|
case PIXFMT_32BPP_PARGB: return "32bpp premultiplied ARGB";
|
||
|
|
case PIXFMT_48BPP_RGB: return "48bpp RGB";
|
||
|
|
case PIXFMT_64BPP_ARGB: return "64bpp ARGB";
|
||
|
|
case PIXFMT_64BPP_PARGB: return "64bpp premultiplied ARGB";
|
||
|
|
case PIXFMT_UNDEFINED:
|
||
|
|
default: return "Unknown";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Force a refresh of the image window
|
||
|
|
//
|
||
|
|
|
||
|
|
inline VOID RefreshImageDisplay()
|
||
|
|
{
|
||
|
|
InvalidateRect(hwndMain, NULL, FALSE);
|
||
|
|
|
||
|
|
// Update window title
|
||
|
|
|
||
|
|
CHAR title[2*MAX_PATH];
|
||
|
|
CHAR* p = title;
|
||
|
|
|
||
|
|
strcpy(p, curFilename);
|
||
|
|
|
||
|
|
SetWindowText(hwndMain, title);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Decodes the specified frame and sets it up for drawing
|
||
|
|
//
|
||
|
|
HRESULT
|
||
|
|
DrawFrame(UINT frame)
|
||
|
|
{
|
||
|
|
HRESULT hresult;
|
||
|
|
|
||
|
|
if (hastimedimension)
|
||
|
|
{
|
||
|
|
if (numframes != -1 && frame > numframes)
|
||
|
|
{
|
||
|
|
return IMGERR_NOFRAME;
|
||
|
|
}
|
||
|
|
|
||
|
|
GUID guid = FRAMEDIM_TIME;
|
||
|
|
hresult = decoder->SelectActiveFrame(&guid, frame);
|
||
|
|
if (FAILED(hresult))
|
||
|
|
return hresult;
|
||
|
|
|
||
|
|
lastsuccframe = frame;
|
||
|
|
|
||
|
|
IPropertySetStorage *propsetstorage;
|
||
|
|
hresult = decoder->GetProperties(&propsetstorage);
|
||
|
|
if (FAILED(hresult))
|
||
|
|
propsetstorage = NULL;
|
||
|
|
|
||
|
|
IPropertyStorage *propstorage;
|
||
|
|
if (propsetstorage)
|
||
|
|
{
|
||
|
|
hresult = propsetstorage->Open(FMTID_ImageInformation, STGM_READ |
|
||
|
|
STGM_SHARE_EXCLUSIVE, &propstorage);
|
||
|
|
if (FAILED(hresult))
|
||
|
|
propstorage = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (propstorage)
|
||
|
|
{
|
||
|
|
PROPSPEC propspec[2];
|
||
|
|
PROPVARIANT propvariant[2];
|
||
|
|
|
||
|
|
propspec[0].ulKind = PRSPEC_LPWSTR;
|
||
|
|
propspec[0].lpwstr = L"Frame delay";
|
||
|
|
propspec[1].ulKind = PRSPEC_LPWSTR;
|
||
|
|
propspec[1].lpwstr = L"Loop count";
|
||
|
|
|
||
|
|
hresult = propstorage->ReadMultiple(2, propspec, propvariant);
|
||
|
|
propstorage->Release();
|
||
|
|
if (SUCCEEDED(hresult))
|
||
|
|
{
|
||
|
|
if (propvariant[0].vt != VT_EMPTY)
|
||
|
|
delay = propvariant[0].uiVal;
|
||
|
|
else
|
||
|
|
delay = 0;
|
||
|
|
|
||
|
|
if (!loopingset)
|
||
|
|
{
|
||
|
|
if (propvariant[1].vt != VT_EMPTY)
|
||
|
|
{
|
||
|
|
loopcount = propvariant[1].iVal;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
loopcount = 0;
|
||
|
|
}
|
||
|
|
loopingset = TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
delay = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
IImageSink *sink;
|
||
|
|
bitmap->QueryInterface(IID_IImageSink, (void**)&sink);
|
||
|
|
|
||
|
|
hresult = decoder->BeginDecode(sink, NULL);
|
||
|
|
sink->Release();
|
||
|
|
if (FAILED(hresult))
|
||
|
|
return hresult;
|
||
|
|
|
||
|
|
hresult = decoder->Decode();
|
||
|
|
if (FAILED(hresult))
|
||
|
|
return hresult;
|
||
|
|
|
||
|
|
hresult = decoder->EndDecode(S_OK);
|
||
|
|
if (FAILED(hresult))
|
||
|
|
return hresult;
|
||
|
|
|
||
|
|
if (curimage)
|
||
|
|
{
|
||
|
|
curimage->Release();
|
||
|
|
curimage = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
bitmap->QueryInterface(IID_IImage, (void**)&curimage);
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Sets us the app for decompressing multiple frames
|
||
|
|
//
|
||
|
|
|
||
|
|
VOID
|
||
|
|
SetCurrentImage()
|
||
|
|
{
|
||
|
|
HRESULT hresult;
|
||
|
|
|
||
|
|
hresult = decoder->GetImageInfo(&imageinfo);
|
||
|
|
if (FAILED(hresult))
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (bitmap)
|
||
|
|
{
|
||
|
|
bitmap->Release();
|
||
|
|
bitmap = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
imgfact->CreateNewBitmap(imageinfo.Width, imageinfo.Height, PIXFMT_32BPP_ARGB, &bitmap);
|
||
|
|
|
||
|
|
UINT count;
|
||
|
|
GUID *dimensions;
|
||
|
|
|
||
|
|
hastimedimension = FALSE;
|
||
|
|
|
||
|
|
hresult = decoder->QueryFrameDimensions(&count, &dimensions);
|
||
|
|
if (SUCCEEDED(hresult))
|
||
|
|
{
|
||
|
|
for (UINT i=0;i<count;i++)
|
||
|
|
{
|
||
|
|
if (dimensions[i] == FRAMEDIM_TIME)
|
||
|
|
{
|
||
|
|
hastimedimension = TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (hresult != E_NOTIMPL) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
DrawFrame(0);
|
||
|
|
SetTimer(hwndMain, 0, delay*10, NULL);
|
||
|
|
|
||
|
|
RefreshImageDisplay();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Resize the window so it fits the image
|
||
|
|
//
|
||
|
|
|
||
|
|
#define MINWINWIDTH 200
|
||
|
|
#define MINWINHEIGHT 100
|
||
|
|
#define MAXWINWIDTH 1024
|
||
|
|
#define MAXWINHEIGHT 768
|
||
|
|
|
||
|
|
VOID
|
||
|
|
DoSizeWindowToFit(
|
||
|
|
HWND hwnd,
|
||
|
|
BOOL strict = FALSE
|
||
|
|
)
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
IBitmapImage* bmp;
|
||
|
|
SIZE size;
|
||
|
|
|
||
|
|
// Check if the current image is a bitmap image
|
||
|
|
// in that case, we'll get the pixel dimension
|
||
|
|
|
||
|
|
hr = curimage->QueryInterface(IID_IBitmapImage, (VOID**) &bmp);
|
||
|
|
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
hr = bmp->GetSize(&size);
|
||
|
|
bmp->Release();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Otherwise, try to get device-independent image dimension
|
||
|
|
|
||
|
|
if (FAILED(hr))
|
||
|
|
{
|
||
|
|
hr = curimage->GetPhysicalDimension(&size);
|
||
|
|
if (FAILED(hr))
|
||
|
|
return;
|
||
|
|
|
||
|
|
size.cx = (INT) (size.cx * 96.0 / 2540.0 + 0.5);
|
||
|
|
size.cy = (INT) (size.cy * 96.0 / 2540.0 + 0.5);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
// Figure out window border dimensions
|
||
|
|
|
||
|
|
RECT r1, r2;
|
||
|
|
INT w, h;
|
||
|
|
|
||
|
|
w = size.cx;
|
||
|
|
h = size.cy;
|
||
|
|
|
||
|
|
if (!strict)
|
||
|
|
{
|
||
|
|
if (w < MINWINWIDTH)
|
||
|
|
w = MINWINWIDTH;
|
||
|
|
else if (w > MAXWINWIDTH)
|
||
|
|
w = MAXWINWIDTH;
|
||
|
|
|
||
|
|
if (h < MINWINHEIGHT)
|
||
|
|
h = MINWINHEIGHT;
|
||
|
|
else if (h > MAXWINHEIGHT)
|
||
|
|
h = MAXWINHEIGHT;
|
||
|
|
}
|
||
|
|
|
||
|
|
GetWindowRect(hwnd, &r1);
|
||
|
|
GetClientRect(hwnd, &r2);
|
||
|
|
|
||
|
|
w += (r1.right - r1.left) - (r2.right - r2.left);
|
||
|
|
h += (r1.bottom - r1.top) - (r2.bottom - r2.top);
|
||
|
|
|
||
|
|
// Resize the window
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
SetWindowPos(
|
||
|
|
hwnd,
|
||
|
|
NULL,
|
||
|
|
0, 0,
|
||
|
|
w, h,
|
||
|
|
SWP_NOMOVE | SWP_NOZORDER);
|
||
|
|
|
||
|
|
GetClientRect(hwnd, &r2);
|
||
|
|
h += GetSystemMetrics(SM_CYMENU);
|
||
|
|
}
|
||
|
|
while (r2.bottom == 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create an image object from a file
|
||
|
|
//
|
||
|
|
|
||
|
|
VOID
|
||
|
|
OpenImageFile(
|
||
|
|
const CHAR* filename
|
||
|
|
)
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
IStream* stream;
|
||
|
|
|
||
|
|
// Use URLMON.DLL to turn file into stream
|
||
|
|
|
||
|
|
CHAR fullpath[MAX_PATH];
|
||
|
|
CHAR* p;
|
||
|
|
|
||
|
|
if (!GetFullPathName(filename, MAX_PATH, fullpath, &p))
|
||
|
|
return;
|
||
|
|
|
||
|
|
hr = URLOpenBlockingStreamA(NULL, fullpath, &stream, 0, NULL);
|
||
|
|
|
||
|
|
if (!CHECKHR(hr))
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (decoder)
|
||
|
|
{
|
||
|
|
decoder->TerminateDecoder();
|
||
|
|
decoder->Release();
|
||
|
|
decoder = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
hr = imgfact->CreateImageDecoder(stream, DECODERINIT_NONE, &decoder);
|
||
|
|
stream->Release();
|
||
|
|
|
||
|
|
// Set the new image as the current image
|
||
|
|
|
||
|
|
if (CHECKHR(hr))
|
||
|
|
{
|
||
|
|
SetCurrentImage();
|
||
|
|
DoSizeWindowToFit(hwndMain);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Handle window repaint event
|
||
|
|
//
|
||
|
|
|
||
|
|
VOID
|
||
|
|
DoPaint(
|
||
|
|
HWND hwnd
|
||
|
|
)
|
||
|
|
{
|
||
|
|
HDC hdc;
|
||
|
|
PAINTSTRUCT ps;
|
||
|
|
RECT rect;
|
||
|
|
DWORD timer;
|
||
|
|
HRESULT hr = E_FAIL;
|
||
|
|
|
||
|
|
hdc = BeginPaint(hwnd, &ps);
|
||
|
|
|
||
|
|
GetClientRect(hwnd, &rect);
|
||
|
|
|
||
|
|
SetStretchBltMode(hdc, COLORONCOLOR);
|
||
|
|
|
||
|
|
timer = GetTickCount();
|
||
|
|
|
||
|
|
IBitmapImage* bmp;
|
||
|
|
|
||
|
|
bmp = ConvertImageToBitmap(
|
||
|
|
curimage,
|
||
|
|
rect.right,
|
||
|
|
rect.bottom,
|
||
|
|
PIXFMT_32BPP_ARGB,
|
||
|
|
INTERP_BICUBIC);
|
||
|
|
|
||
|
|
if (!bmp)
|
||
|
|
goto endPaint;
|
||
|
|
|
||
|
|
//VERBOSE(("Stretch time: %dms, ", GetTickCount() - timer));
|
||
|
|
|
||
|
|
IImage* image;
|
||
|
|
|
||
|
|
hr = bmp->QueryInterface(IID_IImage, (VOID**) &image);
|
||
|
|
bmp->Release();
|
||
|
|
|
||
|
|
if (FAILED(hr))
|
||
|
|
goto endPaint;
|
||
|
|
|
||
|
|
//timer = GetTickCount();
|
||
|
|
hr = image->Draw(hdc, &rect, NULL);
|
||
|
|
//VERBOSE(("GDI time: %dms\n", GetTickCount() - timer));
|
||
|
|
|
||
|
|
image->Release();
|
||
|
|
|
||
|
|
endPaint:
|
||
|
|
|
||
|
|
if (FAILED(hr))
|
||
|
|
FillRect(hdc, &rect, (HBRUSH) GetStockObject(BLACK_BRUSH));
|
||
|
|
|
||
|
|
EndPaint(hwnd, &ps);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Compose a file type filter string given an array of
|
||
|
|
// ImageCodecInfo structures
|
||
|
|
//
|
||
|
|
|
||
|
|
#define SizeofWSTR(s) (sizeof(WCHAR) * (wcslen(s) + 1))
|
||
|
|
#define SizeofSTR(s) (strlen(s) + 1)
|
||
|
|
|
||
|
|
CHAR*
|
||
|
|
MakeFilterFromCodecs(
|
||
|
|
UINT count,
|
||
|
|
const ImageCodecInfo* codecs,
|
||
|
|
BOOL open
|
||
|
|
)
|
||
|
|
{
|
||
|
|
static const CHAR allFiles[] = "All Files\0*.*\0";
|
||
|
|
|
||
|
|
// Figure out the total size of the filter string
|
||
|
|
|
||
|
|
UINT index, size;
|
||
|
|
|
||
|
|
for (index=size=0; index < count; index++)
|
||
|
|
{
|
||
|
|
size += SizeofWSTR(codecs[index].FormatDescription) +
|
||
|
|
SizeofWSTR(codecs[index].FilenameExtension);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (open)
|
||
|
|
size += sizeof(allFiles);
|
||
|
|
|
||
|
|
size += sizeof(CHAR);
|
||
|
|
|
||
|
|
// Allocate memory
|
||
|
|
|
||
|
|
CHAR *filter = (CHAR*) malloc(size);
|
||
|
|
CHAR* p = filter;
|
||
|
|
const WCHAR* ws;
|
||
|
|
|
||
|
|
if (!filter)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
for (index=0; index < count; index++)
|
||
|
|
{
|
||
|
|
ws = codecs[index].FormatDescription;
|
||
|
|
size = SizeofWSTR(ws);
|
||
|
|
|
||
|
|
if (UnicodeToAnsiStr(ws, p, size))
|
||
|
|
p += SizeofSTR(p);
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
|
||
|
|
ws = codecs[index].FilenameExtension;
|
||
|
|
size = SizeofWSTR(ws);
|
||
|
|
|
||
|
|
if (UnicodeToAnsiStr(ws, p, size))
|
||
|
|
p += SizeofSTR(p);
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (index < count)
|
||
|
|
{
|
||
|
|
free(filter);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (open)
|
||
|
|
{
|
||
|
|
size = sizeof(allFiles);
|
||
|
|
memcpy(p, allFiles, size);
|
||
|
|
p += size;
|
||
|
|
}
|
||
|
|
|
||
|
|
*((CHAR*) p) = '\0';
|
||
|
|
return filter;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Open image file
|
||
|
|
//
|
||
|
|
|
||
|
|
VOID
|
||
|
|
DoOpen(
|
||
|
|
HWND hwnd
|
||
|
|
)
|
||
|
|
{
|
||
|
|
OPENFILENAME ofn;
|
||
|
|
CHAR filename[MAX_PATH];
|
||
|
|
|
||
|
|
ZeroMemory(&ofn, sizeof(ofn));
|
||
|
|
|
||
|
|
ofn.lStructSize = sizeof(ofn);
|
||
|
|
ofn.hwndOwner = hwnd;
|
||
|
|
ofn.hInstance = appInstance;
|
||
|
|
ofn.lpstrFile = filename;
|
||
|
|
ofn.nMaxFile = MAX_PATH;
|
||
|
|
ofn.lpstrTitle = "Open Image File";
|
||
|
|
ofn.lpstrInitialDir = ".";
|
||
|
|
ofn.Flags = OFN_FILEMUSTEXIST;
|
||
|
|
filename[0] = '\0';
|
||
|
|
|
||
|
|
// Make up the file type filter string
|
||
|
|
|
||
|
|
HRESULT hr;
|
||
|
|
ImageCodecInfo* codecs;
|
||
|
|
UINT count;
|
||
|
|
|
||
|
|
hr = imgfact->GetInstalledDecoders(&count, &codecs);
|
||
|
|
|
||
|
|
if (!CHECKHR(hr))
|
||
|
|
return;
|
||
|
|
|
||
|
|
CHAR* filter = MakeFilterFromCodecs(count, codecs, TRUE);
|
||
|
|
|
||
|
|
if (codecs)
|
||
|
|
CoTaskMemFree(codecs);
|
||
|
|
|
||
|
|
if (!filter)
|
||
|
|
{
|
||
|
|
CHECKHR(LASTWIN32HRESULT);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
ofn.lpstrFilter = filter;
|
||
|
|
|
||
|
|
// Present the file/open dialog
|
||
|
|
|
||
|
|
if (GetOpenFileName(&ofn))
|
||
|
|
OpenImageFile(filename);
|
||
|
|
|
||
|
|
free(filter);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
//Figures out which frame to draw next and draws it.
|
||
|
|
//
|
||
|
|
|
||
|
|
void
|
||
|
|
NextFrame()
|
||
|
|
{
|
||
|
|
BOOL tryagain = TRUE;
|
||
|
|
while (tryagain)
|
||
|
|
{
|
||
|
|
tryagain = FALSE;
|
||
|
|
HRESULT hresult = DrawFrame(currentframe);
|
||
|
|
if (SUCCEEDED(hresult))
|
||
|
|
{
|
||
|
|
if (viewagain)
|
||
|
|
currentframe++;
|
||
|
|
}
|
||
|
|
else if (hresult == IMGERR_NOFRAME)
|
||
|
|
{
|
||
|
|
if (currentframe > 0)
|
||
|
|
{
|
||
|
|
if (loopcount != 0)
|
||
|
|
{
|
||
|
|
if (loopcount > 0)
|
||
|
|
loopcount--;
|
||
|
|
currentframe = 0;
|
||
|
|
tryagain = TRUE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
currentframe--;
|
||
|
|
tryagain = TRUE;
|
||
|
|
viewagain = FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
printf("No frames are displayable.\n");
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Window callback procedure
|
||
|
|
//
|
||
|
|
|
||
|
|
LRESULT CALLBACK
|
||
|
|
MyWindowProc(
|
||
|
|
HWND hwnd,
|
||
|
|
UINT uMsg,
|
||
|
|
WPARAM wParam,
|
||
|
|
LPARAM lParam
|
||
|
|
)
|
||
|
|
{
|
||
|
|
switch (uMsg)
|
||
|
|
{
|
||
|
|
case WM_KEYDOWN:
|
||
|
|
//For debugging
|
||
|
|
//NextFrame();
|
||
|
|
|
||
|
|
//RefreshImageDisplay();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WM_PAINT:
|
||
|
|
DoPaint(hwnd);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WM_DESTROY:
|
||
|
|
PostQuitMessage(0);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WM_TIMER:
|
||
|
|
{
|
||
|
|
KillTimer(hwndMain, 0);
|
||
|
|
|
||
|
|
NextFrame();
|
||
|
|
|
||
|
|
RefreshImageDisplay();
|
||
|
|
|
||
|
|
if (viewagain)
|
||
|
|
SetTimer(hwndMain, 0, delay*10, NULL);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create main application window
|
||
|
|
//
|
||
|
|
|
||
|
|
#define MYWNDCLASSNAME "AniTest"
|
||
|
|
|
||
|
|
VOID
|
||
|
|
CreateMainWindow(
|
||
|
|
VOID
|
||
|
|
)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Register window class
|
||
|
|
//
|
||
|
|
|
||
|
|
WNDCLASS wndClass =
|
||
|
|
{
|
||
|
|
CS_HREDRAW|CS_VREDRAW,
|
||
|
|
MyWindowProc,
|
||
|
|
0,
|
||
|
|
0,
|
||
|
|
appInstance,
|
||
|
|
LoadIcon(NULL, IDI_APPLICATION),
|
||
|
|
LoadCursor(NULL, IDC_ARROW),
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
MYWNDCLASSNAME
|
||
|
|
};
|
||
|
|
|
||
|
|
RegisterClass(&wndClass);
|
||
|
|
|
||
|
|
hwndMain = CreateWindow(
|
||
|
|
MYWNDCLASSNAME,
|
||
|
|
MYWNDCLASSNAME,
|
||
|
|
WS_OVERLAPPEDWINDOW,
|
||
|
|
CW_USEDEFAULT,
|
||
|
|
CW_USEDEFAULT,
|
||
|
|
CW_USEDEFAULT,
|
||
|
|
CW_USEDEFAULT,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
appInstance,
|
||
|
|
NULL);
|
||
|
|
|
||
|
|
if (!hwndMain)
|
||
|
|
{
|
||
|
|
CHECKHR(HRESULT_FROM_WIN32(GetLastError()));
|
||
|
|
exit(-1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Main program entrypoint
|
||
|
|
//
|
||
|
|
|
||
|
|
INT _cdecl
|
||
|
|
main(
|
||
|
|
INT argc,
|
||
|
|
CHAR **argv
|
||
|
|
)
|
||
|
|
{
|
||
|
|
programName = *argv++;
|
||
|
|
argc--;
|
||
|
|
appInstance = GetModuleHandle(NULL);
|
||
|
|
CoInitialize(NULL);
|
||
|
|
|
||
|
|
bitmap = NULL;
|
||
|
|
decoder = NULL;
|
||
|
|
numframes = -1;
|
||
|
|
lastsuccframe = -1;
|
||
|
|
currentframe = 0;
|
||
|
|
loopingset = FALSE;
|
||
|
|
viewagain = TRUE;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create an IImagingFactory object
|
||
|
|
//
|
||
|
|
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
hr = CoCreateInstance(
|
||
|
|
CLSID_ImagingFactory,
|
||
|
|
NULL,
|
||
|
|
CLSCTX_INPROC_SERVER,
|
||
|
|
IID_IImagingFactory,
|
||
|
|
(VOID**) &imgfact);
|
||
|
|
|
||
|
|
if (!CHECKHR(hr))
|
||
|
|
exit(-1);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create the main application window
|
||
|
|
//
|
||
|
|
|
||
|
|
CreateMainWindow();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create a test image
|
||
|
|
//
|
||
|
|
|
||
|
|
if (argc != 0)
|
||
|
|
OpenImageFile(*argv);
|
||
|
|
|
||
|
|
if (!curimage)
|
||
|
|
exit(-1);
|
||
|
|
|
||
|
|
DoSizeWindowToFit(hwndMain);
|
||
|
|
ShowWindow(hwndMain, SW_SHOW);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Main message loop
|
||
|
|
//
|
||
|
|
|
||
|
|
MSG msg;
|
||
|
|
|
||
|
|
while (GetMessage(&msg, NULL, 0, 0))
|
||
|
|
{
|
||
|
|
TranslateMessage(&msg);
|
||
|
|
DispatchMessage(&msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
imgfact->Release();
|
||
|
|
|
||
|
|
CoUninitialize();
|
||
|
|
return (INT)(msg.wParam);
|
||
|
|
}
|