Windows2003-3790/enduser/netmeeting/av/nmcap/capture.cpp
2020-09-30 16:53:55 +02:00

1795 lines
58 KiB
C++

#include <objbase.h>
#include <qos.h>
#include <winsock2.h>
#define INITGUID // Only do this in one file
#include "capture.h"
#include "frameop.h"
#include "filters.h"
#include <confdbg.h>
#include <avutil.h>
#include "..\nac\utils.h"
#include "vidinout.h"
#include "vcmstrm.h"
CCaptureChain::CCaptureChain(void)
{
m_opchain = NULL;
m_filterchain = NULL;
m_filtertags = NULL;
InitializeCriticalSection(&m_capcs);
}
CCaptureChain::~CCaptureChain(void)
{
CFrameOp *pchain;
EnterCriticalSection(&m_capcs);
pchain = m_opchain;
m_opchain = NULL;
LeaveCriticalSection(&m_capcs);
if (pchain)
pchain->Release();
DeleteCriticalSection(&m_capcs);
}
STDMETHODIMP
CCaptureChain::GrabFrame(
IBitmapSurface** ppBS
)
{
CFrameOp *cfo;
HRESULT hres;
*ppBS = NULL;
EnterCriticalSection(&m_capcs);
if (m_opchain) {
m_opchain->AddRef(); // lock chain - prevents chain from being released
cfo = m_opchain;
while (cfo && ((hres = cfo->DoOp(ppBS)) == NOERROR)) {
cfo = cfo->m_next;
}
if (*ppBS && hres != NOERROR) {
// failed conversion, so discard last pBSin frame
(*ppBS)->Release();
*ppBS = NULL;
}
m_opchain->Release(); // unlock chain
}
else
hres = E_UNEXPECTED;
LeaveCriticalSection(&m_capcs);
return hres;
}
typedef struct _CONVERTINFO
{
long ci_width;
long ci_height;
long ci_dstwidth;
long ci_dstheight;
long ci_delta;
long ci_UVDownSampling;
long ci_ZeroingDWORD;
void (*ci_Copy) (LPBYTE *, LPBYTE *);
RGBQUAD ci_colortable[1];
} CONVERTINFO, FAR* PCONVERTINFO;
#ifdef ENABLE_ZOOM_CODE
typedef struct _rv
{
long x_i;
long p;
long p1;
} ROW_VALUES;
typedef struct _ZOOMCONVERTINFO
{
long ci_width;
long ci_height;
long ci_dstwidth;
long ci_dstheight;
ROW_VALUES *ci_rptr;
RGBQUAD ci_colortable[1];
} ZOOMCONVERTINFO, FAR* PZOOMCONVERTINFO;
#endif // ENABLE_ZOOM_CODE
// sub worker routines for conversion of RGB16, RGB24 and RGB32 to RGB24
BYTE Byte16[32] = {0,8,16,25,33,41,49,58,66,74,82,91,99,107,115,123,132,140,148,156,165,173,
181,189,197,206,214,222,230,239,247,255};
void Copy16(LPBYTE *ppsrc, LPBYTE *ppdst)
{
DWORD tmp;
tmp = *(WORD *)(*ppsrc);
*(*ppdst)++ = Byte16[tmp & 31]; // blue
*(*ppdst)++ = Byte16[(tmp >> 5) & 31]; // green
*(*ppdst)++ = Byte16[(tmp >> 10) & 31]; // red
*ppsrc += 2;
}
void Copy24(LPBYTE *ppsrc, LPBYTE *ppdst)
{
*(*ppdst)++ = *(*ppsrc)++; // blue
*(*ppdst)++ = *(*ppsrc)++; // green
*(*ppdst)++ = *(*ppsrc)++; // red
}
void Copy32(LPBYTE *ppsrc, LPBYTE *ppdst)
{
*(*ppdst)++ = *(*ppsrc)++; // blue
*(*ppdst)++ = *(*ppsrc)++; // green
*(*ppdst)++ = *(*ppsrc)++; // red
(*ppsrc)++;
}
// worker routine to shrink an RGB16, RGB24 or RGB32 in half (width & height)
// result is RGB24
BOOL DoHalfSize(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long x, y;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
ipitch = (ipitch * 2) - (refdata->ci_dstwidth * 2 * refdata->ci_delta);
opitch -= refdata->ci_dstwidth * 3; // bytes at end of each row
pIn = pBits;
pOut = pCvtBits;
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth; x++) {
refdata->ci_Copy(&pIn, &pOut);
pIn += refdata->ci_delta; // skip to next pixel
}
pIn += ipitch; // get to start of row after next
pOut += opitch; // get to start of next row
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink an RGB4 in half (width & height)
// result is RGB24
BOOL DoHalfSize4(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long x, y;
BYTE pixel;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
ipitch = (ipitch * 2) - refdata->ci_dstwidth;
opitch -= refdata->ci_dstwidth * 3; // bytes at end of each row
pIn = pBits;
pOut = pCvtBits;
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth; x++) {
pixel = (*pIn++/16) & 15;
*pOut++ = refdata->ci_colortable[pixel].rgbBlue;
*pOut++ = refdata->ci_colortable[pixel].rgbGreen;
*pOut++ = refdata->ci_colortable[pixel].rgbRed;
}
pIn += ipitch; // get to start of row after next
pOut += opitch; // get to start of next row
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink an RGB8 in half (width & height)
// result is RGB24
BOOL DoHalfSize8(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long x, y;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
ipitch = (ipitch * 2) - refdata->ci_dstwidth * 2;
opitch -= refdata->ci_dstwidth * 3; // bytes at end of each row
pIn = pBits;
pOut = pCvtBits;
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth; x++) {
*pOut++ = refdata->ci_colortable[*pIn].rgbBlue;
*pOut++ = refdata->ci_colortable[*pIn].rgbGreen;
*pOut++ = refdata->ci_colortable[*pIn].rgbRed;
pIn += 2;
}
pIn += ipitch; // get to start of row after next
pOut += opitch; // get to start of next row
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink a YVU9 or YUV12 in half (width & height)
// result is YVU9 or YUV12
BOOL DoHalfSizeYUVPlanar(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pIn2, pOut;
long pitch;
long x, y, w, h;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &pitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &pitch);
// Do the Y component first
pitch = refdata->ci_width * 2 - refdata->ci_dstwidth * 2; // amount to add for skip
pIn = pBits;
pOut = pCvtBits;
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth; x++) {
*pOut++ = *pIn++;
pIn++; // skip to next pixel
}
pIn += pitch; // get to start of row after next
}
// if source height is odd, then we've added 1 line too many onto pIn
if (refdata->ci_height & 1)
pIn -= refdata->ci_width;
// Do the first color component next
h = refdata->ci_dstheight / refdata->ci_UVDownSampling;
w = refdata->ci_dstwidth / refdata->ci_UVDownSampling;
pitch = refdata->ci_width / refdata->ci_UVDownSampling * 2 - w * 2;
pIn2 = pIn + refdata->ci_width / refdata->ci_UVDownSampling;
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
*pOut++ = (*pIn++ + *(++pIn) + *pIn2++ + *(++pIn2)) / 4;
}
pIn += pitch; // get to start of row after next
pIn2 += pitch; // get to start of row after next
}
// if source height is odd, then we've added 1 line too many onto pIn
if (refdata->ci_height & 1)
pIn -= refdata->ci_width / refdata->ci_UVDownSampling;
// Do the second color component next
pIn2 = pIn + refdata->ci_width / refdata->ci_UVDownSampling;
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
*pOut++ = (*pIn++ + *(++pIn) + *pIn2++ + *(++pIn2)) / 4;
}
pIn += pitch; // get to start of row after next
pIn2 += pitch; // get to start of row after next
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink a YUV packed DIB in half (width & height)
// result is YUY2, or UYVY
BOOL DoHalfSizeYUVPacked(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits;
LPDWORD pIn, pOut;
long ipitch, opitch;
long x, y;
long prelines, postlines, prebytes, postbytes, ibytes, obytes;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
pIn = (LPDWORD)pBits;
pOut = (LPDWORD)pCvtBits;
// copy one line out of two
for (y = 0; y < refdata->ci_dstheight; y++) {
// copy one pixel out of two
for (x = 0; x < refdata->ci_dstwidth / 2; x++) {
*pOut++ = *pIn++;
pIn++; // skip to next pixel
}
pIn += refdata->ci_width / 2; // skip to next line
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink an RGB16, RGB24 or RGB32 by cropping
// result is RGB24
BOOL Crop(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long extra, x, y;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
pOut = pCvtBits;
// pIn starts by skipping half of the height change
pIn = pBits + (refdata->ci_height - refdata->ci_dstheight) / 2 * ipitch;
// extra = # of source bytes per scan line that are to be cropped
extra = (refdata->ci_width - refdata->ci_dstwidth) * refdata->ci_delta;
// advance pIn by half of extra to crop left most pixels
pIn += extra / 2;
// adjust ipitch so we can add it at the end of each scan to get to start of next scan
ipitch = ipitch - (refdata->ci_width * refdata->ci_delta) + extra;
opitch -= refdata->ci_dstwidth * 3; // bytes at end of each row
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth; x++) {
refdata->ci_Copy(&pIn, &pOut);
}
pIn += ipitch; // get to start of next row
pOut += opitch; // get to start of next row
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink an RGB4 by cropping
// result is RGB24
BOOL Crop4(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long extra, x, y;
BYTE val, pixel;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
pOut = pCvtBits;
// pIn starts by skipping half of the height change
pIn = pBits + (refdata->ci_height - refdata->ci_dstheight) / 2 * ipitch;
// extra = # of source bytes per scan line that are to be cropped
extra = (refdata->ci_width - refdata->ci_dstwidth) / 2;
// advance pIn by half of extra to crop left most pixels
pIn += extra / 2;
// adjust ipitch so we can add it at the end of each scan to get to start of next scan
ipitch = ipitch - (refdata->ci_width / 2) + extra;
opitch -= refdata->ci_dstwidth * 3; // bytes at end of each row
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth/2; x++) {
val = *pIn++;
pixel = (val/16) & 15;
*pOut++ = refdata->ci_colortable[pixel].rgbBlue;
*pOut++ = refdata->ci_colortable[pixel].rgbGreen;
*pOut++ = refdata->ci_colortable[pixel].rgbRed;
pixel = val & 15;
*pOut++ = refdata->ci_colortable[pixel].rgbBlue;
*pOut++ = refdata->ci_colortable[pixel].rgbGreen;
*pOut++ = refdata->ci_colortable[pixel].rgbRed;
}
pIn += ipitch; // get to start of next row
pOut += opitch; // get to start of next row
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink an RGB8 by cropping
// result is RGB24
BOOL Crop8(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long extra, x, y;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
pOut = pCvtBits;
// pIn starts by skipping half of the height change
pIn = pBits + (refdata->ci_height - refdata->ci_dstheight) / 2 * ipitch;
// extra = # of source bytes per scan line that are to be cropped
extra = refdata->ci_width - refdata->ci_dstwidth;
// advance pIn by half of extra to crop left most pixels
pIn += extra / 2;
// adjust ipitch so we can add it at the end of each scan to get to start of next scan
ipitch = ipitch - refdata->ci_width + extra;
opitch -= refdata->ci_dstwidth * 3; // bytes at end of each row
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth; x++) {
*pOut++ = refdata->ci_colortable[*pIn].rgbBlue;
*pOut++ = refdata->ci_colortable[*pIn].rgbGreen;
*pOut++ = refdata->ci_colortable[*pIn++].rgbRed;
}
pIn += ipitch; // get to start of next row
pOut += opitch; // get to start of next row
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink a YVU9 or YUV12 by cropping
// result is YVU9 or YUV12
BOOL CropYUVPlanar(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long pitch, prelines, bytes, prebytes;
long extra, y;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &pitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &pitch);
pOut = pCvtBits;
// pIn starts by skipping half of the height change
prelines = ((refdata->ci_height - refdata->ci_dstheight) >> 1) / refdata->ci_UVDownSampling * refdata->ci_UVDownSampling;
pIn = pBits + prelines * refdata->ci_width;
// extra = # of source bytes per scan line that are to be cropped
extra = refdata->ci_width - refdata->ci_dstwidth;
prebytes = (extra >> 1) / refdata->ci_UVDownSampling * refdata->ci_UVDownSampling;
// advance pIn by half of extra to crop left most pixels
pIn += prebytes;
// Do the Y component first
pitch = extra + refdata->ci_dstwidth;
for (y = 0; y < refdata->ci_dstheight; y++) {
CopyMemory (pOut, pIn, refdata->ci_dstwidth);
pIn += pitch;
pOut += refdata->ci_dstwidth;
}
// Do the first color component next
prelines /= refdata->ci_UVDownSampling;
prebytes /= refdata->ci_UVDownSampling;
pIn = pBits + (refdata->ci_width * refdata->ci_height) + // skip Y section
prelines * refdata->ci_width / refdata->ci_UVDownSampling + // skip half of the crop lines
prebytes; // skip half of the crop pixels
pitch /= refdata->ci_UVDownSampling;
bytes = refdata->ci_dstwidth / refdata->ci_UVDownSampling;
for (y=0; y < refdata->ci_dstheight / refdata->ci_UVDownSampling; y++)
{
CopyMemory (pOut, pIn, bytes);
pIn += pitch;
pOut += bytes;
}
// Do the second color component next
pIn = pBits + (refdata->ci_width * refdata->ci_height) + // skip Y section
(refdata->ci_width * refdata->ci_height) / (refdata->ci_UVDownSampling * refdata->ci_UVDownSampling) + // skip first color component section
prelines * refdata->ci_width / refdata->ci_UVDownSampling + // skip half of the crop lines
prebytes; // skip half of the crop pixels
for (y=0; y < refdata->ci_dstheight / refdata->ci_UVDownSampling; y++)
{
CopyMemory (pOut, pIn, bytes);
pIn += pitch;
pOut += bytes;
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to shrink a YUV packed DIB by cropping
// result is YUY2 or UYVY
BOOL CropYUVPacked(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long extra, x, y;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
pOut = pCvtBits;
// pIn starts by skipping half of the height change
pIn = pBits + (refdata->ci_height - refdata->ci_dstheight) * refdata->ci_width * 2;
// extra = # of source bytes per scan line that are to be cropped
extra = (refdata->ci_width - refdata->ci_dstwidth) * 2;
// advance pIn by half of extra to crop left most pixels
pIn += extra / 2;
// adjust ipitch so we can add it at the end of each scan to get to start of next scan
ipitch = refdata->ci_width * 2;
opitch = refdata->ci_dstwidth * 2; // bytes at end of each row
for (y = 0; y < refdata->ci_dstheight; y++) {
for (x = 0; x < refdata->ci_dstwidth; x++) {
CopyMemory(pOut, pIn, refdata->ci_dstwidth * 2);
}
pIn += ipitch; // get to start of next row
pOut += opitch; // get to start of next row
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// routine to prepare for calling shrink worker routines
// it allocates and initializes a reference data structure
BOOL
InitShrink(
LPBITMAPINFOHEADER lpbmhIn,
long desiredwidth,
long desiredheight,
LPBITMAPINFOHEADER *lpbmhOut,
FRAMECONVERTPROC **convertproc,
LPVOID *refdata
)
{
PCONVERTINFO pcvt;
DWORD dwSize;
long crop_ratio, black_ratio, target_size;
*convertproc = NULL;
*refdata = NULL;
if ((lpbmhIn->biCompression != VIDEO_FORMAT_BI_RGB) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_YVU9) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_YUY2) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_UYVY) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_I420) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_IYUV))
return FALSE;
// calculate size of convertinfo struct, if we need a colortable, then add 256 entries
// else subtract off the 1 built into the struct definition
dwSize = sizeof(CONVERTINFO) - sizeof(RGBQUAD);
if (lpbmhIn->biBitCount <= 8)
dwSize += 256 * sizeof(RGBQUAD);
// for RGB, and YUV input formats, we know that the output format will never need
// an attached color table, so we can allocate lpbmhOut without one
if ((pcvt = (PCONVERTINFO)LocalAlloc(LPTR, dwSize)) &&
(*lpbmhOut = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, lpbmhIn->biSize))) {
CopyMemory(*lpbmhOut, lpbmhIn, lpbmhIn->biSize);
pcvt->ci_width = lpbmhIn->biWidth;
pcvt->ci_height = lpbmhIn->biHeight;
target_size = desiredwidth * desiredheight;
crop_ratio = pcvt->ci_width * pcvt->ci_height;
black_ratio = ((target_size - (crop_ratio / 4)) * 100) / target_size;
crop_ratio = ((crop_ratio - target_size) * 100) / crop_ratio;
if (crop_ratio < black_ratio) {
// cropping the source makes more sense
pcvt->ci_dstwidth = desiredwidth;
pcvt->ci_dstheight = desiredheight;
crop_ratio = 1; // flag that we'll crop
}
else {
// halfsizing makes more sense
pcvt->ci_dstwidth = lpbmhIn->biWidth / 2;
pcvt->ci_dstheight = lpbmhIn->biHeight / 2;
crop_ratio = 0; // flag that we'll half size
}
(*lpbmhOut)->biWidth = pcvt->ci_dstwidth;
(*lpbmhOut)->biHeight = pcvt->ci_dstheight;
// copy colortable from input bitmapinfoheader
if (lpbmhIn->biBitCount <= 8)
CopyMemory(&pcvt->ci_colortable[0], (LPBYTE)lpbmhIn + lpbmhIn->biSize, 256 * sizeof(RGBQUAD));
if (lpbmhIn->biCompression == VIDEO_FORMAT_BI_RGB) {
(*lpbmhOut)->biBitCount = 24;
(*lpbmhOut)->biSizeImage = pcvt->ci_dstwidth * pcvt->ci_dstheight * 3;
if (lpbmhIn->biBitCount == 4) {
if (crop_ratio)
*convertproc = (FRAMECONVERTPROC*)&Crop4;
else
*convertproc = (FRAMECONVERTPROC*)&DoHalfSize4;
}
else if (lpbmhIn->biBitCount == 8) {
if (crop_ratio)
*convertproc = (FRAMECONVERTPROC*)&Crop8;
else
*convertproc = (FRAMECONVERTPROC*)&DoHalfSize8;
}
else {
if (crop_ratio)
*convertproc = (FRAMECONVERTPROC*)&Crop;
else
*convertproc = (FRAMECONVERTPROC*)&DoHalfSize;
pcvt->ci_delta = lpbmhIn->biBitCount / 8;
if (lpbmhIn->biBitCount == 16) {
pcvt->ci_Copy = &Copy16;
}
else if (lpbmhIn->biBitCount == 24) {
pcvt->ci_Copy = &Copy24;
}
else if (lpbmhIn->biBitCount == 32) {
pcvt->ci_Copy = &Copy32;
}
}
}
else if (lpbmhIn->biCompression == VIDEO_FORMAT_YVU9) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = pcvt->ci_dstwidth * pcvt->ci_dstheight + (pcvt->ci_dstwidth * pcvt->ci_dstheight)/8;
if (crop_ratio)
*convertproc = (FRAMECONVERTPROC*)&CropYUVPlanar;
else
*convertproc = (FRAMECONVERTPROC*)&DoHalfSizeYUVPlanar;
pcvt->ci_UVDownSampling = 4;
}
else if ((lpbmhIn->biCompression == VIDEO_FORMAT_YUY2) || (lpbmhIn->biCompression == VIDEO_FORMAT_UYVY)) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = (DWORD)WIDTHBYTES(pcvt->ci_dstwidth * lpbmhIn->biBitCount) * pcvt->ci_dstheight;
if (crop_ratio)
*convertproc = (FRAMECONVERTPROC*)&CropYUVPacked;
else
*convertproc = (FRAMECONVERTPROC*)&DoHalfSizeYUVPacked;
}
else if ((lpbmhIn->biCompression == VIDEO_FORMAT_I420) || (lpbmhIn->biCompression == VIDEO_FORMAT_IYUV)) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = (DWORD)WIDTHBYTES(pcvt->ci_dstwidth * lpbmhIn->biBitCount) * pcvt->ci_dstheight;
if (crop_ratio)
*convertproc = (FRAMECONVERTPROC*)&CropYUVPlanar;
else
*convertproc = (FRAMECONVERTPROC*)&DoHalfSizeYUVPlanar;
pcvt->ci_UVDownSampling = 2;
}
*refdata = (LPVOID)pcvt;
return TRUE;
}
else {
if (pcvt)
LocalFree((HANDLE)pcvt);
}
return FALSE;
}
// worker routine to expand an RGB16, RGB24 or RGB32 by copying source into middle of destination
// result is RGB24
BOOL DoBlackBar(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch, oextra;
long x, y;
long prelines, postlines, prebytes, postbytes, bytes;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
prelines = (refdata->ci_dstheight - refdata->ci_height) / 2;
postlines = refdata->ci_dstheight - refdata->ci_height - prelines;
prebytes = (refdata->ci_dstwidth - refdata->ci_width) / 2;
postbytes = (refdata->ci_dstwidth - refdata->ci_width - prebytes) * 3;
prebytes *= 3;
ipitch -= refdata->ci_width * refdata->ci_delta; // bytes at end of each src row
bytes = refdata->ci_dstwidth * 3;
oextra = opitch - bytes + postbytes; // bytes at end of each dst row
pIn = pBits;
pOut = pCvtBits;
// do blank lines at front of destination
for (y = 0; y < prelines; y++) {
ZeroMemory (pOut, bytes);
pOut += opitch;
}
// copy source lines with blank space at front and rear
for (y = 0; y < refdata->ci_height; y++) {
ZeroMemory (pOut, prebytes);
pOut += prebytes;
for (x = 0; x < refdata->ci_width; x++) {
refdata->ci_Copy(&pIn, &pOut);
}
ZeroMemory (pOut, postbytes);
pIn += ipitch;
pOut += oextra;
}
// do blank lines at end of destination
for (y = 0; y < postlines; y++) {
ZeroMemory (pOut, bytes);
pOut += opitch;
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to expand an RGB4 by copying source into middle of destination
// result is RGB24
BOOL DoBlackBar4(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch, oextra;
long x, y;
long prelines, postlines, prebytes, postbytes, bytes;
BYTE val, pixel;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
prelines = (refdata->ci_dstheight - refdata->ci_height) / 2;
postlines = refdata->ci_dstheight - refdata->ci_height - prelines;
prebytes = (refdata->ci_dstwidth - refdata->ci_width) / 2;
postbytes = (refdata->ci_dstwidth - refdata->ci_width - prebytes) * 3;
prebytes *= 3;
ipitch -= refdata->ci_width/2; // bytes at end of each src row
bytes = refdata->ci_dstwidth * 3;
oextra = opitch - bytes + postbytes; // bytes at end of each dst row
pIn = pBits;
pOut = pCvtBits;
// do blank lines at front of destination
for (y = 0; y < prelines; y++) {
ZeroMemory (pOut, bytes);
pOut += opitch;
}
// copy source lines with blank space at front and rear
for (y = 0; y < refdata->ci_height; y++) {
ZeroMemory (pOut, prebytes);
pOut += prebytes;
for (x = 0; x < refdata->ci_width/2; x++) {
val = *pIn++;
pixel = (val/16) & 15;
*pOut++ = refdata->ci_colortable[pixel].rgbBlue;
*pOut++ = refdata->ci_colortable[pixel].rgbGreen;
*pOut++ = refdata->ci_colortable[pixel].rgbRed;
pixel = val & 15;
*pOut++ = refdata->ci_colortable[pixel].rgbBlue;
*pOut++ = refdata->ci_colortable[pixel].rgbGreen;
*pOut++ = refdata->ci_colortable[pixel].rgbRed;
}
ZeroMemory (pOut, postbytes);
pIn += ipitch;
pOut += oextra;
}
// do blank lines at end of destination
for (y = 0; y < postlines; y++) {
ZeroMemory (pOut, bytes);
pOut += opitch;
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to expand an RGB8 by copying source into middle of destination
// result is RGB24
BOOL DoBlackBar8(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch, oextra;
long x, y;
long prelines, postlines, prebytes, postbytes, bytes;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
prelines = (refdata->ci_dstheight - refdata->ci_height) / 2;
postlines = refdata->ci_dstheight - refdata->ci_height - prelines;
prebytes = (refdata->ci_dstwidth - refdata->ci_width) / 2;
postbytes = (refdata->ci_dstwidth - refdata->ci_width - prebytes) * 3;
prebytes *= 3;
ipitch -= refdata->ci_width; // bytes at end of each src row
bytes = refdata->ci_dstwidth * 3;
oextra = opitch - bytes + postbytes; // bytes at end of each dst row
pIn = pBits;
pOut = pCvtBits;
// do blank lines at front of destination
for (y = 0; y < prelines; y++) {
ZeroMemory (pOut, bytes);
pOut += opitch;
}
// copy source lines with blank space at front and rear
for (y = 0; y < refdata->ci_height; y++) {
ZeroMemory (pOut, prebytes);
pOut += prebytes;
for (x = 0; x < refdata->ci_width; x++) {
*pOut++ = refdata->ci_colortable[*pIn].rgbBlue;
*pOut++ = refdata->ci_colortable[*pIn].rgbGreen;
*pOut++ = refdata->ci_colortable[*pIn++].rgbRed;
}
ZeroMemory (pOut, postbytes);
pIn += ipitch;
pOut += oextra;
}
// do blank lines at end of destination
for (y = 0; y < postlines; y++) {
ZeroMemory (pOut, bytes);
pOut += opitch;
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to expand a YVU9 or YUV12 by copying source into middle of destination
// result is YVU9 or YUV12
BOOL DoBlackBarYUVPlanar(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits;
LONG prelines, postlines, bytesperpixel, prebytes, postbytes, y, bytes;
LONG prelinebytes, postlinebytes;
LPBYTE lpsrc, lpdst;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &bytes);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &bytes);
lpsrc = pBits;
lpdst = pCvtBits;
// Do the Y component first
prelines = ((refdata->ci_dstheight - refdata->ci_height) / (refdata->ci_UVDownSampling << 1)) * refdata->ci_UVDownSampling;
postlines = refdata->ci_dstheight - refdata->ci_height - prelines;
prebytes = ((refdata->ci_dstwidth - refdata->ci_width) / (refdata->ci_UVDownSampling << 1)) * refdata->ci_UVDownSampling;
postbytes = (refdata->ci_dstwidth - refdata->ci_width - prebytes);
bytes = prelines * refdata->ci_dstwidth + prebytes;
FillMemory (lpdst, bytes, 0x10);
lpdst += bytes;
bytes = refdata->ci_width;
prebytes += postbytes;
for (y=0; y < refdata->ci_height; y++)
{
MoveMemory (lpdst, lpsrc, bytes);
lpsrc += bytes;
lpdst += bytes;
FillMemory (lpdst, prebytes, 0x10);
lpdst += prebytes;
}
// already filled the prebytes of the first postline in loop above
prebytes -= postbytes;
bytes = postlines * refdata->ci_dstwidth - prebytes;
FillMemory (lpdst, bytes, (BYTE)0x10);
lpdst += bytes;
// Do the first color component next
prelines /= refdata->ci_UVDownSampling;
postlines = refdata->ci_dstheight / refdata->ci_UVDownSampling - refdata->ci_height / refdata->ci_UVDownSampling - prelines;
prebytes = prebytes / refdata->ci_UVDownSampling;
postbytes = refdata->ci_dstwidth / refdata->ci_UVDownSampling - refdata->ci_width / refdata->ci_UVDownSampling - prebytes;
prelinebytes = prelines * refdata->ci_dstwidth / refdata->ci_UVDownSampling + prebytes;
FillMemory (lpdst, prelinebytes, 0x80);
lpdst += prelinebytes;
bytes = refdata->ci_width / refdata->ci_UVDownSampling;
prebytes += postbytes;
for (y=0; y < refdata->ci_height / refdata->ci_UVDownSampling; y++)
{
MoveMemory (lpdst, lpsrc, bytes);
lpsrc += bytes;
lpdst += bytes;
FillMemory (lpdst, prebytes, 0x80);
lpdst += prebytes;
}
// already filled the prebytes of the first postline in loop above
postlinebytes = postlines * refdata->ci_dstwidth / refdata->ci_UVDownSampling - (prebytes - postbytes);
FillMemory (lpdst, postlinebytes, 0x80);
lpdst += postlinebytes;
// Do the second color component next
FillMemory (lpdst, prelinebytes, 0x80);
lpdst += prelinebytes;
for (y=0; y < refdata->ci_height / refdata->ci_UVDownSampling; y++)
{
MoveMemory (lpdst, lpsrc, bytes);
lpsrc += bytes;
lpdst += bytes;
FillMemory (lpdst, prebytes, 0x80);
lpdst += prebytes;
}
FillMemory (lpdst, postlinebytes, 0x80);
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// worker routine to expand a YUV packed DIB by copying source into middle of destination
// result is YUY2 or UYVY
BOOL DoBlackBarYUVPacked(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn, pOut;
long ipitch, opitch;
long x, y;
long prelines, postlines, prebytes, postbytes, ibytes, obytes;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &ipitch);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &opitch);
prelines = (refdata->ci_dstheight - refdata->ci_height) / 2;
postlines = refdata->ci_dstheight - refdata->ci_height - prelines;
prebytes = (refdata->ci_dstwidth - refdata->ci_width) / 2;
postbytes = (refdata->ci_dstwidth - refdata->ci_width - prebytes) / 2;
prebytes /= 2;
ibytes = refdata->ci_width * 2;
obytes = refdata->ci_dstwidth / 2;
pIn = pBits;
pOut = pCvtBits;
// do blank lines at front of destination
for (y = 0; y < prelines; y++) {
for (x = 0; x < obytes; x++) {
*(DWORD *)pOut = refdata->ci_ZeroingDWORD;
pOut += sizeof(DWORD);
}
}
// copy source lines with blank space at front and rear
for (y = 0; y < refdata->ci_height; y++) {
for (x = 0; x < prebytes; x++) {
*(DWORD *)pOut = refdata->ci_ZeroingDWORD;
pOut += sizeof(DWORD);
}
CopyMemory(pOut, pIn, ibytes);
pOut += ibytes;
pIn += ibytes;
for (x = 0; x < postbytes; x++) {
*(DWORD *)pOut = refdata->ci_ZeroingDWORD;
pOut += sizeof(DWORD);
}
}
// do blank lines at end of destination
for (y = 0; y < postlines; y++) {
for (x = 0; x < obytes; x++) {
*(DWORD *)pOut = refdata->ci_ZeroingDWORD;
pOut += sizeof(DWORD);
}
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
// routine to prepare for calling blackbar worker routines
// it allocates and initializes a reference data structure
BOOL
InitBlackbar(
LPBITMAPINFOHEADER lpbmhIn,
long desiredwidth,
long desiredheight,
LPBITMAPINFOHEADER *lpbmhOut,
FRAMECONVERTPROC **convertproc,
LPVOID *refdata
)
{
PCONVERTINFO pcvt;
DWORD dwSize;
*convertproc = NULL;
*refdata = NULL;
if ((lpbmhIn->biCompression != VIDEO_FORMAT_BI_RGB) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_YVU9) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_YUY2) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_UYVY) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_I420) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_IYUV))
return FALSE;
// calculate size of convertinfo struct, if we need a colortable, then add 256 entries
// else subtract off the 1 built into the struct definition
dwSize = sizeof(CONVERTINFO) - sizeof(RGBQUAD);
if (lpbmhIn->biBitCount <= 8)
dwSize += 256 * sizeof(RGBQUAD);
// for RGB, YUV input formats, we know that the output format will never need
// an attached color table, so we can allocate lpbmhOut without one
if ((pcvt = (PCONVERTINFO)LocalAlloc(LPTR, dwSize)) &&
(*lpbmhOut = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, lpbmhIn->biSize))) {
CopyMemory(*lpbmhOut, lpbmhIn, lpbmhIn->biSize);
pcvt->ci_width = lpbmhIn->biWidth;
pcvt->ci_height = lpbmhIn->biHeight;
pcvt->ci_dstwidth = desiredwidth;
pcvt->ci_dstheight = desiredheight;
(*lpbmhOut)->biWidth = desiredwidth;
(*lpbmhOut)->biHeight = desiredheight;
// copy colortable from input bitmapinfoheader
if (lpbmhIn->biBitCount <= 8)
CopyMemory(&pcvt->ci_colortable[0], (LPBYTE)lpbmhIn + lpbmhIn->biSize, 256 * sizeof(RGBQUAD));
if (lpbmhIn->biCompression == VIDEO_FORMAT_BI_RGB) {
(*lpbmhOut)->biBitCount = 24;
(*lpbmhOut)->biSizeImage = desiredwidth * desiredheight * 3;
if (lpbmhIn->biBitCount == 4) {
*convertproc = (FRAMECONVERTPROC*)&DoBlackBar4;
}
else if (lpbmhIn->biBitCount == 8) {
*convertproc = (FRAMECONVERTPROC*)&DoBlackBar8;
}
else {
*convertproc = (FRAMECONVERTPROC*)&DoBlackBar;
pcvt->ci_delta = lpbmhIn->biBitCount / 8;
if (lpbmhIn->biBitCount == 16) {
pcvt->ci_Copy = &Copy16;
}
else if (lpbmhIn->biBitCount == 24) {
pcvt->ci_Copy = &Copy24;
}
else if (lpbmhIn->biBitCount == 32) {
pcvt->ci_Copy = &Copy32;
}
}
}
else if (lpbmhIn->biCompression == VIDEO_FORMAT_YVU9) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = desiredwidth * desiredheight + (desiredwidth * desiredheight)/8;
*convertproc = (FRAMECONVERTPROC*)&DoBlackBarYUVPlanar;
pcvt->ci_UVDownSampling = 4;
}
else if (lpbmhIn->biCompression == VIDEO_FORMAT_YUY2) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = (DWORD)WIDTHBYTES(desiredwidth * lpbmhIn->biBitCount) * desiredheight;
pcvt->ci_ZeroingDWORD = 0x80108010;
*convertproc = (FRAMECONVERTPROC*)&DoBlackBarYUVPacked;
}
else if (lpbmhIn->biCompression == VIDEO_FORMAT_UYVY) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = (DWORD)WIDTHBYTES(desiredwidth * lpbmhIn->biBitCount) * desiredheight;
pcvt->ci_ZeroingDWORD = 0x10801080;
*convertproc = (FRAMECONVERTPROC*)&DoBlackBarYUVPacked;
}
else if ((lpbmhIn->biCompression == VIDEO_FORMAT_I420) || (lpbmhIn->biCompression == VIDEO_FORMAT_IYUV)) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = (DWORD)WIDTHBYTES(desiredwidth * lpbmhIn->biBitCount) * desiredheight;
*convertproc = (FRAMECONVERTPROC*)&DoBlackBarYUVPlanar;
pcvt->ci_UVDownSampling = 2;
}
*refdata = (LPVOID)pcvt;
return TRUE;
}
else {
if (pcvt)
LocalFree((HANDLE)pcvt);
}
return FALSE;
}
#ifdef ENABLE_ZOOM_CODE
BOOL Zoom4(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PZOOMCONVERTINFO refdata
)
{
return FALSE;
}
BOOL Zoom8(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PZOOMCONVERTINFO refdata
)
{
return FALSE;
}
BOOL Zoom16(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PZOOMCONVERTINFO refdata
)
{
return FALSE;
}
BOOL Zoom24(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PZOOMCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn1, pIn2, pTmp, pOut;
ROW_VALUES *rptr;
long i, j, yfac_inv, src_y, src_y_i, q, q1;
long a;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &i);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &i);
pOut = pCvtBits;
yfac_inv = refdata->ci_height * 256 / refdata->ci_dstheight;
for (i = 0; i < refdata->ci_dstheight; i++) {
src_y = i * yfac_inv;
src_y_i = src_y / 256;
q = src_y - src_y_i * 256;
q1 = 256 - q;
rptr = refdata->ci_rptr;
pIn1 = pBits + src_y_i * refdata->ci_width * 3;
pIn2 = pIn1 + refdata->ci_width * 3;
for (j = 0; j < refdata->ci_dstwidth; j++, rptr++) {
a = rptr->x_i * 3;
pIn1 += a;
pIn2 += a;
a = (((*pIn1) * rptr->p1 + (*(pIn1+3)) * rptr->p) * q1 +
((*pIn2) * rptr->p1 + (*(pIn2+3)) * rptr->p) * q) / 256 / 256;
if (a > 256) a = 255;
*pOut++ = (BYTE)a; // blue
pIn1++;
pIn2++;
a = (((*pIn1) * rptr->p1 + (*(pIn1+3)) * rptr->p) * q1 +
((*pIn2) * rptr->p1 + (*(pIn2+3)) * rptr->p) * q) / 256 / 256;
if (a > 256) a = 255;
*pOut++ = (BYTE)a; // green
pIn1++;
pIn2++;
a = (((*pIn1) * rptr->p1 + (*(pIn1+3)) * rptr->p) * q1 +
((*pIn2) * rptr->p1 + (*(pIn2+3)) * rptr->p) * q) / 256 / 256;
if (a > 256) a = 255;
*pOut++ = (BYTE)a; // red
pIn1 -= 2;
pIn2 -= 2;
}
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
BOOL ZoomYVU9(
IBitmapSurface* pbsIn,
IBitmapSurface* pbsOut,
PZOOMCONVERTINFO refdata
)
{
LPBYTE pBits, pCvtBits, pIn1, pIn2, pOut, pOut2, pU1;
ROW_VALUES *rptr;
long i, j, yfac_inv, src_y, src_y_i, q, q1;
long a, b, c, d;
pbsIn->LockBits(NULL, 0, (void**)&pBits, &i);
pbsOut->LockBits(NULL, 0, (void**)&pCvtBits, &i);
pOut = pCvtBits;
yfac_inv = refdata->ci_height * 256 / refdata->ci_dstheight;
// Do the Y component first as a bilinear zoom
for (i = 0; i < refdata->ci_dstheight; i++) {
src_y = i * yfac_inv;
src_y_i = src_y / 256;
q = src_y - src_y_i * 256;
q1 = 256 - q;
rptr = refdata->ci_rptr;
pIn1 = pBits + src_y_i * refdata->ci_width;
pIn2 = pIn1 + refdata->ci_width;
for (j = 0; j < refdata->ci_dstwidth; j++, rptr++) {
pIn1 += rptr->x_i;
pIn2 += rptr->x_i;
a = *pIn1;
b = *(pIn1+1);
c = *pIn2;
d = *(pIn2+1);
a = ((a * rptr->p1 + b * rptr->p) * q1 +
(c * rptr->p1 + d * rptr->p) * q) / 256 / 256;
if (a > 256) a = 255;
*pOut++ = (BYTE)a;
}
}
// Do the V and U components next as a nearest neighbor zoom
pIn1 = pBits + refdata->ci_width * refdata->ci_height; // start of source V table
pU1 = pIn1 + (refdata->ci_width * refdata->ci_height) / 16; // start of source U table
pOut2 = pOut + (refdata->ci_dstwidth * refdata->ci_dstheight) / 16; // start of dest U table
src_y = 0;
for (i = 0; i < refdata->ci_dstheight; i += 4) {
src_y_i = (i * yfac_inv) / 256 / 4;
d = (src_y_i - src_y) * refdata->ci_width / 4;
pIn1 += d;
pU1 += d;
src_y = src_y_i;
a = 0;
rptr = refdata->ci_rptr;
for (j = 0; j < refdata->ci_dstwidth/4; j++) {
*pOut++ = *(pIn1+a/4);
*pOut2++ = *(pU1+a/4);
a += rptr->x_i;
rptr++;
a += rptr->x_i;
rptr++;
a += rptr->x_i;
rptr++;
a += rptr->x_i;
rptr++;
}
}
pbsIn->UnlockBits(NULL, pBits);
pbsOut->UnlockBits(NULL, pCvtBits);
return TRUE;
}
BOOL
InitScale(
LPBITMAPINFOHEADER lpbmhIn,
long desiredwidth,
long desiredheight,
LPBITMAPINFOHEADER *lpbmhOut,
FRAMECONVERTPROC **convertproc,
LPVOID *refdata
)
{
PZOOMCONVERTINFO pcvt;
DWORD dwSize, dwBaseSize;
ROW_VALUES *rptr;
long i, x, xfac_inv, x_i_last, tmp;
*convertproc = NULL;
*refdata = NULL;
if ((lpbmhIn->biCompression != VIDEO_FORMAT_BI_RGB) &&
(lpbmhIn->biCompression != VIDEO_FORMAT_YVU9))
return FALSE;
// calculate size of zoomconvertinfo struct, if we need a colortable, then add 256 entries
// else subtract off the 1 built into the struct definition
dwBaseSize = sizeof(ZOOMCONVERTINFO) - sizeof(RGBQUAD);
if (lpbmhIn->biBitCount <= 8)
dwBaseSize += 256 * sizeof(RGBQUAD);
dwSize = dwBaseSize + desiredwidth * sizeof(ROW_VALUES);
// for RGB and YVU9 input formats, we know that the output format will never need
// an attached color table, so we can allocate lpbmhOut without one
if ((pcvt = (PZOOMCONVERTINFO)LocalAlloc(LPTR, dwSize)) &&
(*lpbmhOut = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, lpbmhIn->biSize))) {
CopyMemory(*lpbmhOut, lpbmhIn, lpbmhIn->biSize);
pcvt->ci_width = lpbmhIn->biWidth;
pcvt->ci_height = lpbmhIn->biHeight;
pcvt->ci_dstwidth = desiredwidth;
pcvt->ci_dstheight = desiredheight;
(*lpbmhOut)->biWidth = desiredwidth;
(*lpbmhOut)->biHeight = desiredheight;
pcvt->ci_rptr = (ROW_VALUES *)(((BYTE *)pcvt) + dwBaseSize);
rptr = pcvt->ci_rptr;
xfac_inv = lpbmhIn->biWidth * 256 / desiredwidth;
x_i_last = 0;
for (i = 0; i < desiredwidth; i++) {
x = i * xfac_inv;
tmp = x / 256;
rptr->x_i = tmp - x_i_last;
x_i_last = tmp;
rptr->p = x - x_i_last * 256;
rptr->p1 = 256 - rptr->p;
rptr++;
}
// copy colortable from input bitmapinfoheader
if (lpbmhIn->biBitCount <= 8)
CopyMemory(&pcvt->ci_colortable[0], (LPBYTE)lpbmhIn + lpbmhIn->biSize, 256 * sizeof(RGBQUAD));
if (lpbmhIn->biCompression == VIDEO_FORMAT_BI_RGB) {
(*lpbmhOut)->biBitCount = 24;
(*lpbmhOut)->biSizeImage = desiredwidth * desiredheight * 3;
if (lpbmhIn->biBitCount == 4) {
*convertproc = (FRAMECONVERTPROC*)&Zoom4;
}
else if (lpbmhIn->biBitCount == 8) {
*convertproc = (FRAMECONVERTPROC*)&Zoom8;
}
else if (lpbmhIn->biBitCount == 16) {
*convertproc = (FRAMECONVERTPROC*)&Zoom16;
}
else {
*convertproc = (FRAMECONVERTPROC*)&Zoom24;
}
}
else if (lpbmhIn->biCompression == VIDEO_FORMAT_YVU9) {
(*lpbmhOut)->biBitCount = lpbmhIn->biBitCount;
(*lpbmhOut)->biSizeImage = desiredwidth * desiredheight + (desiredwidth * desiredheight)/8;
*convertproc = (FRAMECONVERTPROC*)&ZoomYVU9;
}
*refdata = (LPVOID)pcvt;
return TRUE;
}
else {
if (pcvt)
LocalFree((HANDLE)pcvt);
}
return FALSE;
}
#endif // ENABLE_ZOOM_CODE
STDMETHODIMP
CCaptureChain::InitCaptureChain(
HCAPDEV hcapdev,
BOOL streaming,
LPBITMAPINFOHEADER lpcap,
LONG desiredwidth,
LONG desiredheight,
DWORD desiredformat,
LPBITMAPINFOHEADER *plpdsp
)
{
CFrameOp *ccf;
CFrameOp *clast;
CFilterChain *cfilterchain;
LPBITMAPINFOHEADER lpcvt;
DWORD lpcapsize;
FX_ENTRY("CCaptureChain::InitCaptureChain");
*plpdsp = NULL;
#ifndef SUPPORT_DESIRED_FORMAT
if (desiredformat != 0) {
ERRORMESSAGE(("%s: Invalid desiredformat parameter", _fx_));
return E_FAIL;
}
#endif
if (streaming) {
if ((ccf = new CStreamCaptureFrame)) {
ccf->AddRef();
if (hcapdev && !((CStreamCaptureFrame*)ccf)->InitCapture(hcapdev, lpcap)) {
ERRORMESSAGE(("%s: Failed to init capture object", _fx_));
ccf->Release();
return E_FAIL;
}
}
}
else {
if ((ccf = new CCaptureFrame)) {
ccf->AddRef();
if (hcapdev && !((CCaptureFrame*)ccf)->InitCapture(hcapdev, lpcap)) {
ERRORMESSAGE(("%s: Failed to init capture object", _fx_));
ccf->Release();
return E_FAIL;
}
}
}
if (!ccf) {
ERRORMESSAGE(("%s: Failed to alloc capture object", _fx_));
return E_OUTOFMEMORY;
}
clast = ccf;
lpcapsize = lpcap->biSize;
if (lpcap->biBitCount <= 8)
lpcapsize += 256 * sizeof(RGBQUAD);
#if 0
if ((lpcap->biCompression != BI_RGB) &&
(lpcap->biCompression != VIDEO_FORMAT_YVU9) &&
(lpcap->biCompression != VIDEO_FORMAT_INTELI420)) {
#else
if ((lpcap->biCompression != BI_RGB) &&
(lpcap->biCompression != VIDEO_FORMAT_YVU9) &&
(lpcap->biCompression != VIDEO_FORMAT_YUY2) &&
(lpcap->biCompression != VIDEO_FORMAT_UYVY) &&
(lpcap->biCompression != VIDEO_FORMAT_I420) &&
(lpcap->biCompression != VIDEO_FORMAT_IYUV)) {
#endif
// attempt to instantiate an ICM CFrameOp
CICMcvtFrame *cicm;
if ((cicm = new CICMcvtFrame)) {
cicm->AddRef();
#if 0
if (cicm->InitCvt(lpcap, lpcapsize, plpdsp, BI_RGB)) {
#else
if (cicm->InitCvt(lpcap, lpcapsize, plpdsp)) {
#endif
clast->m_next = (CFrameOp*)cicm; // add ICM FrameOp into chain
clast = (CFrameOp*)cicm;
}
else {
cicm->Release();
if (!*plpdsp)
{
ERRORMESSAGE(("%s: Failed to find a codec", _fx_));
}
}
}
else
{
ERRORMESSAGE(("%s: Failed to alloc codec object", _fx_));
}
}
else if (!*plpdsp) {
if (*plpdsp = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, lpcapsize))
CopyMemory(*plpdsp, lpcap, lpcapsize);
else
{
ERRORMESSAGE(("%s: Failed to alloc display bitmapinfoheader", _fx_));
}
}
#ifdef SUPPORT_DESIRED_FORMAT
#if 0
// LOOKLOOK RP - this isn't done yet, something to do beyond NM2.0
if ((desiredformat == VIDEO_FORMAT_INTELI420) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_INTELI420)) {
CConvertFrame *ccvt;
if (ccvt = new CConvertFrame) {
ccvt->AddRef();
if (ccvt->InitConverter(lpcvt, convertproc, refdata)) {
LocalFree((HANDLE)*plpdsp);
*plpdsp = lpcvt;
clast->m_next = (CFrameOp*)ccvt; // add FrameOp into chain
clast = (CFrameOp*)ccvt;
}
else
ccvt->Release();
}
}
#endif
#if 0
if (((desiredformat == VIDEO_FORMAT_YVU9) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_YVU9)) ||
((desiredformat == VIDEO_FORMAT_INTELI420) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_INTELI420))) {
#else
if (((desiredformat == VIDEO_FORMAT_YVU9) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_YVU9)) ||
((desiredformat == VIDEO_FORMAT_YUY2) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_YUY2)) ||
((desiredformat == VIDEO_FORMAT_UYVY) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_UYVY)) ||
((desiredformat == VIDEO_FORMAT_I420) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_I420)) ||
((desiredformat == VIDEO_FORMAT_IYUV) &&
((*plpdsp)->biCompression != VIDEO_FORMAT_IYUV))) {
#endif
// attempt to instantiate an ICM CFrameOp
CICMcvtFrame *cicm;
if ((cicm = new CICMcvtFrame)) {
cicm->AddRef();
if (cicm->InitCvt(*plpdsp, lpcapsize, &lpcvt, desiredformat)) {
clast->m_next = (CFrameOp*)cicm; // add ICM FrameOp into chain
clast = (CFrameOp*)cicm;
LocalFree((HANDLE)*plpdsp);
*plpdsp = lpcvt;
}
else {
cicm->Release();
if (!*plpdsp)
{
ERRORMESSAGE(("%s: Failed to find a codec", _fx_));
}
}
}
else
{
ERRORMESSAGE(("%s: Failed to alloc codec object", _fx_));
}
}
#endif // SUPPORT_DESIRED_FORMAT
{
CConvertFrame *ccvt;
FRAMECONVERTPROC *convertproc;
LPVOID refdata;
#ifdef ENABLE_ZOOM_CODE
BOOL attemptzoom;
attemptzoom = TRUE;
#endif
while (*plpdsp && (((*plpdsp)->biWidth != desiredwidth) ||
((*plpdsp)->biHeight != desiredheight) ||
(((*plpdsp)->biCompression == BI_RGB) && ((*plpdsp)->biBitCount <= 8)))) {
lpcvt = NULL;
#ifdef ENABLE_ZOOM_CODE
if (attemptzoom) {
InitScale(*plpdsp, desiredwidth, desiredheight, &lpcvt, &convertproc, &refdata);
attemptzoom = FALSE;
}
#endif
if (!lpcvt) {
if (((*plpdsp)->biWidth >= desiredwidth) && ((*plpdsp)->biHeight >= desiredheight)) {
// try to shrink
InitShrink(*plpdsp, desiredwidth, desiredheight, &lpcvt, &convertproc, &refdata);
}
else {
// try to blackbar
InitBlackbar(*plpdsp, desiredwidth, desiredheight, &lpcvt, &convertproc, &refdata);
}
}
if (lpcvt) {
if (ccvt = new CConvertFrame) {
ccvt->AddRef();
if (ccvt->InitConverter(lpcvt, convertproc, refdata)) {
LocalFree((HANDLE)*plpdsp);
*plpdsp = lpcvt;
clast->m_next = (CFrameOp*)ccvt; // add FrameOp into chain
clast = (CFrameOp*)ccvt;
continue;
}
else
ccvt->Release();
}
}
else {
ERRORMESSAGE(("%s: Can't convert", _fx_));
LocalFree((HANDLE)*plpdsp);
*plpdsp = NULL;
}
}
}
if (*plpdsp) {
// allocate a placeholder for a filter chain
if (cfilterchain = new CFilterChain) {
cfilterchain->AddRef();
// placeholder needs reference to a pool to pass to added filters
if (clast->m_pool && clast->m_pool->Growable()) {
cfilterchain->m_pool = clast->m_pool;
cfilterchain->m_pool->AddRef();
}
else {
if ((cfilterchain->m_pool = new CVidPool)) {
cfilterchain->m_pool->AddRef();
if (cfilterchain->m_pool->InitPool(2, *plpdsp) != NO_ERROR) {
ERRORMESSAGE(("%s: Failed to init filter pool", _fx_));
cfilterchain->m_pool->Release();
cfilterchain->m_pool = NULL;
}
}
else
{
ERRORMESSAGE(("%s: Failed to alloc filter pool", _fx_));
}
}
if (cfilterchain->m_pool) {
clast->m_next = (CFrameOp*)cfilterchain; // add placeholder FrameOp into chain
clast = (CFrameOp*)cfilterchain;
}
else {
cfilterchain->Release();
cfilterchain = NULL;
}
}
if (m_opchain)
m_opchain->Release();
m_opchain = ccf;
m_filterchain = cfilterchain;
return NO_ERROR;
}
ccf->Release(); // discard partial chain
return E_FAIL;
}
// AddFilter
// Adds a filter to the chain. If hAfter is NULL, the filter is added
// to the head of the chain.
STDMETHODIMP
CCaptureChain::AddFilter(
CLSID* pclsid,
LPBITMAPINFOHEADER lpbmhIn,
HANDLE* phNew,
HANDLE hAfter
)
{
HRESULT hres;
IBitmapEffect *effect;
CFilterFrame *cff;
CFilterChain *chain;
CFilterFrame *previous;
if (m_filterchain) {
m_filterchain->AddRef(); // lock chain from destruction
// find insertion point
previous = m_filterchain->m_head;
if (hAfter) {
while (previous && (previous->m_tag != hAfter))
previous = (CFilterFrame*)previous->m_next;
if (!previous) {
// can't find hAfter, so fail call
m_filterchain->Release(); // unlock m_filterchain
return E_INVALIDARG;
}
}
// load, init and link in new filter
if (cff = new CFilterFrame) {
cff->AddRef();
if ((hres = LoadFilter(pclsid, &effect)) == NO_ERROR) {
m_filterchain->m_pool->AddRef();
if (cff->InitFilter(effect, lpbmhIn, m_filterchain->m_pool))
hres = NO_ERROR;
else
hres = E_OUTOFMEMORY;
m_filterchain->m_pool->Release();
if (hres == NO_ERROR) {
cff->m_clsid = *pclsid;
cff->m_tag = (HANDLE)(++m_filtertags);
if (phNew)
*phNew = (HANDLE)cff->m_tag;
EnterCriticalSection(&m_capcs);
if (previous) {
cff->m_next = previous->m_next;
previous->m_next = cff;
}
else {
cff->m_next = m_filterchain->m_head;
m_filterchain->m_head = cff;
}
LeaveCriticalSection(&m_capcs);
m_filterchain->Release();
return NO_ERROR;
}
}
cff->Release();
}
else
hres = E_OUTOFMEMORY;
m_filterchain->Release(); // unlock m_filterchain
return hres;
}
return E_UNEXPECTED;
}
STDMETHODIMP
CCaptureChain::RemoveFilter(
HANDLE hFilter
)
{
return E_NOTIMPL;
}
STDMETHODIMP
CCaptureChain::DisplayFilterProperties(
HANDLE hFilter,
HWND hwndParent
)
{
return E_NOTIMPL;
}