예제 #1
0
CJS_Runtime::CJS_Runtime(CPDFDoc_Environment* pApp)
    : m_pApp(pApp),
      m_pDocument(nullptr),
      m_bBlocking(FALSE),
      m_isolate(nullptr),
      m_isolateManaged(false) {
#ifndef PDF_ENABLE_XFA
  IPDF_JSPLATFORM* pPlatform = m_pApp->GetFormFillInfo()->m_pJsPlatform;
  if (pPlatform->version <= 2) {
    unsigned int embedderDataSlot = 0;
    v8::Isolate* pExternalIsolate = nullptr;
    if (pPlatform->version == 2) {
      pExternalIsolate = reinterpret_cast<v8::Isolate*>(pPlatform->m_isolate);
      embedderDataSlot = pPlatform->m_v8EmbedderSlot;
    }
    FXJS_Initialize(embedderDataSlot, pExternalIsolate);
  }
  m_isolateManaged = FXJS_GetIsolate(&m_isolate);
#else
  if (CPDFXFA_App::GetInstance()->GetJSERuntime()) {
    // TODO(tsepez): CPDFXFA_App should also use the embedder provided isolate.
    m_isolate = (v8::Isolate*)CPDFXFA_App::GetInstance()->GetJSERuntime();
  } else {
    IPDF_JSPLATFORM* pPlatform = m_pApp->GetFormFillInfo()->m_pJsPlatform;
    if (pPlatform->version <= 2) {
      unsigned int embedderDataSlot = 0;
      v8::Isolate* pExternalIsolate = nullptr;
      if (pPlatform->version == 2) {
        pExternalIsolate = reinterpret_cast<v8::Isolate*>(pPlatform->m_isolate);
        embedderDataSlot = pPlatform->m_v8EmbedderSlot;
      }
      FXJS_Initialize(embedderDataSlot, pExternalIsolate);
    }
    m_isolateManaged = FXJS_GetIsolate(&m_isolate);
  }

  v8::Isolate* isolate = m_isolate;
  v8::Isolate::Scope isolate_scope(isolate);
  v8::HandleScope handle_scope(isolate);
  if (CPDFXFA_App::GetInstance()->IsJavaScriptInitialized()) {
    CJS_Context* pContext = (CJS_Context*)NewContext();
    FXJS_InitializeRuntime(GetIsolate(), this, &m_context, &m_StaticObjects);
    ReleaseContext(pContext);
    return;
  }
#endif

  if (m_isolateManaged || FXJS_GlobalIsolateRefCount() == 0)
    DefineJSObjects();

#ifdef PDF_ENABLE_XFA
  CPDFXFA_App::GetInstance()->SetJavaScriptInitialized(TRUE);
#endif

  CJS_Context* pContext = (CJS_Context*)NewContext();
  FXJS_InitializeRuntime(GetIsolate(), this, &m_context, &m_StaticObjects);
  ReleaseContext(pContext);
}
AvFormatDecoderDVD::~AvFormatDecoderDVD()
{
    ReleaseContext(m_curContext);
    ReleaseContext(m_returnContext);

    while (m_contextList.size() > 0)
        m_contextList.takeFirst()->DecrRef();

    ReleaseLastVideoPkt();
}
예제 #3
0
bool ClientSession::PostSend()
{
	if (!IsConnected())
		return false;
	
	if ( 0 == mCircularBuffer->GetContiguiousBytes() )
		return true;

	RioIoContext* sendContext = new RioIoContext(this, IO_SEND);

	sendContext->BufferId = mRioBufferId;
	sendContext->Length = static_cast<ULONG>(mCircularBuffer->GetContiguiousBytes()); 
	sendContext->Offset = mCircularBuffer->GetReadableOffset();

	DWORD sendbytes = 0;
	DWORD flags = 0;

	/// start async send
	if (!RIO.RIOSend(mRequestQueue, (PRIO_BUF)sendContext, 1, flags, sendContext))
	{
		printf_s("[DEBUG] RIOSend error: %d\n", GetLastError());
		ReleaseContext(sendContext);
		return false;
	}
	
	return true;
}
예제 #4
0
CJS_Runtime::CJS_Runtime(CPDFSDK_FormFillEnvironment* pFormFillEnv)
    : m_pFormFillEnv(pFormFillEnv),
      m_bBlocking(false),
      m_isolateManaged(false) {
  v8::Isolate* pIsolate = nullptr;

  IPDF_JSPLATFORM* pPlatform = m_pFormFillEnv->GetFormFillInfo()->m_pJsPlatform;
  if (pPlatform->version <= 2) {
    unsigned int embedderDataSlot = 0;
    v8::Isolate* pExternalIsolate = nullptr;
    if (pPlatform->version == 2) {
      pExternalIsolate = reinterpret_cast<v8::Isolate*>(pPlatform->m_isolate);
      embedderDataSlot = pPlatform->m_v8EmbedderSlot;
    }
    FXJS_Initialize(embedderDataSlot, pExternalIsolate);
  }
  m_isolateManaged = FXJS_GetIsolate(&pIsolate);
  SetIsolate(pIsolate);

#ifdef PDF_ENABLE_XFA
  v8::Isolate::Scope isolate_scope(pIsolate);
  v8::HandleScope handle_scope(pIsolate);
#endif

  if (m_isolateManaged || FXJS_GlobalIsolateRefCount() == 0)
    DefineJSObjects();

  CJS_Context* pContext = (CJS_Context*)NewContext();
  InitializeEngine();
  ReleaseContext(pContext);

  SetFormFillEnvToDocument();
}
예제 #5
0
CJS_Runtime::CJS_Runtime(CPDFDoc_Environment* pApp)
    : m_pApp(pApp),
      m_pDocument(NULL),
      m_bBlocking(FALSE),
      m_isolate(NULL),
      m_isolateManaged(false) {
  unsigned int embedderDataSlot = 0;
  if (m_pApp->GetFormFillInfo()->m_pJsPlatform->version >= 2) {
    m_isolate = reinterpret_cast<v8::Isolate*>(
        m_pApp->GetFormFillInfo()->m_pJsPlatform->m_isolate);
    embedderDataSlot = pApp->GetFormFillInfo()->m_pJsPlatform->m_v8EmbedderSlot;
  }
  if (!m_isolate) {
    m_pArrayBufferAllocator.reset(new FXJS_ArrayBufferAllocator());

    v8::Isolate::CreateParams params;
    params.array_buffer_allocator = m_pArrayBufferAllocator.get();
    m_isolate = v8::Isolate::New(params);
    m_isolateManaged = true;
  }

  FXJS_Initialize(embedderDataSlot);
  DefineJSObjects();

  CJS_Context* pContext = (CJS_Context*)NewContext();
  FXJS_InitializeRuntime(GetIsolate(), this, pContext, m_context);
  ReleaseContext(pContext);
}
예제 #6
0
bool ClientSession::PostRecv()
{
	if (!IsConnected())
		return false;

	if (0 == mCircularBuffer->GetFreeSpaceSize())
		return false;

	RioIoContext* recvContext = new RioIoContext(this, IO_RECV);

	recvContext->BufferId = mRioBufferId;
	recvContext->Length = static_cast<ULONG>(mCircularBuffer->GetFreeSpaceSize());
	recvContext->Offset = mCircularBuffer->GetWritableOffset();
	
	DWORD recvbytes = 0;
	DWORD flags = 0;

	/// start async recv
	if (!RIO.RIOReceive(mRequestQueue, (PRIO_BUF)recvContext, 1, flags, recvContext))
	{
		printf_s("[DEBUG] RIOReceive error: %d\n", GetLastError());
		ReleaseContext(recvContext);
		return false;
	}

	return true;
}
예제 #7
0
void
FLTAPI
ContextCleanup (
    __in PVOID Pool,
    __in FLT_CONTEXT_TYPE ContextType
    )
{
    switch ( ContextType )
    {
    case FLT_INSTANCE_CONTEXT:
        {
        }
        break;

    case FLT_STREAM_CONTEXT:
        {
            PStreamContext pStreamContext = (PStreamContext) Pool;
            ReleaseContext( (PFLT_CONTEXT*) &pStreamContext->m_InstanceCtx );
            ASSERT( pStreamContext );
        }
        break;

    case FLT_STREAMHANDLE_CONTEXT:
        {
            PStreamHandleContext pStreamHandleContext = (PStreamHandleContext) Pool;
            ReleaseContext( (PFLT_CONTEXT*) &pStreamHandleContext->m_StreamCtx );
        }
        break;

    case FLT_VOLUME_CONTEXT:
        {
            PVolumeContext pVolumeContext = (PVolumeContext) Pool;
            FREE_POOL( pVolumeContext->m_DeviceId.Buffer );
        }
        break;

    default:
        {
            ASSERT( "cleanup for unknown context!" );
        }
        break;
    }
}
예제 #8
0
파일: OpenAL.cpp 프로젝트: hallor/ufo
void OpenAL::ReleaseDevice()
{
    ReleaseContext();

    if(m_Device)
    {
        LogInfo("Releasing OAL device");
        alcCloseDevice(m_Device);
        m_Device = NULL;
    }
}
예제 #9
0
EndPoint::~EndPoint()
{
    // No network thread if networking isn't enabled.
    if (mContext->Enabled())
    {
        // Kill the network thread and wait for it to terminate.
        mRunning = false;
        mNetworkThread.Join();
    }

    // Release the per-process context.
    ReleaseContext();
}
예제 #10
0
__checkReturn
FLT_POSTOP_CALLBACK_STATUS
FLTAPI
PostWrite (
    __inout PFLT_CALLBACK_DATA Data,
    __in PCFLT_RELATED_OBJECTS FltObjects,
    __in PVOID CompletionContext,
    __in FLT_POST_OPERATION_FLAGS Flags
    )
{
    FLT_POSTOP_CALLBACK_STATUS fltStatus = FLT_POSTOP_FINISHED_PROCESSING;
    PStreamContext pStreamContext = (PStreamContext) CompletionContext;

    ASSERT( pStreamContext );

    __try
    {
        if ( FlagOn( Flags, FLTFL_POST_OPERATION_DRAINING ) )
        {
            __leave;
        }

        if ( !NT_SUCCESS( Data->IoStatus.Status ) )
        {
            __leave;
        }

        if ( !Data->IoStatus.Information )
        {
            __leave;
        }

        if ( FlagOn( Data->Iopb->IrpFlags, IRP_PAGING_IO ) )
        {
            //! \todo обработка MM файлов
            __leave;
        }

        InterlockedIncrement( &pStreamContext->m_WriteCount );
        InterlockedAnd( &pStreamContext->m_Flags, ~_STREAM_FLAGS_CASHE1 );
        InterlockedOr( &pStreamContext->m_Flags, _STREAM_FLAGS_MODIFIED );
    }
    __finally
    {
        ReleaseContext( (PFLT_CONTEXT*) &pStreamContext );
    }

    return fltStatus;
}
예제 #11
0
CJS_Runtime::CJS_Runtime(CPDFDoc_Environment * pApp) : 
	m_pApp(pApp),
	m_pDocument(NULL),
	m_pFieldEventPath(NULL),
	m_bBlocking(FALSE),
	m_bRegistered(FALSE)
{
	m_isolate = v8::Isolate::New();
	//m_isolate->Enter();

	InitJSObjects();

	CJS_Context * pContext = (CJS_Context*)NewContext();
	JS_InitialRuntime(*this, this, pContext, m_context);
	ReleaseContext(pContext);
}
예제 #12
0
CJS_Runtime::CJS_Runtime(CPDFDoc_Environment * pApp) : 
	m_pApp(pApp),
	m_pDocument(NULL),
	m_bBlocking(FALSE),
	m_bRegistered(FALSE),
	m_pFieldEventPath(NULL)
{
	m_pArrayBufferAllocator.reset(new CJS_ArrayBufferAllocator());

	v8::Isolate::CreateParams params;
	params.array_buffer_allocator = m_pArrayBufferAllocator.get();
	m_isolate = v8::Isolate::New(params);

	InitJSObjects();

	CJS_Context * pContext = (CJS_Context*)NewContext();
	JS_InitialRuntime(*this, this, pContext, m_context);
	ReleaseContext(pContext);
}
예제 #13
0
파일: OpenAL.cpp 프로젝트: hallor/ufo
bool OpenAL::CreateContext()
{
    ReleaseContext();

    if(!m_Device)
    {
        LogError("Couldn't create OAL context, device not opened");
        return false;
    }

    m_Context = alcCreateContext(m_Device, NULL);

    if(m_Context)
    {
        LogInfo("Created OAL context");
        alcMakeContextCurrent(m_Context);
    }

    return m_Context != NULL;
}
예제 #14
0
//
// 更新接收消息
//
void CGateServer::OnUpdateRecv(DWORD dwDeltaTime)
{
	CIOContext *pContext = m_pActiveContext;

	while (pContext) {
		CIOContext *pNextContext = pContext->pNextActive;

		if (pContext->IsAlive()) {
			pContext->SwitchRecvBuffer();
			pContext->dwHeartTime += dwDeltaTime;

			while (TRUE) {
				WORD msg;
				WORD fullSize;
				WORD bodySize;

				if (pContext->GetRecvBuffer().GetData((BYTE *)&fullSize, sizeof(fullSize)) != sizeof(fullSize)) break;
				if (pContext->GetRecvBuffer().GetActiveBufferSize() < sizeof(fullSize) + fullSize) break;

				if (pContext->GetRecvBuffer().PopData((BYTE *)&fullSize, sizeof(fullSize)) != sizeof(fullSize)) break;
				if (pContext->GetRecvBuffer().PopData((BYTE *)&msg, sizeof(msg)) != sizeof(msg))  break;

				bodySize = fullSize - sizeof(msg);
				m_dwRecvDataSize += sizeof(fullSize) + fullSize;

				ResponseFuncs::const_iterator itFunc = m_responses.find(msg);
				if (itFunc == m_responses.end()) continue;

				(this->*itFunc->second)(pContext, bodySize);
				OnHeartReset(pContext);
			}
		}

		if (pContext->Check((DWORD)(1000 * m_timeOut)) == FALSE) {
			ReleaseContext(pContext, FALSE);
		}

		pContext = pNextContext;
	}
}
예제 #15
0
CJS_Runtime::CJS_Runtime(CPDFDoc_Environment* pApp)
    : m_pApp(pApp),
      m_pDocument(NULL),
      m_bBlocking(FALSE),
      m_isolate(NULL),
      m_isolateManaged(false) {
  IPDF_JSPLATFORM* pPlatform = m_pApp->GetFormFillInfo()->m_pJsPlatform;
  if (pPlatform->version <= 2) {
    unsigned int embedderDataSlot = 0;
    v8::Isolate* pExternalIsolate = nullptr;
    if (pPlatform->version == 2) {
      pExternalIsolate = reinterpret_cast<v8::Isolate*>(pPlatform->m_isolate);
      embedderDataSlot = pPlatform->m_v8EmbedderSlot;
    }
    FXJS_Initialize(embedderDataSlot, pExternalIsolate);
  }
  m_isolateManaged = FXJS_GetIsolate(&m_isolate);
  if (m_isolateManaged || FXJS_GlobalIsolateRefCount() == 0)
    DefineJSObjects();

  CJS_Context* pContext = (CJS_Context*)NewContext();
  FXJS_InitializeRuntime(GetIsolate(), this, &m_context, &m_StaticObjects);
  ReleaseContext(pContext);
}
예제 #16
0
파일: IOCP.CPP 프로젝트: chenboo/GameServer
void CIOCPServer::HandleIO(DWORD dwKey, CIOCPBuffer *pBuffer, DWORD dwTrans, int nError)
{
	CIOCPContext *pContext = (CIOCPContext *)dwKey;

#ifdef _DEBUG
	//	::OutputDebugString("	HandleIO... \n");
#endif // _DEBUG
	
	// 1)首先减少套节字上的未决I/O计数
	if(pContext != NULL)
	{
		::EnterCriticalSection(&pContext->Lock);
		
		if(pBuffer->nOperation == OP_READ)
			pContext->nOutstandingRecv --;
		else if(pBuffer->nOperation == OP_WRITE)
			pContext->nOutstandingSend --;
		
		::LeaveCriticalSection(&pContext->Lock);
		
		// 2)检查套节字是否已经被我们关闭
		if(pContext->bClosing) 
		{
#ifdef _DEBUG
			::OutputDebugString(" pContext->bClosing 检查到套节字已经被我们关闭 \n");
#endif // _DEBUG
			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
			{		
				ReleaseContext(pContext);
			}
			// 释放已关闭套节字的未决I/O
			ReleaseBuffer(pBuffer);	
			return;
		}
	}
	else
	{
		RemovePendingAccept(pBuffer);
#ifdef _DEBUG
			::OutputDebugString("RemovePendingAccept	检查到套节字连接超时未完成被我们关闭 \n");
#endif // _DEBUG
		
	}

	// 3)检查套节字上发生的错误,如果有的话,通知用户,然后关闭套节字
	if(nError != NO_ERROR)
	{
		if(pBuffer->nOperation != OP_ACCEPT)
		{
			OnConnectionError(pContext, pBuffer, nError);
			CloseAConnection(pContext);
			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
			{		
				ReleaseContext(pContext);
			}
#ifdef _DEBUG
			::OutputDebugString("nError	非OP_ACCEPT检查到客户套节字上发生错误 \n");
#endif // _DEBUG
		}
		else // 在监听套节字上发生错误,也就是监听套节字处理的客户出错了
		{
			// 客户端出错,释放I/O缓冲区
			if(pBuffer->sClient != INVALID_SOCKET)
			{
				::closesocket(pBuffer->sClient);
				pBuffer->sClient = INVALID_SOCKET;
			}
#ifdef _DEBUG
			::OutputDebugString("nError	Listen SOCKET检查到监听套节字上发生错误 \n");
#endif // _DEBUG
		}

		ReleaseBuffer(pBuffer);
		return;
	}


	// 开始处理
	if(pBuffer->nOperation == OP_ACCEPT)
	{
		if(dwTrans == 0)
		{
#ifdef _DEBUG
			::OutputDebugString("OP_ACCEPT	监听套节字上客户端关闭 \n");
#endif // _DEBUG
			
			if(pBuffer->sClient != INVALID_SOCKET)
			{
				::closesocket(pBuffer->sClient);
				pBuffer->sClient = INVALID_SOCKET;
			}
		}
		else
		{
			// 为新接受的连接申请客户上下文对象
			CIOCPContext *pClient = AllocateContext(pBuffer->sClient);
			if(pClient != NULL)
			{
				if(AddAConnection(pClient))
				{	
					// 取得客户地址
					int nLocalLen, nRmoteLen;
					LPSOCKADDR pLocalAddr, pRemoteAddr;
					m_lpfnGetAcceptExSockaddrs(
						pBuffer->buff,
						pBuffer->nLen - ((sizeof(sockaddr_in) + 16) * 2),
						sizeof(sockaddr_in) + 16,
						sizeof(sockaddr_in) + 16,
						(SOCKADDR **)&pLocalAddr,
						&nLocalLen,
						(SOCKADDR **)&pRemoteAddr,
						&nRmoteLen);
					memcpy(&pClient->addrLocal, pLocalAddr, nLocalLen);
					memcpy(&pClient->addrRemote, pRemoteAddr, nRmoteLen);
					
					// 关联新连接到完成端口对象
					::CreateIoCompletionPort((HANDLE)pClient->s, m_hCompletion, (DWORD)pClient, 0);
					
					// 通知用户
					pBuffer->nLen = dwTrans;
					OnConnectionEstablished(pClient, pBuffer);
					
					// 向新连接投递几个Read请求,这些空间在套节字关闭或出错时释放
					for(int i=0; i<m_nInitialReads ; i++)
					{
						CIOCPBuffer *p = AllocateBuffer(BUFFER_SIZE);
						if(p != NULL)
						{
							if(!PostRecv(pClient, p))
							{
								CloseAConnection(pClient);
								break;
							}
						}
					}
				}
				else	// 连接数量已满,关闭连接
				{
					CloseAConnection(pClient);
					ReleaseContext(pClient);
				}
			}
			else
			{
				// 资源不足,关闭与客户的连接即可
				::closesocket(pBuffer->sClient);
				pBuffer->sClient = INVALID_SOCKET;
			}
		}
		
		// Accept请求完成,释放I/O缓冲区
		ReleaseBuffer(pBuffer);	

		// 通知监听线程继续再投递一个Accept请求
		::InterlockedIncrement(&m_nRepostCount);
		::SetEvent(m_hRepostEvent);
	}
	else if(pBuffer->nOperation == OP_READ)
	{
		if(dwTrans == 0)	// 对方关闭套节字
		{
			// 先通知用户
			pBuffer->nLen = 0;
			OnConnectionClosing(pContext, pBuffer);	
			// 再关闭连接
			CloseAConnection(pContext);
			// 释放客户上下文和缓冲区对象
			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
			{		
				ReleaseContext(pContext);
			}
			ReleaseBuffer(pBuffer);	
		}
		else
		{
			pBuffer->nLen = dwTrans;
			// 按照I/O投递的顺序读取接收到的数据
			CIOCPBuffer *p = GetNextReadBuffer(pContext, pBuffer);
			while(p != NULL)
			{
				// 通知用户
				OnReadCompleted(pContext, p);
				// 增加要读的序列号的值
				::InterlockedIncrement((LONG*)&pContext->nCurrentReadSequence);
				// 释放这个已完成的I/O
				ReleaseBuffer(p);
				p = GetNextReadBuffer(pContext, NULL);
			}

//			printf("空闲buffer数:%d \n",m_nFreeBufferCount);
			if (pContext->nOutstandingRecv <= 0)
			{
				for(int i=0; i<m_nInitialReads ; i++)
				{
            	    // 继续投递几个新的重叠接收请求,这样能达到最快速度
					// 因为此时pBuffer已经释放或被保存到缓冲区,所以分配一个新的
					pBuffer = AllocateBuffer(BUFFER_SIZE);
					if(pBuffer != NULL)
					{
						if(!PostRecv(pContext, pBuffer))
						{
							CloseAConnection(pContext);
							break;
						}
					}
				}
			}

		}
	}
	else if(pBuffer->nOperation == OP_WRITE)
	{

		if(dwTrans == 0)	// 对方关闭套节字
		{
			// 先通知用户
			pBuffer->nLen = 0;
			OnConnectionClosing(pContext, pBuffer);	

			// 再关闭连接
			CloseAConnection(pContext);

			// 释放客户上下文和缓冲区对象
			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
			{		
				ReleaseContext(pContext);
			}
			ReleaseBuffer(pBuffer);	
		}
		else
		{
			// 写操作完成,通知用户
			pBuffer->nLen = dwTrans;
			OnWriteCompleted(pContext, pBuffer);
			// 释放SendText函数申请的缓冲区
			ReleaseBuffer(pBuffer);
		}
	}
}
void AvFormatDecoderDVD::CheckContext(int64_t pts)
{
    if (pts != AV_NOPTS_VALUE)
    {
        // Remove any contexts we should have
        // already processed.(but have somehow jumped past)
        while (m_contextList.size() > 0 &&
               pts >= m_contextList.first()->GetEndPTS())
        {
            ReleaseContext(m_curContext);
            m_curContext = m_contextList.takeFirst();

            LOG(VB_GENERAL, LOG_ERR, LOC +
                QString("DVD context missed! lba: %1, curpts: %2, nav end pts: %3")
                .arg(m_curContext->GetLBA())
                .arg(pts)
                .arg(m_curContext->GetEndPTS()));
        }

        // See whether we can take the next context from the list
        if (m_contextList.size() > 0 &&
            pts >= m_contextList.first()->GetStartPTS())
        {
            ReleaseContext(m_curContext);
            m_curContext = m_contextList.takeFirst();

            if (m_curContext->GetLBAPrevVideoFrame() != m_lbaLastVideoPkt)
                ReleaseLastVideoPkt();

            if (m_curContext->GetNumFramesPresent() == 0)
            {
                if (m_lastVideoPkt)
                {
                    // No video frames present, so we need to generate
                    // them based on the last 'sequence end' video packet.
                    m_framesReq = m_curContext->GetNumFrames();
                }
                else
                {
                    // There are no video frames in this VOBU and
                    // we don't have one stored.  We've probably
                    // jumped into the middle of a cell.
                    // Jump back to the first VOBU that contains
                    // video so we can get the video frame we need
                    // before jumping back again.
                    m_framesReq = 0;
                    uint32_t lastVideoSector = m_curContext->GetLBAPrevVideoFrame();

                    if (lastVideoSector != INVALID_LBA)
                    {
                        LOG(VB_PLAYBACK, LOG_DEBUG, LOC + QString( "Missing video.  Jumping to sector %1")
                            .arg(lastVideoSector));

                        ringBuffer->DVD()->SectorSeek(lastVideoSector);

                        m_returnContext = m_curContext;
                        m_curContext = NULL;
                    }
                    else
                    {
                        LOG(VB_GENERAL, LOG_ERR, LOC +
                            QString("Missing video frame and no previous frame available! lba: %1")
                            .arg(m_curContext->GetLBA()));
                    }
                }
            }
            else
            {
                // Normal VOBU with at least one video frame so we don't need to generate frames.
                m_framesReq = 0;
                ReleaseLastVideoPkt();
            }
        }
    }
}
예제 #18
0
__checkReturn
NTSTATUS
FLTAPI
InstanceSetup (
    __in PCFLT_RELATED_OBJECTS FltObjects,
    __in FLT_INSTANCE_SETUP_FLAGS Flags,
    __in DEVICE_TYPE VolumeDeviceType,
    __in FLT_FILESYSTEM_TYPE VolumeFilesystemType
    )
{
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    PInstanceContext pInstanceCtx = NULL;
    PVolumeContext pVolumeContext = NULL;

    UNREFERENCED_PARAMETER( Flags );

    ASSERT( FltObjects->Filter == gFileMgr.m_FileFilter );

    if ( FLT_FSTYPE_RAW == VolumeFilesystemType)
    {
        return STATUS_FLT_DO_NOT_ATTACH;
    }

    if ( FILE_DEVICE_NETWORK_FILE_SYSTEM == VolumeDeviceType )
    {
        return STATUS_FLT_DO_NOT_ATTACH;
    }

    __try
    {
        status = FltAllocateContext(
            gFileMgr.m_FileFilter,
            FLT_INSTANCE_CONTEXT,
            sizeof( InstanceContext ),
            NonPagedPool,
            (PFLT_CONTEXT*) &pInstanceCtx
            );

        if ( !NT_SUCCESS( status ) )
        {
            pInstanceCtx = NULL;
            __leave;
        }

        RtlZeroMemory( pInstanceCtx, sizeof( InstanceContext ) );

        status = FltAllocateContext(
            gFileMgr.m_FileFilter,
            FLT_VOLUME_CONTEXT,
            sizeof( VolumeContext ),
            NonPagedPool,
            (PFLT_CONTEXT*) &pVolumeContext
            );

        if ( !NT_SUCCESS( status ) )
        {
            pVolumeContext = NULL;
            __leave;
        }
        
        RtlZeroMemory( pVolumeContext, sizeof( VolumeContext ) );

        // just for fun
        pInstanceCtx->m_VolumeDeviceType = VolumeDeviceType;
        pInstanceCtx->m_VolumeFilesystemType = VolumeFilesystemType;

        status = FillVolumeProperties( FltObjects, pVolumeContext );
        if ( !NT_SUCCESS( status ) )
        {
            __leave;
        }

        ASSERT( VolumeDeviceType != FILE_DEVICE_NETWORK_FILE_SYSTEM );

        VERDICT Verdict = VERDICT_NOT_FILTERED;
        if ( gFileMgr.m_FltSystem->IsFiltersExist() )
        {
            VolumeInterceptorContext event(
                FltObjects,
                pInstanceCtx,
                pVolumeContext,
                VOLUME_MINIFILTER,
                OP_VOLUME_ATTACH,
                0,
                PostProcessing
                );

            PARAMS_MASK params2user;
            status = gFileMgr.m_FltSystem->FilterEvent(
                &event,
                &Verdict,
                &params2user
                );

            if ( NT_SUCCESS( status ) && FlagOn( Verdict, VERDICT_ASK ) )
            {
                status = ChannelAskUser( &event, params2user, &Verdict );
                if ( NT_SUCCESS( status ) )
                {
                }
            }
        }

        status = FltSetInstanceContext(
            FltObjects->Instance,
            FLT_SET_CONTEXT_KEEP_IF_EXISTS,
            pInstanceCtx,
            NULL
            );

        pVolumeContext->m_Instance = FltObjects->Instance;
        status = FltSetVolumeContext(
            FltObjects->Volume,
            FLT_SET_CONTEXT_KEEP_IF_EXISTS,
            pVolumeContext,
            NULL
            );
    }
    __finally
    {
        ReleaseContext( (PFLT_CONTEXT*) &pInstanceCtx );
        ReleaseContext( (PFLT_CONTEXT*) &pVolumeContext );
    }

    return STATUS_SUCCESS;
}
예제 #19
0
파일: keystore.c 프로젝트: 0x00dec0de/GMbot
//
//	Creates key store report.
//
WINERROR KeyStoreReport(
	PWCHAR*	ppReport,	// receives key report
	PULONG	pLength,	// size of the report in chars
	BOOL	bDelete
	)
{
	WINERROR Status = ERROR_NOT_ENOUGH_MEMORY;
	PKEY_CONTEXT Ctx, NextCtx;
	ULONG	bLen, TotalLen = 1, Index = 0, Length, InitialSize;
	ULONG   LengthClipbrd = 0;
	PWCHAR	Buffer, NewBuffer;
	SYSTEMTIME	DateTime;
	FILETIME	LocalTime;
	PLIST_ENTRY ListEntry;
#if _DEBUG
	HANDLE	PrevKey = 0;
#endif

	InitialSize = MAX_REPORT_BUFFER_SIZE;

	if (Buffer = AppAlloc(InitialSize))
	{
		bLen = MAX_REPORT_BUFFER_SIZE / sizeof(WCHAR);
		Buffer[0] = 0xfeff;	// Unicode file magic
		Buffer[1] = 0;

		bLen -= 1;

		NextCtx = EnumContext(NULL);

		while(Ctx = NextCtx)
		{
#if _DEBUG
			PHANDLE_RECORD pHRec = CONTAINING_RECORD(Ctx, HANDLE_RECORD, Context);
			ASSERT(pHRec->RefCount == 2);
			ASSERT(PrevKey != pHRec->Key);
			PrevKey = pHRec->Key;
#endif
			if (Ctx->bActive)
			{
				FileTimeToLocalFileTime(&Ctx->Time, &LocalTime);
				FileTimeToSystemTime(&LocalTime, &DateTime);

				// Calculating new message length
				Length = cstrlenW(wczReportFormat) + lstrlenW(Ctx->ProcessPath) + lstrlenW(Ctx->WindowText) + Ctx->Count + 1;

				// Checking if there's enough free space within the buffer to fit the message
				if ((bLen >= Length) ||
					// Trying to reallocate the buffer
					((NewBuffer = ReallocBuffer(Buffer, (InitialSize += max(Length, MAX_KEY_BUFFER_SIZE) * sizeof(WCHAR)), (bLen * sizeof(WCHAR)))) &&
					(Buffer = NewBuffer) && (bLen = (InitialSize / sizeof(WCHAR)) - bLen)))
				{
					Length = wnsprintfW(
						Buffer + TotalLen,
						bLen,
						wczReportFormat,
						DateTime.wDay,
						DateTime.wMonth,
						DateTime.wYear,
						DateTime.wHour,
						DateTime.wMinute,
						DateTime.wSecond,
						(LPWSTR)&Ctx->ProcessPath,
						(LPWSTR)&Ctx->WindowText,
						(LPWSTR)&Ctx->KeyBuffer
						);
					bLen -= Length;
					TotalLen += Length;
				}
			}	// if (Ctx->bActive)

			if (!IsListEmpty(&Ctx->ClipboardChain))
			{
				for ( ListEntry = Ctx->ClipboardChain.Flink;
					ListEntry != &Ctx->ClipboardChain;
					ListEntry = ListEntry->Flink)
				{
					PCLIPBOARD_ENTRY CEntry = CONTAINING_RECORD(ListEntry,CLIPBOARD_ENTRY,qLink);
					Length = cstrlenW(wczFormatClipbrd) + lstrlenA(CEntry->Buffer);

					// Checking if there's enough free space within the buffer to fit the message
					if ((bLen >= Length) ||
						// Trying to reallocate the buffer
						((NewBuffer = ReallocBuffer(Buffer, (InitialSize += max(Length, MAX_KEY_BUFFER_SIZE) * sizeof(WCHAR)), (bLen * sizeof(WCHAR)))) &&
						(Buffer = NewBuffer) && (bLen = (InitialSize / sizeof(WCHAR)) - bLen)))
					{
						FileTimeToLocalFileTime(&CEntry->Time, &LocalTime);
						FileTimeToSystemTime(&LocalTime, &DateTime);

						Length = wnsprintfW(
							Buffer + TotalLen, 
							bLen,
							wczFormatClipbrd,
							DateTime.wDay,
							DateTime.wMonth,
							DateTime.wYear,
							DateTime.wHour,
							DateTime.wMinute,
							DateTime.wSecond,
							(LPWSTR)CEntry->Buffer
							);
						bLen -= Length;
						TotalLen += Length;
					}
				}
			}	// if (!IsListEmpty(&Ctx->ClipboardChain))

			NextCtx = EnumContext(Ctx);

			if (bDelete)
				ReleaseContext(Ctx);
			else
				Index += 1;

			ReleaseContext(Ctx);
		}	// while(Ctx = NextCtx)

		if (TotalLen > 1)
		{
			*ppReport = Buffer;
			*pLength = TotalLen;
			Status = NO_ERROR;
		}
		else
		{
			AppFree(Buffer);
			Status = ERROR_NO_MORE_FILES;
		}
	}	// if (Buffer = AppAlloc(DEFAULT_REPORT_BUFFER_SIZE))

	return(Status);
}
예제 #20
0
파일: keystore.c 프로젝트: 0x00dec0de/GMbot
//
//	Adds a new pressed key information into the key store.
//
WINERROR KeyStoreAdd(
	PKEY_INFO	pKeyInfo
	)
{
	WINERROR		Status = ERROR_NOT_ENOUGH_MEMORY;
	ULONG			KeyHandle;
	PKEY_CONTEXT	Ctx;
	BOOL            bDeref = FALSE;

	KeyHandle = Crc32((PCHAR)&pKeyInfo->Client, sizeof(CLIENT_INFO));
	
	if (Ctx = GetContext(KeyHandle))
	{
		bDeref = Ctx->bDirty;		
		if (Ctx->bDirty == FALSE) // just created
		{
			// Context has just been created, initializing
			HANDLE	hProcess;

			// Resolving process path
			if (hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pKeyInfo->Client.ProcessId))
			{
				GetModuleFileNameExW(hProcess, NULL, (LPWSTR)&Ctx->ProcessPath, MAX_PATH);
				CloseHandle(hProcess);
			}

			Ctx->bActive = TRUE;

			// Saving current date and time
			GetSystemTimeAsFileTime(&Ctx->Time);
			
			// Resolving parent window text
			GetWindowTextW(pKeyInfo->Client.ParentWindow, (LPWSTR)&Ctx->WindowText, MAX_WINDOW_TEXT);
		}	// if (Ctx->bDirty == FALSE) // just created

		Ctx->bDirty = TRUE;

		if (Ctx->bActive)
		{
			if (pKeyInfo->wChar && Ctx->Count < MAX_KEY_BUFFER_SIZE)
			{
				if (pKeyInfo->wChar == VK_BACK)
				{
					if (Ctx->Count)
						Ctx->Count -= 1;
				}
				else
				{
					Ctx->KeyBuffer[Ctx->Count] = pKeyInfo->wChar;
					Ctx->Count += 1;
					DbgPrint("KEYLOG: Adding key to a buffer: 0x%x, %C\n", pKeyInfo->wChar, pKeyInfo->wChar);
				}
				Status = NO_ERROR;
			}	// if (Ctx->Count < MAX_KEY_BUFFER_SIZE)
			else
				Status = ERROR_BUFFER_OVERFLOW;

			if ( pKeyInfo->clipboard )
			{
				PCLIPBOARD_ENTRY Entry = (PCLIPBOARD_ENTRY)AppAlloc( sizeof(CLIPBOARD_ENTRY) );
				if ( Entry )
				{
					// Saving current date and time
					GetSystemTimeAsFileTime(&Entry->Time);
					Entry->Buffer = pKeyInfo->clipboard;
					pKeyInfo->clipboard = NULL; // we'll free it later
					InsertTailList(&Ctx->ClipboardChain,&Entry->qLink);
				}
			}	// if ( pKeyInfo->clipboard )
		}	// if (Ctx->bActive)

		if ( bDeref )
			// Context has been reused, dereferencing it
			ReleaseContext(Ctx);
	}	// if (Ctx = GetContext(KeyHandle))

	return(Status);
}
예제 #21
0
void GameContext::Release()
  {
  ReleaseContext();
  m_objects.clear();
  m_controllers.clear();
  }
예제 #22
0
__checkReturn
FLT_POSTOP_CALLBACK_STATUS
FLTAPI
PostCreate (
    __inout PFLT_CALLBACK_DATA Data,
    __in PCFLT_RELATED_OBJECTS FltObjects,
    __in PVOID CompletionContext,
    __in FLT_POST_OPERATION_FLAGS Flags
    )
{
    UNREFERENCED_PARAMETER( CompletionContext );

    FLT_POSTOP_CALLBACK_STATUS fltStatus = FLT_POSTOP_FINISHED_PROCESSING;

    /// \todo access to volume - generate access event

    PStreamHandleContext pStreamHandleContext = NULL;

    __try
    {
        NTSTATUS status;

        if ( IsSkipPostCreate( Data, FltObjects, Flags ) )
        {
            __leave;
        }

        status = GenerateStreamHandleContext(
            gFileMgr.m_FileFilter,
            FltObjects,
            &pStreamHandleContext
            );

        if ( !NT_SUCCESS( status ) )
        {
            pStreamHandleContext = NULL;

            __leave;
        }

        if ( IsPrefetchEcpPresent( gFileMgr.m_FileFilter, Data ) )
        {
            SetFlag( pStreamHandleContext->m_Flags, _STREAM_H_FLAGS_ECPPREF );

            __leave;
        }

        if ( !gFileMgr.m_FltSystem->IsFiltersExist() )
        {
            __leave;
        }

        VERDICT Verdict = VERDICT_NOT_FILTERED;
        FileInterceptorContext event(
            Data,
            FltObjects,
            pStreamHandleContext->m_StreamCtx,
            FILE_MINIFILTER,
            OP_FILE_CREATE,
            0,
            PostProcessing
            );

        PARAMS_MASK params2user;
        status = gFileMgr.m_FltSystem->FilterEvent(
            &event,
            &Verdict,
            &params2user
            );

        if ( NT_SUCCESS( status ) )
        {
            if ( FlagOn( Verdict, VERDICT_ASK ) )
            {
               status = ChannelAskUser( &event, params2user, &Verdict );
                if ( NT_SUCCESS( status ) )
                {
                    // nothing todo
                }
            }

            if ( FlagOn( Verdict, VERDICT_DENY ) )
            {
                Data->IoStatus.Status = STATUS_ACCESS_DENIED;
                Data->IoStatus.Information = 0;

                if ( FlagOn( FltObjects->FileObject->Flags, FO_HANDLE_CREATED ) )
                {
                    // file already has handle(s)!
                    // skip blocking
                }
                else
                {
                    FltCancelFileOpen( FltObjects->Instance, FltObjects->FileObject );
                }
            }
            else
            {
                if ( FlagOn( Verdict, VERDICT_CACHE1 ) )
                {
                    event.SetCache1();
                }
            }
        }
    }
    __finally
    {
        ReleaseContext( (PFLT_CONTEXT*) &pStreamHandleContext );
    }

    return fltStatus;
}
예제 #23
0
__checkReturn
FLT_PREOP_CALLBACK_STATUS
FLTAPI
PreCleanup (
    __inout PFLT_CALLBACK_DATA Data,
    __in PCFLT_RELATED_OBJECTS FltObjects,
    __out PVOID *CompletionContext
    )
{
    NTSTATUS status;
    UNREFERENCED_PARAMETER( CompletionContext );

    FLT_PREOP_CALLBACK_STATUS fltStatus = FLT_PREOP_SUCCESS_NO_CALLBACK;

    PStreamHandleContext pStreamHandleContext = NULL;
    
    __try
    {
        status = GetStreamHandleContext( FltObjects, &pStreamHandleContext );

        if ( !NT_SUCCESS( status ) )
        {
            pStreamHandleContext = NULL;

            __leave;
        }

        if ( FlagOn( pStreamHandleContext->m_Flags, _STREAM_H_FLAGS_ECPPREF ) )
        {
            __leave;
        }

        if ( !gFileMgr.m_FltSystem->IsFiltersExist() )
        {
            __leave;
        }

        VERDICT Verdict = VERDICT_NOT_FILTERED;
        FileInterceptorContext event(
            Data,
            FltObjects,
            pStreamHandleContext->m_StreamCtx,
            FILE_MINIFILTER,
            OP_FILE_CLEANUP,
            0,
            PreProcessing
            );

        PARAMS_MASK params2user;
        status = gFileMgr.m_FltSystem->FilterEvent(
            &event,
            &Verdict,
            &params2user
            );

        if ( NT_SUCCESS( status ) && FlagOn( Verdict, VERDICT_ASK ) )
        {
            status = ChannelAskUser( &event, params2user, &Verdict );
            if ( NT_SUCCESS( status ) )
            {
                if (
                    !FlagOn( Verdict, VERDICT_DENY)
                    &&
                    FlagOn( Verdict, VERDICT_CACHE1 )
                    )
                {
                    event.SetCache1();
                }
            }
        }
    }
    __finally
    {
        ReleaseContext( (PFLT_CONTEXT*) &pStreamHandleContext );
    }

    return fltStatus;
}
bool AvFormatDecoderDVD::ProcessVideoPacket(AVStream *stream, AVPacket *pkt)
{
    int64_t pts = pkt->pts;

    if (pts == AV_NOPTS_VALUE)
        pts = pkt->dts;

    CheckContext(pts);

    bool ret = AvFormatDecoder::ProcessVideoPacket(stream, pkt);
        
    if( ret &&
        m_curContext &&
        pts != AV_NOPTS_VALUE &&
        pts + pkt->duration == m_curContext->GetSeqEndPTS())
    {
        // If this video frame is the last in the sequence,
        // make a copy of it so we can 'generate' more
        // to fill in the gaps (e.g. when a single frame
        // should be displayed with audio)
        if (!m_lastVideoPkt)
        {
            m_lastVideoPkt = new AVPacket;
            memset(m_lastVideoPkt, 0, sizeof(AVPacket));
        }
        else
        {
            av_free_packet(m_lastVideoPkt);
        }

        av_init_packet(m_lastVideoPkt);
        av_copy_packet(m_lastVideoPkt, pkt);
        m_lbaLastVideoPkt = m_curContext->GetLBA();

        if (m_returnContext)
        {
            // After seeking in a slideshow, we needed to find
            // the previous video frame to display.
            // We've found it now, so we need to jump back to
            // where we originally wanted to be.
            LOG(VB_PLAYBACK, LOG_DEBUG, LOC + QString( "Found video packet, jumping back to sector %1")
                .arg(m_returnContext->GetLBA()));

            ringBuffer->DVD()->SectorSeek(m_returnContext->GetLBA());
            ReleaseContext(m_returnContext);
        }
        else
        {
            if (m_lastVideoPkt->pts != AV_NOPTS_VALUE)
                m_lastVideoPkt->pts += pkt->duration;

            if (m_lastVideoPkt->dts != AV_NOPTS_VALUE)
                m_lastVideoPkt->dts += pkt->duration;

            m_framesReq = m_curContext->GetNumFrames() - m_curContext->GetNumFramesPresent();

            LOG(VB_PLAYBACK, LOG_DEBUG, LOC + QString( "SeqEnd @ %1 - require %2 frame(s)")
                .arg(pkt->pts)
                .arg(m_framesReq));
        }
    }

    return ret;
}
int AvFormatDecoderDVD::ReadPacket(AVFormatContext *ctx, AVPacket* pkt)
{
    int result = 0;

    if (m_framesReq > 0)
    {
        m_framesReq--;

        if (m_lastVideoPkt)
        {
            av_copy_packet(pkt, m_lastVideoPkt);

            if (m_lastVideoPkt->pts != AV_NOPTS_VALUE)
                m_lastVideoPkt->pts += pkt->duration;

            if (m_lastVideoPkt->dts != AV_NOPTS_VALUE)
                m_lastVideoPkt->dts += pkt->duration;
        }
        else
        {
            LOG(VB_GENERAL, LOG_ERR, LOC + QString( "Need to generate frame @ %1 - %2 but no frame available!")
                .arg(pkt->pts)
                .arg(m_framesReq));
        }
    }
    else
    {
        bool gotPacket;

        do
        {
            gotPacket = true;

            result = av_read_frame(ctx, pkt);

            while (result == AVERROR_EOF && errno == EAGAIN)
            {
                if (ringBuffer->DVD()->IsReadingBlocked())
                {
                    if (ringBuffer->DVD()->GetLastEvent() == DVDNAV_HOP_CHANNEL)
                    {
                        // Non-seamless jump - clear all buffers
                        m_framesReq = 0;
                        ReleaseContext(m_curContext);

                        while (m_contextList.size() > 0)
                            m_contextList.takeFirst()->DecrRef();

                        Reset(true, false, false);
                        m_audio->Reset();
                        m_parent->DiscardVideoFrames(false);
                    }
                    ringBuffer->DVD()->UnblockReading();
                    result = av_read_frame(ctx, pkt);
                }
                else
                {
                    break;
                }
            }

            if (result >= 0)
            {
                pkt->dts = ringBuffer->DVD()->AdjustTimestamp(pkt->dts);
                pkt->pts = ringBuffer->DVD()->AdjustTimestamp(pkt->pts);

                if (m_returnContext)
                {
                    // We've jumped in a slideshow and have had to jump again
                    // to find the right video packet to show so only allow
                    // the packets through that let us find it.
                    gotPacket = false;

                    AVStream *curstream = ic->streams[pkt->stream_index];

                    if ((curstream->codec->codec_type == AVMEDIA_TYPE_VIDEO) ||
                        (curstream->codec->codec_id == AV_CODEC_ID_DVD_NAV))
                    {
                        // Allow video or NAV packets through
                        gotPacket = true;
                    }
                }
            }
        }while(!gotPacket);
    }

    return result;
}
예제 #26
0
int
main(int argc, char const * argv[])
{
  char const * const target_platform_substring = "Intel";
  char const * const target_device_substring   = "Graphics";

  //
  // find platform and device ids
  //
  cl_platform_id platform_id;
  cl_device_id   device_id;

#define HS_DEVICE_NAME_SIZE  64

  char   device_name[HS_DEVICE_NAME_SIZE];
  size_t device_name_size;

  cl(FindIdsByName(target_platform_substring,
                   target_device_substring,
                   &platform_id,
                   &device_id,
                   HS_DEVICE_NAME_SIZE,
                   device_name,
                   &device_name_size,
                   true));
  //
  // create context
  //
  cl_context_properties context_properties[] =
    {
      CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id,
      0
    };

  cl_int     cl_err;
  cl_context context = clCreateContext(context_properties,
                                       1,
                                       &device_id,
                                       NULL,
                                       NULL,
                                       &cl_err);
  cl_ok(cl_err);

  //
  // create command queue
  //
#if 0 // OPENCL 2.0

  cl_queue_properties props[] = {
    CL_QUEUE_PROPERTIES,
    (cl_queue_properties)CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
#ifndef NDEBUG
    (cl_queue_properties)CL_QUEUE_PROFILING_ENABLE,
#endif
    0
  };

  cl_queue_properties props_profile[] = {
    CL_QUEUE_PROPERTIES,
    (cl_queue_properties)CL_QUEUE_PROFILING_ENABLE,
    0
  };

  cl_command_queue cq = clCreateCommandQueueWithProperties(context,
                                                           device_id,
                                                           props,
                                                           &cl_err); cl_ok(cl_err);

  cl_command_queue cq_profile = clCreateCommandQueueWithProperties(context,
                                                                   device_id,
                                                                   props_profile,
                                                                   &cl_err); cl_ok(cl_err);
#else // OPENCL 1.2

  cl_command_queue cq = clCreateCommandQueue(context,
                                             device_id,
#ifndef NDEBUG
                                             CL_QUEUE_PROFILING_ENABLE |
#endif
                                             CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
                                             &cl_err); cl_ok(cl_err);

  cl_command_queue cq_profile = clCreateCommandQueue(context,
                                                     device_id,
                                                     CL_QUEUE_PROFILING_ENABLE,
                                                     &cl_err); cl_ok(cl_err);
#endif

  //
  // Intel GEN workaround -- create dummy kernel for semi-accurate
  // profiling on an out-of-order queue.
  //
  hs_dummy_kernel_create(context,device_id);

  //
  // select the target
  //

  uint32_t const key_val_words = (argc == 1) ? 2 : strtoul(argv[1],NULL,0);

  struct hs_cl_target const * hs_target;

  if (key_val_words == 1)
    hs_target = &hs_intel_gen8_u32;
  else
    hs_target = &hs_intel_gen8_u64;

  //
  // create kernels
  //
  fprintf(stdout,"Creating... ");

  struct hs_cl * const hs = hs_cl_create(hs_target,context,device_id);

  fprintf(stdout,"done.\n");

  //
  //
  //

#ifdef NDEBUG
#define HS_BENCH_LOOPS   100
#define HS_BENCH_WARMUP  100
#else
#define HS_BENCH_LOOPS   1
#define HS_BENCH_WARMUP  0
#endif

  //
  // sort sizes and loops
  //
  uint32_t const kpb        = hs_target->config.slab.height << hs_target->config.slab.width_log2;

  uint32_t const count_lo   = (argc <= 2) ? kpb             : strtoul(argv[2],NULL,0);
  uint32_t const count_hi   = (argc <= 3) ? count_lo        : strtoul(argv[3],NULL,0);
  uint32_t const count_step = (argc <= 4) ? count_lo        : strtoul(argv[4],NULL,0);
  uint32_t const loops      = (argc <= 5) ? HS_BENCH_LOOPS  : strtoul(argv[5],NULL,0);
  uint32_t const warmup     = (argc <= 6) ? HS_BENCH_WARMUP : strtoul(argv[6],NULL,0);
  bool     const linearize  = (argc <= 7) ? true            : strtoul(argv[7],NULL,0);

  //
  // labels
  //
  fprintf(stdout,
          "Device, "
          "Driver, "
          "Type, "
          "Slab/Linear, "
          "Verified?, "
          "Keys, "
          "Keys Padded In, "
          "Keys Padded Out, "
          "CPU Algorithm, "
          "CPU Msecs, "
          "CPU Mkeys/s, "
          "Trials, "
          "Avg. Msecs, "
          "Min Msecs, "
          "Max Msecs, "
          "Avg. Mkeys/s, "
          "Max. Mkeys/s\n");

  //
  // we want to track driver versions
  //
  size_t driver_version_size;

  cl(GetDeviceInfo(device_id,
                   CL_DRIVER_VERSION,
                   0,
                   NULL,
                   &driver_version_size));

  char * const driver_version = ALLOCA_MACRO(driver_version_size);

  cl(GetDeviceInfo(device_id,
                   CL_DRIVER_VERSION,
                   driver_version_size,
                   driver_version,
                   NULL));
  //
  // benchmark
  //
  hs_bench(context,
           cq,cq_profile,
           device_name,
           driver_version,
           hs_target->config.words.key + hs_target->config.words.val,
           1 << hs_target->config.slab.width_log2,
           hs_target->config.slab.height,
           hs,
           count_lo,
           count_hi,
           count_step,
           loops,
           warmup,
           linearize);

  //
  // release everything
  //
  hs_cl_release(hs);

  hs_dummy_kernel_release();

  cl(ReleaseCommandQueue(cq));
  cl(ReleaseCommandQueue(cq_profile));

  cl(ReleaseContext(context));

  return 0;
}