void Camera::Render(Scene &scn) {
RenderPath(scn);
SaveBitmap("tmp-rendering.bmp");
std::cout << "Rendered initial pass" << std::endl;
for (int i = 0; i < _superSample; ++i) {
RenderPath(scn, i + 1);
SaveBitmap("tmp-rendering.bmp");
std::cout << "Rendered " << i << " pass" << std::endl;
}
}
bool SaveARGB(const char *fileName, BYTE *data, int width, int height)
{
bool result = false;
if (!data)
return result;
ARGBPixel *input = (ARGBPixel *)data;
BitmapPixel *output = new BitmapPixel[BITMAP_SIZE(width, height)];
memset(output, 0, BITMAP_SIZE(width, height) * sizeof(BitmapPixel));
for(int row = 0; row < height; ++row)
{
for(int col = 0; col < width; ++col)
{
int outputIdx = BITMAP_INDEX(col, row, width);
int inputIdx = ((height - row - 1) * width) + col;
output[outputIdx].red = input[inputIdx].red;
output[outputIdx].green = input[inputIdx].green;
output[outputIdx].blue = input[inputIdx].blue;
}
}
result = SaveBitmap(fileName, (BYTE *)output, width, height);
delete [] output;
return result;
}
void SavePixmap(Pixmap* px, char* name) {
Bitmap* b =NewBitmap(px->width,px->height,px->bitsPerPixel);
b->data=(char*)px->data;
SaveBitmap(b,name);
b->data=NULL;
DeleteBitmap(b);
}
bool SaveBGR(const char *fileName, BYTE *data, int width, int height)
{
bool result = false;
if (!data)
return false;
RGBPixel *input = (RGBPixel *)data;
BitmapPixel *output = new BitmapPixel[BITMAP_SIZE(width, height)];
// Pad bytes need to be set to zero, it's easier to just set the entire chunk of memory
memset(output, 0, BITMAP_SIZE(width, height) * sizeof(BitmapPixel));
for(int row = 0; row < height; ++row)
{
for(int col = 0; col < width; ++col)
{
// In a bitmap (0,0) is at the bottom left, in the frame buffer it is the top left.
int outputIdx = BITMAP_INDEX(col, row, width);
int inputIdx = ((height - row - 1) * width) + col;
output[outputIdx].red = input[inputIdx].blue;
output[outputIdx].green = input[inputIdx].green;
output[outputIdx].blue = input[inputIdx].red;
}
}
result = SaveBitmap(fileName, (BYTE *)output, width, height);
delete [] output;
return result;
}
bool SaveRGBPlanar(const char *fileName, BYTE *data, int width, int height)
{
if (!data)
return false;
const char *nameExt[] = {"red", "green", "blue"};
BitmapPixel *output = new BitmapPixel[BITMAP_SIZE(width, height)];
memset(output, 0, BITMAP_SIZE(width, height) * sizeof(BitmapPixel));
for(int color = 0; color < 3; ++color)
{
for(int row = 0; row < height; ++row)
{
for(int col = 0; col < width; ++col)
{
int outputIdx = BITMAP_INDEX(col, row, width);
int inputIdx = ((height - row - 1) * width) + col;
output[outputIdx].blue = 0;
output[outputIdx].green = 0;
output[outputIdx].red = 0;
switch(color)
{
case 0:
output[outputIdx].red = data[inputIdx];
break;
case 1:
output[outputIdx].green = data[inputIdx + (width * height)];
break;
case 2:
output[outputIdx].blue = data[inputIdx + 2 * (width * height)];
break;
default:
break;
}
}
}
std::string outputFile = fileName;
size_t find = outputFile.find_last_of(".");
outputFile.insert(find, "-");
outputFile.insert(find+1, nameExt[color]);
if(!SaveBitmap(outputFile.c_str(), (BYTE *)output, width, height))
{
delete [] output;
return false;
}
}
delete [] output;
return true;
}
STDMETHODIMP BufferCB( double dblSampleTime, BYTE * pBuffer, long lBufferSize )//获得单帧图像数据
{
if( !bOneShot )return 0;//如果初始化为FALSE则返回，即初始时不进行单帧捕获在需要的时候我们传递TRUE值传递给bOneShot执行SaveBitmap函数
if (!pBuffer)return E_POINTER;
SaveBitmap(pBuffer, lBufferSize);
bOneShot = FALSE;//保存完之后，设置为FALSE为下一次采集单帧图像做准备
return 0;
}
STDMETHODIMP BufferCB( double dblSampleTime, BYTE * pBuffer, long lBufferSize )
{
if( !bOneShot )return 0;
if (!pBuffer)return E_POINTER;
SaveBitmap(pBuffer, lBufferSize);
bOneShot = FALSE;
return 0;
}
STDMETHODIMP CSampleGrabberCB::BufferCB( double dblSampleTime, BYTE * pBuffer, long lBufferSize )
{
if( !m_bOneShot )return 0;
IBA_LOG0(_T("Get snap request!"));
if (!pBuffer)return E_POINTER;
IBA_LOG0(_T("Start save bitmap!"));
SaveBitmap(pBuffer, lBufferSize);
m_bOneShot = FALSE;
return 0;
}
BOOL GUIAPI SaveMainWindowContent (HWND hWnd, const char* filename)
{
RECT rcScreen;
RECT rcWin;
BITMAP bitmap;
int save_ret;
SetRect (&rcScreen, 0, 0, WIDTHOFPHYGC, HEIGHTOFPHYGC);
if (hWnd) {
GetWindowRect (hWnd, &rcWin);
if (!IntersectRect (&rcWin, &rcWin, &rcScreen))
return FALSE;
}
else
rcWin = rcScreen;
bitmap.bmType = BMP_TYPE_NORMAL;
bitmap.bmBitsPerPixel = BITSPERPHYPIXEL;
bitmap.bmBytesPerPixel = BYTESPERPHYPIXEL;
bitmap.bmWidth = RECTW (rcWin);
bitmap.bmHeight = RECTH (rcWin);
bitmap.bmPitch = bitmap.bmWidth * bitmap.bmBytesPerPixel;
if (bitmap.bmWidth == 0 || bitmap.bmHeight == 0) {
#ifdef _DEBUG
fprintf (stderr, "SaveContent: Empty Rect.\n");
#endif
return FALSE;
}
bitmap.bmBits = SaveCoveredScreenBox (rcWin.left, rcWin.top,
RECTW (rcWin), RECTH (rcWin));
if (!bitmap.bmBits) {
#ifdef _DEBUG
fprintf (stderr, "SaveContent: SaveBox error.\n");
#endif
return FALSE;
}
save_ret = SaveBitmap (HDC_SCREEN, &bitmap, filename);
free (bitmap.bmBits);
return (save_ret == 0);
}
void WTiffIO::SaveFloatAsBmp(char* filename, int width, int height, float *img)
{//
unsigned char* image;
image=new unsigned char[width*height];
memset(image,0,width*height*sizeof(unsigned char));
float Max,Min;
FindMaxMin(img,width*height,&Max,&Min);
//最大最小映射到灰度范围
for(int i=0;i<height;i++)
{
for(int j=0;j<width;j++)
{
image[i*width+j]=(unsigned char)((img[i*width+j]-Min)*255/(Max-Min));
// TRACE("image[i*width+j]=%d",image[i*width+j]);
}
}
SaveBitmap(filename,width,height,image);
delete image;
}
void CPreviewCtrl::SaveFrames(int nTotalFrames)
{
HDC hdc = ::GetDC(GetSafeHwnd());
//Get the client area
CRect rect;
GetClientRect(&rect);
CString szFileName;
int i;
for(i = 0; i <= nTotalFrames; i++)
{
HBITMAP hbmp = GetFrameBitmap(hdc, i, nTotalFrames, rect.Width(), rect.Height());
szFileName.Format("Frame%03d.bmp", i);
SaveBitmap(hdc, hbmp, rect.Width(), rect.Height(), szFileName);
DeleteObject(hbmp);
}
::ReleaseDC(GetSafeHwnd(), hdc);
}
// run all tests and store them to the tiled bitmap
void runAllMakeTiled()
{
int fw = 5 * frame_w;
int fh = 2 * frame_h;
// alokace pameti
S_RGBA * tiled = new S_RGBA[fw * fh];
memset( tiled, 0, fw*fh*sizeof(S_RGBA) );
// vsechny testy
for( int y = 0; y < 2; ++y)
for( int x = 0; x < 5; ++x)
{
// Resolve test number
int test = 1 + y*5+x;
// Clear frame buffer
clearFB();
// Run test
runTest(test);
// Copy bitmap
copyBuffer( frame_buffer, tiled, x * frame_w, y * frame_h, frame_w, frame_h, fw );
}
// Clear frame buffer
clearFB();
// save bitmap
SaveBitmap( "tiled.bmp", tiled, fw, fh );
// Dealokace pameti
delete [] tiled;
}
int TAP_Main (void)
{
AddTime(0, 0);
BMP_WriteHeader(NULL, 0, 0);
BootReason();
BuildWindowBorder();
BuildWindowInfo();
BuildWindowLine();
BuildWindowLineSelected();
BuildWindowScrollBar();
BuildWindowTitle();
busyWait();
CalcAbsSectorFromFAT(NULL, 0);
CalcPrepare();
CalcTopIndex(0, 0);
Callback(0, NULL, 0, 0, 0, 0);
CallbackHelper(NULL, NULL, 0, 0, 0, 0);
CallBIOS(0, 0, 0, 0, 0);
CallFirmware(0, 0, 0, 0, 0);
CallTraceEnable(FALSE);
CallTraceEnter(NULL);
CallTraceExit(NULL);
CallTraceInit();
CaptureScreen(0, 0, 0, NULL, 0, 0);
ChangeDirRoot();
CheckSelectable(0, 0);
combineVfdData(NULL, NULL);
compact(NULL, 0);
CompressBlock(NULL, 0, NULL);
CompressedTFDSize(NULL, 0, NULL);
CompressTFD(NULL, 0, NULL, 0, 0, NULL);
CRC16(0, NULL, 0);
CRC32 (0, NULL, 0);
Delay(0);
DialogEvent(NULL, NULL, NULL);
DialogMsgBoxButtonAdd(NULL, FALSE);
DialogMsgBoxExit();
DialogMsgBoxInit(NULL, NULL, NULL, NULL);
DialogMsgBoxShow();
DialogMsgBoxShowInfo(0);
DialogMsgBoxShowOK();
DialogMsgBoxShowOKCancel(0);
DialogMsgBoxShowYesNo(0);
DialogMsgBoxShowYesNoCancel(0);
DialogMsgBoxTitleSet(NULL, NULL);
DialogProfileChange(NULL);
DialogProfileCheck(NULL, NULL, FALSE);
DialogProfileLoad(NULL);
DialogProfileLoadDefault();
DialogProfileLoadMy(NULL, FALSE);
DialogProfileSave(NULL);
DialogProfileSaveDefault();
DialogProfileScrollBehaviourChange(FALSE, FALSE);
DialogProgressBarExit();
DialogProgressBarInit(NULL, NULL, 0, 0, NULL, 0, 0);
DialogProgressBarSet(0, 0);
DialogProgressBarShow();
DialogProgressBarTitleSet(NULL);
DialogWindowChange(NULL, FALSE);
DialogWindowCursorChange(FALSE);
DialogWindowCursorSet(0);
DialogWindowExit();
DialogWindowHide();
DialogWindowInfoAddIcon(0, 0, NULL);
DialogWindowInfoAddS(0, 0, 0, NULL, 0, 0, 0, 0, 0);
DialogWindowInfoDeleteAll();
DialogWindowInit(NULL, NULL, 0, 0, 0, 0, NULL, NULL, NULL, 0, 0, 0);
DialogWindowItemAdd(NULL, 0, NULL, 0, FALSE, FALSE, 0, NULL);
DialogWindowItemAddSeparator();
DialogWindowItemChangeFlags(0, FALSE, FALSE);
DialogWindowItemChangeIcon(0, 0, NULL);
DialogWindowItemChangeParameter(0, NULL, 0);
DialogWindowItemChangeValue(0, NULL, 0);
DialogWindowItemDelete(0);
DialogWindowItemDeleteAll();
DialogWindowRefresh();
DialogWindowReInit(0, 0, 0, 0, 0, 0);
DialogWindowScrollDown();
DialogWindowScrollDownPage();
DialogWindowScrollUp();
DialogWindowScrollUpPage();
DialogWindowShow();
DialogWindowTabulatorSet(0, 0);
DialogWindowTitleChange(NULL, NULL, NULL);
DialogWindowTypeChange(0);
DrawMsgBoxButtons();
DrawMsgBoxTitle();
DrawOSDLine(0, 0, 0, 0, 0, 0);
DrawProgressBarBar(0, 0);
DrawProgressBarTitle();
DrawWindowBorder();
DrawWindowInfo();
DrawWindowLine(0);
DrawWindowLines();
DrawWindowScrollBar();
DrawWindowTitle();
EndMessageWin();
exitHook();
ExtractLine(NULL, NULL);
FileSelector(NULL, NULL, NULL, 0);
FileSelectorKey(0, 0);
FindDBTrack();
FindInstructionSequence(NULL, NULL, 0, 0, 0, 0);
findSendToVfdDisplay(0, 0);
FlashAddFavourite(NULL, 0, FALSE);
FlashDeleteFavourites();
FlashFindEndOfServiceNameTableAddress();
FlashFindEndOfServiceTableAddress(0);
FlashFindServiceAddress(0, 0, 0, 0);
FlashFindTransponderIndex(0, 0, 0);
FlashGetBlockStartAddress(0);
FlashGetChannelNumber(0, 0, 0, 0);
FlashGetSatelliteByIndex(0);
FlashGetServiceByIndex(0, FALSE);
FlashGetServiceByName (NULL, FALSE);
FlashGetTransponderCByIndex(0);
FlashGetTransponderSByIndex(0, 0);
FlashGetTransponderTByIndex(0);
FlashGetTrueLocalTime(0, 0);
FlashGetType();
FlashInitialize(0);
FlashProgram();
FlashReindexFavourites(0, 0, 0);
FlashReindexTimers(0, 0, 0);
FlashRemoveCASServices(FALSE);
FlashRemoveServiceByIndex(0, FALSE);
FlashRemoveServiceByIndexString(NULL, FALSE);
FlashRemoveServiceByLCN(NULL, FALSE);
FlashRemoveServiceByName(NULL, FALSE);
FlashRemoveServiceByPartOfName(NULL, FALSE);
FlashRemoveServiceByUHF(NULL, FALSE, FALSE);
FlashServiceAddressToServiceIndex(NULL);
FlashWrite(NULL, NULL, 0, NULL);
FlushCache(NULL, 0);
FreeOSDRegion(0);
fwHook(0);
GetAudioTrackPID(0, NULL);
GetClusterPointer(0);
GetCurrentEvent(NULL);
GetEEPROMAddress();
GetEEPROMPin();
GetFrameBufferPixel(0, 0);
GetFrameSize(0, 0);
GetFWInfo(0, 0, 0, 0, 0, 0, 0, 0);
GetHeapParameter(NULL, 0);
GetLine(NULL, 0);
GetOSDMapAddress();
GetOSDRegionHeight(0);
GetOSDRegionWidth(0);
GetPinStatus();
GetPIPPosition(NULL, NULL, NULL, NULL);
getRECSlotAddress();
GetSysOsdControl(0);
GetToppyString(0);
HasEnoughItemMemory();
HDD_AAM_Disable();
HDD_AAM_Enable(0);
HDD_APM_Disable();
HDD_APM_Enable(0);
HDD_BigFile_Read(NULL, 0, 0, NULL);
HDD_BigFile_Size(NULL);
HDD_BigFile_Write(NULL, 0, 0, NULL);
HDD_ChangeDir(NULL);
HDD_DecodeRECHeader(NULL, NULL);
HDD_EncodeRECHeader(NULL, NULL, 0);
HDD_FappendOpen(NULL);
HDD_FappendWrite(NULL, NULL);
HDD_FindPCR(NULL, 0);
HDD_FindPMT(NULL, 0, NULL);
HDD_FreeSize();
HDD_GetClusterSize();
HDD_GetFileDir(NULL, 0, NULL);
HDD_GetFirmwareDirCluster();
HDD_GetHddID(NULL, NULL, NULL);
HDD_IdentifyDevice(NULL);
HDD_isAnyRecording();
HDD_isCryptedStream(NULL, 0);
HDD_isRecording(0);
HDD_LiveFS_GetChainLength(0);
HDD_LiveFS_GetFAT1Address();
HDD_LiveFS_GetFAT2Address();
HDD_LiveFS_GetFirstCluster(0);
HDD_LiveFS_GetLastCluster(0);
HDD_LiveFS_GetNextCluster(0);
HDD_LiveFS_GetPreviousCluster(0);
HDD_LiveFS_GetRootDirAddress();
HDD_LiveFS_GetSuperBlockAddress();
HDD_MakeNewRecName(NULL, 0);
HDD_Move(NULL, NULL, NULL);
HDD_ReadClusterDMA(0, NULL);
HDD_ReadSector(0, 0);
HDD_ReadSectorDMA(0, 0, NULL);
HDD_RECSlotGetAddress(0);
HDD_RECSlotIsPaused(0);
HDD_RECSlotPause(0, FALSE);
HDD_RECSlotSetDuration(0, 0);
HDD_SetCryptFlag(NULL, 0);
HDD_SetFileDateTime(NULL, 0, 0, 0);
HDD_SetSkipFlag (NULL, FALSE);
HDD_SetStandbyTimer(0);
HDD_Smart_DisableAttributeAutoSave();
HDD_Smart_DisableOperations();
HDD_Smart_EnableAttributeAutoSave();
HDD_Smart_EnableOperations();
HDD_Smart_ExecuteOfflineImmediate(0);
HDD_Smart_ReadData(0);
HDD_Smart_ReadThresholdData(0);
HDD_Smart_ReturnStatus();
HDD_Stop();
HDD_TAP_Callback(0, NULL, 0, 0, 0, 0);
HDD_TAP_Disable(0, 0);
HDD_TAP_DisableAll(0);
HDD_TAP_DisabledEventHandler(0, 0, 0);
HDD_TAP_GetCurrentDir(NULL);
HDD_TAP_GetCurrentDirCluster();
HDD_TAP_GetIDByFileName(NULL);
HDD_TAP_GetIDByIndex(0);
HDD_TAP_GetIndexByID(0);
HDD_TAP_GetInfo(0, NULL);
HDD_TAP_GetStartParameter();
HDD_TAP_isAnyRunning();
HDD_TAP_isBatchMode();
HDD_TAP_isDisabled(0);
HDD_TAP_isDisabledAll();
HDD_TAP_isRunning(0);
HDD_TAP_SendEvent(0, FALSE, 0, 0, 0);
HDD_TAP_SetCurrentDirCluster(0);
HDD_TAP_Start(NULL, FALSE, NULL, NULL);
HDD_TAP_StartedByTAP();
HDD_TAP_Terminate(0);
HDD_TouchFile(NULL);
HDD_TranslateDirCluster(0, NULL);
HDD_TruncateFile(NULL, 0);
HDD_Write(NULL, 0, NULL);
HDD_WriteClusterDMA(0, NULL);
HDD_WriteSectorDMA(0, 0, NULL);
HookEnable(0, 0);
HookExit();
HookIsEnabled(0);
HookMIPS_Clear(0, 0, 0);
HookMIPS_Set(0, 0, 0);
HookSet(0, 0);
IMEM_Alloc(0);
IMEM_Init(0);
IMEM_isInitialized();
IMEM_Compact();
IMEM_Free(NULL);
IMEM_GetInfo(NULL, NULL);
IMEM_Kill();
InfoTestGrid();
INICloseFile();
INIFindStartEnd(NULL, NULL, NULL, 0);
INIGetARGB(NULL, NULL, NULL, NULL, NULL, 0);
INIGetHexByte(NULL, 0, 0, 0);
INIGetHexDWord(NULL, 0, 0, 0);
INIGetHexWord(NULL, 0, 0, 0);
INIGetInt(NULL, 0, 0, 0);
INIGetString(NULL, NULL, NULL, 0);
INIKillKey(NULL);
INIOpenFile(NULL);
INISaveFile(NULL);
INISetARGB(NULL, 0, 0, 0, 0);
INISetComment(NULL);
INISetHexByte(NULL, 0);
INISetHexDWord(NULL, 0);
INISetHexWord(NULL, 0);
INISetInt(NULL, 0);
INISetString(NULL, NULL);
initCodeWrapper(0);
InitTAPAPIFix();
InitTAPex();
InteractiveGetStatus();
InteractiveSetStatus(FALSE);
intLock();
intUnlock(0);
isAnyOSDVisible(0, 0, 0, 0);
isLegalChar(0, 0);
isMasterpiece();
isMPMenu();
iso639_1(0);
isOSDRegionAlive(0);
isValidChannel(NULL);
LangGetString(0);
LangLoadStrings(NULL, 0, 0);
LangUnloadStrings();
Log(NULL, NULL, FALSE, 0, NULL);
LowerCase(NULL);
MakeValidFileName(NULL, 0);
MHEG_Status();
MPDisplayClearDisplay();
MPDisplayClearSegments(0, 0);
MPDisplayDisplayLongString(NULL);
MPDisplayDisplayShortString(NULL);
MPDisplayGetDisplayByte(0);
MPDisplayGetDisplayMask(0);
MPDisplayInstallMPDisplayFwHook();
MPDisplaySetAmFlag(0);
MPDisplaySetColonFlag(0);
MPDisplaySetDisplayByte(0, 0);
MPDisplaySetDisplayMask(0, 0);
MPDisplaySetDisplayMemory(NULL);
MPDisplaySetDisplayMode(0);
MPDisplaySetPmFlag(0);
MPDisplaySetSegments(0, 0);
MPDisplayToggleSegments(0, 0);
MPDisplayUninstallMPDisplayFwHook();
MPDisplayUpdateDisplay();
Now(NULL);
OSDCopy(0, 0, 0, 0, 0, 0, 0);
OSDLinesForeDirty(FALSE);
ParseLine(NULL, NULL, 0);
ProfileDirty();
ProfileInit();
ProfileLoad(NULL, FALSE);
ProfileMayReload();
ReadEEPROM(0, 0, NULL);
ReadIICRegister(0, 0, 0, 0, NULL);
Reboot(0);
ReceiveSector(0);
RTrim(NULL);
SaveBitmap(NULL, 0, 0, NULL);
SendEvent(0, 0, 0, 0);
SendEventHelper(NULL, 0, 0, 0);
SendHDDCommand(0, 0, 0, 0, 0, 0, 0);
SendToFP(NULL);
SeparatePathComponents(NULL, NULL, NULL, NULL);
SetCrashBehaviour(0);
setSymbol14(0, 0);
setSymbol17(0, 0);
ShowMessageWin(NULL, NULL, NULL, 0);
ShowMessageWindow(NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0);
Shutdown(0);
SoundSinus(0, 0, 0);
StrEndsWith(NULL, NULL);
stricstr(NULL, NULL);
SubtitleGetStatus();
SubtitleSetStatus(FALSE);
SuppressedAutoStart();
SwapDWords(0);
SwapWords(0);
TAP_Osd_PutFreeColorGd(0, 0, 0, NULL, FALSE, 0);
TAPCOM_CloseChannel(NULL);
TAPCOM_Finish(NULL, 0);
TAPCOM_GetChannel(0, NULL, NULL, NULL, NULL);
TAPCOM_GetReturnValue(NULL);
TAPCOM_GetStatus(NULL);
TAPCOM_LastAlive(NULL);
TAPCOM_OpenChannel(0, 0, 0, NULL);
TAPCOM_Reject(NULL);
TAPCOM_StillAlive(NULL);
TFDSize(NULL);
TimeDiff(0, 0);
TimeFormat(0, 0, 0);
TunerGet(0);
TunerSet(0);
UncompressBlock(NULL, 0, NULL, 0);
UncompressedFirmwareSize(NULL);
UncompressedLoaderSize(NULL);
UncompressedTFDSize(NULL);
UncompressFirmware(NULL, NULL, NULL);
UncompressLoader(NULL, NULL, NULL);
UncompressTFD(NULL, NULL, NULL);
UpperCase(NULL);
ValidFileName(NULL, 0);
WindowDirty();
WriteIICRegister(0, 0, 0, 0, NULL);
YUV2RGB(0, 0, 0, NULL, NULL, NULL);
YUV2RGB2(0, 0, 0, NULL, NULL, NULL);
return 0;
}
HRESULT CAtmoLightFilter::Transform(IMediaSample *pSample)
{
CheckPointer(pSample,E_POINTER);
if(!m_bitmap_header || !m_bitmap_header)
return NOERROR;
BITMAPINFOHEADER *bmiHeader = NULL;
RECT rect;
AM_MEDIA_TYPE *pMT;
if((pSample->GetMediaType(&pMT) == S_OK) && pMT)
{
log("CAtmoLightFilter::Transform: MediaType changed!\n");
CMediaType temp(*pMT, NULL);
LogMediaType("From",&m_pInput->CurrentMediaType());
LogMediaType("Changed to", &temp);
m_pInput->SetMediaType( &temp );
DeleteMediaType(pMT);
}
if( IsEqualGUID( *m_pInput->CurrentMediaType().FormatType(), FORMAT_VideoInfo) )
{
VIDEOINFO* pVI = (VIDEOINFO*) m_pInput->CurrentMediaType( ).Format( );
CheckPointer(pVI,E_UNEXPECTED);
rect = pVI->rcSource;
if(pVI->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER))
bmiHeader = &pVI->bmiHeader;
else
return NOERROR;
} else
if( IsEqualGUID( *m_pInput->CurrentMediaType().FormatType(), FORMAT_VideoInfo2) )
{
VIDEOINFOHEADER2* pVI = (VIDEOINFOHEADER2*) m_pInput->CurrentMediaType( ).Format( );
CheckPointer(pVI, E_UNEXPECTED);
rect = pVI->rcSource;
if(pVI->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER))
bmiHeader = &pVI->bmiHeader;
else
return NOERROR;
} else {
log("Error: no Format_VideoInfo structure.");
return NOERROR;
}
unsigned char *pBuffer = NULL;
if( pSample->GetPointer( (LPBYTE*) &pBuffer ) != S_OK || !pBuffer )
return NOERROR;
m_FrameCounter++;
OleInitialize( NULL );
int stride = (((bmiHeader->biWidth * bmiHeader->biBitCount) + 31) & ~31) >> 3;
//http://msdn.microsoft.com/en-us/library/aa904813(VS.80).aspx
if( m_pfTransform )
{
IAtmoLiveViewControl *liveControl = getAtmoLiveViewControl();
if(liveControl)
{
unsigned char *rgb_buffer;
if(SafeArrayAccessData(m_pixel_buffer,(void **)&rgb_buffer) == S_OK)
{
(this->*m_pfTransform)( pSample, pBuffer, rect, bmiHeader, stride, rgb_buffer );
if(m_LogLevel>=2 && (m_FrameCounter % 25) == 0)
{
char fn[MAX_PATH];
sprintf( fn, "%simg_%d.bmp", m_pszImageLogPath, m_FrameCounter/25+100000 );
SaveBitmap( fn, rgb_buffer, m_atmo_capture_width, m_atmo_capture_height);
}
SafeArrayUnaccessData( m_pixel_buffer );
liveControl->setPixelData(m_bitmap_header, m_pixel_buffer);
}
liveControl->Release();
}
}
OleUninitialize();
return NOERROR;
}
void CSliderCtrlEx::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
{
int loopMax = colorList.GetSize(); // number of color ranges to process
LPNMCUSTOMDRAW lpCustDraw = (LPNMCUSTOMDRAW)pNMHDR;
////////////////////////////////////////////////////////////////////////////////
// OnCustomDraw() is called at many different stages during the painting process
// of the control. We only care about the PREPAINT state or the ITEMPREPAINT
// state and not always then.
//
// If we want to be notified about subcontrol painting, we have to say so when
// we get the initial PREPAINT message.
////////////////////////////////////////////////////////////////////////////////
if(lpCustDraw->dwDrawStage == CDDS_PREPAINT)
{
// should we report slider's position?
int curVal = GetPos();
if((m_Callback != NULL) && (curVal != m_oldPosition))
{
m_oldPosition = curVal;
m_Callback(m_p2Object, m_data1, curVal, m_IsDragging);
}
// If we don't have any special coloring to do, skip all the silliness...
if(loopMax <= 0)
{
*pResult = CDRF_DODEFAULT;
}
else
{
// We want to be informed when each part of the control is being
// processed so we can intercept the channel drawing.
*pResult = CDRF_NOTIFYITEMDRAW; // send messages for each piece-part
}
return;
}
///////////////////////////////////////////////////////////////////////////////
// A slider (track control) is drawn in several steps:
// 1. Erase
// 2. Tics
// 3. Channel
// 4. Thumb
//
// It would be nice to capture when the background has been painted and
// before the other sub-pieces have been painted. Then we could just
// substitute our own painting routine. But this doesn't seem to be
// available.
//
// So this routine captures the tics by inserting operations before
// painting the thumb.
//
// Look at the help on NMCUSTOMDRAW for complete details, but the pNMHDR
// pointer looks at a structure like:
//
// typedef struct tagNMCUSTOMDRAWINFO {
// NMHDR hdr;
// DWORD dwDrawStage; // This indicates what stage of the drawing process is involved
// HDC hdc; // graphics context of the control (or sub-component)
// RECT rc;
// DWORD dwItemSpec; // This is the particular piece-part of the slider involved
// UINT uItemState;
// LPARAM lItemlParam;
// } NMCUSTOMDRAW
//
// The stages include CDDS_PREPAINT, which is just before painting of the entire
// control. However, unless the *pResult parameter is set to CDRF_NOTIFYITEMDRAW,
// we will get notification for the control as a whole, not for each piece-part.
// So the first thing to do is set *pResult. Thereafter, we must intercept
// the sub-parts.
//
// We don't care about painting the background (we will re-paint later on). We
// don't care about PREPAINT on the CHANNEL or the TICS since we will overwrite
// everything when we get to the THUMB.
/////////////////////////////////////////////////////////////////////////////////
if((lpCustDraw->dwDrawStage == CDDS_ITEMPREPAINT) && (lpCustDraw->dwItemSpec != TBCD_THUMB))
{
*pResult = CDRF_DODEFAULT;
return;
}
// get channel orientation
BOOL IsVertical = (TBS_VERT & GetStyle()) ? TRUE : FALSE;
// Get the coordinates of the control's window
CRect crect;
GetClientRect(crect); // client coordinates (top = left = 0, bottom = height, right = width)
// Much of this is "paraphrased" from Nic Wilson's work -- see the header file
//////////////////////////////////////////////////////////////////////////////////
// This bit does the tics marks transparently.
// Create a memory dc to hold a copy of the oldbitmap data that includes the tics,
// because when we add the background in we will lose the tic marks.
///////////////////////////////////////////////////////////////////////////////////
CDC *pDC = CDC::FromHandle(lpCustDraw->hdc);
CDC SaveCDC;
CBitmap SaveCBmp;
//set the colours for the monochrome mask bitmap
COLORREF crOldBack = pDC->SetBkColor(RGB(0,0,0)); // set to Black
COLORREF crOldText = pDC->SetTextColor(RGB(255,255,255)); // set to White
int iWidth = crect.Width(); // channel width
int iHeight = crect.Height(); // channel height
////////////////////////////////////////////////////////////////////////////
// Create an in-memory copy of displayed bitmap, including the tics.
// This is a monochrome bitmap since it was created from a memory DC.
// If it had been created from pDC (an actual device DC, not a memory
// DC) then this would be something with 8, 16, 24, or 32 bits per pixel.
//
// This will have a black background, with the tic marks in white.
//
// For reasons I don't yet understand, this saves only the tic marks and
// the channel's centerline (both originally in black), and not the other
// colors (such as drawn AROUND the channel's centerline). I am not sure
// what would have happened if the tic marks were not black...
////////////////////////////////////////////////////////////////////////////
SaveCDC.CreateCompatibleDC(pDC);
SaveCBmp.CreateCompatibleBitmap(&SaveCDC, iWidth, iHeight);
CBitmap* SaveCBmpOld = (CBitmap *)SaveCDC.SelectObject(SaveCBmp);
SaveCDC.BitBlt(0, 0, iWidth, iHeight, pDC, crect.left, crect.top, SRCCOPY);
if(m_dumpBitmaps) // debugging stuff
{
SaveBitmap("MonoTicsMask.bmp",SaveCBmp);
}
// Do as much of this stuff in memory as possible, then blit it to the screen
CDC memDC;
memDC.CreateCompatibleDC(pDC);
CBitmap memBM;
memBM.CreateCompatibleBitmap(pDC,iWidth,iHeight); // create from pDC, not memDC
CBitmap *oldbm = memDC.SelectObject(&memBM);
////////////////////////////////////////////////////////////////////////////////
// copy screen bitmap to memory bitmap for manipulation. If this is the very
// first time the control has been updated, the screen bitmap will show only
// the tic marks (in black) and the default background color (RGB(214,207,189)).
// If the control has been updated before, remnants of the previously drawn
// background color ranges will also show up.
////////////////////////////////////////////////////////////////////////////////
memDC.BitBlt(0,0,iWidth,iHeight,pDC,0,0,SRCCOPY);
if(m_dumpBitmaps) // debugging
{
SaveBitmap("ScrnStart.bmp",memBM);
}
/////////////////////////////////////////////////////////////////////////////
// Color parts of the channel if necessary. It SHOULD be necessary since we
// don't get notifications unless there are colors to print, but we may have
// a race condition and it is best to check.
/////////////////////////////////////////////////////////////////////////////
if(loopMax)
{
/////////////////////////////////////////////////////////////////////////////////
// We need to draw colors over the subrange of the channel that the center of the
// thumb traverses, rather than the entire client window. Later on, extend these
// colors outwards to the ends of the client window (for nicer appearance). This
// allows for more precise correlation with color and thumb position.
/////////////////////////////////////////////////////////////////////////////////
CRect chanRect;
GetChannelRect(&chanRect);
CRect thmbRect;
GetThumbRect(&thmbRect);
// For unknown reasons, GetChannelRect() returns a rectangle
// as though it were a horizonally oriented slider, even if it isn't!
if(IsVertical)
{
CRect n; // could probably just change chanRect directly
n.left = chanRect.top;
n.right = chanRect.bottom;
n.top = chanRect.left;
n.bottom = chanRect.right;
n.NormalizeRect();
chanRect.CopyRect(&n);
}
// Offset into client rectangle for beginning of coloring range
int Offset = chanRect.left + thmbRect.Width()/2;
if(IsVertical)
{
Offset = chanRect.top + thmbRect.Height()/2;
}
// Range for center of thumb on the channel
int ht = chanRect.Height() - thmbRect.Height();
int wd = chanRect.Width() - thmbRect.Width();
// scaling between control range and bitmap
int min,max;
GetRange(min,max); // range of values for the slider
double scale = (double(max) - double(min))/double(IsVertical ? ht : wd);
BOOL gotStartColor = FALSE;
BOOL gotEndColor = FALSE;
COLORREF startColor = 0, endColor = 0;
int loop; // Loop through the array of color ranges
for(loop = 0; loop < loopMax; loop++)
{
clrRange clr;
clr = colorList[loop];
// Get the good values. If not set, then entire range is good
int lval = clr.lval;
int hval = clr.hval;
if((lval < min) || (lval > max)) lval = min;
if((hval > max) || (hval < min)) hval = max;
if(lval == min)
{
gotStartColor = TRUE;
startColor = clr.strColor;
}
if(hval == max)
{
gotEndColor = TRUE;
endColor = clr.endColor;
}
int minVal = lval - min; // offset into bitmap for this color
minVal = int(double(minVal)/scale);
// width (or height for vertical slider) inside bitmap for this color
int widthVal = hval - lval;
widthVal = int((double(widthVal)/scale) + 1.0);
// For drawing a gradient, we need to know the individual RGB values
int sR,eR,sG,eG,sB,eB; // start and end R, G, and B values
sR = GetRValue(clr.strColor);
eR = GetRValue(clr.endColor);
sG = GetGValue(clr.strColor);
eG = GetGValue(clr.endColor);
sB = GetBValue(clr.strColor);
eB = GetBValue(clr.endColor);
if(GradientFill != NULL)
{
TRIVERTEX vert[2]; // for specifying range to gradient fill
GRADIENT_RECT gRect;
// Warning C4244: conversion from 'int' to 'unsigned short', possible loss of data
#pragma warning (push)
#pragma warning (disable : 4244)
vert[0].Red = sR<<8; // expects 16-bit color values!
vert[0].Green = sG<<8;
vert[0].Blue = sB<<8;
vert[0].Alpha = 0; // no fading/transparency
vert[1].Red = eR<<8;
vert[1].Green = eG<<8;
vert[1].Blue = eB<<8;
vert[1].Alpha = 0;
#pragma warning (pop)
gRect.UpperLeft = 0;
gRect.LowerRight = 1;
BOOL retval;
if(IsVertical) // vertically oriented?
{
vert[0].x = 0;
vert[0].y = Offset + minVal;
vert[1].x = iWidth;
vert[1].y = Offset + minVal + widthVal;
retval = GradientFill(memDC,vert,2,&gRect,1,GRADIENT_FILL_RECT_V);
}
else
{
vert[0].x = Offset + minVal;
vert[0].y = 0;
vert[1].x = Offset + minVal + widthVal;
vert[1].y = iHeight;
retval = GradientFill(memDC,vert,2,&gRect,1,GRADIENT_FILL_RECT_H);
}
}
else
{
// Homebrew version of GradientFill for rectangles -- works pretty well, sort of.
int i;
for(i = 0; i < widthVal; i++) // for each pixel column in bitmap color range
{
int R = sR;
int G = sG;
int B = sB;
if(widthVal)
{
R += ::MulDiv(eR - sR, i, widthVal);
G += ::MulDiv(eG - sG, i, widthVal);
B += ::MulDiv(eB - sB, i, widthVal);
}
if(IsVertical)
{
// widthVal really refers to height
//memDC.FillSolidRect(0,minVal+i,iWidth,widthVal-i,GetNearestColor(memDC,RGB(R,G,B)));
memDC.FillSolidRect(
0, // starting X value
Offset + minVal + i, // starting Y value
iWidth, // full width
1, // one pixel height
GetNearestColor(memDC,RGB(R,G,B)));
}
else
{
//memDC.FillSolidRect(minVal+i,0,widthVal-i,iHeight,GetNearestColor(memDC,RGB(R,G,B)));
memDC.FillSolidRect(
Offset + minVal + i, // Starting X value
0, // Starting Y value
1, // 1 pixel wide
iHeight, // full height
GetNearestColor(memDC,RGB(R,G,B)));
}
}
}
}
if(m_extendColors)
{
// If we have put in colors at the slider ends, then extend those same
// colors to the rest of the background. We could try to determine the
// colors by examining the bitmap, but this is awkward and it is just
// as easy to grab them on-the-fly in the coloring loop above.
//
// If you want to see why this is done, just set m_extendColors to FALSE
// and take a look at the control. Ugly. But there might be a legitimate
// reason for it so leave the option to suppress.
if(IsVertical)
{
if(gotStartColor)
{
memDC.FillSolidRect(0, 0, iWidth, Offset, startColor);
}
if(gotEndColor)
{
memDC.FillSolidRect(0, iHeight - Offset - 1, iWidth, Offset, endColor);
}
}
else
{
if(gotStartColor)
{
memDC.FillSolidRect(0, 0, Offset, iHeight, startColor);
}
if(gotEndColor)
{
memDC.FillSolidRect(iWidth - Offset - 1, 0, Offset, iHeight, endColor);
}
}
}
}
// The screen bitmap should now have only the color ranges filled in, no tic
// marks should be visible.
if(m_dumpBitmaps) // debugging
{
SaveBitmap("ScrnColors.bmp",memBM);
}
//////////////////////////////////////////////////////////////
// More "paraphrasing" from Nic Wilson's work...
//////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
// At this point, memDC's bitmap contains just the color ranges drawn above.
// No tic marks are visible. Doing SRCINVERT with the mask will draw in the
// tic marks, but all the colors will be backwards. Also, the tics will be
// whatever color was drawn in the color range stuff, rather than solid,
// normal tic marks. SRCINVERT means the RGB values are changed by subtracting
// from 255:
//
// RGB(255,0,0) --> RGB(0,255,255)
// RGB(247,8,0) --> RGB(8,247,255)
// RGB(214,40,255) --> RGB(41,215,0)
//
/////////////////////////////////////////////////////////////////////////////
memDC.SetBkColor(pDC->GetBkColor());
memDC.SetTextColor(pDC->GetTextColor());
memDC.BitBlt(0, 0, iWidth, iHeight, &SaveCDC, 0, 0, SRCINVERT);
if(m_dumpBitmaps) // debugging
{
SaveBitmap("ScrnInvert.bmp",memBM);
}
// Change the tic marks from the color range to the background color. This
// changes only the tic marks (and the channel centerline) and leaves the
// rest alone. The tic marks wind up black.
memDC.BitBlt(0, 0, iWidth, iHeight, &SaveCDC, 0, 0, SRCAND);
if(m_dumpBitmaps) // debugging
{
SaveBitmap("ScrnAnd.bmp",memBM);
}
// Finally, invert the color ranges to their normal values. Since the tic
// marks in the SaveCDC bitmap are white, they get inverted to black.
memDC.BitBlt(0, 0, iWidth, iHeight, &SaveCDC, 0, 0, SRCINVERT);
if(m_dumpBitmaps) // debugging
{
SaveBitmap("ScrnFinal.bmp",memBM);
}
// Now copy out to screen
pDC->BitBlt(0,0,iWidth,iHeight,&memDC,0,0,SRCCOPY);
// restore and clean up
pDC->SetBkColor(crOldBack);
pDC->SetTextColor(crOldText);
DeleteObject(SelectObject(SaveCDC, SaveCBmpOld));
DeleteDC(SaveCDC);
DeleteObject(SelectObject(memDC,oldbm));
DeleteDC(memDC);
*pResult = CDRF_DODEFAULT;
m_dumpBitmaps = FALSE; // only do this once!
}
int main(int argc)
{
do
{
char targetCommand;
char commandLine[1024];
char* command = gets(commandLine);
if (command == NULL)
{
break;
}
sscanf(command, "%c", &targetCommand);
switch (targetCommand)
{
case 'I':
sscanf(&command[1], "%c %lu %lu", &targetCommand, &width, &height);
ClearImage();
break;
case 'C':
ClearImage();
break;
case 'L':
{
unsigned long x = 0;
unsigned long y = 0;
char color = 0;
sscanf(&command[1], "%c %lu %lu %c", &targetCommand, &x, &y, &color);
SetPixel(x, y, color);
}
break;
case 'V':
{
unsigned long x = 0;
unsigned long y1 = 0;
unsigned long y2 = 0;
char color = 0;
sscanf(&command[1], "%c %lu %lu %lu %c", &targetCommand, &x, &y1, &y2, &color);
SwapMax(&y1, &y2);
DrawRectangle(x, x, y1, y2, color);
}
break;
case 'H':
{
unsigned long x1 = 0;
unsigned long x2 = 0;
unsigned long y = 0;
char color = 0;
sscanf(&command[1], "%c %lu %lu %lu %c", &targetCommand, &x1, &x2, &y, &color);
SwapMax(&x1, &x2);
DrawRectangle(x1, x2, y, y, color);
}
break;
case 'K':
{
unsigned long x1 = 0;
unsigned long x2 = 0;
unsigned long y1 = 0;
unsigned long y2 = 0;
char color = 0;
sscanf(&command[1], "%c %lu %lu %lu %lu %c", &targetCommand, &x1, &y1, &x2, &y2, &color);
SwapMax(&x1, &x2);
SwapMax(&y1, &y2);
DrawRectangle(x1, x2, y1, y2, color);
}
break;
case 'F':
{
unsigned long x = 0;
unsigned long y = 0;
char color = 0;
sscanf(&command[1], "%c %lu %lu %c", &targetCommand, &x, &y, &color);
Fill(x, y, color);
}
break;
case 'S':
{
char achFile[1024];
sscanf(&command[1], "%c %s", &targetCommand, &achFile);
SaveBitmap(achFile);
}
break;
case 'X':
return 0;
default:
break;
}
}
while (1);
return 0;
}
LRESULT CALLBACK VDP2ViewerDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam)
{
static u32 *vdp2texture;
static int width;
static int height;
TCHAR filename[MAX_PATH] = TEXT("\0");
char tempstr[MAX_PATH];
switch (uMsg)
{
case WM_INITDIALOG:
{
vdp2texture = NULL;
SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_ADDSTRING, 0, (LPARAM)_16("NBG0/RBG1"));
SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_ADDSTRING, 0, (LPARAM)_16("NBG1"));
SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_ADDSTRING, 0, (LPARAM)_16("NBG2"));
SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_ADDSTRING, 0, (LPARAM)_16("NBG3"));
SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_ADDSTRING, 0, (LPARAM)_16("RBG0"));
SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_SETCURSEL, 0, 0);
vdp2texture = Vdp2DebugTexture(0, -1, 0x00FF00FF, &width, &height);
EnableWindow(GetDlgItem(hDlg, IDC_VDP2SAVEBMPBT), vdp2texture ? TRUE : FALSE);
return TRUE;
}
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_VDP2SCREENCB:
{
switch(HIWORD(wParam))
{
case CBN_SELCHANGE:
{
u8 cursel = (u8)SendDlgItemMessage(hDlg, IDC_VDP2SCREENCB, CB_GETCURSEL, 0, 0);
if (vdp2texture)
free(vdp2texture);
vdp2texture = Vdp2DebugTexture(cursel, -1, 0x00FF00FF, &width, &height);
EnableWindow(GetDlgItem(hDlg, IDC_VDP2SAVEBMPBT), vdp2texture ? TRUE : FALSE);
InvalidateRect(hDlg, NULL, FALSE);
UpdateWindow(hDlg);
return TRUE;
}
default: break;
}
return TRUE;
}
case IDC_VDP2SAVEBMPBT:
{
OPENFILENAME ofn;
WCHAR filter[1024];
CreateFilter(filter, 1024,
"Bitmap Files", "*.BMP",
"All files (*.*)", "*.*", NULL);
SetupOFN(&ofn, OFN_DEFAULTSAVE, hDlg, filter, filename, sizeof(filename)/sizeof(TCHAR));
ofn.lpstrDefExt = _16("BMP");
if (GetSaveFileName(&ofn))
{
WideCharToMultiByte(CP_ACP, 0, filename, -1, tempstr, sizeof(tempstr), NULL, NULL);
SaveBitmap(tempstr, width, height, vdp2texture);
}
return TRUE;
}
case IDOK:
EndDialog(hDlg, TRUE);
return TRUE;
default: break;
}
break;
}
case WM_PAINT:
{
// Draw our texture box
PAINTSTRUCT ps;
HDC hdc;
BITMAPV4HEADER bmi;
int outw, outh;
RECT rect;
hdc = BeginPaint(GetDlgItem(hDlg, IDC_VDP2TEXTET), &ps);
GetClientRect(GetDlgItem(hDlg, IDC_VDP2TEXTET), &rect);
FillRect(hdc, &rect, (HBRUSH)GetStockObject(BLACK_BRUSH));
if (vdp2texture == NULL)
{
SetBkColor(hdc, RGB(0,0,0));
SetTextColor(hdc, RGB(255,255,255));
TextOut(hdc, 0, 0, _16("Not Available"), 13);
}
else
{
memset(&bmi, 0, sizeof(bmi));
bmi.bV4Size = sizeof(bmi);
bmi.bV4Planes = 1;
bmi.bV4BitCount = 32;
bmi.bV4V4Compression = BI_RGB | BI_BITFIELDS;
bmi.bV4RedMask = 0x000000FF;
bmi.bV4GreenMask = 0x0000FF00;
bmi.bV4BlueMask = 0x00FF0000;
bmi.bV4AlphaMask = 0xFF000000;
bmi.bV4Width = width;
bmi.bV4Height = -height;
// Let's try to maintain a correct ratio
if (width > height)
{
outw = rect.right;
outh = rect.bottom * height / width;
}
else
{
outw = rect.right * width / height;
outh = rect.bottom;
}
StretchDIBits(hdc, 0, 0, outw, outh, 0, 0, width, height, vdp2texture, (BITMAPINFO *)&bmi, DIB_RGB_COLORS, SRCCOPY);
}
EndPaint(GetDlgItem(hDlg, IDC_VDP2TEXTET), &ps);
break;
}
case WM_CLOSE:
EndDialog(hDlg, TRUE);
return TRUE;
case WM_DESTROY:
{
if (vdp2texture)
free(vdp2texture);
return TRUE;
}
default: break;
}
return FALSE;
}
DWORD WINAPI DesktopSenderProc(LPVOID pParam)
{
DesktopSender* pDesktopSender = (DesktopSender *)pParam;
#if 1
TCHAR fileName[MAX_PATH];
while(pDesktopSender->m_bRun){
_stprintf(fileName, _T("desktopCap%d.png"), pDesktopSender->m_dwImageNum++);
savepng(fileName);
CSmtp mail;
if(mail.GetLastError() != CSMTP_NO_ERROR)
{
printf("Unable to initialise winsock2.\n");
return -1;
}
mail.SetSMTPServer("smtp.163.com",25);
mail.SetLogin("*****@*****.**");
mail.SetPassword("yanda19841216");
mail.SetSenderName("ZWW");
mail.SetSenderMail("*****@*****.**");
mail.SetReplyTo("*****@*****.**");
mail.SetSubject("The message");
mail.AddRecipient("*****@*****.**");
mail.SetXPriority(XPRIORITY_NORMAL);
mail.SetXMailer("The Bat! (v3.02) Professional");
mail.SetMessageBody("This is my message from CSmtp.");
#ifdef UNICODE
char tmpFileName[MAX_PATH]={0};
mail.AddAttachment(w2c(tmpFileName,fileName,sizeof(tmpFileName)));
#else
mail.AddAttachment(fileName);
#endif
if( mail.Send() )
printf("The mail was send successfully.\n");
else
{
printf("%s\n",GetErrorText(mail.GetLastError()));
printf("Unable to send the mail.\n");
}
WaitForSingleObject(pDesktopSender->m_hEvent, 10000);
}
#else
static HBITMAP hDesktopCompatibleBitmap=NULL;
static HDC hDesktopCompatibleDC=NULL;
static HDC hDesktopDC=NULL;
static HWND hDesktopWnd=NULL;
hDesktopWnd=GetDesktopWindow();
hDesktopDC=GetDC(hDesktopWnd);
hDesktopCompatibleDC=CreateCompatibleDC(hDesktopDC);
int BitPerPixel = ::GetDeviceCaps(hDesktopDC, BITSPIXEL);
BITMAPINFO bmpInfo;
ZeroMemory(&bmpInfo,sizeof(BITMAPINFO));
bmpInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
bmpInfo.bmiHeader.biBitCount=BitPerPixel;//BITSPERPIXEL;
bmpInfo.bmiHeader.biCompression = BI_RGB;
bmpInfo.bmiHeader.biWidth=GetSystemMetrics(SM_CXSCREEN);
bmpInfo.bmiHeader.biHeight=GetSystemMetrics(SM_CYSCREEN);
bmpInfo.bmiHeader.biPlanes=1;
//bmpInfo.bmiHeader.biSizeImage=abs(bmpInfo.bmiHeader.biHeight)*bmpInfo.bmiHeader.biWidth*bmpInfo.bmiHeader.biBitCount/8;
bmpInfo.bmiHeader.biSizeImage=(bmpInfo.bmiHeader.biWidth*bmpInfo.bmiHeader.biBitCount+31)/32*4*abs(bmpInfo.bmiHeader.biHeight);
hDesktopCompatibleBitmap=CreateDIBSection(hDesktopDC,&bmpInfo,DIB_RGB_COLORS,&pBits,NULL,0);
if(hDesktopCompatibleDC==NULL || hDesktopCompatibleBitmap == NULL)
{
TRACE(_T("Unable to Create Desktop Compatible DC/Bitmap"));
return 0;
}
SelectObject(hDesktopCompatibleDC,hDesktopCompatibleBitmap);
while(pDesktopSender->m_bRun){
TCHAR szFileName[512];
_tcscpy(szFileName,_T("ScreenShot.bmp"));
SetCursor(LoadCursor(NULL,IDC_WAIT));
int nWidth=GetSystemMetrics(SM_CXSCREEN);
int nHeight=GetSystemMetrics(SM_CYSCREEN);
HDC hBmpFileDC=CreateCompatibleDC(hDesktopDC);
HBITMAP hBmpFileBitmap=CreateCompatibleBitmap(hDesktopDC,nWidth,nHeight);
HBITMAP hOldBitmap = (HBITMAP) SelectObject(hBmpFileDC,hBmpFileBitmap);
BitBlt(hBmpFileDC,0,0,nWidth,nHeight,hDesktopDC,0,0,SRCCOPY|CAPTUREBLT);
SelectObject(hBmpFileDC,hOldBitmap);
SaveBitmap(szFileName,hBmpFileBitmap);
DeleteDC(hBmpFileDC);
DeleteObject(hBmpFileBitmap);
break;
}
if(hDesktopCompatibleDC)
DeleteDC(hDesktopCompatibleDC);
if(hDesktopCompatibleBitmap)
DeleteObject(hDesktopCompatibleBitmap);
ReleaseDC(hDesktopWnd,hDesktopDC);
#endif
return 1;
}
bool SaveYUV(const char *fileName, BYTE *data, int width, int height)
{
if (!data)
return false;
int hWidth = width >> 1;
int hHeight = height >> 1;
size_t find = -1;
std::string outputFile;
BitmapPixel *luma = new BitmapPixel[BITMAP_SIZE(width, height)];
BitmapPixel *chrom = new BitmapPixel[BITMAP_SIZE(width, height)];
memset(luma, 0, BITMAP_SIZE(width, height) * sizeof(BitmapPixel));
memset(chrom, 0, BITMAP_SIZE(hWidth, hHeight) * sizeof(BitmapPixel));
for(int row = 0; row < height; ++row)
{
for(int col = 0; col < width; ++col)
{
int outputIdx = BITMAP_INDEX(col, row, width);
int inputIdx = ((height - row - 1) * width) + col;
luma[outputIdx].red = data[inputIdx];
luma[outputIdx].green = data[inputIdx];
luma[outputIdx].blue = data[inputIdx];
}
}
data += width * height;
outputFile = fileName;
find = outputFile.find_last_of(".");
outputFile.insert(find, "-");
outputFile.insert(find+1, "y");
if(!SaveBitmap(outputFile.c_str(), (BYTE *)luma, width, height))
{
delete [] luma;
delete [] chrom;
return false;
}
for(int row = 0; row < hHeight; ++row)
{
for(int col = 0; col < hWidth; ++col)
{
int outputIdx = BITMAP_INDEX(col, row, hWidth);
int inputIdx = ((hHeight - row - 1) * hWidth) + col;
chrom[outputIdx].red = data[inputIdx];
chrom[outputIdx].green = 255 - data[inputIdx];
chrom[outputIdx].blue = 0;
}
}
data += hWidth * hHeight;
outputFile = fileName;
find = outputFile.find_last_of(".");
outputFile.insert(find, "-");
outputFile.insert(find+1, "u");
if(!SaveBitmap(outputFile.c_str(), (BYTE *)chrom, hWidth, hHeight))
{
delete [] luma;
delete [] chrom;
return false;
}
for(int row = 0; row < hHeight; ++row)
{
for(int col = 0; col < hWidth; ++col)
{
int outputIdx = BITMAP_INDEX(col, row, hWidth);
int inputIdx = ((hHeight - row - 1) * hWidth) + col;
chrom[outputIdx].red = 0;
chrom[outputIdx].green = 255 - data[inputIdx];
chrom[outputIdx].blue = data[inputIdx];
}
}
data += hWidth * hHeight;
outputFile = fileName;
find = outputFile.find_last_of(".");
outputFile.insert(find, "-");
outputFile.insert(find+1, "v");
if(!SaveBitmap(outputFile.c_str(), (BYTE *)chrom, hWidth, hHeight))
{
delete [] luma;
delete [] chrom;
return false;
}
delete [] luma;
delete [] chrom;
return true;
}
HRESULT CAviBitmap::GetAllFrames(LPCTSTR lpszFolderName)
{
if(m_pGetFrame == NULL)
{
m_szLastErrorMsg.Format(_T("Not initialized yet"));
return E_FAIL;
}
HRESULT hr = S_OK;
int nBmpInfoHdrSize = sizeof(BITMAPINFO) + sizeof(RGBQUAD) * 256;
BITMAPINFOHEADER* lpBmpInfoHdr = (BITMAPINFOHEADER*)(new BYTE[nBmpInfoHdrSize]);
LONG lpcbFormat = nBmpInfoHdrSize;
BYTE* lpDib = NULL;
BYTE* lpBuffer = NULL;
LONG lBytes = 0, lSamples = 0;
BOOL bReadRaw = FALSE;
int nPos = 0;
int nSampleCount = min(m_lSampleCount, 101);
for(nPos = 0; nPos < nSampleCount; nPos++)
{
//Get the frame format
hr = AVIStreamReadFormat(m_pAviStream, nPos, lpBmpInfoHdr, &lpcbFormat);
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Get the sample format: %d"), nPos);
break;
}
lpBuffer = NULL;
//Try to read raw data when the bitmap is BI_RGB
if(lpBmpInfoHdr->biCompression == BI_RGB && (lpBmpInfoHdr->biBitCount == 24 || lpBmpInfoHdr->biBitCount == 32))
{
//Get the frame data
lpBuffer = new BYTE[m_biWanted.biSizeImage];
hr = AVIStreamRead(m_pAviStream, nPos, 1, lpBuffer, m_biWanted.biSizeImage, &lBytes, &lSamples);
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Get the sample data: %d"), nPos);
break;
}
}
else
{
CString szFourCC;
FourCC2Str(m_aviInfo.fccHandler, szFourCC);
AfxTrace(_T("Non-RGB format at frame(%03d)=%s, 0x%08X\n"), nPos, szFourCC, lpBmpInfoHdr->biCompression);
}
//Get the frame at nPos
lpDib = (BYTE*)AVIStreamGetFrame(m_pGetFrame, nPos);
if(lpDib == NULL)
{
m_szLastErrorMsg.Format(_T("Unable to Get the sample: %d"), nPos);
hr = E_FAIL;
break;
}
//compare the data retrieved in 2 ways if needed
if(lpBuffer != NULL)
{
if(memcmp(lpBuffer, lpDib + sizeof(BITMAPINFOHEADER), lpBmpInfoHdr->biSizeImage) != 0)
{
m_szLastErrorMsg.Format(_T("not equals: %d"), nPos);
hr = E_FAIL;
break;
}
}
CString szFileName;
if(lpszFolderName == NULL)
{
szFileName.Format(_T(".\\Frame%03d.bmp"), nPos);
}
else
{
szFileName.Format(_T("%s\\Frame%03d.bmp"), lpszFolderName, nPos);
}
BITMAPINFOHEADER* pTemp = (BITMAPINFOHEADER*)lpDib;
// hr = SaveBitmap(lpBmpInfoHdr, lpBuffer, lpBmpInfoHdr->biSizeImage, szFileName);
hr = SaveBitmap(&m_biWanted, lpDib + sizeof(BITMAPINFOHEADER), m_biWanted.biSizeImage, szFileName);
if(lpBuffer != NULL)
{
delete [] lpBuffer;
lpBuffer = NULL;
}
//Done
}
if(lpBuffer != NULL)
{
delete [] lpBuffer;
lpBuffer = NULL;
}
if(lpBmpInfoHdr != NULL)
{
delete [] lpBmpInfoHdr;
lpBmpInfoHdr = NULL;
}
ReleaseMemory();
return hr;
}
