/// <summary>
/// processes incoming image
/// </summary>
/// <returns>error code, refer to AL_XXX codes</returns>
/// <remarks>
/// working parallel code with single loop, using active waits to protect data dependencies
/// [Filter processing of full resolution image] in [1.131 seconds]
/// </remarks>
int CParallelActiveWaitAltaLuxFilter::Run()
{
if (ClipLimit == 1.0)
return AL_OK; //< is OK, immediately returns original image
PixelType *pImage = (PixelType *)ImageBuffer;
/// pulMapArray is pointer to mappings
unsigned int *pulMapArray = new unsigned int[NumHorRegions * NumVertRegions * NUM_GRAY_LEVELS];
if (pulMapArray == 0)
return AL_OUT_OF_MEMORY; //< not enough memory
/// region pixel count
unsigned int NumPixels = (unsigned int)RegionWidth * (unsigned int)RegionHeight; //< region pixel count
unsigned int ulClipLimit; //< clip limit
if (ClipLimit > 0.0)
{
/// calculate actual cliplimit
ulClipLimit = (unsigned int) (ClipLimit * (RegionWidth * RegionHeight) / NUM_GRAY_LEVELS);
ulClipLimit = (ulClipLimit < 1UL) ? 1UL : ulClipLimit;
}
else
ulClipLimit = 1UL<<14; //< large value, do not clip (AHE)
/// Interpolate greylevel mappings to get CLAHE image
// create events for signaling that the first phase is completed
__declspec(align(32)) volatile LONG FirstPhaseCompleted[MAX_VERT_REGIONS+1];
for (int i = 0; i <= NumVertRegions; i++)
InterlockedExchange((volatile LONG*)&FirstPhaseCompleted[i], -1);
concurrency::parallel_for((LONG)0, (LONG)(NumVertRegions + 1), [&](LONG uiY)
{
// first half
PixelType* pImPointer = pImage;
if (uiY > 0)
pImPointer += ((RegionHeight >> 1) + ((uiY - 1) * RegionHeight)) * OriginalImageWidth;
if (uiY < NumVertRegions)
{
/// calculate greylevel mappings for each contextual region
for (LONG uiX = 0; uiX < NumHorRegions; uiX++, pImPointer += RegionWidth)
{
unsigned int *pHistogram = &pulMapArray[NUM_GRAY_LEVELS * (uiY * NumHorRegions + uiX)];
MakeHistogram(pImPointer, pHistogram);
ClipHistogram(pHistogram, ulClipLimit);
MapHistogram(pHistogram, NumPixels);
InterlockedExchange((volatile LONG*) &FirstPhaseCompleted[uiY], uiX);
}
}
// second half
unsigned int uiSubX, uiSubY; //< size of subimages
unsigned int uiXL, uiXR, uiYU, uiYB; //< auxiliary variables interpolation routine
pImPointer = pImage;
if (uiY > 0)
pImPointer += ((RegionHeight >> 1) + ((uiY - 1) * RegionHeight)) * OriginalImageWidth;
if (uiY == 0)
{
/// special case: top row
uiSubY = RegionHeight >> 1;
uiYU = 0;
uiYB = 0;
} else {
VOID
DCamSurpriseRemoval(
IN PHW_STREAM_REQUEST_BLOCK pSrb
)
/*++
Routine Description:
Response to SRB_SURPRISE_REMOVAL.
Arguments:
pSrb - Pointer to the stream request block
Return Value:
None.
--*/
{
PIRP pIrp;
PIRB pIrb;
PDCAM_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
NTSTATUS Status;
PAGED_CODE();
pIrb = (PIRB) pSrb->SRBExtension;
ASSERT(pIrb);
pDevExt = (PDCAM_EXTENSION) pSrb->HwDeviceExtension;
ASSERT(pDevExt);
//
// Set this to stop accepting incoming read.
//
pDevExt->bDevRemoved = TRUE;
//
// Wait until all pending work items are completed!
//
KeWaitForSingleObject( &pDevExt->PendingWorkItemEvent, Executive, KernelMode, FALSE, NULL );
//
// Wait for currect read to be attached so we cancel them all.
//
pStrmEx = pDevExt->pStrmEx;
if(pStrmEx) {
// Make sure that this structure is still valid.
if(pStrmEx->pVideoInfoHeader) {
KeWaitForSingleObject( &pStrmEx->hMutex, Executive, KernelMode, FALSE, 0 );
KeReleaseMutex(&pStrmEx->hMutex, FALSE);
}
}
pIrp = IoAllocateIrp(pDevExt->BusDeviceObject->StackSize, FALSE);
if(!pIrp) {
ERROR_LOG(("DCamSurpriseRemovalPacket: faile to get resource; pIrb=%p, pDevExt=%p, pIrp\n", pIrb, pDevExt));
pSrb->Status = STATUS_INSUFFICIENT_RESOURCES;
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
return;
}
//
// un-register a bus reset callback notification
//
pIrb->FunctionNumber = REQUEST_BUS_RESET_NOTIFICATION;
pIrb->Flags = 0;
pIrb->u.BusResetNotification.fulFlags = DEREGISTER_NOTIFICATION_ROUTINE;
pIrb->u.BusResetNotification.ResetRoutine = (PBUS_BUS_RESET_NOTIFICATION) DCamBusResetNotification;
pIrb->u.BusResetNotification.ResetContext = 0;
Status = DCamSubmitIrpSynch(pDevExt, pIrp, pIrb);
if(Status) {
ERROR_LOG(("DCamSurpriseRemoval: Status %x while trying to deregister bus reset notification.\n", Status));
}
if(pStrmEx && pStrmEx->pVideoInfoHeader) {
//
// Stop isoch transmission so we can detach buffers and cancel pending SRBs
//
pIrb->FunctionNumber = REQUEST_ISOCH_STOP;
pIrb->Flags = 0;
pIrb->u.IsochStop.hResource = pDevExt->hResource;
pIrb->u.IsochStop.fulFlags = 0;
Status = DCamSubmitIrpSynch(pDevExt, pIrp, pIrb);
if(Status) {
ERROR_LOG(("DCamSurpriseRemoval: Status %x while trying to ISOCH_STOP.\n", Status));
}
IoFreeIrp(pIrp);
if( InterlockedExchange((PLONG)&pStrmEx->CancelToken, 1 ) == 0 ) {
DCamCancelAllPackets(
pDevExt,
&pDevExt->PendingReadCount );
}
COMPLETE_SRB( pSrb );
} else {
IoFreeIrp(pIrp);
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
}
}
AtomicCounter& AtomicCounter::operator = (AtomicCounter::ValueType value)
{
InterlockedExchange(&_counter, value);
return *this;
}
int CMraProto::SetStatus(int iNewStatus)
{
// remap global statuses to local supported
switch (iNewStatus) {
case ID_STATUS_OCCUPIED:
iNewStatus = ID_STATUS_DND;
break;
case ID_STATUS_NA:
case ID_STATUS_ONTHEPHONE:
case ID_STATUS_OUTTOLUNCH:
iNewStatus = ID_STATUS_AWAY;
break;
}
// nothing to change
if (m_iStatus == iNewStatus)
return 0;
DWORD dwOldStatusMode;
//set all contacts to offline
if ((m_iDesiredStatus = iNewStatus) == ID_STATUS_OFFLINE) {
m_bLoggedIn = FALSE;
dwOldStatusMode = InterlockedExchange((volatile LONG*)&m_iStatus, m_iDesiredStatus);
// всех в offline, только если мы бывали подключены
if (dwOldStatusMode > ID_STATUS_OFFLINE)
for (HANDLE hContact = db_find_first(m_szModuleName); hContact; hContact = db_find_next(hContact, m_szModuleName))
SetContactBasicInfoW(hContact, SCBIFSI_LOCK_CHANGES_EVENTS, (SCBIF_ID|SCBIF_GROUP_ID|SCBIF_SERVER_FLAG|SCBIF_STATUS), -1, -1, 0, 0, ID_STATUS_OFFLINE, 0, 0, 0);
Netlib_CloseHandle(m_hConnection);
}
else {
// если offline то сразу ставим connecting, но обработка как offline
dwOldStatusMode = InterlockedCompareExchange((volatile LONG*)&m_iStatus, ID_STATUS_CONNECTING, ID_STATUS_OFFLINE);
switch (dwOldStatusMode) {
case ID_STATUS_OFFLINE: // offline, connecting
if (StartConnect() != NO_ERROR) {
m_bLoggedIn = FALSE;
m_iDesiredStatus = ID_STATUS_OFFLINE;
dwOldStatusMode = InterlockedExchange((volatile LONG*)&m_iStatus, m_iDesiredStatus);
}
break;
case ID_STATUS_ONLINE:// connected, change status
case ID_STATUS_AWAY:
case ID_STATUS_DND:
case ID_STATUS_FREECHAT:
case ID_STATUS_INVISIBLE:
MraSendNewStatus(m_iDesiredStatus, m_iXStatus, _T(""), _T(""));
case ID_STATUS_CONNECTING:
// предотвращаем переход в любой статус (кроме offline) из статуса connecting, если он не вызван самим плагином
if (dwOldStatusMode == ID_STATUS_CONNECTING && iNewStatus != m_iDesiredStatus)
break;
default:
dwOldStatusMode = InterlockedExchange((volatile LONG*)&m_iStatus, m_iDesiredStatus);
break;
}
}
MraSetContactStatus(NULL, m_iStatus);
ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)dwOldStatusMode, m_iStatus);
return 0;
}
/* Release spin lock */
static int slrelease (LOCKLONG *sl)
{
InterlockedExchange ((volatile LONG*)sl, 0);
return 0;
}
//! Удаляет DeletedFrame изо всех очередей!
//! Назначает следующий активный, (исходя из своих представлений)
//! Но только в том случае, если активный фрейм еще не назначен заранее.
void Manager::DeleteCommit()
{
_MANAGER(CleverSysLog clv(L"Manager::DeleteCommit()"));
_MANAGER(SysLog(L"DeletedFrame=%p",DeletedFrame));
if (!DeletedFrame)
{
return;
}
// <ifDoubleInstance>
//BOOL ifDoubI=ifDoubleInstance(DeletedFrame);
// </ifDoubleInstance>
int ModalIndex=IndexOfStack(DeletedFrame);
if (ModalIndex!=-1)
{
/* $ 14.05.2002 SKV
Надёжнее найти и удалить именно то, что
нужно, а не просто верхний.
*/
for (int i=0; i<ModalStackCount; i++)
{
if (ModalStack[i]==DeletedFrame)
{
for (int j=i+1; j<ModalStackCount; j++)
{
ModalStack[j-1]=ModalStack[j];
}
ModalStackCount--;
break;
}
}
if (ModalStackCount)
{
ActivateFrame(ModalStack[ModalStackCount-1]);
}
}
for (int i=0; i<FrameCount; i++)
{
if (FrameList[i]->FrameToBack==DeletedFrame)
{
FrameList[i]->FrameToBack=CtrlObject->Cp();
}
}
int FrameIndex=IndexOf(DeletedFrame);
if (-1!=FrameIndex)
{
DeletedFrame->DestroyAllModal();
for (int j=FrameIndex; j<FrameCount-1; j++)
{
FrameList[j]=FrameList[j+1];
}
FrameCount--;
if (FramePos >= FrameCount)
{
FramePos=0;
}
if (DeletedFrame->FrameToBack==CtrlObject->Cp())
{
ActivateFrame(FrameList[FramePos]);
}
else
{
ActivateFrame(DeletedFrame->FrameToBack);
}
}
/* $ 14.05.2002 SKV
Долго не мог понять, нужен всё же этот код или нет.
Но вроде как нужен.
SVS> Когда понадобится - в некоторых местах расскомментить куски кода
помеченные скобками <ifDoubleInstance>
if (ifDoubI && IsSemiModalBackFrame(ActivatedFrame)){
for(int i=0;i<ModalStackCount;i++)
{
if(ModalStack[i]==ActivatedFrame)
{
break;
}
}
if(i==ModalStackCount)
{
if (ModalStackCount == ModalStackSize){
ModalStack = (Frame **) xf_realloc (ModalStack, ++ModalStackSize * sizeof (Frame *));
}
ModalStack[ModalStackCount++]=ActivatedFrame;
}
}
*/
DeletedFrame->OnDestroy();
if (CurrentFrame==DeletedFrame)
{
CurrentFrame=0;
InterlockedExchange(&CurrentWindowType,-1);
}
if (DeletedFrame->GetDynamicallyBorn())
{
_MANAGER(SysLog(L"delete DeletedFrame %p", DeletedFrame));
/* $ 14.05.2002 SKV
Так как в деструкторе фрэйма неявно может быть
вызван commit, то надо подстраховаться.
*/
Frame *tmp=DeletedFrame;
DeletedFrame=nullptr;
delete tmp;
}
// Полагаемся на то, что в ActevateFrame не будет переписан уже
// присвоенный ActivatedFrame
if (ModalStackCount)
{
ActivateFrame(ModalStack[ModalStackCount-1]);
}
else
{
ActivateFrame(FramePos);
}
}
//
// Add fault to Lurn fault list for future analysys
//
// ErrorCode is dependent on fault type. It can be custom error code.
//
// Param is Type dependent parameter.
// Param is CCB if / Ccb is valid only for fault type LURN_ERR_IO, LURN_ERR_LOCK
//
NTSTATUS
LurnRecordFault(PLURELATION_NODE Lurn, LURN_FAULT_TYPE Type, UINT32 ErrorCode, PVOID Param)
{
PLURN_FAULT_INFO fInfo = &Lurn->FaultInfo;
LONG count;
LURN_FAULT_TYPE LastFaultType;
LONG LastErrorCode;
PLURN_FAULT_IO pLfi= (PLURN_FAULT_IO) Param;
LastFaultType = fInfo->LastFaultType;
LastErrorCode = fInfo->LastErrorCode[LastFaultType];
//
// To do: Recognize some indirect error patterns.
//
#if 0
//
// Check accesing same range failed.
//
if ((Type == LURN_ERR_READ || Type == LURN_ERR_WRITE || Type == LURN_ERR_VERIFY) && pLfi &&
(ErrorCode == LURN_FAULT_COMMUNICATION)) {
if (fInfo->LastIoOperation) {
//
// Check accesing same range failed and error occured multiple times.
//
if (fInfo->LastIoAddr + fInfo->LastIoLength > pLfi->Address
&& pLfi->Address+pLfi->Length > fInfo->LastIoAddr &&
fInfo->ErrorCount[Type] > 5) {
KDPrintM(NDASSCSI_DBG_LUR_ERROR, ("IO failed on same location. Marking error\n"));
ErrorCode = LURN_FAULT_BAD_SECTOR;
}
} else {
// no previous IO error recorded.
}
}
#endif
//
// to do: handle disk hang after bad sector..
//
//
// Update internal fault record.
//
switch(Type) {
case LURN_ERR_SUCCESS:
count = InterlockedIncrement(&fInfo->ErrorCount[Type]);
if (count == 128) {
KDPrintM(NDASSCSI_DBG_LUR_TRACE, ("Resetting error count\n"));
//
// If some IO operation completed without any error, clear all other errors.
//
LurnResetFaultInfo(Lurn);
InterlockedExchange(&fInfo->ErrorCount[Type], count);
}
break;
case LURN_ERR_CONNECT:
case LURN_ERR_LOGIN:
case LURN_ERR_NDAS_OP:
case LURN_ERR_DISK_OP:
case LURN_ERR_READ:
case LURN_ERR_WRITE:
case LURN_ERR_VERIFY:
case LURN_ERR_UNKNOWN:
case LURN_ERR_FLUSH:
default:
// Error occured. Reset success count
InterlockedExchange(&fInfo->ErrorCount[LURN_ERR_SUCCESS], 0);
InterlockedIncrement(&fInfo->ErrorCount[Type]);
InterlockedExchange(&fInfo->LastErrorCode[Type], ErrorCode);
fInfo->LastFaultType = Type;
KeQuerySystemTime(&fInfo->LastFaultTime);
break;
}
if (Type == LURN_ERR_READ || Type == LURN_ERR_WRITE) {
if (pLfi) {
fInfo->LastIoOperation = Type;
fInfo->LastIoAddr = pLfi->Address;
fInfo->LastIoLength = pLfi->Length;
}
}
//
// Update error causes.
//
//
// Guess error cause. Be cautious when setting error because this can mark a disk as defective permanently.
//
if (Type == LURN_ERR_CONNECT) {
fInfo->FaultCause |= LURN_FCAUSE_TARGET_DOWN;
} else {
// At least target is not down
fInfo->FaultCause &= ~LURN_FCAUSE_TARGET_DOWN;
}
if ((Type == LURN_ERR_READ || Type == LURN_ERR_WRITE || Type == LURN_ERR_VERIFY) &&
ErrorCode == LURN_FAULT_BAD_SECTOR) {
fInfo->FaultCause |= LURN_FCAUSE_BAD_SECTOR;
}
if (Type == LURN_ERR_DISK_OP) {
if (fInfo->ErrorCount[LURN_ERR_DISK_OP] > 5 && ErrorCode == LURN_FAULT_IDENTIFY) {
NDAS_ASSERT(FALSE);
//
// If HDD's board is broken, identify may not work.
//
// To do: mark LURN_FAULT_IDENTIFY fault only when this is just communication problem. (Need support from lpx)
//
fInfo->FaultCause |= LURN_FCAUSE_BAD_DISK;
} else if (ErrorCode == LURN_FAULT_NOT_EXIST){
//
// NDAS chip cannot detect HDD. HDD may be removed or dead
//
fInfo->FaultCause |= LURN_FAULT_NO_TARGET;
}
}
//
// to do: handle more error cases: LURN_ERR_FLUSH, LURN_ERR_LOGIN, LURN_ERR_NDAS_OP
//
return STATUS_SUCCESS;
}
/*
* Monotonic and real time functions
*/
unsigned __stdcall wince_clock_gettime_threaded(void* param)
{
LARGE_INTEGER hires_counter, li_frequency;
LONG nb_responses;
int timer_index;
// Init - find out if we have access to a monotonic (hires) timer
if (!QueryPerformanceFrequency(&li_frequency)) {
usbi_dbg("no hires timer available on this platform");
hires_frequency = 0;
hires_ticks_to_ps = UINT64_C(0);
} else {
hires_frequency = li_frequency.QuadPart;
// The hires frequency can go as high as 4 GHz, so we'll use a conversion
// to picoseconds to compute the tv_nsecs part in clock_gettime
hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency);
}
// Signal wince_init() that we're ready to service requests
if (ReleaseSemaphore(timer_response, 1, NULL) == 0) {
usbi_dbg("unable to release timer semaphore: %s", windows_error_str(0));
}
// Main loop - wait for requests
while (1) {
timer_index = WaitForMultipleObjects(2, timer_request, FALSE, INFINITE) - WAIT_OBJECT_0;
if ( (timer_index != 0) && (timer_index != 1) ) {
usbi_dbg("failure to wait on requests: %s", windows_error_str(0));
continue;
}
if (request_count[timer_index] == 0) {
// Request already handled
ResetEvent(timer_request[timer_index]);
// There's still a possiblity that a thread sends a request between the
// time we test request_count[] == 0 and we reset the event, in which case
// the request would be ignored. The simple solution to that is to test
// request_count again and process requests if non zero.
if (request_count[timer_index] == 0)
continue;
}
switch (timer_index) {
case 0:
WaitForSingleObject(timer_mutex, INFINITE);
// Requests to this thread are for hires always
if (QueryPerformanceCounter(&hires_counter) != 0) {
timer_tp.tv_sec = (long)(hires_counter.QuadPart / hires_frequency);
timer_tp.tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency)/1000) * hires_ticks_to_ps);
} else {
// Fallback to real-time if we can't get monotonic value
// Note that real-time clock does not wait on the mutex or this thread.
wince_clock_gettime(USBI_CLOCK_REALTIME, &timer_tp);
}
ReleaseMutex(timer_mutex);
nb_responses = InterlockedExchange((LONG*)&request_count[0], 0);
if ( (nb_responses)
&& (ReleaseSemaphore(timer_response, nb_responses, NULL) == 0) ) {
usbi_dbg("unable to release timer semaphore: %s", windows_error_str(0));
}
continue;
case 1: // time to quit
usbi_dbg("timer thread quitting");
return 0;
}
}
usbi_dbg("ERROR: broken timer thread");
return 1;
}
DWORD WINAPI CIOCPServer::_ListenThreadProc(LPVOID lpParam)
{
CIOCPServer *pThis = (CIOCPServer*)lpParam;
// 先在监听套节字上投递几个Accept I/O
CIOCPBuffer *pBuffer;
for(int i=0; i<pThis->m_nInitialAccepts; i++)
{
pBuffer = pThis->AllocateBuffer(BUFFER_SIZE);
if(pBuffer == NULL)
return -1;
pThis->InsertPendingAccept(pBuffer);
pThis->PostAccept(pBuffer);
}
// 构建事件对象数组，以便在上面调用WSAWaitForMultipleEvents函数
HANDLE hWaitEvents[2 + MAX_THREAD];
int nEventCount = 0;
hWaitEvents[nEventCount ++] = pThis->m_hAcceptEvent;
hWaitEvents[nEventCount ++] = pThis->m_hRepostEvent;
// 创建指定数量的工作线程在完成端口上处理I/O
int i = 0;
for(i=0; i<MAX_THREAD; i++)
{
hWaitEvents[nEventCount ++] = ::CreateThread(NULL, 0, _WorkerThreadProc, pThis, 0, NULL);
}
// 下面进入无限循环，处理事件对象数组中的事件
while(TRUE)
{
int nIndex = ::WSAWaitForMultipleEvents(nEventCount, hWaitEvents, FALSE, 1000, FALSE);
// 首先检查是否要停止服务
if(pThis->m_bShutDown || nIndex == WSA_WAIT_FAILED)
{
// 关闭所有连接
pThis->CloseAllConnections();
::Sleep(0); // 给I/O工作线程一个执行的机会
// 关闭监听套节字
::closesocket(pThis->m_sListen);
pThis->m_sListen = INVALID_SOCKET;
::Sleep(0); // 给I/O工作线程一个执行的机会
// 通知所有I/O处理线程退出
for(int i=2; i<MAX_THREAD + 2; i++)
{
::PostQueuedCompletionStatus(pThis->m_hCompletion, -1, 0, NULL);
}
// 等待I/O处理线程退出
::WaitForMultipleObjects(MAX_THREAD, &hWaitEvents[2], TRUE, 5*1000);
for(i=2; i<MAX_THREAD + 2; i++)
{
::CloseHandle(hWaitEvents[i]);
}
::CloseHandle(pThis->m_hCompletion);
pThis->FreeBuffers();
pThis->FreeContexts();
::ExitThread(0);
}
// 1）定时检查所有未返回的AcceptEx I/O的连接建立了多长时间
if(nIndex == WSA_WAIT_TIMEOUT)
{
pBuffer = pThis->m_pPendingAccepts;
while(pBuffer != NULL)
{
int nSeconds;
int nLen = sizeof(nSeconds);
// 取得连接建立的时间
::getsockopt(pBuffer->sClient,
SOL_SOCKET, SO_CONNECT_TIME, (char *)&nSeconds, &nLen);
// 如果超过10秒钟客户还不发送初始数据，就让这个客户go away
if(nSeconds != -1 && nSeconds >= 10)
{
closesocket(pBuffer->sClient);
pBuffer->sClient = INVALID_SOCKET;
}
pBuffer = pBuffer->pNext;
}
}
else
{
nIndex = nIndex - WAIT_OBJECT_0;
WSANETWORKEVENTS ne;
int nLimit=0;
if(nIndex == 0) // 2）m_hAcceptEvent事件对象受信，说明投递的Accept请求不够，需要增加
{
::WSAEnumNetworkEvents(pThis->m_sListen, hWaitEvents[nIndex], &ne);
if(ne.lNetworkEvents & FD_ACCEPT)
{
nLimit = 50; // 增加的个数，这里设为50个
}
}
else if(nIndex == 1) // 3）m_hRepostEvent事件对象受信，说明处理I/O的线程接受到新的客户
{
nLimit = InterlockedExchange(&pThis->m_nRepostCount, 0);
}
else if(nIndex > 1) // I/O服务线程退出，说明有错误发生，关闭服务器
{
pThis->m_bShutDown = TRUE;
continue;
}
// 投递nLimit个AcceptEx I/O请求
int i = 0;
while(i++ < nLimit && pThis->m_nPendingAcceptCount < pThis->m_nMaxAccepts)
{
pBuffer = pThis->AllocateBuffer(BUFFER_SIZE);
if(pBuffer != NULL)
{
pThis->InsertPendingAccept(pBuffer);
pThis->PostAccept(pBuffer);
}
}
}
}
return 0;
}
NTSTATUS
NTAPI
CmBattGetBatteryStatus(IN PCMBATT_DEVICE_EXTENSION DeviceExtension,
IN ULONG Tag)
{
ULONG PsrData = 0;
NTSTATUS Status;
ULONG BstState;
ULONG DesignVoltage, PresentRate, RemainingCapacity;
PAGED_CODE();
if (CmBattDebug & CMBATT_GENERIC_INFO)
DbgPrint("CmBattGetBatteryStatus - CmBatt (%08x) Tag (%d)\n", DeviceExtension, Tag);
/* Validate ACPI data */
Status = CmBattVerifyStaticInfo(DeviceExtension, Tag);
if (!NT_SUCCESS(Status)) return Status;
/* Check for delayed status notifications */
if (DeviceExtension->DelayNotification)
{
/* Process them now and don't do any other work */
CmBattNotifyHandler(DeviceExtension, ACPI_BATT_NOTIFY_STATUS);
return Status;
}
/* Get _BST from ACPI */
Status = CmBattGetBstData(DeviceExtension, &DeviceExtension->BstData);
if (!NT_SUCCESS(Status))
{
/* Fail */
InterlockedExchange(&DeviceExtension->ArLockValue, 0);
return Status;
}
/* Clear current BST information */
DeviceExtension->State = 0;
DeviceExtension->RemainingCapacity = 0;
DeviceExtension->PresentVoltage = 0;
DeviceExtension->Rate = 0;
/* Get battery state */
BstState = DeviceExtension->BstData.State;
/* Is the battery both charging and discharging? */
if ((BstState & ACPI_BATT_STAT_DISCHARG) && (BstState & ACPI_BATT_STAT_CHARGING) &&
(CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_WARNING)))
DbgPrint("************************ ACPI BIOS BUG ********************\n* "
"CmBattGetBatteryStatus: Invalid state: _BST method returned 0x%08x for Battery State.\n"
"* One battery cannot be charging and discharging at the same time.\n",
BstState);
/* Is the battery discharging? */
if (BstState & ACPI_BATT_STAT_DISCHARG)
{
/* Set power state and check if it just started discharging now */
DeviceExtension->State |= BATTERY_DISCHARGING;
if (!(DeviceExtension->State & ACPI_BATT_STAT_DISCHARG))
{
/* Remember the time when the state changed */
DeviceExtension->InterruptTime = KeQueryInterruptTime();
}
}
else if (BstState & ACPI_BATT_STAT_CHARGING)
{
/* Battery is charging, update power state */
DeviceExtension->State |= (BATTERY_CHARGING | BATTERY_POWER_ON_LINE);
}
/* Is the battery in a critical state? */
if (BstState & ACPI_BATT_STAT_CRITICAL) DeviceExtension->State |= BATTERY_CRITICAL;
/* Read the voltage data */
DeviceExtension->PresentVoltage = DeviceExtension->BstData.PresentVoltage;
/* Check if we have an A/C adapter */
if (AcAdapterPdo)
{
/* Query information on it */
CmBattGetPsrData(AcAdapterPdo, &PsrData);
}
else
{
/* Otherwise, check if the battery is charging */
if (BstState & ACPI_BATT_STAT_CHARGING)
{
/* Then we'll assume there's a charger */
PsrData = 1;
}
else
{
/* Assume no charger */
PsrData = 0;
}
}
/* Is there a charger? */
if (PsrData)
{
/* Set the power state flag to reflect this */
DeviceExtension->State |= BATTERY_POWER_ON_LINE;
if (CmBattDebug & (CMBATT_GENERIC_INFO | CMBATT_GENERIC_STATUS))
DbgPrint("CmBattGetBatteryStatus: AC adapter is connected\n");
}
else if (CmBattDebug & (CMBATT_GENERIC_INFO | CMBATT_GENERIC_STATUS))
{
DbgPrint("CmBattGetBatteryStatus: AC adapter is NOT connected\n");
}
/* Get some data we'll need */
DesignVoltage = DeviceExtension->BifData.DesignVoltage;
PresentRate = DeviceExtension->BstData.PresentRate;
RemainingCapacity = DeviceExtension->BstData.RemainingCapacity;
/* Check if we have battery data in Watts instead of Amps */
if (DeviceExtension->BifData.PowerUnit == ACPI_BATT_POWER_UNIT_WATTS)
{
/* Get the data from the BST */
DeviceExtension->RemainingCapacity = RemainingCapacity;
DeviceExtension->Rate = PresentRate;
/* Check if the rate is invalid */
if (PresentRate > CM_MAX_VALUE)
{
/* Set an unknown rate and don't touch the old value */
DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
if ((PresentRate != CM_UNKNOWN_VALUE) && (CmBattDebug & CMBATT_ACPI_WARNING))
{
DbgPrint("CmBattGetBatteryStatus - Rate is greater than CM_MAX_VALUE\n");
DbgPrint("---------------------- PresentRate = 0x%08x\n", PresentRate);
}
}
}
else if ((DesignVoltage != CM_UNKNOWN_VALUE) && (DesignVoltage))
{
/* We have voltage data, what about capacity? */
if (RemainingCapacity == CM_UNKNOWN_VALUE)
{
/* Unable to calculate it */
DeviceExtension->RemainingCapacity = BATTERY_UNKNOWN_CAPACITY;
if (CmBattDebug & CMBATT_ACPI_WARNING)
{
DbgPrint("CmBattGetBatteryStatus - Can't calculate RemainingCapacity \n");
DbgPrint("---------------------- RemainingCapacity = CM_UNKNOWN_VALUE\n");
}
}
else
{
/* Compute the capacity with the information we have */
DeviceExtension->RemainingCapacity = (DesignVoltage * RemainingCapacity + 500) / 1000;
}
/* Check if we have a rate */
if (PresentRate != CM_UNKNOWN_VALUE)
{
/* Make sure the rate isn't too large */
if (PresentRate > (-500 / DesignVoltage))
{
/* It is, so set unknown state */
DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
if (CmBattDebug & CMBATT_ACPI_WARNING)
{
DbgPrint("CmBattGetBatteryStatus - Can't calculate Rate \n");
DbgPrint("---------------------- Overflow: PresentRate = 0x%08x\n", PresentRate);
}
}
/* Compute the rate */
DeviceExtension->Rate = (PresentRate * DesignVoltage + 500) / 1000;
}
else
{
/* We don't have a rate, so set unknown value */
DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
if (CmBattDebug & CMBATT_ACPI_WARNING)
{
DbgPrint("CmBattGetBatteryStatus - Can't calculate Rate \n");
DbgPrint("---------------------- Present Rate = CM_UNKNOWN_VALUE\n");
}
}
}
else
{
/* We have no rate, and no capacity, set unknown values */
DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
DeviceExtension->RemainingCapacity = BATTERY_UNKNOWN_CAPACITY;
if (CmBattDebug & CMBATT_ACPI_WARNING)
{
DbgPrint("CmBattGetBatteryStatus - Can't calculate RemainingCapacity and Rate \n");
DbgPrint("---------------------- DesignVoltage = 0x%08x\n", DesignVoltage);
}
}
/* Check if we have an unknown rate */
if (DeviceExtension->Rate == BATTERY_UNKNOWN_RATE)
{
/* The battery is discharging but we don't know by how much... this is bad! */
if ((BstState & ACPI_BATT_STAT_DISCHARG) &&
(CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_WARNING)))
DbgPrint("CmBattGetBatteryStatus: battery rate is unkown when battery is not charging!\n");
}
else if (DeviceExtension->State & BATTERY_DISCHARGING)
{
/* The battery is discharging, so treat the rate as a negative rate */
DeviceExtension->Rate = -DeviceExtension->Rate;
}
else if (!(DeviceExtension->State & BATTERY_CHARGING) && (DeviceExtension->Rate))
{
/* We are not charging, not discharging, but have a rate? Ignore it! */
if (CmBattDebug & CMBATT_GENERIC_WARNING)
DbgPrint("CmBattGetBatteryStatus: battery is not charging or discharging, but rate = %x\n",
DeviceExtension->Rate);
DeviceExtension->Rate = 0;
}
/* Done */
return STATUS_SUCCESS;
}
ALCboolean xaudio2_do_reset_playback(ALCdevice * device)
{
XAudio2Data* data = (XAudio2Data*)device->ExtraData;
HRESULT hr;
DWORD outputchannelMasks;
XAUDIO2_VOICE_DETAILS outputDetails;
WAVEFORMATEXTENSIBLE SourceType;
data->masterVoice->GetChannelMask(&outputchannelMasks);
data->masterVoice->GetVoiceDetails(&outputDetails);
if (!(device->Flags&DEVICE_FREQUENCY_REQUEST))
device->Frequency = outputDetails.InputSampleRate;
if (!(device->Flags&DEVICE_CHANNELS_REQUEST))
{
if (outputDetails.InputChannels == 1 && outputchannelMasks == MONO)
device->FmtChans = DevFmtMono;
else if (outputDetails.InputChannels == 2 && outputchannelMasks == STEREO)
device->FmtChans = DevFmtStereo;
else if (outputDetails.InputChannels == 4 && outputchannelMasks == QUAD)
device->FmtChans = DevFmtQuad;
else if (outputDetails.InputChannels == 6 && outputchannelMasks == X5DOT1)
device->FmtChans = DevFmtX51;
else if (outputDetails.InputChannels == 6 && outputchannelMasks == X5DOT1SIDE)
device->FmtChans = DevFmtX51Side;
else if (outputDetails.InputChannels == 7 && outputchannelMasks == X6DOT1)
device->FmtChans = DevFmtX61;
else if (outputDetails.InputChannels == 8 && outputchannelMasks == X7DOT1)
device->FmtChans = DevFmtX71;
else
ERR("Unhandled channel config: %d -- 0x%08lx\n", outputDetails.InputChannels, outputchannelMasks);
}
SetDefaultWFXChannelOrder(device);
switch (device->FmtChans)
{
case DevFmtMono:
SourceType.Format.nChannels = 1;
SourceType.dwChannelMask = MONO;
break;
case DevFmtStereo:
SourceType.Format.nChannels = 2;
SourceType.dwChannelMask = STEREO;
break;
case DevFmtQuad:
SourceType.Format.nChannels = 4;
SourceType.dwChannelMask = QUAD;
break;
case DevFmtX51:
SourceType.Format.nChannels = 6;
SourceType.dwChannelMask = X5DOT1;
break;
case DevFmtX51Side:
SourceType.Format.nChannels = 6;
SourceType.dwChannelMask = X5DOT1SIDE;
break;
case DevFmtX61:
SourceType.Format.nChannels = 7;
SourceType.dwChannelMask = X6DOT1;
break;
case DevFmtX71:
SourceType.Format.nChannels = 8;
SourceType.dwChannelMask = X7DOT1;
break;
}
switch (device->FmtType)
{
case DevFmtByte:
device->FmtType = DevFmtUByte;
/* fall-through */
case DevFmtUByte:
SourceType.Format.wBitsPerSample = 8;
SourceType.Samples.wValidBitsPerSample = 8;
SourceType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
break;
case DevFmtUShort:
device->FmtType = DevFmtShort;
/* fall-through */
case DevFmtShort:
SourceType.Format.wBitsPerSample = 16;
SourceType.Samples.wValidBitsPerSample = 16;
SourceType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
break;
case DevFmtFloat:
SourceType.Format.wBitsPerSample = 32;
SourceType.Samples.wValidBitsPerSample = 32;
SourceType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
break;
}
SourceType.Format.cbSize = (sizeof(SourceType) - sizeof(WAVEFORMATEX));
SourceType.Format.nSamplesPerSec = device->Frequency;
SourceType.Format.nBlockAlign = SourceType.Format.nChannels *
SourceType.Format.wBitsPerSample / 8;
SourceType.Format.nAvgBytesPerSec = SourceType.Format.nSamplesPerSec *
SourceType.Format.nBlockAlign;
SourceType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
/*-----------create source voice-------------*/
data->sourceVoiceCallback = new (std::nothrow) XAudio2SourceVoiceCallback(device);
if (data->sourceVoiceCallback == NULL)
{
ERR("create XAudio2SourceVoiceCallback() failed\n");
return ALC_FALSE;
}
data->sourceVoiceCallback->callbackEvent = CreateEventEx(NULL, NULL, 0, EVENT_ACCESS_MASK);
if (data->sourceVoiceCallback->callbackEvent == NULL)
{
ERR("create callback event failed\n");
return ALC_FALSE;
}
hr = data->xAudioObj->CreateSourceVoice(&data->sourceVoice, &SourceType.Format, 0,
XAUDIO2_DEFAULT_FREQ_RATIO, data->sourceVoiceCallback);
if (FAILED(hr))
{
ERR("CreateSourceVoice() failed: 0x%08lx\n", hr);
return ALC_FALSE;
}
/*---------create buffer--------------*/
//calculate frame size
data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
//start playing the audio engine
data->sourceVoice->Start();
//wait for the buffer to be created
WaitForSingleObjectEx(data->sourceVoiceCallback->callbackEvent, INFINITE, FALSE);
device->UpdateSize = data->bufferSize / data->frameSize;
device->NumUpdates = 1;
//set the running flag
InterlockedExchange(&data->running, TRUE);
return ALC_TRUE;
}
VOID
NTAPI
CmBattWakeDpc(IN PKDPC Dpc,
IN PCMBATT_DEVICE_EXTENSION FdoExtension,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2)
{
PDEVICE_OBJECT CurrentObject;
BOOLEAN AcNotify = FALSE;
PCMBATT_DEVICE_EXTENSION DeviceExtension;
ULONG ArFlag;
if (CmBattDebug & 2) DbgPrint("CmBattWakeDpc: Entered.\n");
/* Loop all device objects */
for (CurrentObject = FdoExtension->DeviceObject;
CurrentObject;
CurrentObject = CurrentObject->NextDevice)
{
/* Turn delay flag off, we're back in S0 */
DeviceExtension = CurrentObject->DeviceExtension;
DeviceExtension->DelayNotification = 0;
/* Check if this is an AC adapter */
if (DeviceExtension->FdoType == CmBattAcAdapter)
{
/* Was there a pending notify? */
if (DeviceExtension->ArFlag & CMBATT_AR_NOTIFY)
{
/* We'll send a notify on the next pass */
AcNotify = TRUE;
DeviceExtension->ArFlag = 0;
if (CmBattDebug & 0x20)
DbgPrint("CmBattWakeDpc: AC adapter notified\n");
}
}
}
/* Loop the device objects again */
for (CurrentObject = FdoExtension->DeviceObject;
CurrentObject;
CurrentObject = CurrentObject->NextDevice)
{
/* Check if this is a battery */
DeviceExtension = CurrentObject->DeviceExtension;
if (DeviceExtension->FdoType == CmBattBattery)
{
/* Check what ARs are pending */
ArFlag = DeviceExtension->ArFlag;
if (CmBattDebug & 0x20)
DbgPrint("CmBattWakeDpc: Performing delayed ARs: %01x\n", ArFlag);
/* Insert notification, clear the lock value */
if (ArFlag & CMBATT_AR_INSERT) InterlockedExchange(&DeviceExtension->ArLockValue, 0);
/* Removal, clear the battery tag */
if (ArFlag & CMBATT_AR_REMOVE) DeviceExtension->Tag = 0;
/* Notification (or AC/DC adapter change from first pass above) */
if ((ArFlag & CMBATT_AR_NOTIFY) || (AcNotify))
{
/* Notify the class driver */
BatteryClassStatusNotify(DeviceExtension->ClassData);
}
}
}
}
VOID
NTAPI
CmBattNotifyHandler(IN PCMBATT_DEVICE_EXTENSION DeviceExtension,
IN ULONG NotifyValue)
{
ULONG ArFlag;
PCMBATT_DEVICE_EXTENSION FdoExtension;
PDEVICE_OBJECT DeviceObject;
if (CmBattDebug & (CMBATT_ACPI_ASSERT | CMBATT_PNP_INFO))
DbgPrint("CmBattNotifyHandler: CmBatt 0x%08x Type %d Number %d Notify Value: %x\n",
DeviceExtension,
DeviceExtension->FdoType,
DeviceExtension->DeviceId,
NotifyValue);
/* Check what kind of notification was received */
switch (NotifyValue)
{
/* ACPI Specification says is sends a "Bus Check" when power source changes */
case ACPI_BUS_CHECK:
/* We treat it as possible physical change */
DeviceExtension->ArFlag |= (CMBATT_AR_NOTIFY | CMBATT_AR_INSERT);
if ((DeviceExtension->Tag) &&
(CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_WARNING)))
DbgPrint("CmBattNotifyHandler: Received battery #%x insertion, but tag was not invalid.\n",
DeviceExtension->DeviceId);
break;
/* Status of the battery has changed */
case ACPI_BATT_NOTIFY_STATUS:
/* All we'll do is notify the class driver */
DeviceExtension->ArFlag |= CMBATT_AR_NOTIFY;
break;
/* Information on the battery has changed, such as physical presence */
case ACPI_DEVICE_CHECK:
case ACPI_BATT_NOTIFY_INFO:
/* Reset all state and let the class driver re-evaluate it all */
DeviceExtension->ArFlag |= (CMBATT_AR_NOTIFY |
CMBATT_AR_INSERT |
CMBATT_AR_REMOVE);
break;
default:
if (CmBattDebug & CMBATT_PNP_INFO)
DbgPrint("CmBattNotifyHandler: Unknown Notify Value: %x\n", NotifyValue);
}
/* Check if we're supposed to delay the notification till later */
if (DeviceExtension->DelayNotification)
{
/* We'll handle this when we get a status query later on */
if (CmBattDebug & CMBATT_PNP_INFO)
DbgPrint("CmBattNotifyHandler: Notification delayed: ARs = %01x\n",
DeviceExtension->ArFlag);
return;
}
/* We're going to handle this now */
if (CmBattDebug & CMBATT_PNP_INFO)
DbgPrint("CmBattNotifyHandler: Performing ARs: %01x\n", DeviceExtension->ArFlag);
/* Check if this is a battery or AC adapter notification */
if (DeviceExtension->FdoType == CmBattBattery)
{
/* Reset the current trip point */
DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
/* Check what ARs have to be done */
ArFlag = DeviceExtension->ArFlag;
/* New battery inserted, reset lock value */
if (ArFlag & CMBATT_AR_INSERT) InterlockedExchange(&DeviceExtension->ArLockValue, 0);
/* Check if the battery may have been removed */
if (ArFlag & CMBATT_AR_REMOVE) DeviceExtension->Tag = 0;
/* Check if there's been any sort of change to the battery */
if (ArFlag & CMBATT_AR_NOTIFY)
{
/* We'll probably end up re-evaluating _BIF and _BST */
DeviceExtension->NotifySent = TRUE;
BatteryClassStatusNotify(DeviceExtension->ClassData);
}
}
else if (DeviceExtension->ArFlag & CMBATT_AR_NOTIFY)
{
/* The only known notification is AC/DC change. Loop device objects. */
for (DeviceObject = DeviceExtension->FdoDeviceObject->DriverObject->DeviceObject;
DeviceObject;
DeviceObject = DeviceObject->NextDevice)
{
/* Is this a battery? */
FdoExtension = DeviceObject->DeviceExtension;
if (FdoExtension->FdoType == CmBattBattery)
{
/* Send a notification to the class driver */
FdoExtension->NotifySent = TRUE;
BatteryClassStatusNotify(FdoExtension->ClassData);
}
}
}
/* ARs have been processed */
DeviceExtension->ArFlag = 0;
}
/*++
ConnectionOpen
Opens a server connection.
Arguments:
context - Opaque context passed to <PoolCreate>.
data - Pointer to a pointer that receives the DB_CONTEXT structure.
Return Values:
If the function succeeds, the return value is nonzero (true).
If the function fails, the return value is zero (false).
--*/
static BOOL FCALL ConnectionOpen(VOID *context, VOID **data)
{
DB_CONTEXT *db;
DB_CONFIG_SERVER *server;
DWORD error;
DWORD i;
INT attempt;
INT attemptMax;
LONG serverIndex;
LONG serverNextIndex;
MYSQL *connection;
my_bool optReconnect;
UINT optTimeout;
UNREFERENCED_PARAMETER(context);
ASSERT(data != NULL);
TRACE("context=%p data=%p", context, data);
db = MemAllocate(sizeof(DB_CONTEXT));
if (db == NULL) {
LOG_ERROR("Unable to allocate memory for database context.");
error = ERROR_NOT_ENOUGH_MEMORY;
goto failed;
}
ZeroMemory(db, sizeof(DB_CONTEXT));
//
// Have the MySQL client library allocate the handle structure for us. This is
// in case the MYSQL structure changes in a future version of the client library.
//
db->handle = mysql_init(NULL);
if (db->handle == NULL) {
LOG_ERROR("Unable to allocate memory for MySQL handle.");
error = ERROR_NOT_ENOUGH_MEMORY;
goto failed;
}
// If the maximum number of attempts were not specified, try all servers
if (dbConfigGlobal.connAttempts > 0) {
attemptMax = dbConfigGlobal.connAttempts;
} else {
attemptMax = dbConfigServerCount;
}
for (attempt = 0; attempt < attemptMax; attempt++) {
// Use the most recent server for the connection attempt
serverIndex = dbIndex;
server = &dbConfigServers[serverIndex];
TRACE("Connecting to server #%d [%s] on attempt %lu/%lu.",
serverIndex, server->name, attempt+1, attemptMax);
// Set connection options
optTimeout = (UINT)dbConfigGlobal.connTimeout;
if (mysql_options(db->handle, MYSQL_OPT_CONNECT_TIMEOUT, &optTimeout) != 0) {
TRACE("Failed to set connection timeout option.");
}
optReconnect = FALSE;
if (mysql_options(db->handle, MYSQL_OPT_RECONNECT, &optReconnect) != 0) {
TRACE("Failed to set reconnection option.");
}
if (server->compression) {
if (mysql_options(db->handle, MYSQL_OPT_COMPRESS, 0) != 0) {
TRACE("Failed to set compression option.");
}
}
if (server->sslEnable) {
//
// This function always returns 0. If the SSL setup is incorrect,
// the call to mysql_real_connect() will return an error.
//
mysql_ssl_set(db->handle, server->sslKeyFile, server->sslCertFile,
server->sslCAFile, server->sslCAPath, server->sslCiphers);
}
// Attempt connection with server
connection = mysql_real_connect(db->handle,
server->host, server->user, server->password,
server->database, server->port, NULL, CLIENT_INTERACTIVE);
if (connection == NULL) {
LOG_ERROR("Unable to connect to server [%s]: %s",
server->name, mysql_error(db->handle));
} else if (mysql_get_server_version(db->handle) < 50019) {
LOG_ERROR("Unsupported version of MySQL Server [%s]: running v%s, must be v5.0.19 or newer.",
server->name, mysql_get_server_info(db->handle));
} else {
// Pointer values should be the same as from mysql_init()
ASSERT(connection == db->handle);
// Allocate pre-compiled statement structures
for (i = 0; i < ELEMENT_COUNT(db->stmt); i++) {
db->stmt[i] = mysql_stmt_init(db->handle);
if (db->stmt[i] == NULL) {
LOG_ERROR("Unable to allocate memory for statement structure.");
error = ERROR_NOT_ENOUGH_MEMORY;
goto failed;
}
}
// Successfully connected, set the global server index
InterlockedExchange(&dbIndex, serverIndex);
// Update context's server index and time stamps
db->index = serverIndex;
GetSystemTimeAsFileTime(&db->created.fileTime);
db->used.value = db->created.value;
LOG_INFO("Connected to %s [%s], running MySQL Server v%s.",
mysql_get_host_info(db->handle), server->name,
mysql_get_server_info(db->handle));
*data = db;
return TRUE;
}
// Unsuccessful connection, continue to the next server
serverNextIndex = serverIndex + 1;
if (serverNextIndex >= (LONG)dbConfigServerCount) {
serverNextIndex = 0;
}
//
// Compare the current server index before swapping values in the
// event that another thread has already changed the index.
//
InterlockedCompareExchange(&dbIndex, serverNextIndex, serverIndex);
}
// Unable to connect to any servers
error = ERROR_CONNECTION_REFUSED;
failed:
if (db != NULL) {
ConnectionClose(NULL, db);
}
SetLastError(error);
return FALSE;
}
int GitRev::SafeFetchFullInfo(CGit *git)
{
if(InterlockedExchange(&m_IsUpdateing,TRUE) == FALSE)
{
this->m_Files.Clear();
git->CheckAndInitDll();
GIT_COMMIT commit;
GIT_COMMIT_LIST list;
GIT_HASH parent;
memset(&commit,0,sizeof(GIT_COMMIT));
CAutoLocker lock(g_Git.m_critGitDllSec);
try
{
if (git_get_commit_from_hash(&commit, this->m_CommitHash.m_hash))
return -1;
}
catch (char *)
{
return -1;
}
int i=0;
git_get_commit_first_parent(&commit,&list);
bool isRoot = (list==NULL);
while(git_get_commit_next_parent(&list,parent) == 0 || isRoot)
{
GIT_FILE file=0;
int count=0;
try
{
if (isRoot)
git_root_diff(git->GetGitDiff(), this->m_CommitHash.m_hash, &file, &count, 1);
else
git_diff(git->GetGitDiff(), parent, commit.m_hash, &file, &count, 1);
}
catch (char *)
{
git_free_commit(&commit);
return -1;
}
isRoot = false;
CTGitPath path;
CString strnewname;
CString stroldname;
for (int j = 0; j < count; ++j)
{
path.Reset();
char *newname;
char *oldname;
strnewname.Empty();
stroldname.Empty();
int mode,IsBin,inc,dec;
git_get_diff_file(git->GetGitDiff(),file,j,&newname,&oldname,
&mode,&IsBin,&inc,&dec);
git->StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
git->StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
path.SetFromGit(strnewname,&stroldname);
path.ParserAction((BYTE)mode);
path.m_ParentNo = i;
this->m_Action|=path.m_Action;
if(IsBin)
{
path.m_StatAdd=_T("-");
path.m_StatDel=_T("-");
}
else
{
path.m_StatAdd.Format(_T("%d"),inc);
path.m_StatDel.Format(_T("%d"),dec);
}
m_Files.AddPath(path);
}
git_diff_flush(git->GetGitDiff());
++i;
}
InterlockedExchange(&m_IsUpdateing,FALSE);
InterlockedExchange(&m_IsFull,TRUE);
git_free_commit(&commit);
}
return 0;
}
// In newer compilers, the inline versions of these are used (in juce_Atomic.h), but in
// older ones we have to actually call the ops as win32 functions..
long juce_InterlockedExchange (volatile long* a, long b) noexcept { return InterlockedExchange (a, b); }
NTSTATUS FWDispatch(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION irpStack;
PDEVICE_EXTENSION deviceExtension;
PVOID ioBuf;
ULONG inBufLength, outBufLength;
ULONG ioControlCode;
ULONG_PTR num=0;
irpStack = IoGetCurrentIrpStackLocation(Irp);
deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
Irp->IoStatus.Information = 0;
//
// Get the pointer to the input/output buffer and it's length
//
ioBuf = Irp->AssociatedIrp.SystemBuffer;
inBufLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;
outBufLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
// Irp->UserBuffer; // If METHOD_NEITHER, This is Output Buffer
switch (ioControlCode)
{
case IOCTL_SETUPFW:
{
//
if (g_AlreadyHookTCPIP)
{
InterlockedExchange(&g_InterceptTCPIPRcv, 1);
}
else
{
Status= FWHookTcpipRecvHandler();
if (NT_SUCCESS(Status))
{
InterlockedExchange(&g_InterceptTCPIPRcv, 1);
g_AlreadyHookTCPIP = 1;
}
}
break;
}
case IOCTL_UNSETFW:
{
//
InterlockedExchange(&g_InterceptTCPIPRcv, 0);
//UNHOOK的行为就放到驱动卸载时候了
break;
}
case IOCTL_PENDDINGCHECKPORT:
{
//pendding进去
IoMarkIrpPending(Irp);
ExInterlockedInsertHeadList(&g_AskUserConnectListHeader, &Irp->Tail.Overlay.ListEntry, &g_AskUserConnectListLock);
Status= STATUS_PENDING;
Irp->IoStatus.Status = Status;
return Status;
break;
}
case IOCTL_SETONEPORTSTATUS:
{
Status = SetupPortStatus(ioBuf, 1);
break;
}
case IOCTL_RESPONSEPORTASK:
{
Status = ResponsePortAsk((PFIREWALL_ASKUSER)ioBuf);
break;
}
case IOCTL_ReleasePENDDINGCHECKPORT:
{
Status = ReleasePenddingCheckPortIrp();
break;
}
case IOCTL_GETPORTSTATUS:
{
Status = GetPortRules(ioBuf, &outBufLength);
if (Status==STATUS_INFO_LENGTH_MISMATCH)
{
Status = STATUS_SUCCESS;
}
Irp->IoStatus.Information = outBufLength;
break;
}
default:
{
//Status = STATUS_INVALID_PARAMETER;
kprintf("[SuperCI] Unknown IOCTL: 0x%X (%04X,%04X)\n",
ioControlCode, DEVICE_TYPE_FROM_CTL_CODE(ioControlCode),
IoGetFunctionCodeFromCtlCode(ioControlCode));
break;
}
}
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
HRESULT __stdcall EnlistmentNotifyShim::PrepareRequest(
BOOL fRetaining,
DWORD grfRM,
BOOL fWantMoniker,
BOOL fSinglePhase
)
{
HRESULT hr = S_OK;
IPrepareInfo* pPrepareInfo = NULL;
BYTE* prepareInfoBuffer = NULL;
ULONG prepareInfoLength = 0;
ITransactionEnlistmentAsync* pEnlistmentAsync = NULL;
#if defined(_X86_)
pEnlistmentAsync = (ITransactionEnlistmentAsync*)InterlockedExchange((LONG volatile*)&this->pEnlistmentAsync, NULL);
#elif defined(_WIN64)
pEnlistmentAsync = (ITransactionEnlistmentAsync*)InterlockedExchange64((LONGLONG volatile*)&this->pEnlistmentAsync, NULL);
#endif
if( pEnlistmentAsync == NULL )
{
return E_UNEXPECTED;
}
hr = pEnlistmentAsync->QueryInterface(
IID_IPrepareInfo,
(void**) &pPrepareInfo
);
if ( FAILED( hr ) )
{
goto ErrorExit;
}
hr = pPrepareInfo->GetPrepareInfoSize( &prepareInfoLength );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
// This buffer will be freed by Managed code through the CoTaskMemHandle object that is
// created when the pointer to this buffer is returned from GetNotification.
prepareInfoBuffer = (BYTE*) CoTaskMemAlloc( prepareInfoLength );
hr = pPrepareInfo->GetPrepareInfo( prepareInfoBuffer );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
this->prepareInfoSize = prepareInfoLength;
this->pPrepareInfo = prepareInfoBuffer;
this->isSinglePhase = fSinglePhase;
this->notificationType = PrepareRequestNotify;
this->shimFactory->NewNotification( this );
ErrorExit:
SafeReleaseInterface( (IUnknown**) &pPrepareInfo );
// We can now release our pEnlistmentAsync reference. We don't need it any longer
// and it causes problems if the app responds to SPC with InDoubt.
SafeReleaseInterface( (IUnknown**) &pEnlistmentAsync );
// We only delete the prepareinInfoBuffer if we had an error.
if ( FAILED( hr ) )
{
if ( NULL != prepareInfoBuffer )
{
CoTaskMemFree( prepareInfoBuffer );
}
}
return hr;
}
static inline Type exchange(volatile Type& storage, Type value) {
return static_cast<Type>(InterlockedExchange((long*)&storage, (long)value));
}
void CCastleSiegeSync::ResetTributeMoney()
{
InterlockedExchange((LPLONG)&this->m_lCastleTributeMoney, 0);
}
/*
* NOTE: this function should be called by the pcap functions that can theoretically
* deal with the Tc library for the first time, namely listing the adapters and
* opening one. All the other ones (close, read, write, set parameters) work
* on an open instance of TC, so we do not care to call this function
*/
TC_API_LOAD_STATUS LoadTcFunctions()
{
TC_API_LOAD_STATUS currentStatus;
do
{
currentStatus = InterlockedCompareExchange((LONG*)&g_TcFunctions.LoadStatus, TC_API_LOADING, TC_API_UNLOADED);
while(currentStatus == TC_API_LOADING)
{
currentStatus = InterlockedCompareExchange((LONG*)&g_TcFunctions.LoadStatus, TC_API_LOADING, TC_API_LOADING);
Sleep(10);
}
/*
* at this point we are either in the LOADED state, unloaded state (i.e. we are the ones loading everything)
* or in cannot load
*/
if(currentStatus == TC_API_LOADED)
{
return TC_API_LOADED;
}
if (currentStatus == TC_API_CANNOT_LOAD)
{
return TC_API_CANNOT_LOAD;
}
currentStatus = TC_API_CANNOT_LOAD;
g_TcFunctions.hTcApiDllHandle = LoadLibrarySafe("TcApi.dll");
if (g_TcFunctions.hTcApiDllHandle == NULL) break;
g_TcFunctions.QueryPortList = (TcFcnQueryPortList) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcQueryPortList");
g_TcFunctions.FreePortList = (TcFcnFreePortList) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcFreePortList");
g_TcFunctions.StatusGetString = (TcFcnStatusGetString) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcStatusGetString");
g_TcFunctions.PortGetName = (TcFcnPortGetName) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcPortGetName");
g_TcFunctions.PortGetDescription = (TcFcnPortGetDescription) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcPortGetDescription");
g_TcFunctions.InstanceOpenByName = (TcFcnInstanceOpenByName) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceOpenByName");
g_TcFunctions.InstanceClose = (TcFcnInstanceClose) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceClose");
g_TcFunctions.InstanceSetFeature = (TcFcnInstanceSetFeature) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceSetFeature");
g_TcFunctions.InstanceQueryFeature = (TcFcnInstanceQueryFeature) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceQueryFeature");
g_TcFunctions.InstanceReceivePackets = (TcFcnInstanceReceivePackets) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceReceivePackets");
g_TcFunctions.InstanceGetReceiveWaitHandle = (TcFcnInstanceGetReceiveWaitHandle)GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceGetReceiveWaitHandle");
g_TcFunctions.InstanceTransmitPackets = (TcFcnInstanceTransmitPackets)GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceTransmitPackets");
g_TcFunctions.InstanceQueryStatistics = (TcFcnInstanceQueryStatistics)GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcInstanceQueryStatistics");
g_TcFunctions.PacketsBufferCreate = (TcFcnPacketsBufferCreate) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcPacketsBufferCreate");
g_TcFunctions.PacketsBufferDestroy = (TcFcnPacketsBufferDestroy) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcPacketsBufferDestroy");
g_TcFunctions.PacketsBufferQueryNextPacket = (TcFcnPacketsBufferQueryNextPacket)GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcPacketsBufferQueryNextPacket");
g_TcFunctions.PacketsBufferCommitNextPacket = (TcFcnPacketsBufferCommitNextPacket)GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcPacketsBufferCommitNextPacket");
g_TcFunctions.StatisticsDestroy = (TcFcnStatisticsDestroy) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcStatisticsDestroy");
g_TcFunctions.StatisticsUpdate = (TcFcnStatisticsUpdate) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcStatisticsUpdate");
g_TcFunctions.StatisticsQueryValue = (TcFcnStatisticsQueryValue) GetProcAddress(g_TcFunctions.hTcApiDllHandle, "TcStatisticsQueryValue");
if ( g_TcFunctions.QueryPortList == NULL
|| g_TcFunctions.FreePortList == NULL
|| g_TcFunctions.StatusGetString == NULL
|| g_TcFunctions.PortGetName == NULL
|| g_TcFunctions.PortGetDescription == NULL
|| g_TcFunctions.InstanceOpenByName == NULL
|| g_TcFunctions.InstanceClose == NULL
|| g_TcFunctions.InstanceSetFeature == NULL
|| g_TcFunctions.InstanceQueryFeature == NULL
|| g_TcFunctions.InstanceReceivePackets == NULL
|| g_TcFunctions.InstanceGetReceiveWaitHandle == NULL
|| g_TcFunctions.InstanceTransmitPackets == NULL
|| g_TcFunctions.InstanceQueryStatistics == NULL
|| g_TcFunctions.PacketsBufferCreate == NULL
|| g_TcFunctions.PacketsBufferDestroy == NULL
|| g_TcFunctions.PacketsBufferQueryNextPacket == NULL
|| g_TcFunctions.PacketsBufferCommitNextPacket == NULL
|| g_TcFunctions.StatisticsDestroy == NULL
|| g_TcFunctions.StatisticsUpdate == NULL
|| g_TcFunctions.StatisticsQueryValue == NULL
)
{
break;
}
/*
* everything got loaded, yay!!
*/
currentStatus = TC_API_LOADED;
}while(FALSE);
if (currentStatus != TC_API_LOADED)
{
if (g_TcFunctions.hTcApiDllHandle != NULL)
{
FreeLibrary(g_TcFunctions.hTcApiDllHandle);
g_TcFunctions.hTcApiDllHandle = NULL;
}
}
InterlockedExchange((LONG*)&g_TcFunctions.LoadStatus, currentStatus);
return currentStatus;
}
DWORD
WINAPI
MixerThreadRoutine(
LPVOID lpParameter)
{
KSPROPERTY Request;
KSAUDIO_POSITION Position;
DWORD Result, MixPosition, BufferPosition, BytesWritten, BytesRead, MixLength, BufferLength;
LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)lpParameter;
/* setup audio position property request */
Request.Id = KSPROPERTY_AUDIO_POSITION;
Request.Set = KSPROPSETID_Audio;
Request.Flags = KSPROPERTY_TYPE_GET;
MixPosition = 0;
BufferPosition = 0;
do
{
/* query current position */
Result = SyncOverlappedDeviceIoControl(This->hPin, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSPROPERTY), (PVOID)&Position, sizeof(KSAUDIO_POSITION), NULL);
/* sanity check */
ASSERT(Result == ERROR_SUCCESS);
/* FIXME implement samplerate conversion */
ASSERT(This->MixFormat.nSamplesPerSec == This->Format->nSamplesPerSec);
/* FIXME implement bitrate conversion */
ASSERT(This->MixFormat.wBitsPerSample == This->Format->wBitsPerSample);
/* sanity check */
ASSERT(BufferPosition <= This->BufferSize);
ASSERT(MixPosition <= This->MixBufferSize);
if (BufferPosition == This->BufferSize)
{
/* restart from front */
BufferPosition = 0;
}
if (MixPosition == This->MixBufferSize)
{
/* restart from front */
MixPosition = 0;
}
if (This->MixFormat.nChannels != This->Format->nChannels)
{
if ((DWORD)Position.PlayOffset >= MixPosition)
{
/* calculate buffer position difference */
MixLength = Position.PlayOffset - MixPosition;
}
else
{
/* buffer overlap */
MixLength = This->MixBufferSize - MixPosition;
}
BufferLength = This->BufferSize - BufferPosition;
/* convert the format */
PerformChannelConversion(&This->MixBuffer[MixPosition], MixLength, &BytesRead, This->MixFormat.nChannels, This->Format->nChannels, This->Format->wBitsPerSample, &This->Buffer[BufferPosition], BufferLength, &BytesWritten);
/* update buffer offsets */
MixPosition += BytesRead;
BufferPosition += BytesWritten;
DPRINT("MixPosition %u BufferPosition %u BytesRead %u BytesWritten %u MixLength %u BufferLength %u\n", MixPosition, BufferPosition, BytesRead, BytesWritten, MixLength, BufferLength);
}
/* Notify Events */
if (This->Notify)
{
DoNotifyPositionEvents(This->Notify, This->CurrentMixPosition, BufferPosition);
}
/* update offset */
InterlockedExchange(&This->CurrentMixPosition, (LONG)BufferPosition);
/* FIXME use timer */
Sleep(10);
}while(InterlockedCompareExchange(&This->StopMixerThread, 0, 0) == 0);
/* signal stop event */
SetEvent(This->hStopEvent);
/* done */
return 0;
}
int _spin_lite_trylock(spin_t *l)
{
CHECK_SPINLOCK_LITE(l);
return InterlockedExchange(&l->l, EBUSY);
}
/*
* This may be called from DllMain, and hence operates under unusual
* constraints.
*/
static GC_thread GC_new_thread(void) {
int i;
/* It appears to be unsafe to acquire a lock here, since this */
/* code is apparently not preeemptible on some systems. */
/* (This is based on complaints, not on Microsoft's official */
/* documentation, which says this should perform "only simple */
/* initialization tasks".) */
/* Hence we make do with nonblocking synchronization. */
/* The following should be a noop according to the win32 */
/* documentation. There is empirical evidence that it */
/* isn't. - HB */
# if defined(MPROTECT_VDB)
if (GC_incremental) SetUnhandledExceptionFilter(GC_write_fault_handler);
# endif
/* cast away volatile qualifier */
for (i = 0; InterlockedExchange((IE_t)&thread_table[i].in_use,1) != 0; i++) {
/* Compare-and-swap would make this cleaner, but that's not */
/* supported before Windows 98 and NT 4.0. In Windows 2000, */
/* InterlockedExchange is supposed to be replaced by */
/* InterlockedExchangePointer, but that's not really what I */
/* want here. */
if (i == MAX_THREADS - 1)
ABORT("too many threads");
}
/* Update GC_max_thread_index if necessary. The following is safe, */
/* and unlike CompareExchange-based solutions seems to work on all */
/* Windows95 and later platforms. */
/* Unfortunately, GC_max_thread_index may be temporarily out of */
/* bounds, so readers have to compensate. */
while (i > GC_max_thread_index) {
InterlockedIncrement((IE_t)&GC_max_thread_index);
}
if (GC_max_thread_index >= MAX_THREADS) {
/* We overshot due to simultaneous increments. */
/* Setting it to MAX_THREADS-1 is always safe. */
GC_max_thread_index = MAX_THREADS - 1;
}
# ifdef CYGWIN32
thread_table[i].pthread_id = pthread_self();
# endif
if (!DuplicateHandle(GetCurrentProcess(),
GetCurrentThread(),
GetCurrentProcess(),
(HANDLE*)&thread_table[i].handle,
0,
0,
DUPLICATE_SAME_ACCESS)) {
DWORD last_error = GetLastError();
GC_printf1("Last error code: %lx\n", last_error);
ABORT("DuplicateHandle failed");
}
thread_table[i].stack_base = GC_get_stack_base();
/* Up until this point, GC_push_all_stacks considers this thread */
/* invalid. */
if (thread_table[i].stack_base == NULL)
ABORT("Failed to find stack base in GC_new_thread");
/* Up until this point, this entry is viewed as reserved but invalid */
/* by GC_delete_thread. */
thread_table[i].id = GetCurrentThreadId();
/* If this thread is being created while we are trying to stop */
/* the world, wait here. Hopefully this can't happen on any */
/* systems that don't allow us to block here. */
while (GC_please_stop) Sleep(20);
return thread_table + i;
}
VOID
DCamCancelOnePacket(
IN PHW_STREAM_REQUEST_BLOCK pSrbToCancel
)
/*++
Routine Description:
This routine is called to cancel a pending streaming SRB. This is likely to
happen when transitioning from PAUSE to STOP state.
Note: This routine is called at DISPATCH_LEVEL !! so we queue a work item
to cancel pending requests at the passive level.
Arguments:
pSrbToCancel - Pointer to SRB to cancel
Return Value:
None.
--*/
{
PDCAM_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
PIO_WORKITEM pIOWorkItem;
pDevExt = (PDCAM_EXTENSION) pSrbToCancel->HwDeviceExtension;
ASSERT(pDevExt);
pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
ASSERT(pStrmEx);
// Nothing to cancel
if(pStrmEx == NULL) {
return;
}
//
// Can cancel stream SRB as a result of aborting a stream.
//
if ( (pSrbToCancel->Flags & SRB_HW_FLAGS_STREAM_REQUEST) != SRB_HW_FLAGS_STREAM_REQUEST) {
ERROR_LOG(("DCamCancelOnePacket: Cannot cancel Device SRB %p\n", pSrbToCancel));
ASSERT( (pSrbToCancel->Flags & SRB_HW_FLAGS_STREAM_REQUEST) == SRB_HW_FLAGS_STREAM_REQUEST );
return;
}
//
// Abort only once so we must obtain the token first.
//
if( InterlockedExchange((PLONG)&pStrmEx->CancelToken, 1 ) == 1 ) {
// Already in cancelling state!
ERROR_LOG( ( "Already cancelling...\n" ) );
return;
}
//
// Start a work item to cancel all pending request
//
pIOWorkItem = IoAllocateWorkItem( pDevExt ->PhysicalDeviceObject );
if( !pIOWorkItem ) {
// Could not do it, release the token.
InterlockedExchange((PLONG)&pStrmEx->CancelToken, 0 );
return;
}
else {
IoQueueWorkItem( pIOWorkItem, AbortWorkItem, DelayedWorkQueue, pDevExt );
}
}
PRECORD_LIST
SpyNewRecord (
VOID
)
/*++
Routine Description:
Allocates a new RECORD_LIST structure if there is enough memory to do so. A
sequence number is updated for each request for a new record.
NOTE: This code must be NON-PAGED because it can be called on the
paging path or at DPC level.
Arguments:
None
Return Value:
Pointer to the RECORD_LIST allocated, or NULL if no memory is available.
--*/
{
PRECORD_LIST newRecord;
ULONG initialRecordType;
//
// Allocate the buffer
//
newRecord = SpyAllocateBuffer( &initialRecordType );
if (newRecord == NULL) {
//
// We could not allocate a record, see if the static buffer is
// in use. If not, we will use it
//
if (!InterlockedExchange( &MiniSpyData.StaticBufferInUse, TRUE )) {
newRecord = (PRECORD_LIST)MiniSpyData.OutOfMemoryBuffer;
initialRecordType |= RECORD_TYPE_FLAG_STATIC;
}
}
//
// If we got a record (doesn't matter if it is static or not), init it
//
if (newRecord != NULL) {
//
// Init the new record
//
newRecord->LogRecord.RecordType = initialRecordType;
newRecord->LogRecord.Length = sizeof(LOG_RECORD);
newRecord->LogRecord.SequenceNumber = InterlockedIncrement( &MiniSpyData.LogSequenceNumber );
RtlZeroMemory( &newRecord->LogRecord.Data, sizeof( RECORD_DATA ) );
}
return( newRecord );
}
AtomicCounter& AtomicCounter::operator = (const AtomicCounter& counter)
{
InterlockedExchange(&_counter, counter.value());
return *this;
}
int GitRev::SafeGetSimpleList(CGit *git)
{
if(InterlockedExchange(&m_IsUpdateing,TRUE) == FALSE)
{
m_SimpleFileList.clear();
git->CheckAndInitDll();
GIT_COMMIT commit;
GIT_COMMIT_LIST list;
GIT_HASH parent;
memset(&commit,0,sizeof(GIT_COMMIT));
CAutoLocker lock(g_Git.m_critGitDllSec);
try
{
if(git_get_commit_from_hash(&commit, this->m_CommitHash.m_hash))
return -1;
}
catch (char *)
{
return -1;
}
int i=0;
bool isRoot = this->m_ParentHash.empty();
git_get_commit_first_parent(&commit,&list);
while(git_get_commit_next_parent(&list,parent) == 0 || isRoot)
{
GIT_FILE file=0;
int count=0;
try
{
if(isRoot)
git_root_diff(git->GetGitSimpleListDiff(), commit.m_hash, &file, &count, 0);
else
git_diff(git->GetGitSimpleListDiff(), parent, commit.m_hash, &file, &count, 0);
}
catch (char *)
{
return -1;
}
isRoot = false;
CTGitPath path;
CString strnewname;
CString stroldname;
for (int j = 0; j < count; ++j)
{
path.Reset();
char *newname;
char *oldname;
strnewname.Empty();
stroldname.Empty();
int mode,IsBin,inc,dec;
try
{
git_get_diff_file(git->GetGitSimpleListDiff(), file, j, &newname, &oldname, &mode, &IsBin, &inc, &dec);
}
catch (char *)
{
return -1;
}
git->StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
m_SimpleFileList.push_back(strnewname);
}
git_diff_flush(git->GetGitSimpleListDiff());
++i;
}
InterlockedExchange(&m_IsUpdateing,FALSE);
InterlockedExchange(&m_IsSimpleListReady, TRUE);
git_free_commit(&commit);
}
return 0;
}
UINT CImportPatchDlg::PatchThread()
{
CTGitPath path;
path.SetFromWin(g_Git.m_CurrentDir);
int i=0;
UpdateOkCancelText();
for (i = m_CurrentItem; i < m_cList.GetItemCount(); ++i)
{
if (m_pTaskbarList)
{
m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
m_pTaskbarList->SetProgressValue(m_hWnd, i, m_cList.GetItemCount());
}
m_cList.SetItemData(i, CPatchListCtrl::STATUS_APPLYING|m_cList.GetItemData(i));
CRect rect;
this->m_cList.GetItemRect(i,&rect,LVIR_BOUNDS);
this->m_cList.InvalidateRect(rect);
if(m_bExitThread)
break;
if(m_cList.GetCheck(i))
{
CString cmd;
while(path.HasRebaseApply())
{
if (m_pTaskbarList)
m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
int ret = CMessageBox::Show(NULL, IDS_PROC_APPLYPATCH_REBASEDIRFOUND,
IDS_APPNAME,
1, IDI_ERROR, IDS_ABORTBUTTON, IDS_SKIPBUTTON, IDS_RESOLVEDBUTTON);
switch(ret)
{
case 1:
cmd = _T("git.exe am --abort");
break;
case 2:
cmd = _T("git.exe am --skip");
++i;
break;
case 3:
cmd = _T("git.exe am --resolved");
break;
default:
cmd.Empty();
}
if(cmd.IsEmpty())
{
m_bExitThread = TRUE;
break;
}
this->AddLogString(cmd);
CString output;
if (g_Git.Run(cmd, &output, CP_UTF8))
{
this->AddLogString(output);
this->AddLogString(CString(MAKEINTRESOURCE(IDS_FAIL)));
}
else
{
this->AddLogString(CString(MAKEINTRESOURCE(IDS_DONE)));
}
}
if(m_bExitThread)
break;
cmd = _T("git.exe am ");
if(this->m_bAddSignedOffBy)
cmd += _T("--signoff ");
if(this->m_b3Way)
cmd += _T("--3way ");
if(this->m_bIgnoreSpace)
cmd += _T("--ignore-space-change ");
if(this->m_bKeepCR)
cmd += _T("--keep-cr ");
cmd += _T("\"");
cmd += m_cList.GetItemText(i,0);
cmd += _T("\"");
this->AddLogString(cmd);
CString output;
if (g_Git.Run(cmd, &output, CP_UTF8))
{
//keep STATUS_APPLYING to let user retry failed patch
m_cList.SetItemData(i, CPatchListCtrl::STATUS_APPLY_FAIL|CPatchListCtrl::STATUS_APPLYING);
this->AddLogString(output);
this->AddLogString(CString(MAKEINTRESOURCE(IDS_FAIL)));
if (m_pTaskbarList)
m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
break;
}
else
{
m_cList.SetItemData(i, CPatchListCtrl::STATUS_APPLY_SUCCESS);
this->AddLogString(CString(MAKEINTRESOURCE(IDS_SUCCESS)));
}
}
else
{
CString sMessage;
sMessage.Format(IDS_PROC_SKIPPATCH, m_cList.GetItemText(i,0));
AddLogString(sMessage);
m_cList.SetItemData(i, CPatchListCtrl::STATUS_APPLY_SKIP);
}
m_cList.SetItemData(m_CurrentItem, (~CPatchListCtrl::STATUS_APPLYING)&m_cList.GetItemData(i));
++m_CurrentItem;
this->m_cList.GetItemRect(i,&rect,LVIR_BOUNDS);
this->m_cList.InvalidateRect(rect);
UpdateOkCancelText();
}
//in case am fail, need refresh finial item status
CRect rect;
this->m_cList.GetItemRect(i,&rect,LVIR_BOUNDS);
this->m_cList.InvalidateRect(rect);
this->m_cList.GetItemRect(m_CurrentItem,&rect,LVIR_BOUNDS);
this->m_cList.InvalidateRect(rect);
if (m_pTaskbarList)
{
m_pTaskbarList->SetProgressValue(m_hWnd, m_CurrentItem, m_cList.GetItemCount());
if (m_bExitThread && m_CurrentItem != m_cList.GetItemCount())
m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
else if (!m_bExitThread && m_CurrentItem == m_cList.GetItemCount())
m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
}
EnableInputCtrl(true);
InterlockedExchange(&m_bThreadRunning, FALSE);
UpdateOkCancelText();
return 0;
}
BOOL AudioStream::ServiceBuffer(void)
{
long vol;
int fRtn = TRUE;
if (status != ASF_USED)
return FALSE;
ENTER_CRITICAL_SECTION(write_lock);
// status may have changed, so lets check once again
if (status != ASF_USED)
{
LEAVE_CRITICAL_SECTION(write_lock);
return FALSE;
}
// Check for reentrance
if (InterlockedExchange(&m_lInService, TRUE) == FALSE)
{
if (m_bFade == TRUE)
{
if (m_lCutoffVolume == -10000)
{
vol = Get_Volume();
// nprintf(("Alan","Volume is: %d\n",vol));
m_lCutoffVolume = MAX(vol - VOLUME_ATTENUATION_BEFORE_CUTOFF, -10000);
}
vol = Get_Volume();
vol = vol - FADE_VOLUME_INTERVAL; // decrease by 1db
// nprintf(("Alan","Volume is now: %d\n",vol));
Set_Volume(vol);
// nprintf(("Sound","SOUND => Volume for stream sound is %d\n",vol));
// nprintf(("Alan","Cuttoff Volume is: %d\n",m_lCutoffVolume));
if (vol < m_lCutoffVolume)
{
m_bFade = 0;
m_lCutoffVolume = -10000;
if (m_bDestroy_when_faded == TRUE)
{
LEAVE_CRITICAL_SECTION(write_lock);
Destroy();
// Reset reentrancy semaphore
InterlockedExchange(&m_lInService, FALSE);
return FALSE;
}
else
{
Stop_and_Rewind();
// Reset reentrancy semaphore
LEAVE_CRITICAL_SECTION(write_lock);
InterlockedExchange(&m_lInService, FALSE);
return TRUE;
}
}
}
// All of sound not played yet, send more data to buffer
DWORD dwFreeSpace = GetMaxWriteSize();
// Determine free space in sound buffer
if (dwFreeSpace)
{
// Some wave data remains, but not enough to fill free space
// Send wave data to buffer, fill remainder of free space with silence
uint num_bytes_written;
if (WriteWaveData(dwFreeSpace, &num_bytes_written) == SUCCESS)
{
// nprintf(("Alan","Num bytes written: %d\n", num_bytes_written));
if (m_pwavefile->m_total_uncompressed_bytes_read >= m_pwavefile->m_max_uncompressed_bytes_to_read)
{
m_fade_timer_id = timer_get_milliseconds() + 1700; // start fading 1.7 seconds from now
m_finished_id = timer_get_milliseconds() + 2000; // 2 seconds left to play out buffer
m_pwavefile->m_max_uncompressed_bytes_to_read = AS_HIGHEST_MAX;
}
if ((m_fade_timer_id > 0) && ((uint)timer_get_milliseconds() > m_fade_timer_id))
{
m_fade_timer_id = 0;
Fade_and_Stop();
}
if ((m_finished_id > 0) && ((uint)timer_get_milliseconds() > m_finished_id))
{
m_finished_id = 0;
m_bPastLimit = TRUE;
}
if ((num_bytes_written < dwFreeSpace) && m_bReadingDone)
{
int num_bytes_silence;
num_bytes_silence = dwFreeSpace - num_bytes_written;
if (num_bytes_silence > 0)
{
m_silence_written += num_bytes_silence;
if (WriteSilence(num_bytes_silence) == FAILURE)
{
fRtn = FALSE;
Int3();
}
if (m_silence_written >= m_cbBufSize)
{
m_silence_written = 0;
if (m_bDestroy_when_faded == TRUE)
{
LEAVE_CRITICAL_SECTION(write_lock);
Destroy();
// Reset reentrancy semaphore
InterlockedExchange(&m_lInService, FALSE);
return FALSE;
}
// All of sound has played, stop playback or loop again
if (m_bLooping && !m_bFade)
{
Play(m_lVolume, m_bLooping);
}
else
{
Stop_and_Rewind();
}
}
}
}
}
else
{
// Error writing wave data
fRtn = FALSE;
Int3();
}
}
// Reset reentrancy semaphore
InterlockedExchange(&m_lInService, FALSE);
}
else
{
// Service routine reentered. Do nothing, just return
fRtn = FALSE;
}
LEAVE_CRITICAL_SECTION(write_lock);
return (fRtn);
}
