void VertexArray::onSubjectStateChange(const gl::Context *context,
angle::SubjectIndex index,
angle::SubjectMessage message)
{
switch (message)
{
case angle::SubjectMessage::ContentsChanged:
setDependentDirtyBit(context, true, index);
break;
case angle::SubjectMessage::SubjectChanged:
if (!IsElementArrayBufferSubjectIndex(index))
{
updateCachedBufferBindingSize(context, &mState.mVertexBindings[index]);
}
setDependentDirtyBit(context, false, index);
break;
case angle::SubjectMessage::BindingChanged:
if (!IsElementArrayBufferSubjectIndex(index))
{
const Buffer *buffer = mState.mVertexBindings[index].getBuffer().get();
updateCachedTransformFeedbackBindingValidation(index, buffer);
}
break;
case angle::SubjectMessage::SubjectMapped:
if (!IsElementArrayBufferSubjectIndex(index))
{
updateCachedMappedArrayBuffersBinding(mState.mVertexBindings[index]);
}
onStateChange(context, angle::SubjectMessage::SubjectMapped);
break;
case angle::SubjectMessage::SubjectUnmapped:
setDependentDirtyBit(context, true, index);
if (!IsElementArrayBufferSubjectIndex(index))
{
updateCachedMappedArrayBuffersBinding(mState.mVertexBindings[index]);
}
onStateChange(context, angle::SubjectMessage::SubjectUnmapped);
break;
default:
UNREACHABLE();
break;
}
}
void VertexArray::setDependentDirtyBit(const gl::Context *context,
bool contentsChanged,
angle::SubjectIndex index)
{
DirtyBitType dirtyBit = getDirtyBitFromIndex(contentsChanged, index);
ASSERT(!mDirtyBitsGuard.valid() || mDirtyBitsGuard.value().test(dirtyBit));
mDirtyBits.set(dirtyBit);
onStateChange(context, angle::SubjectMessage::ContentsChanged);
}
SipPlugin::SipPlugin( const QString& pluginId, QObject* parent )
: QObject( parent )
, m_pluginId( pluginId )
{
connect( this, SIGNAL( error( int, QString ) ), this, SLOT( onError( int,QString ) ) );
connect( this, SIGNAL( stateChanged( SipPlugin::ConnectionState ) ), this, SLOT( onStateChange( SipPlugin::ConnectionState ) ) );
connect( this, SIGNAL( peerOnline( QString ) ), this, SLOT( onPeerOnline( QString ) ) );
connect( this, SIGNAL( peerOffline( QString ) ), this, SLOT( onPeerOffline( QString ) ) );
}
void MusicAudioRecorderCore::onRecordPlay()
{
m_mpOutputFile->open(QIODevice::ReadOnly | QIODevice::Truncate);
m_mpAudioOutputFile = new QAudioOutput(m_mFormatFile, this);
connect(m_mpAudioOutputFile, SIGNAL(stateChanged(QAudio::State)), SLOT(onStateChange(QAudio::State)));
m_mpAudioOutputFile->start(m_mpOutputFile);
}
void Session::setState(SessionState state)
{
if(state == this->state)
return;
if(state == SessionState::Closed)
peer = nullptr;
assert(state == SessionState::Open && peer != nullptr && hasHash );
this->state = state;
onStateChange(state);
}
void BTN_Update(BTN * btn, BTN_STATE_ENUM state)
{
if (btn)
{
BTN_STATE_ENUM new_state = debounce(btn, state);
if (new_state != btn->current_state)
{
onStateChange(btn, new_state);
}
else
{
onSameState(btn);
}
}
}
void Button::sendStateMessage()
{
Component::BailOutChecker checker (this);
buttonStateChanged();
if (checker.shouldBailOut())
return;
buttonListeners.callChecked (checker, [this] (Listener& l) { l.buttonStateChanged (this); });
if (checker.shouldBailOut())
return;
if (onStateChange != nullptr)
onStateChange();
}
lastfm::LNetworkConnectionMonitor::LNetworkConnectionMonitor( QObject* parent ) :
NetworkConnectionMonitor( parent )
{
m_nmInterface = new QDBusInterface( NM_DBUS_SERVICE,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
QDBusConnection::systemBus(),
this );
if ( !m_nmInterface->isValid() )
{
qDebug() << "Unable to watch network state changes via D-Bus.";
return;
}
//get current connection state
QDBusReply<uint> reply = m_nmInterface->call( QDBus::AutoDetect, "state" );
if ( reply.isValid() )
{
if ( reply.value() == NM_STATE_CONNECTED_GLOBAL )
{
setConnected( true );
}
else if ( reply.value() == NM_STATE_DISCONNECTED || reply.value() == NM_STATE_ASLEEP )
{
setConnected( false );
}
}
else
{
qDebug() << "Error: " << reply.error();
}
//connect network manager signals
m_nmInterface->connection().connect( NM_DBUS_SERVICE,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"StateChanged",
this,
SLOT( onStateChange( uint ) )
);
}
BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState,
BytesConsumer* consumer)
: UnderlyingSourceBase(scriptState),
m_scriptState(scriptState),
m_consumer(consumer),
m_madeFromReadableStream(false) {
v8::Local<v8::Value> bodyValue = toV8(this, scriptState);
DCHECK(!bodyValue.IsEmpty());
DCHECK(bodyValue->IsObject());
v8::Local<v8::Object> body = bodyValue.As<v8::Object>();
ScriptValue readableStream = ReadableStreamOperations::createReadableStream(
scriptState, this,
ReadableStreamOperations::createCountQueuingStrategy(scriptState, 0));
DCHECK(!readableStream.isEmpty());
V8HiddenValue::setHiddenValue(
scriptState, body,
V8HiddenValue::internalBodyStream(scriptState->isolate()),
readableStream.v8Value());
m_consumer->setClient(this);
onStateChange();
}
LNetworkConnectionMonitor::LNetworkConnectionMonitor( QObject* parent ) :
NetworkConnectionMonitor( parent )
{
m_nmInterface = new QDBusInterface( QString( "org.freedesktop.NetworkManager" ),
QString( "/org/freedesktop/NetworkManager" ),
QString( "org.freedesktop.NetworkManager" ),
QDBusConnection::systemBus(),
this );
//get current connection state
QDBusInterface* dbusInterface = new QDBusInterface( QString( "org.freedesktop.NetworkManager" ),
QString( "/org/freedesktop/NetworkManager" ),
QString( "org.freedesktop.DBus.Properties" ),
QDBusConnection::systemBus(),
this );
QDBusReply<QVariant> reply = dbusInterface->call( "Get", "org.freedesktop.NetworkManager", "state" );
if ( reply.isValid() )
{
if ( reply.value() == Connected )
{
setConnected( true );
}
else if ( reply.value() == Disconnected )
{
setConnected( false );
}
}
else
{
qDebug() << "Error: " << reply.error();
}
delete dbusInterface;
//connect network manager signals
connect( m_nmInterface, SIGNAL( StateChange( uint ) ), this, SLOT( onStateChange( uint ) ) );
}
void ToolInstance::onRun()
{
QScrollBar* scrollbar = m_ui.edtOutput->verticalScrollBar();
bool end = scrollbar->value() == scrollbar->maximum();
int oldValue = scrollbar->value();
m_ui.edtOutput->setTextColor(Qt::gray);
m_ui.edtOutput->setPlainText(m_ui.edtOutput->toPlainText());
if (end)
{
scrollbar->setValue(scrollbar->maximum());
}
else
{
scrollbar->setValue(oldValue);
}
QString exec = executable();
if (exec.contains(" "))
{
exec = QString("\"%1\"").arg(exec);
}
exec.append(" ").append(arguments());
m_process.start(exec, QIODevice::ReadOnly);
if (m_process.waitForStarted(1000))
{
mCRL2log(mcrl2::log::info) << "Started " << exec.toStdString() << std::endl;
m_ui.tabWidget->setCurrentIndex(1);
}
else
{
mCRL2log(mcrl2::log::error) << m_process.errorString().toStdString() << " (" << exec.toStdString() << ")" << std::endl;
onStateChange(QProcess::NotRunning);
}
}
void Widget::setState(MouseState inState)
{
mMouseState = inState;
onStateChange();
}
void Link::turnOff(){
if (isOn()) {
Resource::turnOff();
onStateChange(this);
}
}
ToolInstance::ToolInstance(QString filename, ToolInformation information, mcrl2::gui::qt::PersistentFileDialog* fileDialog, QWidget *parent) :
QWidget(parent),
m_filename(filename),
m_info(information),
m_fileDialog(fileDialog)
{
m_ui.setupUi(this);
connect(this, SIGNAL(colorChanged(QColor)), this, SLOT(onColorChanged(QColor)));
connect(&m_process, SIGNAL(stateChanged(QProcess::ProcessState)), this, SLOT(onStateChange(QProcess::ProcessState)));
connect(&m_process, SIGNAL(readyReadStandardOutput()), this, SLOT(onStandardOutput()));
connect(&m_process, SIGNAL(readyReadStandardError()), this, SLOT(onStandardError()));
connect(m_ui.btnRun, SIGNAL(clicked()), this, SLOT(onRun()));
connect(m_ui.btnAbort, SIGNAL(clicked()), this, SLOT(onAbort()));
connect(m_ui.btnSave, SIGNAL(clicked()), this, SLOT(onSave()));
connect(m_ui.btnClear, SIGNAL(clicked()), m_ui.edtOutput, SLOT(clear()));
QFileInfo fileInfo(filename);
m_process.setWorkingDirectory(fileInfo.absoluteDir().absolutePath());
m_ui.lblDirectoryValue->setText(fileInfo.absoluteDir().absolutePath());
m_ui.lblFileValue->setText(fileInfo.fileName());
if (m_info.hasOutput())
{
QDir dir = fileInfo.absoluteDir();
QString newfile = fileInfo.baseName().append(".%1").arg(m_info.output);
int filenr = 0;
while(dir.exists(newfile))
{
filenr++;
newfile = fileInfo.baseName().append("_%1.%2").arg(filenr).arg(m_info.output);
}
m_pckFileOut = new FilePicker(m_fileDialog, m_ui.pckFileOut);
m_ui.pckFileOut->layout()->addWidget(m_pckFileOut);
m_pckFileOut->setText(newfile);
}
else
{
m_pckFileOut = NULL;
m_ui.lblFileOut->setVisible(false);
m_ui.pckFileOut->setVisible(false);
}
if (m_info.hasSecondInput())
{
m_pckFileIn = new FilePicker(m_fileDialog, m_ui.pckFileIn, false);
m_ui.pckFileIn->layout()->addWidget(m_pckFileIn);
}
else
{
m_pckFileIn = NULL;
m_ui.lblFileIn->setVisible(false);
m_ui.pckFileIn->setVisible(false);
}
QFormLayout *formLayout = new QFormLayout();
formLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
for (int i = 0; i < m_info.options.count(); i++)
{
ToolOption option = m_info.options.at(i);
QWidget *nameOpt = NULL;
QCheckBox* cbOpt = NULL;
QVBoxLayout *lytOpt = new QVBoxLayout();
if (option.argument.type == EnumArgument)
{
nameOpt = new QLabel("<b>"+option.nameLong+": </b>");
}
else
{
cbOpt = new QCheckBox(option.nameLong + ": ", this);
cbOpt->setChecked(option.standard);
QFont font(cbOpt->font());
font.setBold(true);
cbOpt->setFont(font);
nameOpt = cbOpt;
}
formLayout->addRow(nameOpt, lytOpt);
QLabel *lblOpt = new QLabel(option.description, this);
lblOpt->setAlignment(Qt::AlignJustify | Qt::AlignTop);
lblOpt->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
lblOpt->setWordWrap(true);
lytOpt->addWidget(lblOpt);
if (!option.hasArgument())
{
m_optionValues.append(new OptionValue(option, cbOpt));
}
else
{
switch (option.argument.type)
{
case StringArgument:
case LevelArgument:
case IntegerArgument:
case RealArgument:
case BooleanArgument:
{
QHBoxLayout *lytArg = new QHBoxLayout();
lytArg->setSpacing(6);
QWidget *edtArg = NULL;
switch (option.argument.type)
{
case LevelArgument:
{
QLineEdit *edtLdt = new QLineEdit("verbose", this);
m_optionValues.append(new OptionValue(option, cbOpt, edtLdt));
edtArg = edtLdt;
}
break;
case IntegerArgument:
{
QSpinBox *edtSpb = new QSpinBox(this);
edtSpb->setRange(std::numeric_limits<int>::min(), std::numeric_limits<int>::max());
if (option.argument.optional)
{
QCheckBox *cbOptional = new QCheckBox(this);
lytArg->addWidget(cbOptional);
m_optionValues.append(new OptionValue(option, cbOpt, edtSpb, cbOptional));
}
else
{
m_optionValues.append(new OptionValue(option, cbOpt, edtSpb));
}
edtArg = edtSpb;
}
break;
case RealArgument:
{
QDoubleSpinBox *edtSpb = new QDoubleSpinBox(this);
edtSpb->setRange(std::numeric_limits<double>::min(), std::numeric_limits<double>::max());
if (option.argument.optional)
{
QCheckBox *cbOptional = new QCheckBox(this);
lytArg->addWidget(cbOptional);
m_optionValues.append(new OptionValue(option, cbOpt, edtSpb, cbOptional));
}
else
{
m_optionValues.append(new OptionValue(option, cbOpt, edtSpb));
}
edtArg = edtSpb;
}
break;
case BooleanArgument:
{
QCheckBox *edtChb = new QCheckBox("Yes", this);
m_optionValues.append(new OptionValue(option, cbOpt, edtChb));
edtArg = edtChb;
}
break;
case StringArgument:
default:
{
QLineEdit *edtLdt = new QLineEdit(this);
m_optionValues.append(new OptionValue(option, cbOpt, edtLdt));
edtArg = edtLdt;
}
break;
}
edtArg->setMinimumWidth(300);
lytArg->addWidget(edtArg);
if (!option.argument.optional && option.argument.type != BooleanArgument)
{
QLabel *lblReq = new QLabel("*", this);
lytArg->addWidget(lblReq);
}
QSpacerItem *spacer = new QSpacerItem(100, 20, QSizePolicy::Expanding);
lytArg->addItem(spacer);
lytOpt->addLayout(lytArg);
}
break;
case FileArgument:
{
QHBoxLayout *lytArg = new QHBoxLayout();
lytArg->setSpacing(6);
FilePicker *edtArg = new FilePicker(m_fileDialog, this, false);
lytArg->addWidget(edtArg);
m_optionValues.append(new OptionValue(option, cbOpt, edtArg));
if (!option.argument.optional)
{
QLabel *lblReq = new QLabel("*", this);
lytArg->addWidget(lblReq);
}
QSpacerItem *spacer = new QSpacerItem(100, 20, QSizePolicy::Expanding);
lytArg->addItem(spacer);
lytOpt->addLayout(lytArg);
}
break;
case EnumArgument:
{
QFormLayout *lytValues = new QFormLayout();
lytValues->setSpacing(6);
QButtonGroup *grpValues = new QButtonGroup(this);
for (int j = 0; j < option.argument.values.count(); j++)
{
ToolValue val = option.argument.values.at(j);
QRadioButton *rbVal = new QRadioButton(val.nameLong, this);
rbVal->setChecked(val.standard);
grpValues->addButton(rbVal);
QLabel *lblVal = new QLabel(val.description, this);
lblVal->setWordWrap(true);
lytValues->addRow(rbVal, lblVal);
}
m_optionValues.append(new OptionValue(option, cbOpt, grpValues));
lytOpt->addLayout(lytValues);
}
break;
default:
break;
}
}
}
m_ui.scrollWidget->setLayout(formLayout);
}
bool FastThread::threadLoop()
{
for (;;) {
// either nanosleep, sched_yield, or busy wait
if (sleepNs >= 0) {
if (sleepNs > 0) {
ALOG_ASSERT(sleepNs < 1000000000);
const struct timespec req = {0, sleepNs};
nanosleep(&req, NULL);
} else {
sched_yield();
}
}
// default to long sleep for next cycle
sleepNs = FAST_DEFAULT_NS;
// poll for state change
const FastThreadState *next = poll();
if (next == NULL) {
// continue to use the default initial state until a real state is available
// FIXME &initial not available, should save address earlier
//ALOG_ASSERT(current == &initial && previous == &initial);
next = current;
}
command = next->mCommand;
if (next != current) {
// As soon as possible of learning of a new dump area, start using it
dumpState = next->mDumpState != NULL ? next->mDumpState : mDummyDumpState;
logWriter = next->mNBLogWriter != NULL ? next->mNBLogWriter : &dummyLogWriter;
setLog(logWriter);
// We want to always have a valid reference to the previous (non-idle) state.
// However, the state queue only guarantees access to current and previous states.
// So when there is a transition from a non-idle state into an idle state, we make a
// copy of the last known non-idle state so it is still available on return from idle.
// The possible transitions are:
// non-idle -> non-idle update previous from current in-place
// non-idle -> idle update previous from copy of current
// idle -> idle don't update previous
// idle -> non-idle don't update previous
if (!(current->mCommand & FastThreadState::IDLE)) {
if (command & FastThreadState::IDLE) {
onIdle();
oldTsValid = false;
#ifdef FAST_MIXER_STATISTICS
oldLoadValid = false;
#endif
ignoreNextOverrun = true;
}
previous = current;
}
current = next;
}
#if !LOG_NDEBUG
next = NULL; // not referenced again
#endif
dumpState->mCommand = command;
// << current, previous, command, dumpState >>
switch (command) {
case FastThreadState::INITIAL:
case FastThreadState::HOT_IDLE:
sleepNs = FAST_HOT_IDLE_NS;
continue;
case FastThreadState::COLD_IDLE:
// only perform a cold idle command once
// FIXME consider checking previous state and only perform if previous != COLD_IDLE
if (current->mColdGen != coldGen) {
int32_t *coldFutexAddr = current->mColdFutexAddr;
ALOG_ASSERT(coldFutexAddr != NULL);
int32_t old = android_atomic_dec(coldFutexAddr);
if (old <= 0) {
syscall(__NR_futex, coldFutexAddr, FUTEX_WAIT_PRIVATE, old - 1, NULL);
}
int policy = sched_getscheduler(0);
if (!(policy == SCHED_FIFO || policy == SCHED_RR)) {
ALOGE("did not receive expected priority boost");
}
// This may be overly conservative; there could be times that the normal mixer
// requests such a brief cold idle that it doesn't require resetting this flag.
isWarm = false;
measuredWarmupTs.tv_sec = 0;
measuredWarmupTs.tv_nsec = 0;
warmupCycles = 0;
sleepNs = -1;
coldGen = current->mColdGen;
#ifdef FAST_MIXER_STATISTICS
bounds = 0;
full = false;
#endif
oldTsValid = !clock_gettime(CLOCK_MONOTONIC, &oldTs);
timestampStatus = INVALID_OPERATION;
} else {
sleepNs = FAST_HOT_IDLE_NS;
}
continue;
case FastThreadState::EXIT:
onExit();
return false;
default:
LOG_ALWAYS_FATAL_IF(!isSubClassCommand(command));
break;
}
// there is a non-idle state available to us; did the state change?
if (current != previous) {
onStateChange();
#if 1 // FIXME shouldn't need this
// only process state change once
previous = current;
#endif
}
// do work using current state here
attemptedWrite = false;
onWork();
// To be exactly periodic, compute the next sleep time based on current time.
// This code doesn't have long-term stability when the sink is non-blocking.
// FIXME To avoid drift, use the local audio clock or watch the sink's fill status.
struct timespec newTs;
int rc = clock_gettime(CLOCK_MONOTONIC, &newTs);
if (rc == 0) {
//logWriter->logTimestamp(newTs);
if (oldTsValid) {
time_t sec = newTs.tv_sec - oldTs.tv_sec;
long nsec = newTs.tv_nsec - oldTs.tv_nsec;
ALOGE_IF(sec < 0 || (sec == 0 && nsec < 0),
"clock_gettime(CLOCK_MONOTONIC) failed: was %ld.%09ld but now %ld.%09ld",
oldTs.tv_sec, oldTs.tv_nsec, newTs.tv_sec, newTs.tv_nsec);
if (nsec < 0) {
--sec;
nsec += 1000000000;
}
// To avoid an initial underrun on fast tracks after exiting standby,
// do not start pulling data from tracks and mixing until warmup is complete.
// Warmup is considered complete after the earlier of:
// MIN_WARMUP_CYCLES write() attempts and last one blocks for at least warmupNs
// MAX_WARMUP_CYCLES write() attempts.
// This is overly conservative, but to get better accuracy requires a new HAL API.
if (!isWarm && attemptedWrite) {
measuredWarmupTs.tv_sec += sec;
measuredWarmupTs.tv_nsec += nsec;
if (measuredWarmupTs.tv_nsec >= 1000000000) {
measuredWarmupTs.tv_sec++;
measuredWarmupTs.tv_nsec -= 1000000000;
}
++warmupCycles;
if ((nsec > warmupNs && warmupCycles >= MIN_WARMUP_CYCLES) ||
(warmupCycles >= MAX_WARMUP_CYCLES)) {
isWarm = true;
dumpState->mMeasuredWarmupTs = measuredWarmupTs;
dumpState->mWarmupCycles = warmupCycles;
}
}
sleepNs = -1;
if (isWarm) {
if (sec > 0 || nsec > underrunNs) {
ATRACE_NAME("underrun");
// FIXME only log occasionally
ALOGV("underrun: time since last cycle %d.%03ld sec",
(int) sec, nsec / 1000000L);
dumpState->mUnderruns++;
ignoreNextOverrun = true;
} else if (nsec < overrunNs) {
if (ignoreNextOverrun) {
ignoreNextOverrun = false;
} else {
// FIXME only log occasionally
ALOGV("overrun: time since last cycle %d.%03ld sec",
(int) sec, nsec / 1000000L);
dumpState->mOverruns++;
}
// This forces a minimum cycle time. It:
// - compensates for an audio HAL with jitter due to sample rate conversion
// - works with a variable buffer depth audio HAL that never pulls at a
// rate < than overrunNs per buffer.
// - recovers from overrun immediately after underrun
// It doesn't work with a non-blocking audio HAL.
sleepNs = forceNs - nsec;
} else {
ignoreNextOverrun = false;
}
}
#ifdef FAST_MIXER_STATISTICS
if (isWarm) {
// advance the FIFO queue bounds
size_t i = bounds & (dumpState->mSamplingN - 1);
bounds = (bounds & 0xFFFF0000) | ((bounds + 1) & 0xFFFF);
if (full) {
bounds += 0x10000;
} else if (!(bounds & (dumpState->mSamplingN - 1))) {
full = true;
}
// compute the delta value of clock_gettime(CLOCK_MONOTONIC)
uint32_t monotonicNs = nsec;
if (sec > 0 && sec < 4) {
monotonicNs += sec * 1000000000;
}
// compute raw CPU load = delta value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
uint32_t loadNs = 0;
struct timespec newLoad;
rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &newLoad);
if (rc == 0) {
if (oldLoadValid) {
sec = newLoad.tv_sec - oldLoad.tv_sec;
nsec = newLoad.tv_nsec - oldLoad.tv_nsec;
if (nsec < 0) {
--sec;
nsec += 1000000000;
}
loadNs = nsec;
if (sec > 0 && sec < 4) {
loadNs += sec * 1000000000;
}
} else {
// first time through the loop
oldLoadValid = true;
}
oldLoad = newLoad;
}
#ifdef CPU_FREQUENCY_STATISTICS
// get the absolute value of CPU clock frequency in kHz
int cpuNum = sched_getcpu();
uint32_t kHz = tcu.getCpukHz(cpuNum);
kHz = (kHz << 4) | (cpuNum & 0xF);
#endif
// save values in FIFO queues for dumpsys
// these stores #1, #2, #3 are not atomic with respect to each other,
// or with respect to store #4 below
dumpState->mMonotonicNs[i] = monotonicNs;
dumpState->mLoadNs[i] = loadNs;
#ifdef CPU_FREQUENCY_STATISTICS
dumpState->mCpukHz[i] = kHz;
#endif
// this store #4 is not atomic with respect to stores #1, #2, #3 above, but
// the newest open & oldest closed halves are atomic with respect to each other
dumpState->mBounds = bounds;
ATRACE_INT("cycle_ms", monotonicNs / 1000000);
ATRACE_INT("load_us", loadNs / 1000);
}
#endif
} else {
// first time through the loop
oldTsValid = true;
sleepNs = periodNs;
ignoreNextOverrun = true;
}
oldTs = newTs;
} else {
// monotonic clock is broken
oldTsValid = false;
sleepNs = periodNs;
}
} // for (;;)
// never return 'true'; Thread::_threadLoop() locks mutex which can result in priority inversion
}
