/*************************************************************************/
/* Copyright (C) 1999 Microsoft Corporation */
/* File: capture.cpp */
/* Description: Convert a captured DVD frame from YUV formats to RGB, */
/* and save to file in various formats. */
/* Author: phillu */
/*************************************************************************/
#include "stdafx.h"
// This version of capture is for Millennium where GDI+ is installed
#include "MSWebDVD.h"
#include "msdvd.h"
#include <initguid.h>
#include "imaging.h"
#include <shlobj.h>
// YUV FourCC Formats (byte-swapped). We support a subset of them.
// Ref: http://www.webartz.com/fourcc/
// packed formats
#define FourCC_IYU1 '1UYI'
#define FourCC_IYU2 '2UYI'
#define FourCC_UYVY 'YVYU' // supported
#define FourCC_UYNV 'VNYU' // supported
#define FourCC_cyuv 'vuyc'
#define FourCC_YUY2 '2YUY' // supported
#define FourCC_YUNV 'VNUY' // supported
#define FourCC_YVYU 'UYVY' // supported
#define FourCC_Y41P 'P14Y'
#define FourCC_Y211 '112Y'
#define FourCC_Y41T 'T14Y'
#define FourCC_Y42T 'T24Y'
#define FourCC_CLJR 'RJLC'
// planar formats
#define FourCC_YVU9 '9UVY'
#define FourCC_IF09 '90FI'
#define FourCC_YV12 '21VY' // supported
#define FourCC_I420 '024I'
#define FourCC_IYUV 'VUYI'
#define FourCC_CLPL 'LPLC'
// global variables
IImagingFactory* g_pImgFact = NULL; // pointer to IImageingFactory object
// helper: calls release on a Non-NULL pointer, and sets it to NULL
#define SAFE_RELEASE(ptr) \
{ \
if (ptr) \
{ \
ptr->Release(); \
ptr = NULL; \
} \
}
extern CComModule _Module;
///////////////////////////////////////////////////////////////////////////
// This block of code handles saving a GDI+ image object to a file,
// allowing user to select a format.
///////////////////////////////////////////////////////////////////////////
//
// Save the current image to a file
//
static HRESULT
SaveImageFile(IImage *pImage, const TCHAR* filename, const CLSID* clsid)
{
USES_CONVERSION;
HRESULT hr = S_OK;
if (!pImage || !g_pImgFact)
return E_FAIL;
// Create an encoder object
IImageEncoder* encoder = NULL;
hr = g_pImgFact->CreateImageEncoderToFile(clsid, T2CW(filename), &encoder);
if (FAILED(hr))
return hr;
// Get an IImageSink interface to the encoder
IImageSink* sink = NULL;
hr = encoder->GetEncodeSink(&sink);
if (SUCCEEDED(hr))
{
hr = pImage->PushIntoSink(sink);
SAFE_RELEASE(sink);
}
encoder->TerminateEncoder();
SAFE_RELEASE(encoder);
return hr;
}
//
// Compose a file type filter string given an array of
// ImageCodecInfo structures; also find the index of JPG format
//
static TCHAR*
MakeFilterFromCodecs(UINT count, const ImageCodecInfo* codecs, UINT *jpgIndex)
{
USES_CONVERSION;
// Figure out the total size of the filter string
UINT index, size;
for (index=size=0; index < count; index++)
{
size += wcslen(codecs[index].FormatDescription) + 1
+ wcslen(codecs[index].FilenameExtension) + 1;
}
size += 1; // for the double trailing '\0'
// Allocate memory
TCHAR *filter = (TCHAR*) malloc(size*sizeof(TCHAR));
UINT strSize = size;
if (!filter)
return NULL;
TCHAR* p = filter;
const WCHAR* ws;
*jpgIndex = 0;
LPCTSTR strTemp = NULL;
for (index=0; index < count; index++)
{
ws = codecs[index].FormatDescription;
size = wcslen(ws) + 1;
strTemp = W2CT(ws);
if (NULL != strTemp)
{
lstrcpyn(p, strTemp, strSize - lstrlen(p));
p += size;
}
ws = codecs[index].FilenameExtension;
size = wcslen(ws) + 1;
strTemp = W2CT(ws);
if (NULL != strTemp)
{
lstrcpyn(p, strTemp, strSize - lstrlen(p));
p += size;
}
// find the index of jpg format
if (wcsstr(ws, L"JPG"))
{
*jpgIndex = index + 1;
}
}
*((TCHAR*) p) = _T('\0');
return filter;
}
//
// Save image file
//
static HRESULT
SaveFileDialog(HWND hwnd, IImage *pImage)
{
USES_CONVERSION;
HRESULT hr = S_OK;
OPENFILENAME ofn;
TCHAR filename[MAX_PATH];
TCHAR FolderPath[MAX_PATH];
const ciBufSize = 256;
TCHAR titlestring[ciBufSize];
// get the path of "My Pictures" and use it as default location
if (SHGetSpecialFolderPath(NULL, FolderPath, CSIDL_MYPICTURES, FALSE) == FALSE)
{
// if My Pictures doesn't exist, try My Documents
if (SHGetSpecialFolderPath(NULL, FolderPath, CSIDL_PERSONAL, FALSE) == FALSE)
{
// use current directory as last resort
lstrcpyn(FolderPath, _T("."), sizeof(FolderPath) / sizeof(FolderPath[0]));
}
}
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwnd;
ofn.hInstance = _Module.m_hInstResource;
ofn.lpstrFile = filename;
ofn.lpstrDefExt = _T("jpg"); // it appears it doesn't matter what string to use
// it will use the ext in lpstrFilter according to selected type.
ofn.nMaxFile = MAX_PATH;
::LoadString(_Module.m_hInstResource, IDS_SAVE_FILE, titlestring, ciBufSize);
ofn.lpstrTitle = titlestring;
ofn.lpstrInitialDir = FolderPath;
ofn.Flags = OFN_CREATEPROMPT | OFN_OVERWRITEPROMPT | OFN_EXPLORER;
lstrcpyn(filename, _T("capture"), sizeof(filename) / sizeof(filename[0]));
// Make up the file type filter string
ImageCodecInfo* codecs;
UINT count;
hr = g_pImgFact->GetInstalledEncoders(&count, &codecs);
if (FAILED(hr))
return hr;
UINT jpgIndex;
TCHAR* filter = MakeFilterFromCodecs(count, codecs, &jpgIndex);
if (!filter)
{
hr = HRESULT_FROM_WIN32(GetLastError());
return hr;
}
else
{
ofn.lpstrFilter = filter;
ofn.nFilterIndex = jpgIndex; // set format to JPG as default
// Present the file/save dialog
if (GetSaveFileName(&ofn))
{
UINT index = ofn.nFilterIndex;
if (index == 0 || index > count)
index = 0;
else
index--;
hr = SaveImageFile(pImage, filename, &codecs[index].Clsid);
}
free(filter);
}
CoTaskMemFree(codecs);
return hr;
}
///////////////////////////////////////////////////////////////////////
// This block of code deals with converting YUV format to RGB bitmap
///////////////////////////////////////////////////////////////////////
inline BYTE Clamp(float x)
{
if (x < 0.0f)
return 0;
else if (x > 255.0f)
return 255;
else
return (BYTE)(x + 0.5f);
}
// Convert YUV to ARGB
static inline ARGB ConvertPixelToARGB(int y, int u, int v)
{
//
// This equation was taken from Video Demystified (2nd Edition)
// by Keith Jack, page 43.
//
BYTE red = Clamp((1.1644f * (y-16)) + (1.5960f * (v-128)) );
BYTE grn = Clamp((1.1644f * (y-16)) - (0.8150f * (v-128)) - (0.3912f * (u-128)));
BYTE blu = Clamp((1.1644f * (y-16)) + (2.0140f * (u-128)));
return MAKEARGB(0xff, red, grn, blu);
}
// Convert image in YUY2 format to RGB bitmap
static void ConvertYUY2ToBitmap(YUV_IMAGE* lpImage, BitmapData* bmpdata)
{
long y, x;
BYTE *pYUVBits;
ARGB *pARGB;
for (y = 0; y < lpImage->lHeight; y++)
{
pYUVBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + y * lpImage->lStride;
pARGB = (ARGB *)((BYTE *)(bmpdata->Scan0) + y * bmpdata->Stride);
for (x = 0; x < lpImage->lWidth; x += 2)
{
int Y0 = (int) *pYUVBits++;
int U0 = (int) *pYUVBits++;
int Y1 = (int) *pYUVBits++;
int V0 = (int) *pYUVBits++;
*pARGB++ = ConvertPixelToARGB(Y0, U0, V0);
*pARGB++ = ConvertPixelToARGB(Y1, U0, V0);
}
}
}
// Convert image in UYVY format to RGB bitmap
static void ConvertUYVYToBitmap(YUV_IMAGE* lpImage, BitmapData* bmpdata)
{
long y, x;
BYTE *pYUVBits;
ARGB *pARGB;
for (y = 0; y < lpImage->lHeight; y++)
{
pYUVBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + y * lpImage->lStride;
pARGB = (ARGB *)((BYTE *)(bmpdata->Scan0) + y * bmpdata->Stride);
for (x = 0; x < lpImage->lWidth; x += 2)
{
int U0 = (int) *pYUVBits++;
int Y0 = (int) *pYUVBits++;
int V0 = (int) *pYUVBits++;
int Y1 = (int) *pYUVBits++;
*pARGB++ = ConvertPixelToARGB(Y0, U0, V0);
*pARGB++ = ConvertPixelToARGB(Y1, U0, V0);
}
}
}
// Convert image in YVYU format to RGB bitmap
static void ConvertYVYUToBitmap(YUV_IMAGE* lpImage, BitmapData* bmpdata)
{
long y, x;
BYTE *pYUVBits;
ARGB *pARGB;
for (y = 0; y < lpImage->lHeight; y++)
{
pYUVBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + y * lpImage->lStride;
pARGB = (ARGB *)((BYTE *)(bmpdata->Scan0) + y * bmpdata->Stride);
for (x = 0; x < lpImage->lWidth; x += 2)
{
int Y0 = (int) *pYUVBits++;
int V0 = (int) *pYUVBits++;
int Y1 = (int) *pYUVBits++;
int U0 = (int) *pYUVBits++;
*pARGB++ = ConvertPixelToARGB(Y0, U0, V0);
*pARGB++ = ConvertPixelToARGB(Y1, U0, V0);
}
}
}
// Convert image in YV12 format to RGB bitmap
static void ConvertYV12ToBitmap(YUV_IMAGE* lpImage, BitmapData* bmpdata)
{
long y, x;
BYTE *pYBits;
BYTE *pUBits;
BYTE *pVBits;
ARGB *pARGB;
for (y = 0; y < lpImage->lHeight; y++)
{
pYBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + y * lpImage->lStride;
pVBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + lpImage->lHeight * lpImage->lStride
+ (y/2) * (lpImage->lStride/2);
pUBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + lpImage->lHeight * lpImage->lStride
+ ((lpImage->lHeight + y)/2) * (lpImage->lStride/2);
pARGB = (ARGB *)((BYTE *)(bmpdata->Scan0) + y * bmpdata->Stride);
for (x = 0; x < lpImage->lWidth; x ++)
{
int Y0 = (int) *pYBits++;
int V0 = (int) *pVBits;
int U0 = (int) *pUBits;
// U, V are shared by 2x2 pixels. only advance pointers every two pixels
if (x&1)
{
pVBits++;
pUBits++;
}
*pARGB++ = ConvertPixelToARGB(Y0, U0, V0);
}
}
}
// Convert image in YVU9 format to RGB bitmap
static void ConvertYVU9ToBitmap(YUV_IMAGE* lpImage, BitmapData* bmpdata)
{
long y, x;
BYTE *pYBits;
BYTE *pUBits;
BYTE *pVBits;
ARGB *pARGB;
for (y = 0; y < lpImage->lHeight; y++)
{
pYBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + y * lpImage->lStride;
pVBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + lpImage->lHeight * lpImage->lStride
+ (y/4) * (lpImage->lStride/4);
pUBits = (BYTE *)lpImage + sizeof(YUV_IMAGE) + lpImage->lHeight * lpImage->lStride
+ ((lpImage->lHeight + y)/4) * (lpImage->lStride/4);
pARGB = (ARGB *)((BYTE *)(bmpdata->Scan0) + y * bmpdata->Stride);
for (x = 0; x < lpImage->lWidth; x ++)
{
int Y0 = (int) *pYBits++;
int V0 = (int) *pVBits;
int U0 = (int) *pUBits;
// U, V are shared by 4x4 pixels. only advance pointers every 4 pixels
if ((x&3) == 3)
{
pVBits++;
pUBits++;
}
*pARGB++ = ConvertPixelToARGB(Y0, U0, V0);
}
}
}
static HRESULT ConvertToBitmapImage(YUV_IMAGE *lpImage, IBitmapImage **bmp)
{
IBitmapImage* bmpimg = NULL;
BitmapData bmpdata;
HRESULT hr = S_OK;
// create a bitmap object
if (!g_pImgFact || bmp == NULL)
{
return E_FAIL;
}
hr = g_pImgFact->CreateNewBitmap(
lpImage->lWidth,
lpImage->lHeight,
PIXFMT_32BPP_ARGB,
&bmpimg);
bool fSupported = true;
if (SUCCEEDED(hr)) // bmpimg created
{
hr = bmpimg->LockBits(
NULL,
IMGLOCK_WRITE,
PIXFMT_DONTCARE,
&bmpdata);
if (SUCCEEDED(hr))
{
// convert different types of YUV formats to RGB
switch (lpImage->dwFourCC)
{
case FourCC_YUY2:
case FourCC_YUNV: // the two are equivalent
ConvertYUY2ToBitmap(lpImage, &bmpdata);
break;
case FourCC_UYVY:
case FourCC_UYNV: // equivalent
ConvertUYVYToBitmap(lpImage, &bmpdata);
break;
case FourCC_YVYU:
ConvertYVYUToBitmap(lpImage, &bmpdata);
break;
case FourCC_YV12:
ConvertYV12ToBitmap(lpImage, &bmpdata);
break;
case FourCC_YVU9:
ConvertYVU9ToBitmap(lpImage, &bmpdata);
break;
default:
fSupported = false;
break;
}
hr = bmpimg->UnlockBits(&bmpdata);
}
if (!fSupported)
{
SAFE_RELEASE(bmpimg);
hr = E_FORMAT_NOT_SUPPORTED;
}
}
*bmp = bmpimg;
// Addref() and Release() cancels out
bmpimg = NULL;
return hr;
}
#ifdef _DEBUG
static void AlertUnsupportedFormat(DWORD dwFourCC, HWND hwnd)
{
char buf[256];
StringCchPrintf(buf, sizeof(buf), "YUV format %c%c%c%c not supported\n",
dwFourCC & 0xff,
(dwFourCC >> 8) & 0xff,
(dwFourCC >> 16) & 0xff,
(dwFourCC >> 24) & 0xff);
MessageBoxA(hwnd, buf, "", MB_OK);
}
#endif
// This helper function does several things.
//
// First, it determines if clipping is necessary, return true if it is,
// and false otherwise.
//
// Second, it maps the ViewClipRect (clipping rect in the view coordinates,
// i.e. the one after correcting aspect ratio) back to the raw captured
// image coordinates. Return it in ImageClipRect. This step is skipped (and
// ImageClipRect will be invalid) if clipping is not necessary.
//
// Third, it calculates the stretched image size. It should be in the same
// aspect ratio as the ViewClipRect. It will also be made as full-size as possible
static bool ClipAndStretchSizes(YUV_IMAGE *lpImage, const RECT *pViewClipRect,
RECT *pImageClipRect, int *pViewWidth, int *pViewHeight)
{
float aspectRaw = (float)lpImage->lHeight / (float)lpImage->lWidth;
float aspectView = (float)lpImage->lAspectY / (float)lpImage->lAspectX;
int viewWidth = lpImage->lWidth;
int viewHeight = (int)(viewWidth * aspectView + 0.5f);
// the rect is given in the stretched (aspect-ratio corrected) window
// we will adjust it back to the raw image space
bool fClip = false;
if (pViewClipRect)
{
RECT rc;
rc.left = pViewClipRect->left;
rc.right = pViewClipRect->right;
rc.top = (int)(pViewClipRect->top * aspectRaw / aspectView + 0.5f);
rc.bottom = (int)(pViewClipRect->bottom * aspectRaw / aspectView + 0.5f);
RECT rcFullImage;
::SetRect(&rcFullImage, 0, 0, lpImage->lWidth, lpImage->lHeight);
if (! ::EqualRect(&rc, &rcFullImage) &&
::IntersectRect(pImageClipRect, &rc, &rcFullImage))
{
fClip = true;
}
}
// adjust the stretched image size according to the rect aspect ratio
if (fClip)
{
float aspectRect = (float)(RECTHEIGHT(pViewClipRect))
/ (float)(RECTWIDTH(pViewClipRect));
if (aspectRect < aspectView)
{
// clip rect has a wider aspect ratio.
// keep the width, adjust the height
viewHeight = (int)(viewWidth * aspectRect + 0.5f);
}
else
{
// clip rect has a taller aspect ratio.
// keep the height, adjust width
viewWidth = (int)(viewHeight / aspectRect + 0.5f);
}
}
*pViewWidth = viewWidth;
*pViewHeight = viewHeight;
return fClip;
}
/////////////////////////////////////////////////////////////////////////////
//
// ConvertImageAndSave: this is the main function to be called by the player.
//
// Convert a captured YUV image to a GDI BitmapImage, and save it to a file
// allowing user to choose file format and file name.
// The clipping rectangle should be in the full size view coordinate system
// with corrected aspect ratio (i.e. 720x540 for 4:3).
HRESULT GDIConvertImageAndSave(YUV_IMAGE *lpImage, RECT *pViewClipRect, HWND hwnd)
{
IBitmapImage* bmpimg = NULL;
IBitmapImage* bmpStretched = NULL;
HRESULT hr = S_OK;
// Create an IImagingFactory object
hr = CoCreateInstance(
CLSID_ImagingFactory,
NULL,
CLSCTX_INPROC_SERVER,
IID_IImagingFactory,
(VOID**) &g_pImgFact);
if (FAILED(hr))
{
return hr;
}
hr = ConvertToBitmapImage(lpImage, &bmpimg);
#ifdef _DEBUG
if (E_FORMAT_NOT_SUPPORTED == hr)
{
AlertUnsupportedFormat(lpImage->dwFourCC, hwnd);
}
#endif
// calculate size and rectangles for clipping and stretching
int viewWidth, viewHeight; // size of the clipped and stretch image
bool fClip; // is clipping necessary
RECT rcClipImage; // view clipping rect mapped to image space
fClip = ClipAndStretchSizes(lpImage, pViewClipRect, &rcClipImage,
&viewWidth, &viewHeight);
// crop the image to the clip rectangle.
if (SUCCEEDED(hr) && fClip) // by now we have valid bits in bmpimg
{
IBasicBitmapOps *bmpops = NULL;
IBitmapImage* bmpClipped = NULL;
hr = bmpimg->QueryInterface(IID_IBasicBitmapOps, (VOID**) &bmpops);
if (SUCCEEDED(hr))
{
hr = bmpops->Clone(&rcClipImage, &bmpClipped);
SAFE_RELEASE(bmpops);
}
if (SUCCEEDED(hr)) // valid bmpClipped
{
// replace bmpimg with bmpClipped
SAFE_RELEASE(bmpimg);
bmpimg = bmpClipped;
bmpimg->AddRef();
SAFE_RELEASE(bmpClipped);
}
}
// stretch the image to the right aspect ratio
if (SUCCEEDED(hr)) // valid bits in bmpimg
{
IImage *image = NULL;
hr = bmpimg->QueryInterface(IID_IImage, (VOID**) &image);
if (SUCCEEDED(hr))
{
hr = g_pImgFact->CreateBitmapFromImage(
image,
viewWidth,
viewHeight,
PIXFMT_DONTCARE,
INTERP_BILINEAR,
&bmpStretched);
SAFE_RELEASE(image);
}
SAFE_RELEASE(bmpimg);
}
// save final bitmap to a file
if (SUCCEEDED(hr)) // bmpStretched valid
{
IImage *image = NULL;
hr = bmpStretched->QueryInterface(IID_IImage, (VOID**) &image);
if (SUCCEEDED(hr))
{
hr = SaveFileDialog(hwnd, image);
SAFE_RELEASE(image);
}
SAFE_RELEASE(bmpStretched);
}
// clean up, release the imaging factory
SAFE_RELEASE(g_pImgFact);
return hr;
}