LRESULT CTestDlg::OnBnClickedButton5(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
bool bRtn = true;
HANDLE hf = INVALID_HANDLE_VALUE;
HANDLE hf2 = INVALID_HANDLE_VALUE;
try
{
hf = CreateFile(_T("E:\\DumpSurface2.temp"),
GENERIC_READ ,
(DWORD) 0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
(HANDLE) NULL);
if (hf == INVALID_HANDLE_VALUE)
{
throw FALSE;
}
DDSURFACEDESC2 ddsd;
DWORD cbRead = 0;
ReadFile(hf,&ddsd,sizeof(ddsd),&cbRead,0);
CFileMappingBitmap file;
file.Create(ddsd.dwWidth,ddsd.dwHeight,ddsd.ddpfPixelFormat.dwRGBBitCount,0,0,_T("1268-1-74EF6127C-0846-4c63-8EAE-6C2DF379A618"));
BYTE*pPointer = (BYTE*)file.GetImagePointer();
int pitch = CalculatePitch(CalculateLine(ddsd.dwWidth,ddsd.ddpfPixelFormat.dwRGBBitCount));
while ( ReadFile(hf,pPointer,pitch,&cbRead,0) )
{
SetFilePointer(hf,ddsd.lPitch - pitch,0,FILE_CURRENT );
pPointer += pitch;
}
hf2 = CreateFile(_T("E:\\DumpSurface2.bmp"),
GENERIC_READ | GENERIC_WRITE,
(DWORD) 0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
(HANDLE) NULL);
WriteFile(hf2,file.GetFilePointer(),file.GetFileSize(),&cbRead,0);
}
catch(bool b1)
{
bRtn = b1;
}
CloseHandle(hf);
CloseHandle(hf2);
return 0;
}
/**
Calculate the size of a FreeImage image.
Align the palette and the pixels on a FIBITMAP_ALIGNMENT bytes alignment boundary.
*/
static unsigned
FreeImage_GetImageSize(int width, int height, int bpp) {
unsigned dib_size = sizeof(FREEIMAGEHEADER);
dib_size += (dib_size % FIBITMAP_ALIGNMENT ? FIBITMAP_ALIGNMENT - dib_size % FIBITMAP_ALIGNMENT : 0);
dib_size += FIBITMAP_ALIGNMENT - sizeof(BITMAPINFOHEADER) % FIBITMAP_ALIGNMENT;
dib_size += sizeof(BITMAPINFOHEADER);
// palette is aligned on a 16 bytes boundary
dib_size += sizeof(RGBQUAD) * CalculateUsedPaletteEntries(bpp);
dib_size += (dib_size % FIBITMAP_ALIGNMENT ? FIBITMAP_ALIGNMENT - dib_size % FIBITMAP_ALIGNMENT : 0);
// pixels are aligned on a 16 bytes boundary
dib_size += CalculatePitch(CalculateLine(width, bpp)) * height;
return dib_size;
}
/**
Calculate the size of a FreeImage image.
Align the palette and the pixels on a FIBITMAP_ALIGNMENT bytes alignment boundary.
This function includes a protection against malicious images, based on a KISS integer overflow detection mechanism.
@param header_only If TRUE, calculate a 'header only' FIBITMAP size, otherwise calculate a full FIBITMAP size
@param width Image width
@param height Image height
@param bpp Number of bits-per-pixel
@param need_masks We only store the masks (and allocate memory for them) for 16-bit images of type FIT_BITMAP
@return Returns a size in BYTE units
@see FreeImage_AllocateBitmap
*/
static size_t
FreeImage_GetInternalImageSize(BOOL header_only, unsigned width, unsigned height, unsigned bpp, BOOL need_masks) {
size_t dib_size = sizeof(FREEIMAGEHEADER);
dib_size += (dib_size % FIBITMAP_ALIGNMENT ? FIBITMAP_ALIGNMENT - dib_size % FIBITMAP_ALIGNMENT : 0);
dib_size += FIBITMAP_ALIGNMENT - sizeof(BITMAPINFOHEADER) % FIBITMAP_ALIGNMENT;
dib_size += sizeof(BITMAPINFOHEADER);
// palette is aligned on a 16 bytes boundary
dib_size += sizeof(RGBQUAD) * CalculateUsedPaletteEntries(bpp);
// we both add palette size and masks size if need_masks is true, since CalculateUsedPaletteEntries
// always returns 0 if need_masks is true (which is only true for 16 bit images).
dib_size += need_masks ? sizeof(DWORD) * 3 : 0;
dib_size += (dib_size % FIBITMAP_ALIGNMENT ? FIBITMAP_ALIGNMENT - dib_size % FIBITMAP_ALIGNMENT : 0);
if(!header_only) {
const size_t header_size = dib_size;
// pixels are aligned on a 16 bytes boundary
dib_size += (size_t)CalculatePitch(CalculateLine(width, bpp)) * (size_t)height;
// check for possible malloc overflow using a KISS integer overflow detection mechanism
{
const double dPitch = floor( ((double)bpp * width + 31.0) / 32.0 ) * 4.0;
const double dImageSize = (double)header_size + dPitch * height;
if(dImageSize != (double)dib_size) {
// here, we are sure to encounter a malloc overflow: try to avoid it ...
return 0;
}
/*
The following constant take into account the additionnal memory used by
aligned malloc functions as well as debug malloc functions.
It is supposed here that using a (8 * FIBITMAP_ALIGNMENT) risk margin will be enough
for the target compiler.
*/
const double FIBITMAP_MAX_MEMORY = (double)((size_t)-1) - 8 * FIBITMAP_ALIGNMENT;
if(dImageSize > FIBITMAP_MAX_MEMORY) {
// avoid possible overflow inside C allocation functions
return 0;
}
}
}
return dib_size;
}
bool CScreenBuffer::Create(HDC hDev,const RECT & rc,LPCTSTR szName )
{
TrackDebugOut;
Destroy();
m_hMemDC = CreateCompatibleDC(hDev);
if(m_hMemDC == NULL){
DebugOutF(filelog::log_error,("CreateCompatibleDC failed with %d"),GetLastError() );
return false;
}
RECT rcscreen = GetDCRect(hDev);
RECT rcdest;
IntersectRect(&rcdest,&rcscreen,&rc);
LONG lWidth = rcdest.right - rcdest.left;
LONG lHeight = rcdest.bottom - rcdest.top;
LONG lBitsPPix = 32;//GetDeviceCaps(hDev,BITSPIXEL);
LONG dwImageSize = lHeight*CalculatePitch(CalculateLine(lWidth,lBitsPPix));
// save [bmp file header] + [bmp info header] + [bmp data] to the file mapping object
//DWORD filesize = 0;
LONG biClrUsed = 0;
RGBQUAD rgbquad[256];
if (lBitsPPix < 16)
{
TrackDebugOut;
biClrUsed = GetDIBColorTable(hDev,0,256,rgbquad);
}
if(!CFileMappingBitmap::Create(lWidth,lHeight,lBitsPPix,biClrUsed,rgbquad,szName))
{
return false;
}
m_hBmp = CreateDIBSection(m_hMemDC,(BITMAPINFO*)InfoHeader(),DIB_RGB_COLORS, (void**)&m_pBuff, GetHandle(), FileHeader()->bfOffBits);
if(m_hBmp == NULL){
DebugOutF(filelog::log_error,("CreateDIBSection failed %d"),GetLastError() );
return false;
}
SelectObject(m_hMemDC,m_hBmp);
//HDC hdc = GetDC(0);
BitBlt(m_hMemDC,0,0,rcdest.right-rcdest.left,rcdest.bottom-rcdest.top,hDev,rcdest.left,rcdest.top,SRCCOPY|CAPTUREBLT);
//ReleaseDC(0,hdc);
return true;
}
BOOL CImageTIFF::Write(FILE* stream)
{
//prepare the palette struct
RGBQUAD pal[256];
if (GetPalette()){
BYTE b;
memcpy(pal,GetPalette(),GetPaletteSize());
for(WORD a=0;a<m_header.biClrUsed;a++){ //swap blue and red components
b=pal[a].rgbBlue; pal[a].rgbBlue=pal[a].rgbRed; pal[a].rgbRed=b;
}
}
TIFF *m_tif=NULL; // = (TIFF *)new(byte[512]);
uint32 height=m_header.biHeight;
uint32 width=m_header.biWidth;
// uint32 rowsperstrip = (uint32) -1;
uint16 bitspersample=m_header.biBitCount;
uint16 samplesperpixel;
uint16 photometric;
uint16 compression;
uint16 pitch;
int line;
uint32 x, y;
samplesperpixel = ((bitspersample == 24) || (bitspersample == 32)) ? 3 : 1;
photometric = (samplesperpixel==3) ? PHOTOMETRIC_RGB : PHOTOMETRIC_PALETTE;
line = CalculateLine(width, bitspersample * samplesperpixel);
pitch = CalculatePitch(line);
m_tif=TIFFOpenEx(stream, "wb");
if (m_tif==NULL) return FALSE;
// handle standard width/height/bpp stuff
TIFFSetField(m_tif, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(m_tif, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(m_tif, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
TIFFSetField(m_tif, TIFFTAG_BITSPERSAMPLE, ((bitspersample == 32) ? 24 : bitspersample) / samplesperpixel);
TIFFSetField(m_tif, TIFFTAG_PHOTOMETRIC, photometric);
TIFFSetField(m_tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); // single image plane
TIFFSetField(m_tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(m_tif, TIFFTAG_ROWSPERSTRIP, 1);
// TIFFSetField(m_tif, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(m_tif, rowsperstrip));
// handle metrics
TIFFSetField(m_tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
TIFFSetField(m_tif, TIFFTAG_XRESOLUTION, 72.0);
TIFFSetField(m_tif, TIFFTAG_YRESOLUTION, 72.0);
// multi-paging
// if (page >= 0) {
// char page_number[20];
// sprintf(page_number, "Page %d", page);
//
// TIFFSetField(m_tif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
// TIFFSetField(m_tif, TIFFTAG_PAGENUMBER, page);
// TIFFSetField(m_tif, TIFFTAG_PAGENAME, page_number);
// } else {
TIFFSetField(m_tif, TIFFTAG_SUBFILETYPE, 0);
// }
// palettes (image colormaps are automatically scaled to 16-bits)
if (photometric == PHOTOMETRIC_PALETTE) {
uint16 *r, *g, *b;
r = (uint16 *) _TIFFmalloc(sizeof(uint16) * 3 * 256);
g = r + 256;
b = g + 256;
for (int i = 255; i >= 0; i--) {
b[i] = SCALE((uint16)pal[i].rgbRed);
g[i] = SCALE((uint16)pal[i].rgbGreen);
r[i] = SCALE((uint16)pal[i].rgbBlue);
}
TIFFSetField(m_tif, TIFFTAG_COLORMAP, r, g, b);
_TIFFfree(r);
}
// compression
switch(bitspersample) {
case 1 :
compression = COMPRESSION_CCITTFAX4;
break;
case 8 :
case 24 :
case 32 :
compression = COMPRESSION_PACKBITS;
break;
default :
compression = COMPRESSION_NONE;
break;
}
TIFFSetField(m_tif, TIFFTAG_COMPRESSION, compression);
// read the DIB lines from bottom to top
// and save them in the TIF
// -------------------------------------
BYTE *bits;
switch(bitspersample) {
case 1 :
case 4 :
case 8 :
{
for (y = 0; y < height; y++) {
bits= m_info.pImage + (height - y - 1)*m_info.dwEffWidth;
TIFFWriteScanline(m_tif,bits, y, 0);
}
break;
}
case 24:
case 32 :
{
BYTE *buffer = (BYTE *)malloc(m_info.dwEffWidth);
for (y = 0; y < height; y++) {
// get a pointer to the scanline
memcpy(buffer, m_info.pImage + (height - y - 1)*m_info.dwEffWidth, m_info.dwEffWidth);
// TIFFs store color data RGB instead of BGR
BYTE *pBuf = buffer;
for (x = 0; x < width; x++) {
BYTE tmp = pBuf[0];
pBuf[0] = pBuf[2];
pBuf[2] = tmp;
pBuf += 3;
}
// write the scanline to disc
TIFFWriteScanline(m_tif, buffer, y, 0);
}
free(buffer);
break;
}
}
TIFFClose(m_tif);
return true;
}
void CVehicleMovementHelicopter::ProcessAI(const float deltaTime)
{
FUNCTION_PROFILER( GetISystem(), PROFILE_GAME );
CryAutoCriticalSection lk(m_lock);
SVehiclePhysicsStatus* physStatus = &m_physStatus[k_physicsThread];
if (m_arcade.m_handling.maxSpeedForward>0.f) // Use the new handling code
{
//ResetActions();
m_movementAction.Clear();
m_movementAction.isAI = true;
SVehiclePhysicsHelicopterProcessAIParams params;
params.pPhysStatus = physStatus;
params.pInputAction = &m_inputAction;
params.pAiRequest = &m_aiRequest;
params.dt = deltaTime;
params.aiRequiredVel = m_CurrentVel;
params.aiCurrentSpeed = m_CurrentSpeed;
params.aiYawResponseScalar = m_yawResponseScalar;
m_yawResponseScalar = 1.f;
// Use helper class to process the AI input
// It will return a requested velocity, and change the input
m_arcade.ProcessAI(params);
// Get the output velocity
m_CurrentVel = params.aiRequiredVel;
m_CurrentSpeed = params.aiCurrentSpeed;
return;
}
////////////////////// OLD DEPRECATED CODE :( //////////////////////////////////
m_movementAction.Clear();
ResetActions();
// Our current state
const Vec3 worldPos = physStatus->pos;
const Matrix33 worldMat( physStatus->q);
const Matrix33 localMat( physStatus->q.GetInverted());
const Ang3 worldAngles = Ang3::GetAnglesXYZ(worldMat);
const Ang3 localAngles = Ang3::GetAnglesXYZ(localMat);
const Vec3 currentVel = physStatus->v;
const Vec3 currentVel2D(currentVel.x, currentVel.y, 0.0f);
m_CurrentSpeed = m_CurrentVel.len(); //currentVel.len();
float currentSpeed2d = currentVel2D.len();
// +ve direction mean rotation anti-clocwise about the z axis - 0 means along y
float currentDir = worldAngles.z;
// to avoid singularity
const Vec3 vWorldDir = worldMat.GetRow(1);
const Vec3 vSideWays = worldMat.GetRow(0);
const Vec3 vWorldDir2D = Vec3( vWorldDir.x, vWorldDir.y, 0.0f ).GetNormalizedSafe();
// Our inputs
float desiredSpeed = m_aiRequest.HasDesiredSpeed() ? m_aiRequest.GetDesiredSpeed() : 0.0f;
Limit(desiredSpeed, -m_maxSpeed, m_maxSpeed);
const Vec3 desiredMoveDir = m_aiRequest.HasMoveTarget() ? (m_aiRequest.GetMoveTarget() - worldPos).GetNormalizedSafe() : vWorldDir;
Vec3 desiredMoveDir2D = Vec3(desiredMoveDir.x, desiredMoveDir.y, 0.0f);
desiredMoveDir2D = desiredMoveDir2D.GetNormalizedSafe(desiredMoveDir2D);
const Vec3 desiredVel = desiredMoveDir * desiredSpeed;
const Vec3 desiredVel2D(desiredVel.x, desiredVel.y, 0.0f);
Vec3 desiredLookDir(desiredMoveDir);
if (m_aiRequest.HasDesiredBodyDirectionAtTarget())
{
desiredLookDir = m_aiRequest.GetDesiredBodyDirectionAtTarget().GetNormalizedSafe(desiredMoveDir);
}
else if (m_aiRequest.HasLookTarget())
{
desiredLookDir = (m_aiRequest.GetLookTarget() - worldPos).GetNormalizedSafe(desiredMoveDir);
}
//const Vec3 desiredLookDir = m_aiRequest.HasLookTarget() ? (m_aiRequest.GetLookTarget() - worldPos).GetNormalizedSafe() : desiredMoveDir;
const Vec3 desiredLookDir2D = Vec3(desiredLookDir.x, desiredLookDir.y, 0.0f).GetNormalizedSafe(vWorldDir2D);
Vec3 prediction = m_aiRequest.HasBodyTarget() ? m_aiRequest.GetBodyTarget() : ZERO;
prediction = (prediction.IsEquivalent(ZERO)) ? desiredMoveDir2D : prediction - worldPos;
prediction.z = 0.0f;
float speedLimit = prediction.GetLength2D();
if(speedLimit > 0.0f)
{
prediction *= 1.0f / speedLimit;
}
Vec3 tempDir = currentVel2D.IsEquivalent(ZERO) ? localMat.GetRow(1) : currentVel2D;
tempDir.z = 0.0f;
tempDir.NormalizeFast();
float dotProd = tempDir.dot(prediction);
Limit(dotProd, FLT_EPSILON, 1.0f);
float accel = m_enginePowerMax * min(2.0f, 1.0f / dotProd); // * dotProd;
if (!m_aiRequest.HasDesiredBodyDirectionAtTarget())
{
dotProd *= dotProd;
dotProd *= dotProd;
float tempf = min(max(speedLimit * speedLimit, 2.0f), m_maxSpeed * dotProd);
Limit(desiredSpeed, -tempf, tempf);
}
else if (dotProd < 0.0125f)
{
Limit(desiredSpeed, -m_maxSpeed * 0.25f, m_maxSpeed * 0.25f);
}
float posNeg = (float)__fsel(desiredSpeed - m_CurrentSpeed, 1.0f, -5.0f);
if (desiredVel2D.GetLengthSquared() > FLT_EPSILON)
{
m_CurrentSpeed = m_CurrentSpeed + posNeg * accel * deltaTime;
}
else
{
m_CurrentSpeed = m_CurrentSpeed + posNeg * accel * deltaTime;
}
if (posNeg > 0.0f && m_CurrentSpeed > desiredSpeed)
{
m_CurrentSpeed = desiredSpeed;
}
else if (posNeg < 0.0f && m_CurrentSpeed < desiredSpeed)
{
m_CurrentSpeed = desiredSpeed;
}
// ---------------------------- Rotation ----------------------------
float desiredDir = (desiredLookDir2D.GetLengthSquared() > 0.0f) ? atan2f(-desiredLookDir2D.x, desiredLookDir2D.y) : atan2f(-vWorldDir2D.x, vWorldDir2D.y);
while (currentDir < desiredDir - gf_PI)
currentDir += 2.0f * gf_PI;
while (currentDir > desiredDir + gf_PI)
currentDir -= 2.0f * gf_PI;
// ---------------------------- Yaw ----------------------------
Ang3 dirDiff(0.0f, 0.0f, desiredDir - currentDir);
dirDiff.RangePI();
float absDiff = fabsf(dirDiff.z);
float rotSpeed = (float)__fsel(dirDiff.z, m_yawPerRoll, -m_yawPerRoll);
m_actionYaw = m_actionYaw + deltaTime * (rotSpeed - m_actionYaw);
float temp = fabsf(m_actionYaw);
float multiplier = ((absDiff / (temp + 0.001f)) + 1.0f) * 0.5f;
m_actionYaw *= (float)__fsel(absDiff - temp, 1.0f, multiplier);
// ---------------------------- Yaw ------------------------------
m_CurrentVel = desiredMoveDir * m_CurrentSpeed;
// ---------------------------- Pitch ----------------------------
if (m_CurrentVel.GetLengthSquared2D() > 0.1f)
{
CalculatePitch(worldAngles, desiredMoveDir, currentSpeed2d, desiredSpeed, deltaTime);
}
else
{
Quat rot;
rot.SetRotationVDir(desiredLookDir, 0.0f);
float desiredXRot = Ang3::GetAnglesXYZ(rot).x + m_steeringDamage.x;
m_actionPitch = worldAngles.x + (desiredXRot - worldAngles.x) * deltaTime/* * 10.0f*/;
Limit(m_actionPitch, -m_maxPitchAngle * 2.0f, m_maxPitchAngle * 2.0f);
}
// ---------------------------- Roll ----------------------------
float rollSpeed = GetRollSpeed();
rollSpeed *= deltaTime;
rollSpeed = (float)__fsel(absDiff - rollSpeed, rollSpeed, absDiff);
float roll =(float) __fsel(dirDiff.z, -rollSpeed, rollSpeed);
float speedPerUnit = 1.5f;
float desiredRollSpeed = absDiff * speedPerUnit * (float)__fsel(dirDiff.z, 1.0f, -1.0f);
desiredRollSpeed = -m_actionYaw * 2.5f;
desiredRollSpeed += m_steeringDamage.y;
m_actionRoll = m_actionRoll + deltaTime * (desiredRollSpeed - m_actionRoll);
Limit(m_actionRoll, -m_maxRollAngle + m_steeringDamage.y, m_maxRollAngle - m_steeringDamage.y);
m_actionRoll *= m_rollDamping;
// ---------------------------- Roll ----------------------------
// ---------------------------- Convert and apply ----------------------------
Ang3 angles(m_actionPitch, m_actionRoll, worldAngles.z + deltaTime * m_actionYaw);
pe_params_pos paramPos;
paramPos.q.SetRotationXYZ(angles);
paramPos.q.Normalize();
IPhysicalEntity * pPhysicalEntity = GetPhysics();
pPhysicalEntity->SetParams(¶mPos, 1);
pe_action_set_velocity vel;
vel.v = m_CurrentVel + m_netPosAdjust;
pPhysicalEntity->Action(&vel, 1);
// ---------------------------- Convert and apply ----------------------------
m_rpmScale = max(0.2f, cry_fabsf(m_CurrentSpeed / m_maxSpeed));
}
static FIBITMAP *
LoadOS21XBMP(FreeImageIO *io, fi_handle handle, int flags, unsigned bitmap_bits_offset) {
FIBITMAP *dib = NULL;
try {
BITMAPINFOOS2_1X_HEADER bios2_1x;
io->read_proc(&bios2_1x, sizeof(BITMAPINFOOS2_1X_HEADER), 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapOS21XHeader(&bios2_1x);
#endif
// keep some general information about the bitmap
int used_colors = 0;
int width = bios2_1x.biWidth;
int height = bios2_1x.biHeight;
int bit_count = bios2_1x.biBitCount;
int pitch = CalculatePitch(CalculateLine(width, bit_count));
switch (bit_count) {
case 1 :
case 4 :
case 8 :
{
used_colors = CalculateUsedPaletteEntries(bit_count);
// allocate enough memory to hold the bitmap (header, palette, pixels) and read the palette
dib = FreeImage_Allocate(width, height, bit_count);
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = 0;
pInfoHeader->biYPelsPerMeter = 0;
// load the palette
RGBQUAD *pal = FreeImage_GetPalette(dib);
for (int count = 0; count < used_colors; count++) {
FILE_BGR bgr;
io->read_proc(&bgr, sizeof(FILE_BGR), 1, handle);
pal[count].rgbRed = bgr.r;
pal[count].rgbGreen = bgr.g;
pal[count].rgbBlue = bgr.b;
}
// Skip over the optional palette
// A 24 or 32 bit DIB may contain a palette for faster color reduction
io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);
// read the pixel data
if (height > 0) {
io->read_proc((void *)FreeImage_GetBits(dib), height * pitch, 1, handle);
} else {
for (int c = 0; c < abs(height); ++c) {
io->read_proc((void *)FreeImage_GetScanLine(dib, height - c - 1), pitch, 1, handle);
}
}
return dib;
}
case 16 :
{
dib = FreeImage_Allocate(width, height, bit_count, FI16_555_RED_MASK, FI16_555_GREEN_MASK, FI16_555_BLUE_MASK);
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = 0;
pInfoHeader->biYPelsPerMeter = 0;
io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
for(int y = 0; y < FreeImage_GetHeight(dib); y++) {
WORD *pixel = (WORD *)FreeImage_GetScanLine(dib, y);
for(int x = 0; x < FreeImage_GetWidth(dib); x++) {
SwapShort(pixel);
pixel++;
}
}
#endif
return dib;
}
case 24 :
case 32 :
{
if( bit_count == 32 ) {
dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
} else {
dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
}
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = 0;
pInfoHeader->biYPelsPerMeter = 0;
// Skip over the optional palette
// A 24 or 32 bit DIB may contain a palette for faster color reduction
io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
for(int y = 0; y < FreeImage_GetHeight(dib); y++) {
BYTE *pixel = FreeImage_GetScanLine(dib, y);
for(int x = 0; x < FreeImage_GetWidth(dib); x++) {
INPLACESWAP(pixel[0], pixel[2]);
pixel += (bit_count>>3);
}
}
#endif
// check if the bitmap contains transparency, if so enable it in the header
FreeImage_SetTransparent(dib, (FreeImage_GetColorType(dib) == FIC_RGBALPHA));
return dib;
}
}
} catch(const char *message) {
if(dib)
FreeImage_Unload(dib);
FreeImage_OutputMessageProc(s_format_id, message);
}
return NULL;
}
static FIBITMAP *
LoadOS22XBMP(FreeImageIO *io, fi_handle handle, int flags, unsigned bitmap_bits_offset) {
FIBITMAP *dib = NULL;
try {
// load the info header
BITMAPINFOHEADER bih;
io->read_proc(&bih, sizeof(BITMAPINFOHEADER), 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapInfoHeader(&bih);
#endif
// keep some general information about the bitmap
int used_colors = bih.biClrUsed;
int width = bih.biWidth;
int height = bih.biHeight;
int bit_count = bih.biBitCount;
int compression = bih.biCompression;
int pitch = CalculatePitch(CalculateLine(width, bit_count));
switch (bit_count) {
case 1 :
case 4 :
case 8 :
{
if ((used_colors <= 0) || (used_colors > CalculateUsedPaletteEntries(bit_count)))
used_colors = CalculateUsedPaletteEntries(bit_count);
// allocate enough memory to hold the bitmap (header, palette, pixels) and read the palette
dib = FreeImage_Allocate(width, height, bit_count);
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
// load the palette
io->seek_proc(handle, sizeof(BITMAPFILEHEADER) + bih.biSize, SEEK_SET);
RGBQUAD *pal = FreeImage_GetPalette(dib);
for (int count = 0; count < used_colors; count++) {
FILE_BGR bgr;
io->read_proc(&bgr, sizeof(FILE_BGR), 1, handle);
pal[count].rgbRed = bgr.r;
pal[count].rgbGreen = bgr.g;
pal[count].rgbBlue = bgr.b;
}
// seek to the actual pixel data.
// this is needed because sometimes the palette is larger than the entries it contains predicts
if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);
// read the pixel data
switch (compression) {
case BI_RGB :
if (height > 0) {
io->read_proc((void *)FreeImage_GetBits(dib), height * pitch, 1, handle);
} else {
for (int c = 0; c < abs(height); ++c) {
io->read_proc((void *)FreeImage_GetScanLine(dib, height - c - 1), pitch, 1, handle);
}
}
return dib;
case BI_RLE4 :
{
BYTE status_byte = 0;
BYTE second_byte = 0;
int scanline = 0;
int bits = 0;
BOOL low_nibble = FALSE;
for (;;) {
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_COMMAND :
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_ENDOFLINE :
bits = 0;
scanline++;
low_nibble = FALSE;
break;
case RLE_ENDOFBITMAP :
return (FIBITMAP *)dib;
case RLE_DELTA :
{
// read the delta values
BYTE delta_x;
BYTE delta_y;
io->read_proc(&delta_x, sizeof(BYTE), 1, handle);
io->read_proc(&delta_y, sizeof(BYTE), 1, handle);
// apply them
bits += delta_x / 2;
scanline += delta_y;
break;
}
default :
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
BYTE *sline = FreeImage_GetScanLine(dib, scanline);
for (int i = 0; i < status_byte; i++) {
if (low_nibble) {
*(sline + bits) |= LOWNIBBLE(second_byte);
if (i != status_byte - 1)
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
bits++;
} else {
*(sline + bits) |= HINIBBLE(second_byte);
}
low_nibble = !low_nibble;
}
if (((status_byte / 2) & 1 ) == 1)
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
break;
};
break;
default :
{
BYTE *sline = FreeImage_GetScanLine(dib, scanline);
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
for (unsigned i = 0; i < status_byte; i++) {
if (low_nibble) {
*(sline + bits) |= LOWNIBBLE(second_byte);
bits++;
} else {
*(sline + bits) |= HINIBBLE(second_byte);
}
low_nibble = !low_nibble;
}
}
break;
};
}
break;
}
case BI_RLE8 :
{
BYTE status_byte = 0;
BYTE second_byte = 0;
int scanline = 0;
int bits = 0;
for (;;) {
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_COMMAND :
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_ENDOFLINE :
bits = 0;
scanline++;
break;
case RLE_ENDOFBITMAP :
return (FIBITMAP *)dib;
case RLE_DELTA :
{
// read the delta values
BYTE delta_x;
BYTE delta_y;
io->read_proc(&delta_x, sizeof(BYTE), 1, handle);
io->read_proc(&delta_y, sizeof(BYTE), 1, handle);
// apply them
bits += delta_x;
scanline += delta_y;
break;
}
default :
io->read_proc((void *)(FreeImage_GetScanLine(dib, scanline) + bits), sizeof(BYTE) * status_byte, 1, handle);
// align run length to even number of bytes
if ((status_byte & 1) == 1)
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
bits += status_byte;
break;
};
break;
default :
BYTE *sline = FreeImage_GetScanLine(dib, scanline);
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
for (unsigned i = 0; i < status_byte; i++) {
*(sline + bits) = second_byte;
bits++;
}
break;
};
}
break;
}
default :
throw "compression type not supported";
}
break;
}
case 16 :
{
if (bih.biCompression == 3) {
DWORD bitfields[3];
io->read_proc(bitfields, 3 * sizeof(DWORD), 1, handle);
dib = FreeImage_Allocate(width, height, bit_count, bitfields[0], bitfields[1], bitfields[2]);
} else {
dib = FreeImage_Allocate(width, height, bit_count, FI16_555_RED_MASK, FI16_555_GREEN_MASK, FI16_555_BLUE_MASK);
}
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);
io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
for(int y = 0; y < FreeImage_GetHeight(dib); y++) {
WORD *pixel = (WORD *)FreeImage_GetScanLine(dib, y);
for(int x = 0; x < FreeImage_GetWidth(dib); x++) {
SwapShort(pixel);
pixel++;
}
}
#endif
return dib;
}
case 24 :
case 32 :
{
if( bit_count == 32 ) {
dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
} else {
dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
}
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
// Skip over the optional palette
// A 24 or 32 bit DIB may contain a palette for faster color reduction
if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);
// read in the bitmap bits
io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
for(int y = 0; y < FreeImage_GetHeight(dib); y++) {
BYTE *pixel = FreeImage_GetScanLine(dib, y);
for(int x = 0; x < FreeImage_GetWidth(dib); x++) {
INPLACESWAP(pixel[0], pixel[2]);
pixel += (bit_count>>3);
}
}
#endif
// check if the bitmap contains transparency, if so enable it in the header
FreeImage_SetTransparent(dib, (FreeImage_GetColorType(dib) == FIC_RGBALPHA));
return dib;
}
}
} catch(const char *message) {
if(dib)
FreeImage_Unload(dib);
FreeImage_OutputMessageProc(s_format_id, message);
}
return NULL;
}
m_bAlphaBlendRequirement = TRUE;
wBpp = 24;
for (int i = 0; i < 3; i++)
{
m_abtBG[i] = BYTE((pclArc->GetOpt()->BgRGB >> (i << 3)) & 0xFF);
}
}
}
m_wBpp = wBpp;
m_pclArc = pclArc;
m_lWidth = lWidth;
m_lHeight = lHeight;
m_lLine = lWidth * (wBpp >> 3);
m_lPitch = CalculatePitch(lWidth, wBpp);
m_lPitchWithAlpha = lWidth * 4;
DWORD dwOriginSize = pclArc->GetOpenFileInfo()->sizeOrg;
m_dwRowSize = dwOriginSize / lHeight;
m_dwRowSizeOfRemainder = dwOriginSize % lHeight;
return OnInit(rfclsFileName);
}
/// Set the validity of alpha blending
///
/// @param bValidityOfAlphaBlend Check validity of alpha-blending
///
void CImageBase::SetValidityOfAlphaBlend(BOOL bValidityOfAlphaBlend)
static FIBITMAP * DLL_CALLCONV
Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
int width;
int height;
int line;
int pitch;
int bpp = 24;
int scan_line_add = 1;
int start_scan_line = 0;
// to make absolute seeks possible we store the current position in the file
long offset_in_file = io->tell_proc(handle);
long seek = 0;
// decide which bitmap in the cabinet to load
switch (flags) {
case PCD_BASEDIV4 :
seek = 0x2000;
width = 192;
height = 128;
break;
case PCD_BASEDIV16 :
seek = 0xB800;
width = 384;
height = 256;
break;
default :
seek = 0x30000;
width = 768;
height = 512;
break;
}
// calculate line and pitch based on the selected bitmap size
line = CalculateLine(width, bpp);
pitch = CalculatePitch(line);
// allocate the dib and write out the header
FIBITMAP *dib = FreeImage_Allocate(width, height, bpp, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
// check if the PCD is bottom-up
if (VerticalOrientation(io, handle)) {
scan_line_add = -1;
start_scan_line = height - 1;
}
// temporary stuff to load PCD
BYTE *y1 = new BYTE[width];
BYTE *y2 = new BYTE[width];
BYTE *cbcr = new BYTE[width];
BYTE *yl[] = { y1, y2 };
// seek to the part where the bitmap data begins
io->seek_proc(handle, offset_in_file, SEEK_SET);
io->seek_proc(handle, seek, SEEK_CUR);
// read the data
for (int y = 0; y < height / 2; ++y) {
io->read_proc(y1, width, 1, handle);
io->read_proc(y2, width, 1, handle);
io->read_proc(cbcr, width, 1, handle);
for (int i = 0; i < 2; ++i) {
BYTE *img = FreeImage_GetScanLine(dib, start_scan_line);
for (int x = 0; x < width; ++x) {
int r, g, b;
YUV2RGB(yl[i][x], cbcr[x / 2], cbcr[(width / 2) + (x / 2)], r, g, b);
img[FI_RGBA_BLUE] = (BYTE)b;
img[FI_RGBA_GREEN] = (BYTE)g;
img[FI_RGBA_RED] = (BYTE)r;
img += 3;
}
start_scan_line += scan_line_add;
}
}
delete [] cbcr;
delete [] y2;
delete [] y1;
return dib;
}
bool COverlaySurfaceCache::CopyToSharedMemory(IDirectDraw7*pDDraw,const OVERLAY_ITEM& item)
{
CAutoLockEx<CMutexLock> lock(g_mLock);
if( !item.pOverlay ) return false;
DumpSurface(item.pOverlay,_T("DumpSurface1.temp"));
CComPtr<IDirectDrawSurface7> pTemp = CopyToOffscreenSurface(pDDraw,item);
DumpSurface(pTemp,_T("DumpSurface2.temp"));
if(!pTemp)
{
OutputDebugStringA("CopyToOffscreenSurface failed");
return false;
}
HRESULT hr=S_OK;
DDSURFACEDESC2 ddsd_dest = {0};
ddsd_dest.dwSize = sizeof(DDSURFACEDESC2);
hr = pTemp->Lock(0,&ddsd_dest,DDLOCK_READONLY|DDLOCK_DONOTWAIT,0);
if (FAILED(hr))
{
OutputDebugStringA("IDirectDrawSurface7::Lock failed");
pTemp->Unlock(0);
return false;
}
try
{
DWORD rgnsize = 0;
// CComPtr<IDirectDrawClipper> pClipper;
// if(SUCCEEDED(item.pOverlay->GetClipper(&pClipper)))
// {
// pClipper->GetClipList(0,0,&rgnsize);
// }
DWORD size;
DWORD imagesize ;
imagesize = CalculatePitch(CalculateLine(ddsd_dest.dwWidth,ddsd_dest.ddpfPixelFormat.dwRGBBitCount)) * ddsd_dest.dwHeight;
size = FIELD_OFFSET(SURFACE_DATA,data) + (rgnsize?rgnsize-sizeof(RGNDATAHEADER):0) + imagesize;
CFileMapping mem;
if(!mem.Open(kChaptureOverlayShareMemory,size,false))
{
// open failed ,maybe size is too small
if(mem.Open(kChaptureOverlayShareMemory,sizeof(SURFACE_DATA),false))
{
SURFACE_DATA*pData = (SURFACE_DATA*)mem.GetPointer();
pData->size = size;
pData->desc = ddsd_dest;
pData->modified = TRUE;
}
OutputDebugStringA("CFileMappingBitmap::Open failed");
throw E_FAIL;
}
SURFACE_DATA*pData = (SURFACE_DATA*)mem.GetPointer();
pData->size = size;
pData->desc = ddsd_dest;
pData->modified = TRUE;
// if(pClipper && rgnsize)
// {
// if(FAILED(pClipper->GetClipList(0,(LPRGNDATA)&pData->rdh,&rgnsize)))
// {
// OutputDebugStringA("IDirectDrawSurface7::GetClipList failed");
// throw E_FAIL;
// }
// }
// if(item.bEntireDest)
// {
// DDSURFACEDESC2 des = {0};
// des.dwSize = sizeof(DDSURFACEDESC2);
// if(FAILED(pPrimary->GetSurfaceDesc(&des)))
// {
// OutputDebugStringA("IDirectDrawSurface7::GetSurfaceDesc failed");
// throw E_FAIL;
// }
// pData->rcDst.left = pData->rcDst.top = 0;
// pData->rcDst.right = des.dwWidth;
// pData->rcDst.bottom = des.dwHeight;
// }
// else
pData->rcDst = item.rcDst;
pData->flags= item.flags;
pData->fx = item.fx;
BYTE *pBegin = pData->data + (rgnsize?rgnsize-sizeof(RGNDATAHEADER):0);
pData->desc.lPitch = CalculatePitch(CalculateLine(ddsd_dest.dwWidth,ddsd_dest.ddpfPixelFormat.dwRGBBitCount));
//int left ;
//left = CalculatePitch(CalculateLine(item.rcDst.left,ddsd_dest.ddpfPixelFormat.dwRGBBitCount));
for (int i= 0;i != ddsd_dest.dwHeight;i++)
{
memcpy( pBegin + i * pData->desc.lPitch ,
(BYTE*)ddsd_dest.lpSurface + i*ddsd_dest.lPitch ,
pData->desc.lPitch);
}
// DebugOutF(filelog::log_info,"CopyToSharedMemory (%d,%d,%d,%d) -> (%d,%d,%d,%d) ok",
// item.rcSrc.left,
// item.rcSrc.top,
// item.rcSrc.right,
// item.rcSrc.bottom,
// item.rcDst.left,
// item.rcDst.top,
// item.rcDst.right,
// item.rcDst.bottom);
}
catch(HRESULT hr1)
{
hr = hr1;
}
pTemp->Unlock(0);
return SUCCEEDED(hr);
}