1 // replay.cxx - a system to record and replay FlightGear flights
3 // Written by Curtis Olson, started July 2003.
4 // Updated by Thorsten Brehm, September 2011.
6 // Copyright (C) 2003 Curtis L. Olson - http://www.flightgear.org/~curt
8 // This program is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU General Public License as
10 // published by the Free Software Foundation; either version 2 of the
11 // License, or (at your option) any later version.
13 // This program is distributed in the hope that it will be useful, but
14 // WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30 #include <simgear/constants.h>
31 #include <simgear/structure/exception.hxx>
33 #include <Main/fg_props.hxx>
36 #include "flightrecorder.hxx"
42 FGReplay::FGReplay() :
44 m_high_res_time(60.0),
45 m_medium_res_time(600.0),
46 m_low_res_time(3600.0),
47 m_medium_sample_rate(0.5), // medium term sample rate (sec)
48 m_long_sample_rate(5.0), // long term sample rate (sec)
49 m_pRecorder(new FGFlightRecorder("replay-config"))
66 * Clear all internal buffers.
71 while ( !short_term.empty() )
73 m_pRecorder->deleteRecord(short_term.front());
74 short_term.pop_front();
76 while ( !medium_term.empty() )
78 m_pRecorder->deleteRecord(medium_term.front());
79 medium_term.pop_front();
81 while ( !long_term.empty() )
83 m_pRecorder->deleteRecord(long_term.front());
84 long_term.pop_front();
86 while ( !recycler.empty() )
88 m_pRecorder->deleteRecord(recycler.front());
94 * Initialize the data structures
100 disable_replay = fgGetNode("/sim/replay/disable", true);
101 replay_master = fgGetNode("/sim/freeze/replay-state", true);
102 replay_time = fgGetNode("/sim/replay/time", true);
103 replay_time_str = fgGetNode("/sim/replay/time-str", true);
104 replay_looped = fgGetNode("/sim/replay/looped", true);
105 speed_up = fgGetNode("/sim/speed-up", true);
110 * Reset replay queues.
122 m_pRecorder->reinit();
124 m_high_res_time = fgGetDouble("/sim/replay/buffer/high-res-time", 60.0);
125 m_medium_res_time = fgGetDouble("/sim/replay/buffer/medium-res-time", 600.0); // 10 mins
126 m_low_res_time = fgGetDouble("/sim/replay/buffer/low-res-time", 3600.0); // 1 h
127 // short term sample rate is as every frame
128 m_medium_sample_rate = fgGetDouble("/sim/replay/buffer/medium-res-sample-dt", 0.5); // medium term sample rate (sec)
129 m_long_sample_rate = fgGetDouble("/sim/replay/buffer/low-res-sample-dt", 5.0); // long term sample rate (sec)
131 // Create an estimated nr of required ReplayData objects
132 // 120 is an estimated maximum frame rate.
133 int estNrObjects = (int) ((m_high_res_time*120) + (m_medium_res_time*m_medium_sample_rate) +
134 (m_low_res_time*m_long_sample_rate));
135 for (int i = 0; i < estNrObjects; i++)
137 FGReplayData* r = m_pRecorder->createEmptyRecord();
139 recycler.push_back(r);
142 SG_LOG(SG_SYSTEMS, SG_ALERT, "ReplaySystem: Out of memory!");
145 replay_master->setIntValue(0);
146 disable_replay->setBoolValue(0);
147 replay_time->setDoubleValue(0);
148 replay_time_str->setStringValue("");
152 * Bind to the property tree
162 * Unbind from the property tree
172 printTimeStr(char* pStrBuffer,double _Time, bool ShowDecimal=true)
176 unsigned int Time = (unsigned int) (_Time*10);
178 int m = (Time % 36000)/600;
179 int s = (Time % 600)/10;
182 sprintf(pStrBuffer,"%u:%02u",h,m);
184 sprintf(pStrBuffer,"%u",m);
186 sprintf(pStrBuffer,"%s:%02u.%u",pStrBuffer,s,d);
188 sprintf(pStrBuffer,"%s:%02u",pStrBuffer,s);
191 /** Start replay session
196 // freeze the fdm, resume from sim pause
197 double StartTime = get_start_time();
198 double EndTime = get_end_time();
199 fgSetDouble("/sim/replay/start-time", StartTime);
200 fgSetDouble("/sim/replay/end-time", EndTime);
202 printTimeStr(StrBuffer,StartTime,false);
203 fgSetString("/sim/replay/start-time-str", StrBuffer);
204 printTimeStr(StrBuffer,EndTime,false);
205 fgSetString("/sim/replay/end-time-str", StrBuffer);
207 unsigned long buffer_elements = short_term.size()+medium_term.size()+long_term.size();
208 fgSetDouble("/sim/replay/buffer-size-mbyte",
209 buffer_elements*m_pRecorder->getRecordSize() / (1024*1024.0));
210 if ((fgGetBool("/sim/freeze/master"))||
211 (0 == replay_master->getIntValue()))
212 fgSetString("/sim/messages/copilot", "Replay active. 'Esc' to stop.");
213 fgSetBool ("/sim/freeze/master", 0);
214 fgSetBool ("/sim/freeze/clock", 0);
215 if (0 == replay_master->getIntValue())
217 replay_master->setIntValue(1);
218 replay_time->setDoubleValue(-1);
219 replay_time_str->setStringValue("");
225 * Update the saved data
229 FGReplay::update( double dt )
231 int current_replay_state = last_replay_state;
235 if ( disable_replay->getBoolValue() )
237 if (fgGetBool("/sim/freeze/master",false)||
238 fgGetBool("/sim/freeze/clock",false))
240 fgSetBool("/sim/freeze/master",false);
241 fgSetBool("/sim/freeze/clock",false);
242 last_replay_state = 1;
245 if ((replay_master->getIntValue() != 3)||
246 (last_replay_state == 3))
248 current_replay_state = replay_master->getIntValue();
249 replay_master->setIntValue(0);
250 replay_time->setDoubleValue(0);
251 replay_time_str->setStringValue("");
252 disable_replay->setBoolValue(0);
253 speed_up->setDoubleValue(1.0);
254 speed_up->setDoubleValue(1.0);
255 if (fgGetBool("/sim/replay/mute",false))
257 fgSetBool("/sim/sound/enabled",true);
258 fgSetBool("/sim/replay/mute",false);
260 fgSetString("/sim/messages/copilot", "Replay stopped. Your controls!");
264 int replay_state = replay_master->getIntValue();
265 if ((replay_state == 0)&&
266 (last_replay_state > 0))
268 if (current_replay_state == 3)
270 // take control at current replay position ("My controls!").
271 // May need to uncrash the aircraft here :)
272 fgSetBool("/sim/crashed", false);
276 // normal replay exit, restore most recent frame
280 // replay is finished
281 last_replay_state = replay_state;
285 // remember recent state
286 last_replay_state = replay_state;
291 // replay inactive, keep recording
293 case 1: // normal replay
294 case 3: // prepare to resume normal flight at current replay position
297 double current_time = replay_time->getDoubleValue();
298 if (current_time<=0.0)
300 // initialize start time
301 double startTime = get_start_time();
302 double endTime = get_end_time();
303 fgSetDouble( "/sim/replay/start-time", startTime );
304 fgSetDouble( "/sim/replay/end-time", endTime );
305 double duration = fgGetDouble( "/sim/replay/duration" );
306 if( duration && (duration < (endTime - startTime)) ) {
307 current_time = endTime - duration;
309 current_time = startTime;
312 bool IsFinished = replay( replay_time->getDoubleValue() );
314 current_time = (replay_looped->getBoolValue()) ? -1 : get_end_time()+0.01;
316 current_time += dt * speed_up->getDoubleValue();
317 replay_time->setDoubleValue(current_time);
319 printTimeStr(StrBuffer,current_time);
320 replay_time_str->setStringValue((const char*)StrBuffer);
321 return; // don't record the replay session
323 case 2: // normal replay operation
324 return; // don't record the replay session
326 throw sg_range_exception("unknown FGReplay state");
331 //cerr << "Recording replay" << endl;
332 sim_time += dt * speed_up->getDoubleValue();
334 // sanity check, don't collect data if FDM data isn't good
335 if (!fgGetBool("/sim/fdm-initialized", false)) {
339 FGReplayData* r = record(sim_time);
342 SG_LOG(SG_SYSTEMS, SG_ALERT, "ReplaySystem: Out of memory!");
346 // update the short term list
348 short_term.push_back( r );
350 FGReplayData *st_front = short_term.front();
354 SG_LOG(SG_SYSTEMS, SG_ALERT, "ReplaySystem: Inconsistent data!");
357 if ( sim_time - st_front->sim_time > m_high_res_time ) {
358 while ( sim_time - st_front->sim_time > m_high_res_time ) {
359 st_front = short_term.front();
360 recycler.push_back(st_front);
361 short_term.pop_front();
364 // update the medium term list
365 if ( sim_time - last_mt_time > m_medium_sample_rate ) {
366 last_mt_time = sim_time;
367 st_front = short_term.front();
368 medium_term.push_back( st_front );
369 short_term.pop_front();
371 FGReplayData *mt_front = medium_term.front();
372 if ( sim_time - mt_front->sim_time > m_medium_res_time ) {
374 while ( sim_time - mt_front->sim_time > m_medium_res_time ) {
375 mt_front = medium_term.front();
376 recycler.push_back(mt_front);
377 medium_term.pop_front();
379 // update the long term list
380 if ( sim_time - last_lt_time > m_long_sample_rate ) {
381 last_lt_time = sim_time;
382 mt_front = medium_term.front();
383 long_term.push_back( mt_front );
384 medium_term.pop_front();
386 FGReplayData *lt_front = long_term.front();
387 if ( sim_time - lt_front->sim_time > m_low_res_time ) {
389 while ( sim_time - lt_front->sim_time > m_low_res_time ) {
390 lt_front = long_term.front();
391 recycler.push_back(lt_front);
392 long_term.pop_front();
401 cout << "short term size = " << short_term.size()
402 << " time = " << sim_time - short_term.front().sim_time
404 cout << "medium term size = " << medium_term.size()
405 << " time = " << sim_time - medium_term.front().sim_time
407 cout << "long term size = " << long_term.size()
408 << " time = " << sim_time - long_term.front().sim_time
411 //stamp("point_finished");
415 FGReplay::record(double time)
417 FGReplayData* r = NULL;
421 r = recycler.front();
422 recycler.pop_front();
425 r = m_pRecorder->capture(time, r);
431 * interpolate a specific time from a specific list
434 FGReplay::interpolate( double time, const replay_list_type &list)
437 if ( list.size() == 0 )
441 } else if ( list.size() == 1 )
443 // handle list size == 1
444 replay(time, list[0]);
448 unsigned int last = list.size() - 1;
449 unsigned int first = 0;
450 unsigned int mid = ( last + first ) / 2;
455 // cout << " " << first << " <=> " << last << endl;
456 if ( last == first ) {
458 } else if ( list[mid]->sim_time < time && list[mid+1]->sim_time < time ) {
461 mid = ( last + first ) / 2;
462 } else if ( list[mid]->sim_time > time && list[mid+1]->sim_time > time ) {
465 mid = ( last + first ) / 2;
471 replay(time, list[mid+1], list[mid]);
475 * Replay a saved frame based on time, interpolate from the two
476 * nearest saved frames.
477 * Returns true when replay sequence has finished, false otherwise.
481 FGReplay::replay( double time ) {
482 // cout << "replay: " << time << " ";
483 // find the two frames to interpolate between
486 if ( short_term.size() > 0 ) {
487 t1 = short_term.back()->sim_time;
488 t2 = short_term.front()->sim_time;
490 // replay the most recent frame
491 replay( time, short_term.back() );
492 // replay is finished now
494 // cout << "first frame" << endl;
495 } else if ( time <= t1 && time >= t2 ) {
496 interpolate( time, short_term );
497 // cout << "from short term" << endl;
498 } else if ( medium_term.size() > 0 ) {
499 t1 = short_term.front()->sim_time;
500 t2 = medium_term.back()->sim_time;
501 if ( time <= t1 && time >= t2 )
503 replay(time, medium_term.back(), short_term.front());
504 // cout << "from short/medium term" << endl;
506 t1 = medium_term.back()->sim_time;
507 t2 = medium_term.front()->sim_time;
508 if ( time <= t1 && time >= t2 ) {
509 interpolate( time, medium_term );
510 // cout << "from medium term" << endl;
511 } else if ( long_term.size() > 0 ) {
512 t1 = medium_term.front()->sim_time;
513 t2 = long_term.back()->sim_time;
514 if ( time <= t1 && time >= t2 )
516 replay(time, long_term.back(), medium_term.front());
517 // cout << "from medium/long term" << endl;
519 t1 = long_term.back()->sim_time;
520 t2 = long_term.front()->sim_time;
521 if ( time <= t1 && time >= t2 ) {
522 interpolate( time, long_term );
523 // cout << "from long term" << endl;
525 // replay the oldest long term frame
526 replay(time, long_term.front());
527 // cout << "oldest long term frame" << endl;
531 // replay the oldest medium term frame
532 replay(time, medium_term.front());
533 // cout << "oldest medium term frame" << endl;
537 // replay the oldest short term frame
538 replay(time, short_term.front());
539 // cout << "oldest short term frame" << endl;
549 * given two FGReplayData elements and a time, interpolate between them
552 FGReplay::replay(double time, FGReplayData* pCurrentFrame, FGReplayData* pOldFrame)
554 m_pRecorder->replay(time,pCurrentFrame,pOldFrame);
558 FGReplay::get_start_time()
560 if ( long_term.size() > 0 )
562 return long_term.front()->sim_time;
563 } else if ( medium_term.size() > 0 )
565 return medium_term.front()->sim_time;
566 } else if ( short_term.size() )
568 return short_term.front()->sim_time;
576 FGReplay::get_end_time()
578 if ( short_term.size() )
580 return short_term.back()->sim_time;