void speech_processor::process(sample_ptr samples,std::size_t count)
{
sample_ptr start=samples;
sample_ptr end=start+count;
while(fill_input_buffer(start,end))
{
on_input();
input.clear();
if(is_stopped())
return;
on_output();
if(is_stopped())
return;
if(!next)
continue;
if(!insertion.empty())
{
next->insert(&insertion[0],insertion.size());
insertion.clear();
if(is_stopped())
{
output.clear();
return;
}
}
if(output.empty())
continue;
next->process(&output[0],output.size());
output.clear();
if(is_stopped())
return;
}
}
virtual uint32_t main(void)
{
bool eof_flag = false, abort_flag = false;
while(!(eof_flag || (abort_flag = is_stopped())))
{
size_t bytes_read = 0;
if(!m_client->read_data(m_buffer, BUFF_SIZE, bytes_read, eof_flag))
{
set_error_text(m_client->get_error_text());
return TRANSFER_ERR_INET;
}
if(bytes_read > 0)
{
m_transferred_bytes.add(bytes_read);
if(!(abort_flag = is_stopped()))
{
if(!m_sink->write(m_buffer, bytes_read))
{
return TRANSFER_ERR_SINK;
}
}
}
}
return abort_flag ? TRANSFER_ERR_ABRT : TRANSFER_COMPLETE;
}
struct kinfo_proc2 *
cmp_procs(struct kinfo_proc2 *p1, struct kinfo_proc2 *p2)
{
if (is_runnable(p1) && !is_runnable(p2))
return (p1);
if (!is_runnable(p1) && is_runnable(p2))
return (p2);
if (is_stopped(p1) && !is_stopped(p2))
return (p1);
if (!is_stopped(p1) && is_stopped(p2))
return (p2);
if (p1->p_estcpu > p2->p_estcpu)
return (p1);
if (p1->p_estcpu < p2->p_estcpu)
return (p2);
if (p1->p_slptime < p2->p_slptime)
return (p1);
if (p1->p_slptime > p2->p_slptime)
return (p2);
if (p1->p_pid > p2->p_pid)
return (p1);
return (p2);
}
static void
mi_cmd_var_update_iter (struct varobj *var, void *data_pointer)
{
struct mi_cmd_var_update *data = data_pointer;
int thread_id, thread_stopped;
thread_id = varobj_get_thread_id (var);
if (thread_id == -1
&& (ptid_equal (inferior_ptid, null_ptid)
|| is_stopped (inferior_ptid)))
thread_stopped = 1;
else
{
struct thread_info *tp = find_thread_id (thread_id);
if (tp)
thread_stopped = is_stopped (tp->ptid);
else
thread_stopped = 1;
}
if (thread_stopped
&& (!data->only_floating || varobj_floating_p (var)))
varobj_update_one (var, data->print_values, 0 /* implicit */);
}
struct kinfo_proc *
cmp_procs(struct kinfo_proc *p1, struct kinfo_proc *p2)
{
if (is_runnable(p1) && !is_runnable(p2))
return (p1);
if (!is_runnable(p1) && is_runnable(p2))
return (p2);
if (is_stopped(p1) && !is_stopped(p2))
return (p1);
if (!is_stopped(p1) && is_stopped(p2))
return (p2);
if (p1->ki_estcpu > p2->ki_estcpu)
return (p1);
if (p1->ki_estcpu < p2->ki_estcpu)
return (p2);
if (p1->ki_slptime < p2->ki_slptime)
return (p1);
if (p1->ki_slptime > p2->ki_slptime)
return (p2);
if (strcmp(p1->ki_comm, p2->ki_comm) < 0)
return (p1);
if (strcmp(p1->ki_comm, p2->ki_comm) > 0)
return (p2);
if (p1->ki_pid > p2->ki_pid)
return (p1);
return (p2);
}
/**
* Main loop of the DrawThread
*/
void
DrawThread::run()
{
set_low_priority();
// bounds_dirty maintains the status of whether the map
// bounds have changed and there are pending idle calls
// to be run in the map.
// wait until the startup is finished
running.wait();
// Get data from the DeviceBlackboard
map.ExchangeBlackboard();
bool bounds_dirty = true;
// circle until application is closed
while (true) {
if (!bounds_dirty)
trigger.wait();
if (!bounds_dirty || trigger.wait(MIN_WAIT_TIME)) {
// take control (or wait for the resume())
running.wait();
/* got the "stop" trigger? */
if (is_stopped())
break;
trigger.reset();
// Get data from the DeviceBlackboard
map.ExchangeBlackboard();
// Draw the moving map
map.repaint();
if (trigger.test()) {
// interrupt re-calculation of bounds if there was a
// request made. Since we will re-enter, we know the remainder
// of this code will be called anyway.
continue;
}
bounds_dirty = map.Idle();
} else if (bounds_dirty) {
// take control (or wait for the resume())
running.wait();
/* got the "stop" trigger? */
if (is_stopped())
break;
bounds_dirty = map.Idle();
}
}
}
void AmRtpReceiverThread::stop_and_wait()
{
if(!is_stopped()) {
stop();
while(!is_stopped())
usleep(10000);
}
}
static void *consumer_thread( void *arg )
{
mlt_consumer consumer = arg;
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
mlt_frame frame = NULL;
// Determine whether to stop at end-of-media
int terminate_on_pause = mlt_properties_get_int( properties, "terminate_on_pause" );
int terminated = 0;
// Loop while running
while ( !terminated && !is_stopped( consumer ) )
{
// Get the next frame
frame = mlt_consumer_rt_frame( consumer );
// Check for termination
if ( terminate_on_pause && frame )
terminated = mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame ), "_speed" ) == 0.0;
// Check that we have a frame to work with
if ( frame && !terminated && !is_stopped( consumer ) )
{
if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES(frame), "rendered" ) )
{
if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES(frame), "_speed" ) == 0 )
foreach_consumer_refresh( consumer );
foreach_consumer_put( consumer, frame );
}
else
{
int dropped = mlt_properties_get_int( properties, "_dropped" );
mlt_log_info( MLT_CONSUMER_SERVICE(consumer), "dropped frame %d\n", ++dropped );
mlt_properties_set_int( properties, "_dropped", dropped );
}
mlt_frame_close( frame );
}
else
{
if ( frame && terminated )
{
// Send this termination frame to nested consumers for their cancellation
foreach_consumer_put( consumer, frame );
}
if ( frame )
mlt_frame_close( frame );
terminated = 1;
}
}
// Indicate that the consumer is stopped
mlt_consumer_stopped( consumer );
return NULL;
}
void CAnimationThread::calculate_frame(bool zoom)
{
current_thread = dialog->NewCalculationThread();
current_thread->start();
current_thread->wait();
if( !is_stopped() )
dialog->PostReadAndWait();
delete current_thread;
current_thread = NULL;
if( !is_stopped() )
dialog->PostUpdateDataAndWait();
if( !is_stopped() && zoom )
dialog->PostZoomAndWait(zoom_in);
}
/**
* @brief Makes the movement restart after a delay when it is finished.
* @param delay the movement will restart after this delay in milliseconds (0 to avoid this)
*/
void CircleMovement::set_loop(uint32_t delay) {
this->loop_delay = delay;
if (delay != 0 && is_stopped()) {
this->restart_date = System::now() + delay;
}
}
std::uint32_t Timer::get_ticks() {
if (is_stopped()) {
return _ticks - _start_ticks;
}
return SDL_GetTicks() - _start_ticks;
}
void Timer::stop() noexcept
{
if (is_stopped())
return;
stop_point = clock::now();
stopped = true;
}
bool CPUThread::check_status()
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
while (true)
{
CHECK_EMU_STATUS; // check at least once
if (!is_paused()) break;
if (!lock)
{
lock.lock();
continue;
}
cv.wait(lock);
}
if (m_state.load() & CPU_STATE_RETURN || is_stopped())
{
return true;
}
if (m_state.load() & CPU_STATE_STEP)
{
// set PAUSE, but allow to execute once
m_state |= CPU_STATE_PAUSED;
m_state &= ~CPU_STATE_STEP;
}
return false;
}
CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<std::string()> thread_name)
: m_id(idm::get_last_id())
, m_type(type)
, m_name(name)
{
start(std::move(thread_name), [this]
{
g_tls_current_cpu_thread = this;
Emu.SendDbgCommand(DID_CREATE_THREAD, this);
std::unique_lock<std::mutex> lock(mutex);
// check thread status
while (joinable() && is_alive())
{
CHECK_EMU_STATUS;
// check stop status
if (!is_stopped())
{
if (lock) lock.unlock();
try
{
task();
}
catch (CPUThreadReturn)
{
;
}
catch (CPUThreadStop)
{
m_state |= CPU_STATE_STOPPED;
}
catch (CPUThreadExit)
{
m_state |= CPU_STATE_DEAD;
break;
}
catch (...)
{
dump_info();
throw;
}
m_state &= ~CPU_STATE_RETURN;
continue;
}
if (!lock)
{
lock.lock();
continue;
}
cv.wait(lock);
}
});
}
static int start( mlt_consumer consumer )
{
// Check that we're not already running
if ( is_stopped( consumer ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
pthread_t *thread = calloc( 1, sizeof( pthread_t ) );
// Assign the thread to properties with automatic dealloc
mlt_properties_set_data( properties, "thread", thread, sizeof( pthread_t ), free, NULL );
// Set the running state
mlt_properties_set_int( properties, "running", 1 );
mlt_properties_set_int( properties, "joined", 0 );
// Construct and start nested consumers
if ( !mlt_properties_get_data( properties, "0.consumer", NULL ) )
foreach_consumer_init( consumer );
foreach_consumer_start( consumer );
// Create the thread
pthread_create( thread, NULL, consumer_thread, consumer );
}
return 0;
}
long worker_thread::execute(void *arg)
{
#ifdef DEBUG_PRINTS
cout << "worker_thread::execute = " + get_name() << endl;
#endif
// Make GCC happy (-Wextra)
if (arg) {
return THREAD_INTERNAL_ERROR;
}
// Get pointer to thread's data
volatile WORKER_DATA *data =
(WORKER_DATA *) (m_data_base_addr + (m_work_id) * sizeof(WORKER_DATA));
*data = 0;
// Produce data
while ( !is_stopped() ) {
*data += 1;
update_exe_cnt();
sleep(1);
}
return THREAD_SUCCESS;
}
struct proc *
cmp_procs(struct proc *p1, struct proc *p2)
{
void *ptr1, *ptr2;
if (is_runnable(p1) && !is_runnable(p2))
return (p1);
if (!is_runnable(p1) && is_runnable(p2))
return (p2);
if (is_stopped(p1) && !is_stopped(p2))
return (p1);
if (!is_stopped(p1) && is_stopped(p2))
return (p2);
if (p1->p_estcpu > p2->p_estcpu)
return (p1);
if (p1->p_estcpu < p2->p_estcpu)
return (p2);
if (p1->p_slptime < p2->p_slptime)
return (p1);
if (p1->p_slptime > p2->p_slptime)
return (p2);
if ((p1->p_flag & P_SINTR) && !(p2->p_flag & P_SINTR))
return (p1);
if (!(p1->p_flag & P_SINTR) && (p2->p_flag & P_SINTR))
return (p2);
ptr1 = LIST_FIRST(&p1->p_children);
ptr2 = LIST_FIRST(&p2->p_children);
if (ptr1 == NULL && ptr2 != NULL)
return (p1);
if (ptr1 != NULL && ptr2 == NULL)
return (p2);
if (strcmp(p1->p_comm, p2->p_comm) < 0)
return (p1);
if (strcmp(p1->p_comm, p2->p_comm) > 0)
return (p2);
if (p1->p_pid > p2->p_pid)
return (p1);
return (p2);
}
LatencyCounter& check_and_stop()
{
if (!is_stopped()) {
return stop();
}
return *this;
}
/**
* \brief This function is called when a switch detects a collision with this entity.
* \param sw the switch
* \param collision_mode the collision mode that detected the event
*/
void Arrow::notify_collision_with_switch(Switch& sw, CollisionMode collision_mode) {
if (sw.is_arrow_target() && is_stopped()) {
sw.try_activate(*this);
}
else if (sw.is_solid() && is_flying()) {
sw.try_activate();
attach_to(sw);
}
}
virtual uint32_t main(void)
{
if(!m_client->open(m_verb, m_url, m_post_data, m_referrer, m_timestamp))
{
set_error_text(m_client->get_error_text());
return CONNECTION_ERR_INET;
}
return is_stopped() ? CONNECTION_ERR_ABRT : CONNECTION_COMPLETE;
}
duration elapsed(void)
{
if (is_stopped())
return duration::zero();
else
if (is_paused<N>())
return (points_[N].second - points_[N].first);
else
return ClockT::now() - points_[N].first;
}
void COutputHandleTask::exec()
{
while(!is_stopped())
{
///
if (m_pIoEvtNotifier->exec() < 0)
{
break;
}
}
}
/**
* @brief Changes the direction of the movement vector, keeping the same speed.
*
* x_speed and y_speed are recomputed so that the total speed is unchanged.
* Warning: if x_speed and y_speed are both equal to zero, this function
* stops the program on an error message.
*
* @param angle the new movement direction in radians
*/
void StraightMovement::set_angle(double angle) {
if (!is_stopped()) {
double speed = get_speed();
set_x_speed(speed * std::cos(angle));
set_y_speed(-speed * std::sin(angle));
}
this->angle = angle;
notify_movement_changed();
}
void DialerThread::run() {
sleep(15); // wait for sems to completely start up
while (!is_stopped()) {
DBG("dialing...");
AmUAC::dialout("blibla", "announce_auth",
r_uri, from, from_uri, to);
// every 10 minutes
sleep(100);
}
}
void CInputHandleTask::exec()
{
CMN_ASSERT(NULL != m_pIoEvtNotifier);
///main logic circle
while (!is_stopped())
{
///
if (m_pIoEvtNotifier->exec() < 0)
{
break;
}
}
}
struct kinfo_proc2 *
cmp_procs(struct kinfo_proc2 *p1, struct kinfo_proc2 *p2)
{
if (is_runnable(p1) && !is_runnable(p2))
return (p1);
if (!is_runnable(p1) && is_runnable(p2))
return (p2);
if (is_stopped(p1) && !is_stopped(p2))
return (p1);
if (!is_stopped(p1) && is_stopped(p2))
return (p2);
if (p1->p_estcpu > p2->p_estcpu)
return (p1);
if (p1->p_estcpu < p2->p_estcpu)
return (p2);
if (p1->p_slptime < p2->p_slptime)
return (p1);
if (p1->p_slptime > p2->p_slptime)
return (p2);
if ((p1->p_flag & P_SINTR) && !(p2->p_flag & P_SINTR))
return (p1);
if (!(p1->p_flag & P_SINTR) && (p2->p_flag & P_SINTR))
return (p2);
if (strcmp(p1->p_comm, p2->p_comm) < 0)
return (p1);
if (strcmp(p1->p_comm, p2->p_comm) > 0)
return (p2);
if (p1->p_pid > p2->p_pid)
return (p1);
return (p2);
}
/**
* \brief Starts the next 8-pixel trajectory of the path movement.
*
* This function is called when an 8-pixel trajectory of the movement is finished,
* or when the movement is restarted.
* Before starting the 8-pixel move, if the property must_be_aligned is true,
* the entity's top-left corner tries to get aligned with the 8*8 squares of the grid.
*/
void PathMovement::start_next_elementary_move() {
Entity* entity = get_entity();
// don't move while the entity is unknown
if (entity == nullptr) {
return;
}
// before starting the move, check that the entity is aligned with the 8*8 squares grid if necessary
if (snap_to_grid && !entity->is_aligned_to_grid()) {
// the entity has to be aligned but is not
snap();
}
// start the next step if we are ready
if (!snap_to_grid || entity->is_aligned_to_grid()) {
snapping = false;
if (remaining_path.empty()) {
// the path is finished
if (loop) {
// if the property 'loop' is true, repeat the same path again
remaining_path = initial_path;
}
else if (!is_stopped()) {
// the movement is finished: stop the entity
stop();
}
}
if (!remaining_path.empty()) {
// normal case: there is a next trajectory to do
current_direction = remaining_path[0] - '0';
Debug::check_assertion(current_direction >= 0 && current_direction < 8,
std::string("Invalid path '") + initial_path + "' (bad direction '"
+ remaining_path[0] + "')"
);
PixelMovement::set_delay(speed_to_delay(speed, current_direction));
PixelMovement::set_trajectory(elementary_moves[current_direction]);
remaining_path = remaining_path.substr(1);
}
}
}
clock_t elapsed(void)
{
if (is_stopped()) return 0;
else
if (is_paused()) return pause_elap_;
else
{
clock_t now = ModelT::clock();
if (start_time_ > now)
{
stop();
return 0;
}
return now - start_time_;
}
}
void
WorkerThread::run()
{
while (true) {
/* wait for work */
event_trigger.wait();
/* paused? */
running.wait();
/* got the "stop" trigger? */
if (is_stopped())
break;
/* do the actual work */
tick();
}
}
long cyclic_thread::execute(void *arg)
{
const float delay_interval = 1.0 / m_frequency;
struct timespec t1;
struct timespec t2;
// Make GCC happy (-Wextra)
if (arg) {
return THREAD_INTERNAL_ERROR;
}
// Prepare first run
if ( clock_gettime(get_clock_id(), &t1) ) {
return THREAD_TIME_ERROR;
}
if ( get_new_time(&t1, delay_interval, &t2) != DELAY_SUCCESS ) {
return THREAD_TIME_ERROR;
}
if ( delay_until(&t2) != DELAY_SUCCESS) {
return THREAD_TIME_ERROR;
}
while ( !is_stopped() ) {
// Do cyclic work
if ( cyclic_execute() != THREAD_SUCCESS ) {
return THREAD_INTERNAL_ERROR;
}
// Calculate next interval
if ( get_new_time(&t2, delay_interval, &t2) != DELAY_SUCCESS ) {
return THREAD_TIME_ERROR;
}
if ( delay_until(&t2) != DELAY_SUCCESS) {
return THREAD_TIME_ERROR;
}
update_exe_cnt();
}
return THREAD_SUCCESS;
}
