void
Periodic::onMain(void)
{
double now = Time::Clock::get();
double delay = (1 / m_frequency);
double next_inv = now + delay;
m_run_time = now;
while (!stopping())
{
delay = (1.0 / m_frequency);
if (next_inv > now)
Time::Delay::wait(next_inv - now);
next_inv += delay;
now = Time::Clock::get();
m_run_time = now;
// Perform job.
consumeMessages();
if (!stopping())
{
task();
++m_run_count;
}
now = Time::Clock::get();
}
}
static void *send_thread(void *data)
{
struct rtmp_stream *stream = data;
os_set_thread_name("rtmp-stream: send_thread");
while (os_sem_wait(stream->send_sem) == 0) {
struct encoder_packet packet;
if (stopping(stream) && stream->stop_ts == 0) {
break;
}
if (!get_next_packet(stream, &packet))
continue;
if (stopping(stream)) {
if (can_shutdown_stream(stream, &packet)) {
obs_free_encoder_packet(&packet);
break;
}
}
if (!stream->sent_headers) {
if (!send_headers(stream)) {
os_atomic_set_bool(&stream->disconnected, true);
break;
}
}
if (send_packet(stream, &packet, false, packet.track_idx) < 0) {
os_atomic_set_bool(&stream->disconnected, true);
break;
}
}
if (disconnected(stream)) {
info("Disconnected from %s", stream->path.array);
} else {
info("User stopped the stream");
}
RTMP_Close(&stream->rtmp);
if (!stopping(stream)) {
pthread_detach(stream->send_thread);
obs_output_signal_stop(stream->output, OBS_OUTPUT_DISCONNECTED);
} else {
obs_output_end_data_capture(stream->output);
}
free_packets(stream);
os_event_reset(stream->stop_event);
os_atomic_set_bool(&stream->active, false);
stream->sent_headers = false;
return NULL;
}
int ThreadedAudioDevice::doStop()
{
if (!stopping()) {
PRINT1("\tThreadedAudioDevice::doStop\n");
stopping(true); // signals play thread
paused(false);
waitForThread();
starting(false);
}
return 0;
}
void AdmittanceController::setMode(unsigned int mode) {
if (mode_ != mode) {
stopping();
mode_ = mode;
starting();
}
}
int ThreadedAudioDevice::waitForDevice(unsigned int wTime) {
int ret;
unsigned waitSecs = int(wTime / 1000.0);
unsigned waitUsecs = 1000 * (wTime - unsigned(waitSecs * 1000));
// Wait wTime msecs for select to return, then bail.
if (!stopping()) {
int nfds = _device + 1;
struct timeval tv;
tv.tv_sec = waitSecs;
tv.tv_usec = waitUsecs;
// If wTime == 0, wait forever by passing NULL as the final arg.
// if (!isPlaying())
// printf("select(%d, 0x%x, 0x%x, NULL, 0x%x)...\n",
// nfds, &_rfdset, &_wfdset, wTime == 0 ? NULL : &tv);
int selret = ::select(nfds, &_rfdset, &_wfdset,
NULL, wTime == 0 ? NULL : &tv);
if (selret <= 0) {
if (errno != EINTR)
fprintf(stderr,
"ThreadedAudioDevice::waitForDevice: select %s\n",
(selret == 0) ? "timed out" : "returned error");
ret = -1;
}
else {
setFDSet();
ret = 0;
}
}
else {
PRINT1("ThreadedAudioDevice::waitForDevice: stopping == true\n");
ret = 1;
}
return ret;
}
void Insteon::run()
{
setStarted();
while (!stopping())
{
// Make sure every devices are idle before atempting to send another command
bool devicesIdle = true;
for (std::map<InsteonID,InsteonDevice*>::iterator it = mModules.begin();it!=mModules.end();it++)
{
time_t t;
time(&t);
it->second->onTimer(t);
if (!it->second->isIdle())
{
devicesIdle = false;
break;
}
}
if (mpInsteonModem->process(devicesIdle))
{
// dont sleep more than 50ms because Insteon modem expects reponses within 85ms
usleep(50000);
}
}
}
static void rtmp_stream_destroy(void *data)
{
struct rtmp_stream *stream = data;
if (stopping(stream) && !connecting(stream)) {
pthread_join(stream->send_thread, NULL);
} else if (connecting(stream) || active(stream)) {
if (stream->connecting)
pthread_join(stream->connect_thread, NULL);
os_event_signal(stream->stop_event);
if (active(stream)) {
os_sem_post(stream->send_sem);
obs_output_end_data_capture(stream->output);
pthread_join(stream->send_thread, NULL);
}
}
if (stream) {
free_packets(stream);
dstr_free(&stream->path);
dstr_free(&stream->key);
dstr_free(&stream->username);
dstr_free(&stream->password);
dstr_free(&stream->encoder_name);
os_event_destroy(stream->stop_event);
os_sem_destroy(stream->send_sem);
pthread_mutex_destroy(&stream->packets_mutex);
circlebuf_free(&stream->packets);
bfree(stream);
}
}
static bool init_connect(struct rtmp_stream *stream)
{
obs_service_t *service;
obs_data_t *settings;
if (stopping(stream))
pthread_join(stream->send_thread, NULL);
free_packets(stream);
service = obs_output_get_service(stream->output);
if (!service)
return false;
os_atomic_set_bool(&stream->disconnected, false);
stream->total_bytes_sent = 0;
stream->dropped_frames = 0;
stream->min_drop_dts_usec= 0;
stream->min_priority = 0;
settings = obs_output_get_settings(stream->output);
dstr_copy(&stream->path, obs_service_get_url(service));
dstr_copy(&stream->key, obs_service_get_key(service));
dstr_copy(&stream->username, obs_service_get_username(service));
dstr_copy(&stream->password, obs_service_get_password(service));
stream->drop_threshold_usec =
(int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD) * 1000;
stream->max_shutdown_time_sec =
(int)obs_data_get_int(settings, OPT_MAX_SHUTDOWN_TIME_SEC);
obs_data_release(settings);
return true;
}
//! Main loop.
void
onMain(void)
{
Counter<double> m_mon_timer(1.0);
while (!stopping())
{
waitForMessages(1.0);
if (m_wdog.overflow())
{
setEntityState(IMC::EntityState::ESTA_ERROR, Status::CODE_COM_ERROR);
throw RestartNeeded(Status::getString(Status::CODE_COM_ERROR), c_restart_delay);
}
else
{
setEntityState(IMC::EntityState::ESTA_NORMAL, Status::CODE_ACTIVE);
}
if (m_mon_timer.overflow())
{
m_mon_timer.reset();
getMonitors();
}
}
}
void
onMain(void)
{
char bfr[32];
while (!stopping())
{
consumeMessages();
if (m_wdog.overflow())
{
setEntityState(IMC::EntityState::ESTA_ERROR, Status::CODE_COM_ERROR);
throw RestartNeeded(DTR(Status::getString(CODE_COM_ERROR)), 5);
}
if (!Poll::poll(*m_uart, 1.0))
continue;
size_t rv = m_uart->readString(bfr, sizeof(bfr));
if (rv == 0)
throw RestartNeeded(DTR("I/O error"), 5);
if (std::sscanf(bfr, "%f", &m_sspeed.value) != 1)
continue;
if ((m_sspeed.value < c_min_speed) || (m_sspeed.value > c_max_speed))
m_sspeed.value = -1;
m_wdog.reset();
dispatch(m_sspeed);
}
}
static void *connect_thread(void *data)
{
struct rtmp_stream *stream = data;
int ret;
os_set_thread_name("rtmp-stream: connect_thread");
if (!init_connect(stream)) {
obs_output_signal_stop(stream->output, OBS_OUTPUT_BAD_PATH);
return NULL;
}
ret = try_connect(stream);
if (ret != OBS_OUTPUT_SUCCESS) {
obs_output_signal_stop(stream->output, ret);
info("Connection to %s failed: %d", stream->path.array, ret);
}
if (!stopping(stream))
pthread_detach(stream->connect_thread);
os_atomic_set_bool(&stream->connecting, false);
return NULL;
}
void
EndSequence::stop()
{
if (!isrunning) return;
isrunning = false;
isdone = true;
stopping();
}
void
BasicUAVAutopilot::onMain(void)
{
while (!stopping())
{
waitForMessages(1.0);
}
}
void
onMain(void)
{
while (!stopping())
{
waitForMessages(1.0);
}
}
void
EventLoop::idle()
{
while (!stopping()) {
MORDOR_LOG_DEBUG(g_log) << m_messageWindow << " Starting new message pump";
schedule(boost::bind(&EventLoop::messagePump, this));
Fiber::yield();
}
}
bool MeasureThreadCounter::runnable()
{
int seconds(m_nSeconds), wait;
if(m_bClientAction)
{
tout << "server wait for some action from any client" << endl;
tout << "and count after that ";
}else
tout << "server count now ";
tout << "between " << getTimeString(seconds, &wait) << "for running folder threads." << endl;
TERMINALEND;
if(m_bClientAction)
{
LOCK(m_CLIENTACTIONMUTEX);
m_bCounting= false;
while(!m_bClientActionDone)
{
CONDITION(m_CLIENTACTIONCOND, m_CLIENTACTIONMUTEX);
if(stopping())
{
m_bCounting= true;
UNLOCK(m_CLIENTACTIONMUTEX);
return false;
}
}
beginCount();
AROUSEALL(m_CLIENTACTIONCOND);
m_bCounting= true;
tout << "wait now for " << getTimeString(seconds, &wait) << endl;
if(m_bClientAction)
{
tout << " activated from " << m_tClient.who << endl;
tout << " to inform " << m_tClient.folder << ":" << m_tClient.subroutine
<< " set with value " << m_tClient.value << endl;
}
UNLOCK(m_CLIENTACTIONMUTEX);
TERMINALEND;
}else
beginCount();
do{
//cout << "sleep for " << wait << " seconds" << endl;
if(SLEEP(wait) != ETIMEDOUT)
{
outputCounting(m_nSeconds - seconds);
return false;
}
seconds-= wait;
if(seconds > 0)
{
tout << "wait for " << getTimeString(seconds, &wait) << endl;
TERMINALEND;
}
}while(seconds > 0);
outputCounting(m_nSeconds);
return false;
}
void
onMain(void)
{
setInitialState();
while (!stopping())
{
if (m_report_timer.overflow())
{
if (m_args.progress)
reportProgress();
dispatch(m_pcs);
m_report_timer.reset();
}
double now = Clock::get();
if ((getEntityState() == IMC::EntityState::ESTA_NORMAL) &&
(now - m_last_vstate >= c_vs_timeout))
{
changeMode(IMC::PlanControlState::PCS_BLOCKED, DTR("vehicle state timeout"));
m_last_vstate = now;
}
// got requests to process
if (!pendingReply() && m_requests.size())
{
processRequest(&m_requests.front());
m_requests.pop();
}
double delta = m_vc_reply_deadline < 0 ? 1 : m_vc_reply_deadline - now;
if (delta > 0)
{
waitForMessages(std::min(1.0, delta));
continue;
}
// handle reply timeout
m_vc_reply_deadline = -1;
changeMode(IMC::PlanControlState::PCS_READY, DTR("vehicle reply timeout"));
// Popping all requests
while (m_requests.size())
m_requests.pop();
// Increment local request id to prevent old replies from being processed
++m_vreq_ctr;
err(DTR("cleared all requests"));
}
}
void eStreamThread::stop() {
if(!stopping())
{
m_stop = true;
::ioctl(m_destfd, 0);
kill();
}
else
eDebug("eStreamThread::stop: thread already stopping, ignoring kill request!");
}
void obs_output_force_stop(obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_force_stop"))
return;
if (!stopping(output)) {
output->stop_code = 0;
do_output_signal(output, "stopping");
obs_output_actual_stop(output, true, 0);
}
}
void
onMain(void)
{
while (!stopping())
{
waitForMessages(1.0);
// Check if we receive valid GPS data.
if (m_time_without_gps.overflow())
setEntityState(IMC::EntityState::ESTA_ERROR, Status::CODE_WAIT_GPS_FIX);
}
}
Window::~Window() {
stopping();
SDL_HideWindow(_window);
SDL_GL_DeleteContext(_context);
SDL_DestroyWindow(_window);
SDL_QuitSubSystem(SDL_INIT_VIDEO);
}
void
ServerImpl::stop (bool wait)
{
if (! stopping())
{
m_work = boost::none;
update();
}
if (wait)
m_stopped.wait();
}
static bool init_connect(struct rtmp_stream *stream)
{
obs_service_t *service;
obs_data_t *settings;
const char *bind_ip;
int64_t drop_p;
int64_t drop_b;
if (stopping(stream)) {
pthread_join(stream->send_thread, NULL);
}
free_packets(stream);
service = obs_output_get_service(stream->output);
if (!service)
return false;
os_atomic_set_bool(&stream->disconnected, false);
stream->total_bytes_sent = 0;
stream->dropped_frames = 0;
stream->min_priority = 0;
settings = obs_output_get_settings(stream->output);
dstr_copy(&stream->path, obs_service_get_url(service));
dstr_copy(&stream->key, obs_service_get_key(service));
dstr_copy(&stream->username, obs_service_get_username(service));
dstr_copy(&stream->password, obs_service_get_password(service));
dstr_depad(&stream->path);
dstr_depad(&stream->key);
drop_b = (int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD);
drop_p = (int64_t)obs_data_get_int(settings, OPT_PFRAME_DROP_THRESHOLD);
stream->max_shutdown_time_sec =
(int)obs_data_get_int(settings, OPT_MAX_SHUTDOWN_TIME_SEC);
if (drop_p < (drop_b + 200))
drop_p = drop_b + 200;
stream->drop_threshold_usec = 1000 * drop_b;
stream->pframe_drop_threshold_usec = 1000 * drop_p;
bind_ip = obs_data_get_string(settings, OPT_BIND_IP);
dstr_copy(&stream->bind_ip, bind_ip);
stream->new_socket_loop = obs_data_get_bool(settings,
OPT_NEWSOCKETLOOP_ENABLED);
stream->low_latency_mode = obs_data_get_bool(settings,
OPT_LOWLATENCY_ENABLED);
obs_data_release(settings);
return true;
}
void
Maneuver::onMain(void)
{
dispatch(m_rm);
while (!stopping())
{
if (isActive())
onStateReport();
waitForMessages(1.0);
}
}
void
Daemon::onMain(void)
{
while (!stopping())
{
waitForMessages(1.0);
if (m_periodic_counter.overflow())
{
m_periodic_counter.reset();
dispatchPeriodic();
}
}
}
void BaseADCDebugLogger::stop()
{
std::lock_guard<std::mutex> lock(_mutex);
_triggerState = false;
_preSamplesCount = 0;
_postSamplesCount = 0;
if (_workState == SavingState)
return;
_workState = NotWorkingState;
stopping();
}
int ThreadedAudioDevice::startThread()
{
stopping(false); // Reset.
if (isPassive()) // Nothing else to do here if passive mode.
return 0;
starting(true);
#ifdef PROFILE
getitimer(ITIMER_PROF, &globalTimerVal);
#endif
PRINT1("\tThreadedAudioDevice::startThread: starting thread\n");
int status = pthread_create(&_thread, NULL, _runProcess, this);
if (status < 0) {
error("Failed to create thread");
}
return status;
}
void
onMain(void)
{
while (!stopping())
{
if (!isInitialized() || !isActive())
{
waitForMessages(1.0);
continue;
}
if (!m_ping_time.overflow())
{
waitForMessages(m_args.ping_delay);
continue;
}
double tstamp = Time::Clock::getSinceEpoch();
for (m_beacon = m_beacons.begin(); m_beacon < m_beacons.end(); ++m_beacon)
{
// Compute error.
double error = 0;
if (m_args.bad_range_prob > 0 && m_prng->random() % 100 <= m_args.bad_range_prob)
error = c_huge_error;
else if (m_args.sigma > 0)
error = m_prng->gaussian() * m_args.sigma;
//! Compute range.
double xd = m_sstate.x - m_beacon->x;
double yd = m_sstate.y - m_beacon->y;
double zd = m_sstate.z - m_beacon->depth;
IMC::LblRange range;
range.setTimeStamp(tstamp);
range.id = m_beacon->id;
range.range = std::sqrt(xd * xd + yd * yd + zd * zd);
range.range += error;
dispatch(range, DF_KEEP_TIME);
trace("beacon %u, range of %0.2f m, simulated error of %0.2f m",
range.id, range.range, error);
}
// Setup next ping.
m_ping_time.reset();
}
}
static void rtmp_stream_destroy(void *data)
{
struct rtmp_stream *stream = data;
if (stopping(stream) && !connecting(stream)) {
pthread_join(stream->send_thread, NULL);
} else if (connecting(stream) || active(stream)) {
if (stream->connecting)
pthread_join(stream->connect_thread, NULL);
stream->stop_ts = 0;
os_event_signal(stream->stop_event);
if (active(stream)) {
os_sem_post(stream->send_sem);
obs_output_end_data_capture(stream->output);
pthread_join(stream->send_thread, NULL);
}
}
free_packets(stream);
dstr_free(&stream->path);
dstr_free(&stream->key);
dstr_free(&stream->username);
dstr_free(&stream->password);
dstr_free(&stream->encoder_name);
dstr_free(&stream->bind_ip);
os_event_destroy(stream->stop_event);
os_sem_destroy(stream->send_sem);
pthread_mutex_destroy(&stream->packets_mutex);
circlebuf_free(&stream->packets);
#ifdef TEST_FRAMEDROPS
circlebuf_free(&stream->droptest_info);
#endif
os_event_destroy(stream->buffer_space_available_event);
os_event_destroy(stream->buffer_has_data_event);
os_event_destroy(stream->socket_available_event);
os_event_destroy(stream->send_thread_signaled_exit);
pthread_mutex_destroy(&stream->write_buf_mutex);
if (stream->write_buf)
bfree(stream->write_buf);
bfree(stream);
}
static void rtmp_stream_stop(void *data)
{
struct rtmp_stream *stream = data;
if (stopping(stream))
return;
if (connecting(stream))
pthread_join(stream->connect_thread, NULL);
os_event_signal(stream->stop_event);
if (active(stream)) {
os_sem_post(stream->send_sem);
obs_output_end_data_capture(stream->output);
}
}
