**
** \legal
** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+** Copyright (c) 2007 Chris Moore
**
** This package is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License as
#include <synfig/general.h>
#include <ETL/clock>
+#include "general.h"
+
#endif
/* === U S I N G =========================================================== */
}
};
std::list<tile_t> tile_queue;
-#ifndef SINGLE_THREADED
Glib::Mutex mutex;
-#endif // SINGLE_THREADED
#ifndef GLIB_DISPATCHER_BROKEN
Glib::Dispatcher tile_ready_signal;
}
void set_dead()
{
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
alive_flag=false;
}
assert(surface);
if(!alive_flag)
return false;
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
tile_queue.push_back(tile_t(surface,gx,gy));
if(tile_queue.size()==1)
{
void tile_ready()
{
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
if(!alive_flag)
{
tile_queue.clear();
{
tile_t& tile(tile_queue.front());
+ if (getenv("SYNFIG_SHOW_TILE_OUTLINES"))
+ {
+ Color red(1,0,0);
+ tile.surface.fill(red, 0, 0, 1, tile.surface.get_h());
+ tile.surface.fill(red, 0, 0, tile.surface.get_w(), 1);
+ }
+
alive_flag=warm_target->add_tile(tile.surface,tile.x,tile.y);
tile_queue.pop_front();
virtual void end_frame()
{
-#ifndef SINGLE_THREADED
- while(alive_flag)
+ if (!single_threaded())
{
- Glib::Mutex::Lock lock(mutex);
- if(!tile_queue.empty() && alive_flag)
+ while(alive_flag)
{
- if(cond_tile_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
+ Glib::Mutex::Lock lock(mutex);
+ if(!tile_queue.empty() && alive_flag)
+ {
+ if(cond_tile_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
+ break;
+ }
+ else
break;
}
- else
- break;
}
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
if(!alive_flag)
return;
return warm_target->end_frame();
int scanline_;
Surface surface;
-#ifndef SINGLE_THREADED
Glib::Mutex mutex;
-#endif // SINGLE_THREADED
#ifndef GLIB_DISPATCHER_BROKEN
Glib::Dispatcher frame_ready_signal;
void set_dead()
{
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
alive_flag=false;
}
virtual void end_frame()
{
{
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
if(!alive_flag)
return;
#else
frame_ready_signal();
#endif
- }
-
-#ifndef SINGLE_THREADED
- while(alive_flag && !ready_next)
- {
- Glib::Mutex::Lock lock(mutex);
- if(cond_frame_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
- break;
}
-#endif // SINGLE_THREADED
+
+ if (single_threaded())
+ signal_progress()();
+ else
+ while(alive_flag && !ready_next)
+ {
+ Glib::Mutex::Lock lock(mutex);
+ if(cond_frame_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
+ break;
+ }
}
virtual Color * start_scanline(int scanline)
{
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
return surface[scanline];
}
void frame_ready()
{
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
if(alive_flag)
alive_flag=warm_target->add_frame(&surface);
- cond_frame_queue_empty.signal();
+ if (!single_threaded()) cond_frame_queue_empty.signal();
ready_next=true;
}
};
AsyncRenderer::AsyncRenderer(etl::handle<synfig::Target> target_,synfig::ProgressCallback *cb):
error(false),
success(false),
- cb(cb)
-#ifdef SINGLE_THREADED
- , updating(false)
-#endif // SINGLE_THREADED
+ cb(cb),
+ updating(false)
{
render_thread=0;
if(etl::handle<synfig::Target_Tile>::cast_dynamic(target_))
{
if(target)
{
-#ifndef SINGLE_THREADED
Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
done_connection.disconnect();
if(render_thread)
{
signal_stop_();
-#ifndef SINGLE_THREADED
#if REJOIN_ON_STOP
- render_thread->join();
-#endif
+ if (!single_threaded()) render_thread->join();
#endif
// Make sure all the dispatch crap is cleared out
);
}
-#ifdef SINGLE_THREADED
void
AsyncRenderer::rendering_progress()
{
while(studio::App::events_pending()) studio::App::iteration(false);
updating = false;
}
-#endif // SINGLE_THREADED
void
AsyncRenderer::start_()
done_connection=signal_done_.connect(mem_fun(*this,&AsyncRenderer::stop));
#endif
-#ifdef SINGLE_THREADED
- synfig::info("%s:%d rendering in the same thread", __FILE__, __LINE__);
- target->signal_progress().connect(sigc::mem_fun(this,&AsyncRenderer::rendering_progress));
- render_thread = (Glib::Thread*)1;
- render_target();
-#else // SINGLE_THREADED
- render_thread=Glib::Thread::create(
- sigc::mem_fun(*this,&AsyncRenderer::render_target),
+ if (single_threaded())
+ {
+ synfig::info("%s:%d rendering in the same thread", __FILE__, __LINE__);
+ target->signal_progress().connect(sigc::mem_fun(this,&AsyncRenderer::rendering_progress));
+ render_thread = (Glib::Thread*)1;
+ render_target();
+ }
+ else
+ {
+ render_thread=Glib::Thread::create(
+ sigc::mem_fun(*this,&AsyncRenderer::render_target),
#if REJOIN_ON_STOP
- true
+ true
#else
- false
+ false
#endif
- );
- assert(render_thread);
-#endif // SINGLE_THREADED
+ );
+ assert(render_thread);
+ }
}
else
{
#endif
}
-#ifndef SINGLE_THREADED
if(mutex.trylock())
-#endif // SINGLE_THREADED
{
#ifdef GLIB_DISPATCHER_BROKEN
done_connection=Glib::signal_timeout().connect(
#else
signal_done_.emit();
#endif
-#ifndef SINGLE_THREADED
mutex.unlock();
-#endif // SINGLE_THREADED
}
}