bool CControlSocket::TryLockCache(const CServerPath& directory)
{
wxASSERT(m_pCurrentServer);
std::list<t_lockInfo>::iterator own = GetLockStatus();
if (own == m_lockInfoList.end())
{
t_lockInfo info;
info.directory = directory;
info.pControlSocket = this;
info.waiting = true;
m_lockInfoList.push_back(info);
own = --m_lockInfoList.end();
}
else
{
wxASSERT(own->waiting);
}
// Try to find other instance holding the lock
for (std::list<t_lockInfo>::const_iterator iter = m_lockInfoList.begin(); iter != own; iter++)
{
if (*m_pCurrentServer != *iter->pControlSocket->m_pCurrentServer)
continue;
if (directory == iter->directory)
{
// Some other instance is holding the lock
return false;
}
}
own->waiting = false;
return true;
}
enum CControlSocket::locking_reason CControlSocket::ObtainLockFromEvent()
{
if (!m_pCurOpData)
return lock_unknown;
std::list<t_lockInfo>::iterator own = GetLockStatus();
if (own == m_lockInfoList.end())
return lock_unknown;
if (!own->waiting)
return lock_unknown;
for (std::list<t_lockInfo>::const_iterator iter = m_lockInfoList.begin(); iter != own; ++iter)
{
if (*m_pCurrentServer != *iter->pControlSocket->m_pCurrentServer)
continue;
if (iter->directory != own->directory)
continue;
if (iter->reason != own->reason)
continue;
// Another instance comes before us
return lock_unknown;
}
own->waiting = false;
own->lockcount++;
return own->reason;
}
bool CControlSocket::IsWaitingForLock()
{
std::list<t_lockInfo>::iterator own = GetLockStatus();
if (own == m_lockInfoList.end())
return false;
return own->waiting == true;
}
bool CControlSocket::TryLockCache(enum locking_reason reason, const CServerPath& directory)
{
wxASSERT(m_pCurrentServer);
wxASSERT(m_pCurOpData);
std::list<t_lockInfo>::iterator own = GetLockStatus();
if (own == m_lockInfoList.end())
{
t_lockInfo info;
info.directory = directory;
info.pControlSocket = this;
info.waiting = true;
info.reason = reason;
info.lockcount = 0;
m_lockInfoList.push_back(info);
own = --m_lockInfoList.end();
}
else
{
if (own->lockcount)
{
if (!m_pCurOpData->holdsLock)
{
m_pCurOpData->holdsLock = true;
own->lockcount++;
}
return true;
}
wxASSERT(own->waiting);
wxASSERT(own->reason == reason);
}
// Needs to be set in any case so that ResetOperation
// unlocks or cancels the lock wait
m_pCurOpData->holdsLock = true;
// Try to find other instance holding the lock
for (std::list<t_lockInfo>::const_iterator iter = m_lockInfoList.begin(); iter != own; ++iter)
{
if (*m_pCurrentServer != *iter->pControlSocket->m_pCurrentServer)
continue;
if (directory != iter->directory)
continue;
if (reason != iter->reason)
continue;
// Some other instance is holding the lock
return false;
}
own->lockcount++;
own->waiting = false;
return true;
}
void CControlSocket::UnlockCache()
{
if (!m_pCurOpData || !m_pCurOpData->holdsLock)
return;
m_pCurOpData->holdsLock = false;
std::list<t_lockInfo>::iterator iter = GetLockStatus();
if (iter == m_lockInfoList.end())
return;
wxASSERT(!iter->waiting || iter->lockcount == 0);
if (!iter->waiting)
{
iter->lockcount--;
wxASSERT(iter->lockcount >= 0);
if (iter->lockcount)
return;
}
CServerPath directory = iter->directory;
enum locking_reason reason = iter->reason;
m_lockInfoList.erase(iter);
// Find other instance waiting for the lock
if (!m_pCurrentServer)
{
LogMessage(MessageType::Debug_Warning, _T("UnlockCache called with !m_pCurrentServer"));
return;
}
for (std::list<t_lockInfo>::const_iterator iter = m_lockInfoList.begin(); iter != m_lockInfoList.end(); ++iter)
{
if (!iter->pControlSocket->m_pCurrentServer)
{
LogMessage(MessageType::Debug_Warning, _T("UnlockCache found other instance with !m_pCurrentServer"));
continue;
}
if (*m_pCurrentServer != *iter->pControlSocket->m_pCurrentServer)
continue;
if (iter->directory != directory)
continue;
if (iter->reason != reason)
continue;
// Send notification
wxCommandEvent evt(fzOBTAINLOCK);
iter->pControlSocket->AddPendingEvent(evt);
break;
}
}
void CControlSocket::UnlockCache()
{
if (!m_pCurOpData || !m_pCurOpData->holdsLock)
return;
m_pCurOpData->holdsLock = false;
std::list<t_lockInfo>::iterator iter = GetLockStatus();
if (iter == m_lockInfoList.end())
return;
wxASSERT(!iter->waiting || iter->lockcount == 0);
if (!iter->waiting)
{
iter->lockcount--;
wxASSERT(iter->lockcount >= 0);
if (iter->lockcount)
return;
}
CServerPath directory = iter->directory;
enum locking_reason reason = iter->reason;
m_lockInfoList.erase(iter);
// Find other instance waiting for the lock
if (!m_pCurrentServer) {
LogMessage(MessageType::Debug_Warning, _T("UnlockCache called with !m_pCurrentServer"));
return;
}
for (auto & lockInfo : m_lockInfoList) {
if (!lockInfo.pControlSocket->m_pCurrentServer){
LogMessage(MessageType::Debug_Warning, _T("UnlockCache found other instance with !m_pCurrentServer"));
continue;
}
if (*m_pCurrentServer != *lockInfo.pControlSocket->m_pCurrentServer)
continue;
if (lockInfo.directory != directory)
continue;
if (lockInfo.reason != reason)
continue;
// Send notification
lockInfo.pControlSocket->send_event<CObtainLockEvent>();
break;
}
}
bool CControlSocket::ObtainLockFromEvent()
{
std::list<t_lockInfo>::iterator own = GetLockStatus();
if (own == m_lockInfoList.end())
return false;
if (!own->waiting)
return false;
for (std::list<t_lockInfo>::const_iterator iter = m_lockInfoList.begin(); iter != own; iter++)
{
if (*m_pCurrentServer != *iter->pControlSocket->m_pCurrentServer)
continue;
if (iter->directory == own->directory)
return false;
}
own->waiting = false;
return true;
}
bool CControlSocket::IsLocked(enum locking_reason reason, const CServerPath& directory)
{
wxASSERT(m_pCurrentServer);
std::list<t_lockInfo>::iterator own = GetLockStatus();
if (own != m_lockInfoList.end())
return true;
// Try to find other instance holding the lock
for (std::list<t_lockInfo>::const_iterator iter = m_lockInfoList.begin(); iter != own; ++iter)
{
if (*m_pCurrentServer != *iter->pControlSocket->m_pCurrentServer)
continue;
if (directory != iter->directory)
continue;
if (reason != iter->reason)
continue;
// Some instance is holding the lock
return true;
}
return false;
}
void CControlSocket::UnlockCache()
{
std::list<t_lockInfo>::iterator iter = GetLockStatus();
if (iter == m_lockInfoList.end())
return;
CServerPath directory = iter->directory;
m_lockInfoList.erase(iter);
// Find other instance waiting for the lock
for (std::list<t_lockInfo>::const_iterator iter = m_lockInfoList.begin(); iter != m_lockInfoList.end(); iter++)
{
if (*m_pCurrentServer != *iter->pControlSocket->m_pCurrentServer)
continue;
if (iter->directory != directory)
continue;
// Send notification
wxCommandEvent evt(fzOBTAINLOCK);
iter->pControlSocket->AddPendingEvent(evt);
break;
}
}
bool Frontend::Tune( Transponder &t )
{
if( !IsPresent( ))
{
LogWarn( "device not present '%s'", name.c_str( ));
return false;
}
Lock( );
if( transponder )
{
if( transponder == &t )
{
usecount++;
Unlock( );
return true;
}
Log( "Frontend busy" );
Unlock( );
return false;
}
if( !Open( ))
{
Unlock( );
return false;
}
state = State_Tuning;
transponder = &t;
usecount++;
Unlock( );
t.SetState( Transponder::State_Tuning );
Log( "Tuning %s", t.toString( ).c_str( ));
uint8_t signal, noise;
LogWarn( "dvb_set_compat_delivery_system %d", t.GetDelSys( ));
int r = dvb_set_compat_delivery_system( fe, t.GetDelSys( ));
if( r != 0 )
{
LogError( "dvb_set_compat_delivery_system return %d", r );
goto fail;
}
SetTuneParams( t );
t.GetParams( fe );
LogWarn( "dvb_estimate_freq_shift");
dvb_estimate_freq_shift( fe );
r = dvb_fe_set_parms( fe );
if( r != 0 )
{
LogError( "dvb_fe_set_parms failed with %d.", r );
dvb_fe_prt_parms( fe );
goto fail;
}
dvb_fe_prt_parms( fe );
/* As the DVB core emulates it, better to always use auto */
dvb_fe_store_parm(fe, DTV_INVERSION, INVERSION_AUTO);
uint32_t freq;
dvb_fe_retrieve_parm(fe, DTV_FREQUENCY, &freq);
dvb_fe_prt_parms(fe);
if( !GetLockStatus( signal, noise, tune_timeout ))
{
LogError( "Tuning failed" );
goto fail;
}
t.SetState( Transponder::State_Tuned );
t.SetSignal( signal, noise );
return true;
fail:
t.SetState( Transponder::State_TuningFailed );
t.SaveConfig( );
Release( );
return false;
}