CTrafficLights::eTrafficLightState CTrafficLights::GetState()
{
if(IsLocked())
return m_eStateSet;
if(m_eStateSet >= TRAFFIC_LIGHT_STATE_FLASHING_FLASHING)
return m_eStateSet;
if(m_uiTotalDuration == 0)
return TRAFFIC_LIGHT_STATE_DISABLED_DISABLED;
// Get the state based on the time elapsed in that cycle
unsigned int uiTimePassed = GetTimeThisCylce();
if(uiTimePassed < m_uiGreenDuration)
return TRAFFIC_LIGHT_STATE_GREEN_RED;
else if(uiTimePassed < m_uiGreenDuration + m_uiYellowDuration)
return TRAFFIC_LIGHT_STATE_YELLOW_RED;
else if(uiTimePassed < m_uiGreenDuration + m_uiYellowDuration + m_uiRedDuration)
return TRAFFIC_LIGHT_STATE_RED_RED_1;
else if(uiTimePassed < m_uiGreenDuration + 2 * m_uiYellowDuration + m_uiRedDuration)
return TRAFFIC_LIGHT_STATE_RED_TO_GREEN;
else if(uiTimePassed < 2 * m_uiGreenDuration + 2 * m_uiYellowDuration + m_uiRedDuration)
return TRAFFIC_LIGHT_STATE_RED_GREEN;
else if(uiTimePassed < 2 * m_uiGreenDuration + 3 * m_uiYellowDuration + m_uiRedDuration)
return TRAFFIC_LIGHT_STATE_RED_YELLOW;
else if(uiTimePassed < 2 * m_uiGreenDuration + 3 * m_uiYellowDuration + 2 * m_uiRedDuration)
return TRAFFIC_LIGHT_STATE_RED_RED_2;
else
return TRAFFIC_LIGHT_STATE_TO_GREEN_RED;
}
void CFrobLock::ToggleOpenTargets()
{
if (IsLocked())
{
// We're still locked, play the locked sound and exit
FrobLockStartSound("snd_locked");
}
else
{
// Actually open any targetted frobmovers
for ( int i = 0 ; i < targets.Num() ; i++ )
{
idEntity* target = targets[i].GetEntity();
if ( (target == NULL) || !target->IsType(CBinaryFrobMover::Type))
{
continue;
}
static_cast<CBinaryFrobMover*>(target)->ToggleOpen();
}
}
}
bool CAccountHD::GetKey(const CKeyID& keyID, CKey& key) const
{
if (IsLocked())
return false;
int64_t nKeyIndex = -1;
CExtKey privKey;
if (externalKeyStore.GetKey(keyID, nKeyIndex)) {
primaryChainKeyPriv.Derive(privKey, nKeyIndex);
if (privKey.Neuter().pubkey.GetID() != keyID)
assert(0);
key = privKey.key;
return true;
}
if (internalKeyStore.GetKey(keyID, nKeyIndex)) {
changeChainKeyPriv.Derive(privKey, nKeyIndex);
if (privKey.Neuter().pubkey.GetID() != keyID)
assert(0);
key = privKey.key;
return true;
}
return false;
}
int32_t CFDE_TxtEdtEngine::SetCaretPos(int32_t nIndex, FX_BOOL bBefore) {
if (IsLocked()) {
return 0;
}
ASSERT(nIndex >= 0 && nIndex <= GetTextBufLength());
if (m_PagePtrArray.GetSize() <= m_nCaretPage) {
return 0;
}
m_bBefore = bBefore;
m_nCaret = nIndex;
MovePage2Char(m_nCaret);
GetCaretRect(m_rtCaret, m_nCaretPage, m_nCaret, m_bBefore);
if (!m_bBefore) {
m_nCaret++;
m_bBefore = TRUE;
}
m_fCaretPosReserve = (m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical)
? m_rtCaret.top
: m_rtCaret.left;
m_Param.pEventSink->On_CaretChanged(this, m_nCaretPage, 0);
m_nAnchorPos = -1;
return m_nCaret;
}
void
DecodedSurfaceProvider::SetLocked(bool aLocked)
{
// See DrawableRef() for commentary on these assertions.
if (Availability().IsPlaceholder()) {
MOZ_ASSERT_UNREACHABLE("Calling SetLocked() on a placeholder");
return;
}
if (!mSurface) {
MOZ_ASSERT_UNREACHABLE("Calling SetLocked() when we have no surface");
return;
}
if (aLocked == IsLocked()) {
return; // Nothing to do.
}
// If we're locked, hold a DrawableFrameRef to |mSurface|, which will keep any
// volatile buffer it owns in memory.
mLockRef = aLocked ? mSurface->DrawableRef()
: DrawableFrameRef();
}
void FLevelViewModel::SelectActors( bool bSelect, bool bNotify, bool bSelectEvenIfHidden, const TSharedPtr< IFilter< const TWeakObjectPtr< AActor >& > >& Filter )
{
if( !Level.IsValid() || IsLocked() )
{
return;
}
Editor->GetSelectedActors()->BeginBatchSelectOperation();
bool bChangesOccurred = false;
// Iterate over all actors, looking for actors in this level.
ULevel* RawLevel = Level.Get();
for ( int32 ActorIndex = 2 ; ActorIndex < RawLevel->Actors.Num() ; ++ActorIndex )
{
AActor* Actor = RawLevel->Actors[ ActorIndex ];
if ( Actor )
{
if( Filter.IsValid() && !Filter->PassesFilter( Actor ) )
{
continue;
}
bool bNotifyForActor = false;
Editor->GetSelectedActors()->Modify();
Editor->SelectActor( Actor, bSelect, bNotifyForActor, bSelectEvenIfHidden );
bChangesOccurred = true;
}
}
Editor->GetSelectedActors()->EndBatchSelectOperation();
if( bNotify )
{
Editor->NoteSelectionChange();
}
}
void FLevelViewModel::Save()
{
if ( !IsLevel() )
{
return;
}
if ( !IsVisible() )
{
FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "UnableToSaveInvisibleLevels", "Save aborted. Levels must be made visible before they can be saved.") );
return;
}
else if ( IsLocked() )
{
FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "UnableToSaveLockedLevels", "Save aborted. Level must be unlocked before it can be saved.") );
return;
}
// Prompt the user to check out the level from source control before saving if it's currently under source control
if ( FEditorFileUtils::PromptToCheckoutLevels( false, Level.Get() ) )
{
FEditorFileUtils::SaveLevel( Level.Get() );
}
}
//------------------------------------------------------------------------------
void
BLocker::Unlock(void)
{
// If the thread currently holds the lockdecrement
if (IsLocked()) {
// Decrement the number of outstanding locks this thread holds
// on this BLocker.
fRecursiveCount--;
// If the recursive count is now at 0, that means the BLocker has
// been released by the thread.
if (fRecursiveCount == 0) {
// The BLocker is no longer owned by any thread.
fLockOwner = B_ERROR;
// Decrement the benaphore count and store the undecremented
// value in oldBenaphoreCount.
//int32 oldBenaphoreCount = atomic_add(&fBenaphoreCount, -1);
// TODO: use atomic_dec(&fBenaphoreCount) instead
int32 oldBenaphoreCount = atomic_add(&fBenaphoreCount, -1);
// If the oldBenaphoreCount is greater than 1, then there is
// at lease one thread waiting for the lock in the case of a
// benaphore.
if (oldBenaphoreCount > 1) {
// Since there are threads waiting for the lock, it must
// be released. Note, the old benaphore count will always be
// greater than 1 for a semaphore so the release is always done.
release_sem(fSemaphoreID);
}
}
}
}
Result Machine::Reset(const bool hard) throw()
{
if (!Is(ON) || IsLocked())
return RESULT_ERR_NOT_READY;
try
{
emulator.Reset( hard );
}
catch (Result result)
{
return result;
}
catch (const std::bad_alloc&)
{
return RESULT_ERR_OUT_OF_MEMORY;
}
catch (...)
{
return RESULT_ERR_GENERIC;
}
return RESULT_OK;
}
BOOL S3PDBSocketPool::ShowAllClientInfo()
{
if (IsLocked())
return FALSE;
Lock();
BOOL b = FALSE;
GatewayIDMap::iterator i = m_clientIDs.begin();
int n = 0;
while (i != m_clientIDs.end())
{
KGatewayDataProcess* p = i->second;
if (p)
{
in_addr add;
add.s_addr = p->m_Address;
gTrace("Client %d: %s(%s)", n, p->m_ServerName.c_str(), inet_ntoa(in_addr(add)));
}
i++;
n++;
}
b = TRUE;
Unlock();
return b;
}
void FLevelModel::SetLocked(bool bLocked)
{
if (LevelCollectionModel.IsReadOnly())
{
return;
}
ULevel* Level = GetLevelObject();
if (Level == NULL)
{
return;
}
// Do nothing if attempting to set the level to the same locked state
if (bLocked == IsLocked())
{
return;
}
// If locking the level, deselect all of its actors and BSP surfaces
if (bLocked)
{
DeselectAllActors();
DeselectAllSurfaces();
// Tell the editor selection status was changed.
Editor->NoteSelectionChange();
// If locking the current level, reset the p-level as the current level
//@todo: fix this!
}
// Change the level's locked status
FLevelUtils::ToggleLevelLock(Level);
}
/// \brief
/// Flag that determines whether the resource can currently unload itself. Used by the resource manager.
inline BOOL CanUnload() const {return IsResourceFlagSet(VRESOURCEFLAG_ALLOWUNLOAD) && !IsLocked();}
BlockFile::~BlockFile()
{
if (!IsLocked() && mFileName.HasName())
wxRemoveFile(mFileName.GetFullPath());
}
HRESULT CHWMFT::GetOutputCurrentType(
DWORD dwOutputStreamID,
IMFMediaType** ppType)
{
/*****************************************
** See http://msdn.microsoft.com/en-us/library/ms696985(v=VS.85).aspx
*****************************************/
HRESULT hr = S_OK;
IMFMediaType* pMT = NULL;
do
{
/************************************
** Since this MFT is a decoder, it
** must not allow this function to be
** called until it is unlocked. If
** your MFT is an encoder, this function
** CAN be called before the MFT is
** unlocked
************************************/
if(IsLocked() != FALSE)
{
hr = MF_E_TRANSFORM_ASYNC_LOCKED;
break;
}
if(ppType == NULL)
{
hr = E_POINTER;
break;
}
/*****************************************
** Todo: If your MFT supports more than one
** stream, make sure you modify
** MFT_MAX_STREAMS and adjust this function
** accordingly
*****************************************/
if(dwOutputStreamID >= MFT_MAX_STREAMS)
{
hr = MF_E_INVALIDSTREAMNUMBER;
break;
}
{
CAutoLock lock(&m_csLock);
if(m_pOutputMT == NULL)
{
hr = MF_E_TRANSFORM_TYPE_NOT_SET;
break;
}
/*******************************************
** Return a copy of the media type, not the
** internal one. Returning the internal one
** will allow an external component to modify
** the internal media type
*******************************************/
hr = MFCreateMediaType(&pMT);
if(FAILED(hr))
{
break;
}
hr = DuplicateAttributes(pMT, m_pOutputMT);
if(FAILED(hr))
{
break;
}
}
(*ppType) = pMT;
(*ppType)->AddRef();
}while(false);
SAFERELEASE(pMT);
return hr;
}
void MODULE::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
{
int nbpad;
wxString msg;
aList.push_back( MSG_PANEL_ITEM( m_Reference->GetShownText(), m_Value->GetShownText(), DARKCYAN ) );
// Display last date the component was edited (useful in Module Editor).
wxDateTime date( m_LastEditTime );
if( m_LastEditTime && date.IsValid() )
// Date format: see http://www.cplusplus.com/reference/ctime/strftime
msg = date.Format( wxT( "%b %d, %Y" ) ); // Abbreviated_month_name Day, Year
else
msg = _( "Unknown" );
aList.push_back( MSG_PANEL_ITEM( _( "Last Change" ), msg, BROWN ) );
// display schematic path
aList.push_back( MSG_PANEL_ITEM( _( "Netlist Path" ), m_Path, BROWN ) );
// display the board side placement
aList.push_back( MSG_PANEL_ITEM( _( "Board Side" ),
IsFlipped()? _( "Back (Flipped)" ) : _( "Front" ), RED ) );
EDA_ITEM* PtStruct = m_Pads;
nbpad = 0;
while( PtStruct )
{
nbpad++;
PtStruct = PtStruct->Next();
}
msg.Printf( wxT( "%d" ), nbpad );
aList.push_back( MSG_PANEL_ITEM( _( "Pads" ), msg, BLUE ) );
msg = wxT( ".." );
if( IsLocked() )
msg[0] = 'L';
if( m_ModuleStatus & MODULE_is_PLACED )
msg[1] = 'P';
aList.push_back( MSG_PANEL_ITEM( _( "Status" ), msg, MAGENTA ) );
msg.Printf( wxT( "%.1f" ), GetOrientationDegrees() );
aList.push_back( MSG_PANEL_ITEM( _( "Rotation" ), msg, BROWN ) );
// Controls on right side of the dialog
switch( m_Attributs & 255 )
{
case 0:
msg = _( "Normal" );
break;
case MOD_CMS:
msg = _( "Insert" );
break;
case MOD_VIRTUAL:
msg = _( "Virtual" );
break;
default:
msg = wxT( "???" );
break;
}
aList.push_back( MSG_PANEL_ITEM( _( "Attributes" ), msg, BROWN ) );
aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), FROM_UTF8( m_fpid.Format().c_str() ), BLUE ) );
if( m_3D_Drawings.empty() )
msg = _( "No 3D shape" );
else
msg = m_3D_Drawings.front().m_Filename;
// Search the first active 3D shape in list
aList.push_back( MSG_PANEL_ITEM( _( "3D-Shape" ), msg, RED ) );
wxString doc, keyword;
doc.Printf( _( "Doc: %s" ), GetChars( m_Doc ) );
keyword.Printf( _( "Key Words: %s" ), GetChars( m_KeyWord ) );
aList.push_back( MSG_PANEL_ITEM( doc, keyword, BLACK ) );
}
void UScheduler::Timer::SetTimeout(U32 timeout)
{
DebugAssertTrue(IsLocked());
_timeoutTime = System::GetTickCount() + timeout;
AddOperationWithTimeout(_node);
}
HRESULT CHWMFT::ProcessOutput(
DWORD dwFlags,
DWORD dwOutputBufferCount,
MFT_OUTPUT_DATA_BUFFER* pOutputSamples,
DWORD* pdwStatus)
{
/*****************************************
** See http://msdn.microsoft.com/en-us/library/ms704014(v=VS.85).aspx
*****************************************/
HRESULT hr = S_OK;
IMFSample* pSample = NULL;
TraceString(CHMFTTracing::TRACE_INFORMATION, L"%S(): Enter", __FUNCTION__);
do
{
if(IsLocked() != FALSE)
{
hr = MF_E_TRANSFORM_ASYNC_LOCKED;
break;
}
{
CAutoLock lock(&m_csLock);
TraceString(CHMFTTracing::TRACE_INFORMATION, L"%S(): HaveOutputCount: %u", __FUNCTION__, m_dwHaveOutputCount);
if(m_dwHaveOutputCount == 0)
{
// This call does not correspond to a have output call
hr = E_UNEXPECTED;
break;
}
else
{
m_dwHaveOutputCount--;
}
}
/*****************************************
** Todo: If your MFT supports more than one
** stream, make sure you modify
** MFT_MAX_STREAMS and adjust this function
** accordingly
*****************************************/
if(dwOutputBufferCount < MFT_MAX_STREAMS)
{
hr = E_INVALIDARG;
break;
}
if(IsMFTReady() == FALSE)
{
hr = MF_E_TRANSFORM_TYPE_NOT_SET;
break;
}
/***************************************
** Since this in an internal function
** we know m_pOutputSampleQueue can never be
** NULL due to InitializeTransform()
***************************************/
hr = m_pOutputSampleQueue->GetNextSample(&pSample);
if(FAILED(hr))
{
break;
}
if(pSample == NULL)
{
hr = MF_E_TRANSFORM_NEED_MORE_INPUT;
break;
}
/*******************************
** Todo: This MFT only has one
** input stream, so the output
** samples array and stream ID
** will only use the first
** member
*******************************/
pOutputSamples[0].dwStreamID = 0;
if((pOutputSamples[0].pSample) == NULL)
{
// The MFT is providing it's own samples
(pOutputSamples[0].pSample) = pSample;
(pOutputSamples[0].pSample)->AddRef();
}
else
{
// The pipeline has allocated the samples
IMFMediaBuffer* pBuffer = NULL;
do
{
hr = pSample->ConvertToContiguousBuffer(&pBuffer);
if(FAILED(hr))
{
break;
}
hr = (pOutputSamples[0].pSample)->AddBuffer(pBuffer);
if(FAILED(hr))
{
break;
}
}while(false);
SAFERELEASE(pBuffer);
if(FAILED(hr))
{
break;
}
}
/***************************************
** Since this in an internal function
** we know m_pOutputSampleQueue can never be
** NULL due to InitializeTransform()
***************************************/
if(m_pOutputSampleQueue->IsQueueEmpty() != FALSE)
{
// We're out of samples in the output queue
CAutoLock lock(&m_csLock);
if((m_dwStatus & MYMFT_STATUS_DRAINING) != 0)
{
// We're done draining, time to send the event
IMFMediaEvent* pDrainCompleteEvent = NULL;
do
{
hr = MFCreateMediaEvent(METransformDrainComplete , GUID_NULL, S_OK, NULL, &pDrainCompleteEvent);
if(FAILED(hr))
{
break;
}
/*******************************
** Todo: This MFT only has one
** input stream, so the drain
** is always on stream zero.
** Update this is your MFT
** has more than one stream
*******************************/
hr = pDrainCompleteEvent->SetUINT32(MF_EVENT_MFT_INPUT_STREAM_ID, 0);
if(FAILED(hr))
{
break;
}
/***************************************
** Since this in an internal function
** we know m_pEventQueue can never be
** NULL due to InitializeTransform()
***************************************/
hr = m_pEventQueue->QueueEvent(pDrainCompleteEvent);
if(FAILED(hr))
{
break;
}
}while(false);
SAFERELEASE(pDrainCompleteEvent);
if(FAILED(hr))
{
break;
}
m_dwStatus &= (~MYMFT_STATUS_DRAINING);
}
}
}while(false);
SAFERELEASE(pSample);
TraceString(CHMFTTracing::TRACE_INFORMATION, L"%S(): Exit (hr=0x%x)", __FUNCTION__, hr);
return hr;
}
BOOL CGatewayEpos2ToMaxonSerialV1::Process_SegmentWrite(CCommand_DCS* pCommand, CProtocolStackManagerBase* pProtocolStackManager, HANDLE hPS_Handle, HANDLE hTransactionHandle)
{
const BYTE MAX_SEGMENT_LENGTH = 63;
//*Constants DCS*
const int PARAMETER_INDEX_NODE_ID = 0;
const int PARAMETER_INDEX_CONTROL_BYTE = 1;
const int PARAMETER_INDEX_DATA = 2;
const int RETURN_PARAMETER_INDEX_ERROR_CODE = 0;
const int RETURN_PARAMETER_INDEX_CONTROL_BYTE = 1;
//*Constants PS*
const BYTE OP_CODE = 0x15;
const BYTE DATA_LENGTH = 1;
const BYTE RETURN_DATA_LENGTH = 6;
//*Variables DCS*
//Parameter
BYTE uNodeId = 0;
UEpos2ControlByte controlByte;
controlByte.bValue = 0;
void* pData = NULL;
//Return Parameter
UEpos2ControlByte retControlByte;
retControlByte.bValue = 0;
DWORD dDeviceErrorCode = 0;
//*Variables PS*
//Parameter
BYTE uOpCode = OP_CODE;
void* pDataBuffer=NULL;
DWORD dDataBufferLength;
BYTE ubKeepLock(1);
//ReturnParameter
void* pRetDataBuffer=NULL;
DWORD dRetDataBufferLength = 0;
BOOL oResult = FALSE;
CErrorInfo comErrorInfo;
CErrorInfo cmdErrorInfo;
void* pDest;
void* pSource;
if(pCommand)
{
//Check CriticalSection
if(!IsLocked(pCommand)) return FALSE;
//GetParameterData
pCommand->GetParameterData(PARAMETER_INDEX_NODE_ID, &uNodeId, sizeof(uNodeId));
pCommand->GetParameterData(PARAMETER_INDEX_CONTROL_BYTE, &controlByte.bValue, sizeof(controlByte.bValue));
//Check Max SegmentLength
if(controlByte.structure.bLength > MAX_SEGMENT_LENGTH) controlByte.structure.bLength = MAX_SEGMENT_LENGTH;
pData = malloc(controlByte.structure.bLength);
pCommand->GetParameterData(PARAMETER_INDEX_DATA, pData, controlByte.structure.bLength);
//Prepare DataBuffer
dDataBufferLength = DATA_LENGTH + controlByte.structure.bLength;
pDataBuffer = malloc(dDataBufferLength);
//Data
pDest = pDataBuffer;
CopyData(pDest, &controlByte.bValue, sizeof(controlByte.bValue));
CopyData(pDest, pData, controlByte.structure.bLength);
//Execute Command
oResult = PS_ProcessProtocol(pProtocolStackManager, hPS_Handle, hTransactionHandle, uOpCode, pDataBuffer, dDataBufferLength, ubKeepLock, &pRetDataBuffer, &dRetDataBufferLength, &comErrorInfo);
//Check ReturnData Size
if(oResult && (dRetDataBufferLength != RETURN_DATA_LENGTH))
{
if(m_pErrorHandling) m_pErrorHandling->GetError(k_Error_MaxonSerialV1_BadDataSizeReceived, &comErrorInfo);
oResult = FALSE;
}
//ReturnData
pSource = pRetDataBuffer;
if(oResult) oResult = CopyReturnData(&dDeviceErrorCode, sizeof(dDeviceErrorCode), pSource, dRetDataBufferLength);
if(oResult) oResult = CopyReturnData(&retControlByte.bValue, sizeof(retControlByte.bValue), pSource, dRetDataBufferLength);
//Evaluate ErrorCode
oResult = EvaluateErrorCode(oResult, dDeviceErrorCode, &comErrorInfo, &cmdErrorInfo);
//Restore controlByte
if(oResult && (controlByte.structure.bToggle != retControlByte.structure.bToggle))
{
if(m_pErrorHandling) m_pErrorHandling->GetError(ERROR_DEVICE_EPOS_TOGGLE, &cmdErrorInfo);
oResult = FALSE;
}
//SetReturnParameterData
pCommand->SetStatus(oResult, &cmdErrorInfo);
pCommand->SetReturnParameterData(RETURN_PARAMETER_INDEX_ERROR_CODE, &dDeviceErrorCode, sizeof(dDeviceErrorCode));
pCommand->SetReturnParameterData(RETURN_PARAMETER_INDEX_CONTROL_BYTE, &retControlByte, sizeof(retControlByte));
//Free DataBuffer
if(pData) free(pData);
if(pDataBuffer) free(pDataBuffer);
if(pRetDataBuffer) free(pRetDataBuffer);
//Unlock CriticalSection
if(!controlByte.structure.bMoreSegments || !oResult)
{
PS_AbortProtocol(pProtocolStackManager, hPS_Handle, hTransactionHandle);
Unlock();
}
}
return oResult;
}
HRESULT CHWMFT::ProcessInput(
DWORD dwInputStreamID,
IMFSample* pSample,
DWORD dwFlags)
{
/*****************************************
** See http://msdn.microsoft.com/en-us/library/ms703131(v=VS.85).aspx
*****************************************/
HRESULT hr = S_OK;
TraceString(CHMFTTracing::TRACE_INFORMATION, L"%S(): Enter", __FUNCTION__);
do
{
if(IsLocked() != FALSE)
{
hr = MF_E_TRANSFORM_ASYNC_LOCKED;
break;
}
{
CAutoLock lock(&m_csLock);
TraceString(CHMFTTracing::TRACE_INFORMATION, L"%S(): NeedInputCount: %u", __FUNCTION__, m_dwNeedInputCount);
if(m_dwNeedInputCount == 0)
{
// This call does not correspond to a need input call
hr = MF_E_NOTACCEPTING;
break;
}
else
{
m_dwNeedInputCount--;
}
}
if(pSample == NULL)
{
hr = E_POINTER;
break;
}
/*****************************************
** Todo: If your MFT supports more than one
** stream, make sure you modify
** MFT_MAX_STREAMS and adjust this function
** accordingly
*****************************************/
if(dwInputStreamID >= MFT_MAX_STREAMS)
{
hr = MF_E_INVALIDSTREAMNUMBER;
break;
}
// First, put sample into the input Queue
/***************************************
** Since this in an internal function
** we know m_pInputSampleQueue can never be
** NULL due to InitializeTransform()
***************************************/
hr = m_pInputSampleQueue->AddSample(pSample);
if(FAILED(hr))
{
break;
}
// Now schedule the work to decode the sample
hr = ScheduleFrameDecode();
if(FAILED(hr))
{
break;
}
}while(false);
TraceString(CHMFTTracing::TRACE_INFORMATION, L"%S(): Exit (hr=0x%x)", __FUNCTION__, hr);
return hr;
}
void b2World::DestroyJoint(b2Joint* j)
{
b2Assert(IsLocked() == false);
if (IsLocked())
{
return;
}
bool collideConnected = j->m_collideConnected;
// Remove from the doubly linked list.
if (j->m_prev)
{
j->m_prev->m_next = j->m_next;
}
if (j->m_next)
{
j->m_next->m_prev = j->m_prev;
}
if (j == m_jointList)
{
m_jointList = j->m_next;
}
// Disconnect from island graph.
b2Body* bodyA = j->m_bodyA;
b2Body* bodyB = j->m_bodyB;
// Wake up connected bodies.
bodyA->SetAwake(true);
bodyB->SetAwake(true);
// Remove from body 1.
if (j->m_edgeA.prev)
{
j->m_edgeA.prev->next = j->m_edgeA.next;
}
if (j->m_edgeA.next)
{
j->m_edgeA.next->prev = j->m_edgeA.prev;
}
if (&j->m_edgeA == bodyA->m_jointList)
{
bodyA->m_jointList = j->m_edgeA.next;
}
j->m_edgeA.prev = NULL;
j->m_edgeA.next = NULL;
// Remove from body 2
if (j->m_edgeB.prev)
{
j->m_edgeB.prev->next = j->m_edgeB.next;
}
if (j->m_edgeB.next)
{
j->m_edgeB.next->prev = j->m_edgeB.prev;
}
if (&j->m_edgeB == bodyB->m_jointList)
{
bodyB->m_jointList = j->m_edgeB.next;
}
j->m_edgeB.prev = NULL;
j->m_edgeB.next = NULL;
b2Joint::Destroy(j, &m_blockAllocator);
b2Assert(m_jointCount > 0);
--m_jointCount;
// If the joint prevents collisions, then flag any contacts for filtering.
if (collideConnected == false)
{
b2ContactEdge* edge = bodyB->GetContactList();
while (edge)
{
if (edge->other == bodyA)
{
// Flag the contact for filtering at the next time step (where either
// body is awake).
edge->contact->FlagForFiltering();
}
edge = edge->next;
}
}
}
status_t ObservableLooper::notify(
BMessage* message) {
ASSERT(IsLocked());
return Invoke(message);
}
BOOL CGatewayInfoteamSerialToI::Process_ProcessProtocolMaxon(CCommand_PS* pCommand,CInterfaceManagerBase* pInterfaceManager,HANDLE hI_Handle,HANDLE hTransactionHandle)
{
const DWORD k_MaxPackageSize_Maxon = 256;
//*Constants PS*
const int k_ParameterIndex_PackageSize = 0;
const int k_ParameterIndex_ChunkSize = 1;
const int k_ParameterIndex_LastChunkFlag = 2;
const int k_ParameterIndex_Checksum = 3;
const int k_ParameterIndex_PackageType = 4;
const int k_ParameterIndex_OpCode = 5;
const int k_ParameterIndex_Data = 6;
const int k_ParameterIndex_KeepLock = 7;
const int k_ReturnParameterIndex_PackageSize = 0;
const int k_ReturnParameterIndex_Checksum = 1;
const int k_ReturnParameterIndex_PackageType = 2;
const int k_ReturnParameterIndex_Data = 3;
//*Variables PS*
//Parameter
DWORD dPackageSize;
WORD wChunkSize;
BYTE uLastChunkFlag;
DWORD dChecksum;
BYTE uPackageType = 0;
BYTE uOpCode = 0;
void* pDataBuffer = NULL;
DWORD dDataBufferLength;
BYTE ubKeepLock = 0;
BYTE* p = NULL;
DWORD dSize;
//ReturnParameter
DWORD dRetPackageSize;
DWORD dRetChecksum;
BYTE uRetPackageType = 0;
void* pRetDataBuffer = NULL;
DWORD dRetDataBufferLength = 0;
BOOL oResult = FALSE;
CErrorInfo errorInfo;
DWORD dTimeout;
if(pCommand && pInterfaceManager)
{
//Lock CriticalSection
if(!IsLocked(pCommand))
{
if(!Lock(pCommand)) return FALSE;
}
//Prepare DataBuffer
dDataBufferLength = pCommand->GetParameterLength(k_ParameterIndex_Data) + sizeof(uPackageType) + sizeof(uOpCode);
if(dDataBufferLength > 0) pDataBuffer = malloc(dDataBufferLength);
//Get PS Parameter Data
pCommand->GetParameterData(k_ParameterIndex_PackageSize,&dPackageSize,sizeof(dPackageSize));
pCommand->GetParameterData(k_ParameterIndex_ChunkSize,&wChunkSize,sizeof(wChunkSize));
pCommand->GetParameterData(k_ParameterIndex_LastChunkFlag,&uLastChunkFlag,sizeof(uLastChunkFlag));
pCommand->GetParameterData(k_ParameterIndex_Checksum,&dChecksum,sizeof(dChecksum));
pCommand->GetParameterData(k_ParameterIndex_KeepLock,&ubKeepLock,sizeof(ubKeepLock));
p = (BYTE*)pDataBuffer;
pCommand->GetParameterData(k_ParameterIndex_PackageType,p,sizeof(uPackageType));p+=sizeof(uPackageType);
pCommand->GetParameterData(k_ParameterIndex_OpCode,p,sizeof(uOpCode));p+=sizeof(uOpCode);
pCommand->GetParameterData(k_ParameterIndex_Data,p,pCommand->GetParameterLength(k_ParameterIndex_Data));
//Execute Command
dTimeout = pCommand->GetTimeout();
oResult = SendFrameRepeated(pInterfaceManager,hI_Handle,hTransactionHandle,dPackageSize,wChunkSize,uLastChunkFlag,&dChecksum,pDataBuffer,dDataBufferLength,&errorInfo);
if(oResult)
{
oResult = ReceiveFrameRepeated(pInterfaceManager,hI_Handle,hTransactionHandle, k_MaxPackageSize_Maxon, &dRetPackageSize,&dRetChecksum,&pRetDataBuffer,&dRetDataBufferLength,dTimeout,&errorInfo);
}
//Set PS ReturnParameter Data
pCommand->SetStatus(oResult,&errorInfo);
pCommand->SetParameterData(k_ParameterIndex_Checksum,&dChecksum,sizeof(dChecksum));
pCommand->SetReturnParameterData(k_ReturnParameterIndex_PackageSize,&dRetPackageSize,sizeof(dRetPackageSize));
pCommand->SetReturnParameterData(k_ReturnParameterIndex_Checksum,&dRetChecksum,sizeof(dRetChecksum));
if(dRetDataBufferLength > 0)
{
p = (BYTE*)pRetDataBuffer;
dSize = dRetDataBufferLength;
pCommand->SetReturnParameterData(k_ReturnParameterIndex_PackageType,p,sizeof(uRetPackageType)); p+=sizeof(uPackageType); dSize -= sizeof(uPackageType);
pCommand->SetReturnParameterData(k_ReturnParameterIndex_Data,p,dSize);
}
//Free DataBuffer
if(pDataBuffer) free(pDataBuffer);
if(pRetDataBuffer) free(pRetDataBuffer);
//Unlock CriticalSection
if(!ubKeepLock) Unlock();
}
return oResult;
}
bool
Matrix<T>::Locked() const
{ return IsLocked( viewType_ ); }
HRESULT CHWMFT::GetInputAvailableType(
DWORD dwInputStreamID,
DWORD dwTypeIndex,
IMFMediaType** ppType)
{
/*****************************************
** Todo: This function will return a media
** type at a given index. The SDK
** implementation uses a static array of
** media types. Your MFT may want to use
** a dynamic array and modify the list
** order depending on the MFTs state
** See http://msdn.microsoft.com/en-us/library/ms704814(v=VS.85).aspx
*****************************************/
HRESULT hr = S_OK;
IMFMediaType* pMT = NULL;
do
{
if(IsLocked() != FALSE)
{
hr = MF_E_TRANSFORM_ASYNC_LOCKED;
break;
}
if(ppType == NULL)
{
hr = E_POINTER;
break;
}
/*****************************************
** Todo: If your MFT supports more than one
** stream, make sure you modify
** MFT_MAX_STREAMS and adjust this function
** accordingly
*****************************************/
if(dwInputStreamID >= MFT_MAX_STREAMS)
{
hr = MF_E_INVALIDSTREAMNUMBER;
break;
}
/*****************************************
** Todo: Modify the accepted input list
** g_ppguidInputTypes or use your own
** implementation of this function
*****************************************/
if(dwTypeIndex >= g_dwNumInputTypes)
{
hr = MF_E_NO_MORE_TYPES;
break;
}
{
CAutoLock lock(&m_csLock);
hr = MFCreateMediaType(&pMT);
if(FAILED(hr))
{
break;
}
hr = pMT->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
if(FAILED(hr))
{
break;
}
hr = pMT->SetGUID(MF_MT_SUBTYPE, *(g_ppguidInputTypes[dwTypeIndex]));
if(FAILED(hr))
{
break;
}
(*ppType) = pMT;
(*ppType)->AddRef();
}
}while(false);
SAFERELEASE(pMT);
return hr;
}
bool FLevelModel::IsEditable() const
{
return (IsLoaded() == true && IsLocked() == false);
}
/**
* Adds a radio distortion to the input buffer if the radio effect is enabled.
*
* @param InputProcessParameterCount Number of elements in pInputProcessParameters.
* @param pInputProcessParameters Input buffer containing audio samples.
* @param OutputProcessParameterCount Number of elements in pOutputProcessParameters.
* @param pOutputProcessParameters Output buffer, which is not touched by this xAPO.
* @param IsEnabled true if this effect is enabled; false, otherwise.
*/
STDMETHOD_( void, Process )( UINT32 InputProcessParameterCount,
const XAPO_PROCESS_BUFFER_PARAMETERS *pInputProcessParameters,
UINT32 OutputProcessParameterCount,
XAPO_PROCESS_BUFFER_PARAMETERS *pOutputProcessParameters,
BOOL IsEnabled )
{
// Verify several condition based on the registration
// properties we used to create the class.
check( IsLocked() );
check( InputProcessParameterCount == 1 );
check( OutputProcessParameterCount == 1 );
check( pInputProcessParameters[0].pBuffer == pOutputProcessParameters[0].pBuffer );
// Check the global volume multiplier because this effect
// will continue to play if the editor loses focus.
if (IsEnabled && FApp::GetVolumeMultiplier() != 0.0f)
{
FAudioRadioEffect* RadioParameters = ( FAudioRadioEffect* )BeginProcess();
check( RadioParameters );
// The total sample size must account for multiple channels.
const uint32 SampleSize = pInputProcessParameters[0].ValidFrameCount * WaveFormat.nChannels;
const float ChebyshevPowerMultiplier = Radio_ChebyshevPowerMultiplier->GetValueOnAnyThread();
const float ChebyshevPower = Radio_ChebyshevPower->GetValueOnAnyThread();
const float ChebyshevCubedMultiplier = Radio_ChebyshevCubedMultiplier->GetValueOnAnyThread();
const float ChebyshevMultiplier = Radio_ChebyshevMultiplier->GetValueOnAnyThread();
// If we have a silent buffer, then allocate the samples. Then, set the sample values
// to zero to avoid getting NANs. Otherwise, the user may hear an annoying popping noise.
if( pInputProcessParameters[0].BufferFlags == XAPO_BUFFER_VALID )
{
float* SampleData = ( float* )pInputProcessParameters[0].pBuffer;
// Process each sample one at a time
for( uint32 SampleIndex = 0; SampleIndex < SampleSize; ++SampleIndex )
{
float Sample = SampleData[SampleIndex];
// Early-out of processing if the sample is zero because a zero sample
// will still create some static even if no audio is playing.
if( Sample == 0.0f )
{
continue;
}
// Waveshape it
const float SampleCubed = Sample * Sample * Sample;
Sample = ( ChebyshevPowerMultiplier * FMath::Pow( Sample, ChebyshevPower ) ) - ( ChebyshevCubedMultiplier * SampleCubed ) + ( ChebyshevMultiplier * Sample );
// Again with the bandpass
Sample = GFinalBandPassFilter.Process( Sample );
// Store the value after done processing
SampleData[SampleIndex] = Sample;
}
EndProcess();
}
}
}
void b2World::DestroyBody(b2Body* b)
{
b2Assert(m_bodyCount > 0);
b2Assert(IsLocked() == false);
if (IsLocked())
{
return;
}
// Delete the attached joints.
b2JointEdge* je = b->m_jointList;
while (je)
{
b2JointEdge* je0 = je;
je = je->next;
if (m_destructionListener)
{
m_destructionListener->SayGoodbye(je0->joint);
}
DestroyJoint(je0->joint);
b->m_jointList = je;
}
b->m_jointList = NULL;
// Delete the attached contacts.
b2ContactEdge* ce = b->m_contactList;
while (ce)
{
b2ContactEdge* ce0 = ce;
ce = ce->next;
m_contactManager.Destroy(ce0->contact);
}
b->m_contactList = NULL;
// Delete the attached fixtures. This destroys broad-phase proxies.
b2Fixture* f = b->m_fixtureList;
while (f)
{
b2Fixture* f0 = f;
f = f->m_next;
if (m_destructionListener)
{
m_destructionListener->SayGoodbye(f0);
}
f0->DestroyProxies(&m_contactManager.m_broadPhase);
f0->Destroy(&m_blockAllocator);
f0->~b2Fixture();
m_blockAllocator.Free(f0, sizeof(b2Fixture));
b->m_fixtureList = f;
b->m_fixtureCount -= 1;
}
b->m_fixtureList = NULL;
b->m_fixtureCount = 0;
// Remove world body list.
if (b->m_prev)
{
b->m_prev->m_next = b->m_next;
}
if (b->m_next)
{
b->m_next->m_prev = b->m_prev;
}
if (b == m_bodyList)
{
m_bodyList = b->m_next;
}
--m_bodyCount;
b->~b2Body();
m_blockAllocator.Free(b, sizeof(b2Body));
}
HRESULT CHWMFT::ProcessMessage(
MFT_MESSAGE_TYPE eMessage,
ULONG_PTR ulParam)
{
/*****************************************
** See http://msdn.microsoft.com/en-us/library/ms701863(v=VS.85).aspx
*****************************************/
HRESULT hr = S_OK;
do
{
if(IsLocked() != FALSE)
{
hr = MF_E_TRANSFORM_ASYNC_LOCKED;
break;
}
if((m_pInputMT == NULL) || (m_pOutputMT == NULL))
{
// Can't process messages until media types are set
hr = MF_E_TRANSFORM_TYPE_NOT_SET;
break;
}
switch(eMessage)
{
case MFT_MESSAGE_NOTIFY_START_OF_STREAM:
{
hr = OnStartOfStream();
if(FAILED(hr))
{
break;
}
}
break;
case MFT_MESSAGE_NOTIFY_END_OF_STREAM:
{
hr = OnEndOfStream();
if(FAILED(hr))
{
break;
}
}
break;
case MFT_MESSAGE_COMMAND_DRAIN:
{
hr = OnDrain((UINT32)ulParam);
if(FAILED(hr))
{
break;
}
}
break;
case MFT_MESSAGE_COMMAND_FLUSH:
{
hr = OnFlush();
if(FAILED(hr))
{
break;
}
}
break;
case MFT_MESSAGE_COMMAND_MARKER:
{
hr = OnMarker(ulParam);
if(FAILED(hr))
{
break;
}
}
break;
/************************************************
** Todo: Add any MFT Messages that are not already
** covered
************************************************/
default:
// Nothing to do, return S_OK
break;
};
}while(false);
return hr;
}
/// unlocks the blockfile only if it has a file that exists. This needs to be done
/// so that the unsaved ODPCMAliasBlockfiles are deleted upon exit
void ODPCMAliasBlockFile::Unlock()
{
if(IsSummaryAvailable() && IsLocked())
PCMAliasBlockFile::Unlock();
}
//------------------------------------------------------------------------------
bool
BLocker::AcquireLock(bigtime_t timeout,
status_t *error)
{
// By default, return no error.
*error = B_OK;
// Only try to acquire the lock if the thread doesn't already own it.
if (!IsLocked()) {
// Increment the benaphore count and test to see if it was already greater
// than 0. If it is greater than 0, then some thread already has the
// benaphore or the style is a semaphore. Either way, we need to acquire
// the semaphore in this case.
//int32 oldBenaphoreCount = atomic_add(&fBenaphoreCount, 1);
// TODO: use atomic_inc(&fBenaphoreCount) instead
int32 oldBenaphoreCount = atomic_add(&fBenaphoreCount, 1);
if (oldBenaphoreCount > 0) {
// NOTE: "timeout" is always considered zero
*error = acquire_sem_etc(fSemaphoreID, 1,
timeout == B_INFINITE_TIMEOUT? 0 : B_RELATIVE_TIMEOUT,
timeout);
// Note, if the lock here does time out, the benaphore count
// is not decremented. By doing this, the benaphore count will
// never go back to zero. This means that the locking essentially
// changes to semaphore style if this was a benaphore.
//
// Doing the decrement of the benaphore count when the acquisition
// fails is a risky thing to do. If you decrement the counter at
// the same time the thread which holds the benaphore does an
// Unlock(), there is serious risk of a race condition.
//
// If the Unlock() sees a positive count and releases the semaphore
// and then the timed out thread decrements the count to 0, there
// is no one to take the semaphore. The next two threads will be
// able to acquire the benaphore at the same time! The first will
// increment the counter and acquire the lock. The second will
// acquire the semaphore and therefore the lock. Not good.
//
// This has been discussed on the becodetalk mailing list and
// Trey from Be had this to say:
//
// I looked at the LockWithTimeout() code, and it does not have
// _this_ (ie the race condition) problem. It circumvents it by
// NOT doing the atomic_add(&count, -1) if the semaphore
// acquisition fails. This means that if a
// BLocker::LockWithTimeout() times out, all other Lock*() attempts
// turn into guaranteed semaphore grabs, _with_ the overhead of a
// (now) useless atomic_add().
//
// Given Trey's comments, it looks like Be took the same approach
// I did. The output of CountLockRequests() of Be's implementation
// confirms Trey's comments also.
//
// Finally some thoughts for the future with this code:
// - If 2^31 timeouts occur on a 32-bit machine (ie today),
// the benaphore count will wrap to a negative number. This
// would have unknown consequences on the ability of the BLocker
// to continue to function.
//
}
}
// If the lock has successfully been acquired.
if (*error == B_NO_ERROR) {
// Set the lock owner to this thread and increment the recursive count
// by one. The recursive count is incremented because one more Unlock()
// is now required to release the lock (ie, 0 => 1, 1 => 2 etc).
fLockOwner = find_thread(NULL);
fRecursiveCount++;
}
// Return true if the lock has been acquired.
return (*error == B_NO_ERROR);
}
