src/timemanager.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Contact:
   4  *   Moonlight List (moonlight-list@lists.ximian.com)
   5  *
   6  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   7  *
   8  * See the LICENSE file included with the distribution for details.
   9  *
  10  */
  11
  12 #include <config.h>
  13
  14 #include "clock.h"
  15 #include "timeline.h"
  16 #include "timemanager.h"
  17 #include "timesource.h"
  18 #include "runtime.h"
  19
  20 #define TIMERS 0
  21 #define PUT_TIME_MANAGER_TO_SLEEP 0
  22
  23 #if TIMERS
  24 #define STARTTICKTIMER(id,str) STARTTIMER(id,str)
  25 #define ENDTICKTIMER(id,str) ENDTIMER(it,str)
  26 #else
  27 #define STARTTICKTIMER(id,str)
  28 #define ENDTICKTIMER(id,str)
  29 #endif
  30
  31
  32 #define MINIMUM_FPS 5
  33 #define DEFAULT_FPS 50
  34 #define MAXIMUM_FPS 50
  35
  36 #define FPS_TO_DELAY(fps) (int)(((double)1/(fps)) * 1000)
  37 #define DELAY_TO_FPS(delay) (1000.0 / delay)
  38
  39 class TickCall : public List::Node {
  40  public:
  41         TickCallHandler func;
  42         EventObject *data;
  43         TickCall (TickCallHandler func, EventObject *data)
  44         {
  45                 this->func = func;
  46                 this->data = data;
  47                 if (this->data)
  48                         this->data->ref ();
  49         }
  50         virtual ~TickCall ()
  51         {
  52                 if (data)
  53                         data->unref ();
  54         }
  55 };
  56
  57
  58 class RootClockGroup : public ClockGroup
  59 {
  60 public:
  61         RootClockGroup (TimelineGroup *timeline) : ClockGroup (timeline, true) { }
  62
  63         virtual bool UpdateFromParentTime (TimeSpan parentTime)
  64         {
  65                 bool rv = ClockGroup::UpdateFromParentTime (parentTime);
  66
  67                 bool children_rv = false;
  68                 for (GList *l = child_clocks; l; l = l->next) {
  69                         Clock *clock = (Clock*)l->data;
  70                         children_rv = clock->UpdateFromParentTime (current_time) || children_rv;
  71                 }
  72
  73                 return rv && children_rv;
  74         }
  75
  76 protected:
  77         virtual ~RootClockGroup () { }
  78 };
  79
  80 TimeManager::TimeManager ()
  81 {
  82         SetObjectType (Type::TIMEMANAGER);
  83
  84         if (moonlight_flags & RUNTIME_INIT_MANUAL_TIMESOURCE)
  85                 source = new ManualTimeSource();
  86         else
  87                 source = new SystemTimeSource(Deployment::GetCurrent ());
  88
  89         current_timeout = FPS_TO_DELAY (DEFAULT_FPS);  /* something suitably small */
  90         max_fps = MAXIMUM_FPS;
  91         flags = (TimeManagerOp) (TIME_MANAGER_UPDATE_CLOCKS | TIME_MANAGER_RENDER | TIME_MANAGER_TICK_CALL /*| TIME_MANAGER_UPDATE_INPUT*/);
  92
  93         start_time = source->GetNow ();
  94         start_time_usec = start_time / 10;
  95         source->AddHandler (TimeSource::TickEvent, source_tick_callback, this);
  96
  97         registered_timeouts = NULL;
  98         source_tick_pending = false;
  99         first_tick = true;
 100
 101         applier = new Applier ();
 102
 103         timeline = new ParallelTimeline();
 104         timeline->SetDuration (Duration::Forever);
 105         root_clock = new RootClockGroup (timeline);
 106         char *name = g_strdup_printf ("Surface clock group for time manager (%p)", this);
 107         root_clock->SetValue(DependencyObject::NameProperty, name);
 108         g_free (name);
 109         root_clock->SetTimeManager (this);
 110 }
 111
 112 TimeManager::~TimeManager ()
 113 {
 114         source->RemoveHandler (TimeSource::TickEvent, source_tick_callback, this);
 115         source->unref ();
 116         source = NULL;
 117
 118         timeline->unref ();
 119         timeline = NULL;
 120
 121         root_clock->unref ();
 122         root_clock = NULL;
 123
 124         delete applier;
 125
 126         RemoveAllRegisteredTimeouts ();
 127 }
 128
 129 void
 130 TimeManager::SetMaximumRefreshRate (int hz)
 131 {
 132         if (hz == 0)
 133                 hz = 1;
 134
 135         max_fps = hz;
 136         current_timeout = FPS_TO_DELAY (hz);
 137         source->SetTimerFrequency (current_timeout);
 138         first_tick = true;
 139 }
 140
 141 void
 142 TimeManager::Start()
 143 {
 144         last_global_time = current_global_time = source->GetNow();
 145         current_global_time_usec = current_global_time / 10;
 146         source->SetTimerFrequency (current_timeout);
 147         source->Start ();
 148         source_tick_pending = true;
 149 }
 150
 151 void
 152 TimeManager::Stop ()
 153 {
 154         source->Stop ();
 155 }
 156
 157 void
 158 TimeManager::Shutdown ()
 159 {
 160         RemoveAllRegisteredTimeouts ();
 161         source->Stop ();
 162 }
 163
 164 void
 165 TimeManager::source_tick_callback (EventObject *sender, EventArgs *calldata, gpointer closure)
 166 {
 167         ((TimeManager *) closure)->SourceTick ();
 168 }
 169
 170 bool
 171 TimeManager::InvokeTickCall ()
 172 {
 173         TickCall *call = (TickCall *) tick_calls.Pop ();
 174
 175         if (call == NULL)
 176                 return false;
 177
 178         call->func (call->data);
 179         delete call;
 180
 181         return true;
 182 }
 183
 184 guint
 185 TimeManager::AddTimeout (gint priority, guint ms_interval, GSourceFunc func, gpointer tick_data)
 186 {
 187         guint rv = g_timeout_add_full (priority, ms_interval, func, tick_data, NULL);
 188         registered_timeouts = g_list_prepend (registered_timeouts, GUINT_TO_POINTER (rv));
 189         return rv;
 190 }
 191
 192 void
 193 TimeManager::RemoveTimeout (guint timeout_id)
 194 {
 195         g_source_remove (timeout_id);
 196         registered_timeouts = g_list_remove_all (registered_timeouts, GUINT_TO_POINTER (timeout_id));
 197 }
 198
 199 void
 200 TimeManager::RemoveAllRegisteredTimeouts ()
 201 {
 202         GList *t;
 203         for (t = registered_timeouts; t; t = t->next)
 204                 g_source_remove (GPOINTER_TO_UINT (t->data));
 205
 206         g_list_free (registered_timeouts);
 207         registered_timeouts = NULL;
 208 }
 209
 210 void
 211 TimeManager::AddTickCall (TickCallHandler func, EventObject *tick_data)
 212 {
 213         tick_calls.Push (new TickCall (func, tick_data));
 214
 215 #if PUT_TIME_MANAGER_TO_SLEEP
 216         flags = (TimeManagerOp)(flags | TIME_MANAGER_TICK_CALL);
 217         if (!source_tick_pending) {
 218                 source_tick_pending = true;
 219                 source->SetTimerFrequency (current_timeout);
 220                 source->Start();
 221         }
 222 #endif
 223 }
 224
 225 void
 226 TimeManager::RemoveTickCall (TickCallHandler func)
 227 {
 228         tick_calls.Lock ();
 229         List::Node * call = tick_calls.LinkedList ()->Find (find_tick_call, (void*)func);
 230         if (call)
 231                 tick_calls.LinkedList ()->Remove (call);
 232 #if PUT_TIME_MANAGER_TO_SLEEP
 233         if (tick_calls.IsEmpty()) {
 234                 flags = (TimeManagerOp)(flags & ~TIME_MANAGER_TICK_CALL);
 235                 if (flags == 0 && source_tick_pending)
 236                         source->Stop();
 237         }
 238 #endif
 239         tick_calls.Unlock ();
 240 }
 241
 242 bool
 243 find_tick_call (List::Node *node, void *data)
 244 {
 245         if (((TickCall*)node)->func == data)
 246                 return true;
 247         return false;
 248 }
 249
 250 void
 251 TimeManager::NeedRedraw ()
 252 {
 253 #if PUT_TIME_MANAGER_TO_SLEEP
 254         flags = (TimeManagerOp)(flags | TIME_MANAGER_RENDER);
 255         if (!source_tick_pending) {
 256                 source_tick_pending = true;
 257                 source->SetTimerFrequency (current_timeout);
 258                 source->Start();
 259         }
 260 #endif
 261 }
 262
 263 void
 264 TimeManager::NeedClockTick ()
 265 {
 266 #if PUT_TIME_MANAGER_TO_SLEEP
 267         flags = (TimeManagerOp)(flags | TIME_MANAGER_UPDATE_CLOCKS);
 268         if (!source_tick_pending) {
 269                 source_tick_pending = true;
 270                 source->SetTimerFrequency (current_timeout);
 271                 source->Start();
 272         }
 273 #endif
 274 }
 275
 276
 277 static void
 278 spaces (int n)
 279 {
 280         while (n--) putchar (' ');
 281
 282 }
 283
 284 static void
 285 output_clock (Clock *clock, int level)
 286 {
 287         spaces (level);
 288         printf (clock->Is(Type::CLOCKGROUP) ? "ClockGroup " : "Clock ");
 289         printf ("(%p) ", clock);
 290         if (clock->GetName ()) {
 291                 printf ("'%s' ", clock->GetName());
 292         }
 293
 294         // getting the natural duration here upsets the clock, so let's not
 295         // printf ("%lld / %lld (%.2f) ", clock->GetCurrentTime(), clock->GetNaturalDuration().GetTimeSpan(), clock->GetCurrentProgress());
 296         printf ("%lld (%.2f) ", clock->GetCurrentTime(), clock->GetCurrentProgress());
 297
 298         printf ("%lld ", clock->GetTimeline()->GetBeginTime());
 299
 300         switch (clock->GetClockState()) {
 301         case Clock::Active:
 302                 printf ("A");
 303                 break;
 304         case Clock::Filling:
 305                 printf ("F");
 306                 break;
 307         case Clock::Stopped:
 308                 printf ("S");
 309                 break;
 310         }
 311
 312         if (clock->GetIsPaused())
 313                 printf (" (paused)");
 314
 315         printf ("\n");
 316
 317         if (clock->Is(Type::CLOCKGROUP)) {
 318                 ClockGroup *cg = (ClockGroup*)clock;
 319                 level += 2;
 320                 for (GList *l = cg->child_clocks; l; l = l->next) {
 321 //                      if (((Clock*)l->data)->GetClockState () != Clock::Stopped)
 322                                 output_clock ((Clock*)l->data, level);
 323                 }
 324         }
 325 }
 326
 327 void
 328 TimeManager::ListClocks()
 329 {
 330         printf ("Currently registered clocks:\n");
 331         printf ("============================\n");
 332
 333         output_clock (root_clock, 2);
 334
 335         printf ("============================\n");
 336 }
 337
 338 void
 339 TimeManager::AddClock (Clock *clock)
 340 {
 341         root_clock->AddChild (clock);
 342
 343         // we delay starting the surface's ClockGroup until the first
 344         // child has been added.  otherwise we run into timing issues
 345         // between timelines that explicitly set a BeginTime and those
 346         // that don't (and so default to 00:00:00).
 347         if (root_clock->GetClockState() != Clock::Active)
 348                 root_clock->Begin (GetCurrentTime());
 349
 350         NeedClockTick ();
 351 }
 352
 353 void
 354 TimeManager::SourceTick ()
 355 {
 356         TimeManagerOp current_flags = flags;
 357
 358 #if PUT_TIME_MANAGER_TO_SLEEP
 359         flags = (TimeManagerOp)0;
 360 #endif
 361
 362         if (current_flags & TIME_MANAGER_TICK_CALL) {
 363                 bool remaining_tick_calls = false;
 364                 do {
 365                         remaining_tick_calls = InvokeTickCall ();
 366                 } while (remaining_tick_calls);
 367         }
 368
 369         if (current_flags & TIME_MANAGER_UPDATE_CLOCKS) {
 370                 STARTTICKTIMER (tick_update_clocks, "TimeManager::Tick - UpdateClocks");
 371                 current_global_time = source->GetNow();
 372                 current_global_time_usec = current_global_time / 10;
 373
 374                 bool need_another_tick = root_clock->UpdateFromParentTime (GetCurrentTime());
 375
 376                 if (need_another_tick)
 377                         NeedClockTick ();
 378
 379                 // ... then cause all clocks to raise the events they've queued up
 380                 root_clock->RaiseAccumulatedEvents ();
 381
 382                 applier->Apply ();
 383                 applier->Flush ();
 384
 385                 root_clock->RaiseAccumulatedCompleted ();
 386
 387 #if CLOCK_DEBUG
 388                 ListClocks ();
 389 #endif
 390
 391                 ENDTICKTIMER (tick_update_clocks, "TimeManager::Tick - UpdateClocks");
 392         }
 393
 394         if (current_flags & TIME_MANAGER_UPDATE_INPUT) {
 395                 STARTTICKTIMER (tick_input, "TimeManager::Tick - Input");
 396                 Emit (UpdateInputEvent);
 397                 ENDTICKTIMER (tick_input, "TimeManager::Tick - Input");
 398         }
 399
 400         if (current_flags & TIME_MANAGER_RENDER) {
 401                 // fprintf (stderr, "rendering\n"); fflush (stderr);
 402                 STARTTICKTIMER (tick_render, "TimeManager::Tick - Render");
 403                 Emit (RenderEvent, new RenderingEventArgs (get_now()));
 404                 ENDTICKTIMER (tick_render, "TimeManager::Tick - Render");
 405         }
 406
 407         last_global_time = current_global_time;
 408 }