void NetMgrEventHandler::Send(const char* data, size_t len)
{
_sendbuffer.Append(data, len);
HandleOutput();
}
int start() {
HandleOutput("hel2mos start-\n");
if (!idInst) {
MessageBox(NULL, "idInst is 0", "ochelp start", MB_OK);
return 0;
}
hszService = DdeCreateStringHandle ( idInst, "NETSCAPE", CP_WINANSI );
hszTopic = DdeCreateStringHandle ( idInst, "WWW_OpenURL", CP_WINANSI );
hszItem = DdeCreateStringHandle ( idInst, "NetscapeData", CP_WINANSI );
hConvExtra = DdeConnect ( idInst, hszService, hszTopic,
(PCONVCONTEXT) NULL );
if (!hConvExtra) {
MessageBox(NULL, "Conversation not established with NETSCAPE",
"ochelp start", MB_OK);
return 0;
}
HandleOutput("Conversation established with NETSCAPE\n");
return 1;
}
void stop() {
HandleOutput("hel2mos stop-\n");
if (hConvExtra) {
DdeDisconnect ( hConvExtra );
}
if (idInst) {
DdeFreeStringHandle ( idInst, hszService );
DdeFreeStringHandle ( idInst, hszTopic );
DdeFreeStringHandle ( idInst, hszItem );
}
}
void HandleError ( WORD DdeError )
{
switch ( DdeError )
{
case DMLERR_DLL_NOT_INITIALIZED:
HandleOutput ( "DLL not initialized." );
break;
case DMLERR_INVALIDPARAMETER:
HandleOutput ( "Invalid parameter." );
break;
case DMLERR_NO_CONV_ESTABLISHED:
HandleOutput ( "No conversation established." );
break;
case DMLERR_NO_ERROR:
HandleOutput ( "No error." );
break;
}
}
static void take(HCONV hc, const char* name) {
if ( hc != (HCONV)NULL ){
DdeFreeStringHandle(idInst, hszItem);
sprintf(szDDEData, "%s,,0xFFFFFFFF,0x0,,", name);
hszItem = DdeCreateStringHandle ( idInst, (LPTSTR)szDDEData, CP_WINANSI );
hData = DdeClientTransaction ( NULL, 0, hc,
hszItem, wFmt, XTYP_REQUEST, 1000, &dwResult );
if (!hData) {
MessageBox(NULL, szDDEData, "WWW_OpenURL failed", MB_OK);
}
}else{
HandleOutput( "A connection to Netscape via DDE is not established." );
}
}
HDDEDATA EXPENTRY DDECallback ( WORD wType, WORD wFmt, HCONV hConvX, HSZ hsz1,
HSZ hsz2, HDDEDATA hData, DWORD dwData1,
DWORD dwData2 )
{
switch ( wType )
{
case XTYP_DISCONNECT:
hConv = NULL;
HandleOutput ( "The server forced a disconnect." );
return ( (HDDEDATA) NULL );
case XTYP_ERROR:
break;
case XTYP_XACT_COMPLETE:
// compare transaction identifier, indicate transaction complete
break;
}
return ( (HDDEDATA) NULL );
}
int main(int argc,char *argv[]){
HANDLE hOutputReadTemp,hOutputRead,hOutputWrite;
HANDLE hInputWriteTemp,hInputRead,hInputWrite;
HANDLE hErrorWrite;
HANDLE hThread;
DWORD ThreadId;
SECURITY_ATTRIBUTES sa;
sa.nLength=sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor=NULL;
sa.bInheritHandle=TRUE;
DWORD i;
CHAR cmd[32767];
cmd[0]='\0';
strcat(cmd,"app.exe");
for(i=1;i<argc;i++){
strcat(cmd," ");
strcat(cmd,argv[i]);
}
CreatePipe(&hOutputReadTemp,&hOutputWrite,&sa,0);
DuplicateHandle(GetCurrentProcess(),hOutputWrite,GetCurrentProcess(),&hErrorWrite,0,TRUE,DUPLICATE_SAME_ACCESS);
CreatePipe(&hInputRead,&hInputWriteTemp,&sa,0);
DuplicateHandle(GetCurrentProcess(),hOutputReadTemp,GetCurrentProcess(),&hOutputRead,0,FALSE,DUPLICATE_SAME_ACCESS);
DuplicateHandle(GetCurrentProcess(),hInputWriteTemp,GetCurrentProcess(),&hInputWrite,0,FALSE,DUPLICATE_SAME_ACCESS);
CloseHandle(hOutputReadTemp);
CloseHandle(hInputWriteTemp);
hStdIn=GetStdHandle(STD_INPUT_HANDLE);
PROCESS_INFORMATION pi;
STARTUPINFO si;
ZeroMemory(&si,sizeof(STARTUPINFO));
si.cb=sizeof(STARTUPINFO);
si.dwFlags=STARTF_USESTDHANDLES;
si.hStdOutput=hOutputWrite;
si.hStdInput=hInputRead;
si.hStdError=hErrorWrite;
CreateProcess(NULL,cmd,NULL,NULL,TRUE,CREATE_NEW_CONSOLE,NULL,NULL,&si,&pi);
hChildProcess=pi.hProcess;
CloseHandle(pi.hThread);
CloseHandle(hOutputWrite);
CloseHandle(hInputRead);
CloseHandle(hErrorWrite);
hThread=CreateThread(NULL,0,RedirThread,(LPVOID)hInputWrite,0,&ThreadId);
HandleOutput(hOutputRead);
CloseHandle(hStdIn);
bRunThread=FALSE;
WaitForSingleObject(hThread,INFINITE);
CloseHandle(hOutputRead);
CloseHandle(hInputWrite);
return 0;
}
static int runmain (int argc, wchar_t *argv[])
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
STARTUPINFO si;
TCHAR *cmd, *parms2;
int len, parmlen, i;
HANDLE cp;
HANDLE out_rd = NULL, out_wr = NULL, out_rd_tmp = NULL;
HANDLE in_rd = NULL, in_wr = NULL, in_wr_tmp = NULL;
HANDLE err_wr;
DWORD tid;
HANDLE thread;
SECURITY_ATTRIBUTES sa;
len = _tcslen (argv[0]);
if (len < 4)
return 0;
cmd = (TCHAR*)malloc ((len + 4 + 1) * sizeof (TCHAR));
_tcscpy (cmd, argv[0]);
if (_tcsicmp (cmd + len - 4, _T(".com")))
_tcscat (cmd + len, _T(".exe"));
else
_tcscpy (cmd + len - 4, _T(".exe"));
parmlen = 0;
for (i = 1; i < argc; i++) {
if (parmlen > 0)
parmlen ++;
parmlen += 1 + _tcslen (argv[i]) + 1;
}
parms2 = (TCHAR*)malloc ((_tcslen (cmd) + 1 + parmlen + 1 + _tcslen (conpar) + 1) * sizeof (TCHAR));
_tcscpy (parms2, cmd);
_tcscat (parms2, _T(" "));
_tcscat (parms2, conpar);
for (i = 1; i < argc; i++) {
int isspace = 0;
_tcscat (parms2, _T(" "));
if (_tcschr (argv[i], ' '))
isspace = 1;
if (isspace)
_tcscat (parms2, _T("\""));
_tcscat (parms2, argv[i]);
if (isspace)
_tcscat (parms2, _T("\""));
}
cp = GetCurrentProcess ();
sa.nLength = sizeof sa;
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
stdout_save = GetStdHandle (STD_OUTPUT_HANDLE);
stdin_save = GetStdHandle (STD_INPUT_HANDLE);
stderr_save = GetStdHandle (STD_ERROR_HANDLE);
//SetConsoleMode (stdin_save, ENABLE_PROCESSED_INPUT|ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT|ENABLE_PROCESSED_OUTPUT);
SetConsoleMode (stdin_save, ENABLE_PROCESSED_INPUT|ENABLE_PROCESSED_OUTPUT);
SetConsoleCP (65001);
SetConsoleOutputCP (65001);
if (GetConsoleScreenBufferInfo (stdout_save, &csbi)) {
if (csbi.dwMaximumWindowSize.Y < 900) {
csbi.dwMaximumWindowSize.Y = 900;
SetConsoleScreenBufferSize (stdout_save, csbi.dwMaximumWindowSize);
}
}
CreatePipe (&out_rd_tmp, &out_wr, &sa, 0);
CreatePipe (&in_rd, &in_wr_tmp, &sa, 0);
DuplicateHandle (cp, out_wr, cp, &err_wr, 0, TRUE, DUPLICATE_SAME_ACCESS);
DuplicateHandle (cp, out_rd_tmp, cp, &out_rd, 0, FALSE, DUPLICATE_SAME_ACCESS);
DuplicateHandle (cp, in_wr_tmp, cp, &in_wr, 0, FALSE, DUPLICATE_SAME_ACCESS);
CloseHandle (out_rd_tmp);
CloseHandle (in_wr_tmp);
memset (&si, 0, sizeof si);
si.cb = sizeof si;
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = in_rd;
si.hStdOutput = out_wr;
si.hStdError = err_wr;
SetConsoleCtrlHandler (&ctrlhandler, TRUE);
if (!CreateProcess (cmd, parms2,
NULL, NULL, TRUE,
CREATE_SUSPENDED | CREATE_NEW_CONSOLE | GetPriorityClass (GetCurrentProcess ()),
NULL, NULL, &si, &pi)) {
_tprintf (_T("CreateProcess(%s) failed\n"), cmd);
goto end;
}
CloseHandle (out_wr);
CloseHandle (in_rd);
CloseHandle (err_wr);
thread = CreateThread (NULL, 0, pipethread, (LPVOID)in_wr, 0, &tid);
ResumeThread (pi.hThread);
HandleOutput (out_rd);
runthread = 0;
CloseHandle (stdin_save);
WaitForSingleObject (thread, INFINITE);
CloseHandle (out_rd);
CloseHandle (in_wr);
CloseHandle (pi.hProcess);
CloseHandle (pi.hThread);
end:
free (parms2);
free (cmd);
return 0;
}
STDMETHODIMP CDecMSDKMVC::Decode(const BYTE *buffer, int buflen, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, BOOL bSyncPoint, BOOL bDiscontinuity)
{
if (!m_mfxSession)
return E_UNEXPECTED;
HRESULT hr = S_OK;
CBitstreamBuffer bsBuffer(&m_buff);
mfxStatus sts = MFX_ERR_NONE;
mfxBitstream bs = { 0 };
BOOL bFlush = (buffer == nullptr);
if (rtStart >= -TIMESTAMP_OFFSET && rtStart != AV_NOPTS_VALUE)
bs.TimeStamp = rtStart + TIMESTAMP_OFFSET;
else
bs.TimeStamp = MFX_TIMESTAMP_UNKNOWN;
bs.DecodeTimeStamp = MFX_TIMESTAMP_UNKNOWN;
if (!bFlush) {
if (m_pAnnexBConverter) {
BYTE *pOutBuffer = nullptr;
int pOutSize = 0;
hr = m_pAnnexBConverter->Convert(&pOutBuffer, &pOutSize, buffer, buflen);
if (FAILED(hr))
return hr;
bsBuffer.SetBuffer(pOutBuffer, pOutSize, true);
}
else {
bsBuffer.SetBuffer((BYTE *)buffer, buflen, false);
}
// Check the buffer for SEI NALU, and some unwanted NALUs that need filtering
// MSDK's SEI reading functionality is slightly buggy
CH264Nalu nalu;
nalu.SetBuffer(bsBuffer.GetBuffer(), bsBuffer.GetBufferSize(), 0);
BOOL bNeedFilter = FALSE;
while (nalu.ReadNext()) {
if (nalu.GetType() == NALU_TYPE_SEI) {
ParseSEI(nalu.GetDataBuffer() + 1, nalu.GetDataLength() - 1, bs.TimeStamp);
}
else if (nalu.GetType() == NALU_TYPE_EOSEQ) {
bsBuffer.EnsureWriteable();
// This is rather ugly, and relies on the bitstream being AnnexB, so simply overwriting the EOS NAL with zero works.
// In the future a more elaborate bitstream filter might be advised
memset(bsBuffer.GetBuffer() + nalu.GetNALPos(), 0, 4);
}
}
bs.Data = bsBuffer.GetBuffer();
bs.DataLength = mfxU32(bsBuffer.GetBufferSize());
bs.MaxLength = bs.DataLength;
AddFrameToGOP(bs.TimeStamp);
}
if (!m_bDecodeReady) {
sts = MFXVideoDECODE_DecodeHeader(m_mfxSession, &bs, &m_mfxVideoParams);
if (sts == MFX_ERR_NOT_ENOUGH_BUFFER) {
hr = AllocateMVCExtBuffers();
if (FAILED(hr))
return hr;
sts = MFXVideoDECODE_DecodeHeader(m_mfxSession, &bs, &m_mfxVideoParams);
}
if (sts == MFX_ERR_NONE) {
m_mfxVideoParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
m_mfxVideoParams.AsyncDepth = ASYNC_DEPTH;
sts = MFXVideoDECODE_Init(m_mfxSession, &m_mfxVideoParams);
if (sts != MFX_ERR_NONE) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Error initializing the MSDK decoder (%d)", sts));
return E_FAIL;
}
if (m_mfxExtMVCSeq.NumView != 2) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Only MVC with two views is supported"));
return E_FAIL;
}
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Initialized MVC with View Ids %d, %d", m_mfxExtMVCSeq.View[0].ViewId, m_mfxExtMVCSeq.View[1].ViewId));
m_bDecodeReady = TRUE;
}
}
if (!m_bDecodeReady)
return S_FALSE;
mfxSyncPoint sync = nullptr;
// Loop over the decoder to ensure all data is being consumed
while (1) {
MVCBuffer *pInputBuffer = GetBuffer();
if (pInputBuffer == nullptr)
return E_OUTOFMEMORY;
mfxFrameSurface1 *outsurf = nullptr;
sts = MFXVideoDECODE_DecodeFrameAsync(m_mfxSession, bFlush ? nullptr : &bs, &pInputBuffer->surface, &outsurf, &sync);
if (sts == MFX_ERR_INCOMPATIBLE_VIDEO_PARAM) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Incompatible video parameters detected, flushing decoder"));
bsBuffer.Clear();
bFlush = TRUE;
m_bDecodeReady = FALSE;
continue;
}
if (sync) {
MVCBuffer * pOutputBuffer = FindBuffer(outsurf);
pOutputBuffer->queued = 1;
pOutputBuffer->sync = sync;
HandleOutput(pOutputBuffer);
continue;
}
if (sts != MFX_ERR_MORE_SURFACE && sts < 0)
break;
}
if (!bs.DataOffset && !sync && !bFlush) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Decoder did not consume any data, discarding"));
bs.DataOffset = mfxU32(bsBuffer.GetBufferSize());
}
bsBuffer.Consume(bs.DataOffset);
if (sts != MFX_ERR_MORE_DATA && sts < 0) {
DbgLog((LOG_TRACE, 10, L"CDevMSDKMVC::Decode(): Error from Decode call (%d)", sts));
return S_FALSE;
}
return S_OK;
}
LRESULT CALLBACK MainWndProc ( HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam )
{
HDC hDC;
PAINTSTRUCT ps;
DLGPROC dlgProcAbout;
int i;
int j;
short y;
switch ( message )
{
case WM_CREATE:
hDC = GetDC ( hWnd );
GetTextMetrics ( hDC, &tm );
cxChar = tm.tmAveCharWidth;
cyChar = tm.tmHeight + tm.tmExternalLeading;
ReleaseDC ( hWnd, hDC );
lpDdeProc = MakeProcInstance ( (FARPROC) DDECallback, hInst );
if ( DdeInitialize ( (LPDWORD)&idInst, (PFNCALLBACK)lpDdeProc,
APPCMD_CLIENTONLY, 0L ) )
{
HandleOutput ( "Client DDE initialization failure." );
return ( FALSE );
}
hszService = DdeCreateStringHandle ( idInst, "Borland", CP_WINANSI );
hszTopic = DdeCreateStringHandle ( idInst, "DDEExample", CP_WINANSI );
hszItem = DdeCreateStringHandle ( idInst, "DDEData", CP_WINANSI );
cCurrentLine = 0;
cTotalLines = 0;
strcpy ( szDDEString, "Client application message number: " );
break;
case WM_COMMAND:
switch ( wParam )
{
case IDM_EXIT:
DestroyWindow ( hWnd );
break;
case IDM_CONNECT_SERVER:
if ( hConv == NULL )
{
hConv = DdeConnect ( idInst, hszService, hszTopic,
(PCONVCONTEXT) NULL );
if ( hConv == NULL )
{
HandleError ( DdeGetLastError ( idInst ) );
HandleOutput ( "Unsuccessful connection." );
}
else
HandleOutput ( "Successful connection." );
}
else
HandleOutput ( "Already connected to DDE Server." );
break;
case IDM_DISCONNECT_SERVER:
if ( hConv != NULL )
{
DdeDisconnect ( hConv );
hConv = NULL;
HandleOutput ( "Disconnected from server." );
}
else
HandleOutput ( "Must be connected before disconnecting." );
break;
case IDM_MSG_TO_SERVER:
if ( hConv != NULL )
{
iClientCount ++;
sprintf ( tbuf, "%3d.", iClientCount );
strncpy ( &szDDEString[36], tbuf, 5 );
hData = DdeCreateDataHandle ( idInst, &szDDEString,
sizeof ( szDDEString ), 0L, hszItem, wFmt, 0 );
if ( hData != NULL )
hData = DdeClientTransaction ( (LPBYTE)hData, -1, hConv,
hszItem, wFmt, XTYP_POKE, 1000, &dwResult );
else
HandleOutput ( "Could not create data handle." );
}
else
HandleOutput ( "A connection to a DDE Server has not been established." );
break;
case IDM_MSG_FROM_SERVER:
if ( hConv != NULL )
{
hData = DdeClientTransaction ( NULL, 0, hConv,
hszItem, wFmt, XTYP_REQUEST, 1000, &dwResult );
if ( dwResult == DDE_FNOTPROCESSED )
HandleOutput ( "Data not available from server." );
else
{
DdeGetData ( hData, (LPBYTE) szDDEData, 80L, 0L );
if ( szDDEData != NULL )
HandleOutput ( szDDEData );
else
HandleOutput ( "Message from server is null." );
}
}
else
HandleOutput ( "A connection to a DDE Server has not been established." );
break;
case IDM_ABOUT:
dlgProcAbout = (DLGPROC) MakeProcInstance ( (FARPROC)About, hInst );
DialogBox ( hInst, "AboutBox", hWnd, dlgProcAbout );
FreeProcInstance ( (FARPROC) dlgProcAbout );
break;
default:
return ( DefWindowProc ( hWnd, message, wParam, lParam ) );
}
break;
case WM_PAINT:
hDC = BeginPaint ( hWnd, &ps );
y = 0;
for ( i = 0; i < cTotalLines; i ++ )
{
if ( cTotalLines == 8 )
j = ( (cCurrentLine + 1 + i) % 9 );
else
j = i; // can't do this if we clear window and start in middle of array
TextOut ( hDC, 0, y, (LPSTR)(szScreenText[j]),
lstrlen ( szScreenText[j] ) );
y = y + cyChar;
}
EndPaint ( hWnd, &ps );
break;
case WM_DESTROY:
if ( hConv != NULL )
{
DdeDisconnect ( hConv );
hConv = NULL;
}
DdeFreeStringHandle ( idInst, hszService );
DdeFreeStringHandle ( idInst, hszTopic );
DdeFreeStringHandle ( idInst, hszItem );
FreeProcInstance ( lpDdeProc );
PostQuitMessage ( 0 );
break;
default:
return ( DefWindowProc ( hWnd, message, wParam, lParam ) );
}
return ( FALSE );
}
HRESULT WIXAPI QuietExecEx(
__inout_z LPWSTR wzCommand,
__in DWORD dwTimeout,
__in BOOL fLogCommand,
__in BOOL fLogOutput
)
{
HRESULT hr = S_OK;
PROCESS_INFORMATION oProcInfo;
STARTUPINFOW oStartInfo;
DWORD dwExitCode = ERROR_SUCCESS;
HANDLE hOutRead = INVALID_HANDLE_VALUE;
HANDLE hOutWrite = INVALID_HANDLE_VALUE;
HANDLE hErrWrite = INVALID_HANDLE_VALUE;
HANDLE hInRead = INVALID_HANDLE_VALUE;
HANDLE hInWrite = INVALID_HANDLE_VALUE;
memset(&oProcInfo, 0, sizeof(oProcInfo));
memset(&oStartInfo, 0, sizeof(oStartInfo));
// Create output redirect pipes
hr = CreatePipes(&hOutRead, &hOutWrite, &hErrWrite, &hInRead, &hInWrite);
ExitOnFailure(hr, "Failed to create output pipes");
// Set up startup structure
oStartInfo.cb = sizeof(STARTUPINFOW);
oStartInfo.dwFlags = STARTF_USESTDHANDLES;
oStartInfo.hStdInput = hInRead;
oStartInfo.hStdOutput = hOutWrite;
oStartInfo.hStdError = hErrWrite;
// Log command if we were asked to do so
if (fLogCommand)
{
WcaLog(LOGMSG_VERBOSE, "%ls", wzCommand);
}
#pragma prefast(suppress:25028)
if (::CreateProcessW(NULL,
wzCommand, // command line
NULL, // security info
NULL, // thread info
TRUE, // inherit handles
::GetPriorityClass(::GetCurrentProcess()) | CREATE_NO_WINDOW, // creation flags
NULL, // environment
NULL, // cur dir
&oStartInfo,
&oProcInfo))
{
ReleaseFile(oProcInfo.hThread);
// Close child output/input handles so it doesn't hang
ReleaseFile(hOutWrite);
ReleaseFile(hErrWrite);
ReleaseFile(hInRead);
// Log output if we were asked to do so; otherwise just read the output handle
HandleOutput(fLogOutput, hOutRead);
// Wait for everything to finish
::WaitForSingleObject(oProcInfo.hProcess, dwTimeout);
if (!::GetExitCodeProcess(oProcInfo.hProcess, &dwExitCode))
{
dwExitCode = ERROR_SEM_IS_SET;
}
ReleaseFile(hOutRead);
ReleaseFile(hInWrite);
ReleaseFile(oProcInfo.hProcess);
}
else
{
ExitOnLastError(hr, "Command failed to execute.");
}
ExitOnWin32Error(dwExitCode, hr, "Command line returned an error.");
LExit:
return hr;
}
