libs/ardour/ltc_slave.cc

   1 /*
   2     Copyright (C) 2012 Paul Davis
   3     Witten by 2012 Robin Gareus <robin@gareus.org>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20 #include <iostream>
  21 #include <errno.h>
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24
  25 #include "pbd/error.h"
  26 #include "pbd/failed_constructor.h"
  27 #include "pbd/pthread_utils.h"
  28
  29 #include "ardour/debug.h"
  30 #include "ardour/profile.h"
  31 #include "ardour/transport_master.h"
  32 #include "ardour/session.h"
  33 #include "ardour/audioengine.h"
  34 #include "ardour/audio_port.h"
  35
  36 #include "pbd/i18n.h"
  37
  38 using namespace std;
  39 using namespace ARDOUR;
  40 using namespace MIDI;
  41 using namespace PBD;
  42 using namespace Timecode;
  43
  44 #define ENGINE AudioEngine::instance()
  45 #define FLYWHEEL_TIMEOUT ( 1 * ENGINE->sample_rate() )
  46
  47 /* XXX USE Config->get_ltc_input */
  48
  49 LTC_TransportMaster::LTC_TransportMaster (std::string const & name)
  50         : TimecodeTransportMaster (name, LTC)
  51         , did_reset_tc_format (false)
  52         , decoder (0)
  53         , samples_per_ltc_frame (0)
  54         , fps_detected (false)
  55         , monotonic_cnt (0)
  56         , delayedlocked (10)
  57         , ltc_detect_fps_cnt (0)
  58         , ltc_detect_fps_max (0)
  59         , sync_lock_broken (false)
  60 {
  61         if ((_port = AudioEngine::instance()->register_input_port (DataType::AUDIO, string_compose ("%1 in", _name))) == 0) {
  62                 throw failed_constructor();
  63         }
  64
  65         DEBUG_TRACE (DEBUG::Slave, string_compose ("LTC registered %1\n", _port->name()));
  66
  67         memset(&prev_sample, 0, sizeof(LTCFrameExt));
  68
  69         resync_latency();
  70
  71         AudioEngine::instance()->Xrun.connect_same_thread (port_connections, boost::bind (&LTC_TransportMaster::resync_xrun, this));
  72         AudioEngine::instance()->GraphReordered.connect_same_thread (port_connections, boost::bind (&LTC_TransportMaster::resync_latency, this));
  73 }
  74
  75 void
  76 LTC_TransportMaster::init ()
  77 {
  78         reset (true);
  79 }
  80
  81 void
  82 LTC_TransportMaster::set_session (Session *s)
  83 {
  84         config_connection.disconnect ();
  85         _session = s;
  86
  87         if (_session) {
  88
  89                 samples_per_ltc_frame = _session->samples_per_timecode_frame();
  90                 timecode.rate = _session->timecode_frames_per_second();
  91                 timecode.drop  = _session->timecode_drop_frames();
  92                 printed_timecode_warning = false;
  93                 ltc_timecode = _session->config.get_timecode_format();
  94                 a3e_timecode = _session->config.get_timecode_format();
  95
  96                 if (Config->get_use_session_timecode_format() && _session) {
  97                         samples_per_timecode_frame = _session->samples_per_timecode_frame();
  98                 }
  99
 100                 if (decoder) {
 101                         ltc_decoder_free (decoder);
 102                 }
 103
 104                 decoder = ltc_decoder_create((int) samples_per_ltc_frame, 128 /*queue size*/);
 105
 106                 parse_timecode_offset();
 107                 reset();
 108
 109                 _session->config.ParameterChanged.connect_same_thread (config_connection, boost::bind (&LTC_TransportMaster::parameter_changed, this, _1));
 110         }
 111 }
 112
 113 LTC_TransportMaster::~LTC_TransportMaster()
 114 {
 115         port_connections.drop_connections();
 116         config_connection.disconnect();
 117
 118         if (did_reset_tc_format) {
 119                 _session->config.set_timecode_format (saved_tc_format);
 120         }
 121
 122         ltc_decoder_free(decoder);
 123 }
 124
 125 void
 126 LTC_TransportMaster::parse_timecode_offset() {
 127         Timecode::Time offset_tc;
 128         Timecode::parse_timecode_format(_session->config.get_slave_timecode_offset(), offset_tc);
 129         offset_tc.rate = _session->timecode_frames_per_second();
 130         offset_tc.drop = _session->timecode_drop_frames();
 131         _session->timecode_to_sample(offset_tc, timecode_offset, false, false);
 132         timecode_negative_offset = offset_tc.negative;
 133 }
 134
 135 void
 136 LTC_TransportMaster::parameter_changed (std::string const & p)
 137 {
 138         if (p == "slave-timecode-offset"
 139                         || p == "timecode-format"
 140                         ) {
 141                 parse_timecode_offset();
 142         }
 143 }
 144
 145 ARDOUR::samplecnt_t
 146 LTC_TransportMaster::resolution () const
 147 {
 148         return (samplecnt_t) (ENGINE->sample_rate() / 1000);
 149 }
 150
 151 bool
 152 LTC_TransportMaster::locked () const
 153 {
 154         return (delayedlocked < 5);
 155 }
 156
 157 bool
 158 LTC_TransportMaster::ok() const
 159 {
 160         return true;
 161 }
 162
 163 void
 164 LTC_TransportMaster::resync_xrun()
 165 {
 166         DEBUG_TRACE (DEBUG::LTC, "LTC resync_xrun()\n");
 167         sync_lock_broken = false;
 168 }
 169
 170 void
 171 LTC_TransportMaster::resync_latency()
 172 {
 173         DEBUG_TRACE (DEBUG::LTC, "LTC resync_latency()\n");
 174         sync_lock_broken = false;
 175
 176         if (!_port) {
 177                 _port->get_connected_latency_range (ltc_slave_latency, false);
 178         }
 179 }
 180
 181 void
 182 LTC_TransportMaster::reset (bool with_ts)
 183 {
 184         DEBUG_TRACE (DEBUG::LTC, "LTC reset()\n");
 185         if (with_ts) {
 186                 current.update (current.position, 0, current.speed);
 187                 _current_delta = 0;
 188         }
 189         transport_direction = 0;
 190         sync_lock_broken = false;
 191         monotonic_cnt = 0;
 192 }
 193
 194 void
 195 LTC_TransportMaster::parse_ltc (const ARDOUR::pframes_t nframes, const Sample* const in, const ARDOUR::samplecnt_t posinfo)
 196 {
 197         pframes_t i;
 198         unsigned char sound[8192];
 199
 200         if (nframes > 8192) {
 201                 /* TODO warn once or wrap, loop conversion below
 202                  * does jack/A3 support > 8192 spp anyway?
 203                  */
 204                 return;
 205         }
 206
 207         for (i = 0; i < nframes; i++) {
 208                 const int snd=(int) rint ((127.0*in[i])+128.0);
 209                 sound[i] = (unsigned char) (snd&0xff);
 210         }
 211
 212         ltc_decoder_write (decoder, sound, nframes, posinfo);
 213
 214         return;
 215 }
 216
 217 bool
 218 LTC_TransportMaster::equal_ltc_sample_time(LTCFrame *a, LTCFrame *b) {
 219         if (a->frame_units != b->frame_units ||
 220             a->frame_tens  != b->frame_tens ||
 221             a->dfbit       != b->dfbit ||
 222             a->secs_units  != b->secs_units ||
 223             a->secs_tens   != b->secs_tens ||
 224             a->mins_units  != b->mins_units ||
 225             a->mins_tens   != b->mins_tens ||
 226             a->hours_units != b->hours_units ||
 227             a->hours_tens  != b->hours_tens) {
 228                 return false;
 229         }
 230         return true;
 231 }
 232
 233 bool
 234 LTC_TransportMaster::detect_discontinuity(LTCFrameExt *sample, int fps, bool fuzzy) {
 235         bool discontinuity_detected = false;
 236
 237         if (fuzzy && (
 238                   ( sample->reverse && prev_sample.ltc.frame_units == 0)
 239                 ||(!sample->reverse && sample->ltc.frame_units == 0)
 240                 )) {
 241                 memcpy(&prev_sample, sample, sizeof(LTCFrameExt));
 242                 return false;
 243         }
 244
 245         if (sample->reverse) {
 246                 ltc_frame_decrement(&prev_sample.ltc, fps, LTC_TV_525_60, 0);
 247         } else {
 248                 ltc_frame_increment(&prev_sample.ltc, fps, LTC_TV_525_60, 0);
 249         }
 250         if (!equal_ltc_sample_time(&prev_sample.ltc, &sample->ltc)) {
 251                 discontinuity_detected = true;
 252         }
 253
 254     memcpy(&prev_sample, sample, sizeof(LTCFrameExt));
 255     return discontinuity_detected;
 256 }
 257
 258 bool
 259 LTC_TransportMaster::detect_ltc_fps(int frameno, bool df)
 260 {
 261         bool fps_changed = false;
 262         double detected_fps = 0;
 263         if (frameno > ltc_detect_fps_max)
 264         {
 265                 ltc_detect_fps_max = frameno;
 266         }
 267         ltc_detect_fps_cnt++;
 268
 269         if (ltc_detect_fps_cnt > 40) {
 270                 if (ltc_detect_fps_cnt > ltc_detect_fps_max) {
 271                         detected_fps = ltc_detect_fps_max + 1;
 272                         if (df) {
 273                                 /* LTC df -> indicates fractional framerate */
 274                                 if (fr2997()) {
 275                                         detected_fps = detected_fps * 999.0 / 1000.0;
 276                                 } else {
 277                                         detected_fps = detected_fps * 1000.0 / 1001.0;
 278                                 }
 279                         }
 280
 281                         if (timecode.rate != detected_fps || timecode.drop != df) {
 282                                 DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC detected FPS: %1%2\n", detected_fps, df?"df":"ndf"));
 283                         } else {
 284                                 detected_fps = 0; /* no cange */
 285                         }
 286                 }
 287                 ltc_detect_fps_cnt = ltc_detect_fps_max = 0;
 288         }
 289
 290         /* when changed */
 291         if (detected_fps != 0 && (detected_fps != timecode.rate || df != timecode.drop)) {
 292                 timecode.rate = detected_fps;
 293                 timecode.drop = df;
 294                 samples_per_ltc_frame = double(_session->sample_rate()) / timecode.rate;
 295                 DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC reset to FPS: %1%2 ; audio-samples per LTC: %3\n",
 296                                 detected_fps, df?"df":"ndf", samples_per_ltc_frame));
 297                 fps_changed=true;
 298         }
 299
 300         /* poll and check session TC */
 301         TimecodeFormat tc_format = apparent_timecode_format();
 302         TimecodeFormat cur_timecode = _session->config.get_timecode_format();
 303
 304         if (Config->get_timecode_sync_frame_rate()) {
 305                 /* enforce time-code */
 306                 if (!did_reset_tc_format) {
 307                         saved_tc_format = cur_timecode;
 308                         did_reset_tc_format = true;
 309                 }
 310                 if (cur_timecode != tc_format) {
 311                         if (ceil(Timecode::timecode_to_frames_per_second(cur_timecode)) != ceil(Timecode::timecode_to_frames_per_second(tc_format))) {
 312                                 warning << string_compose(_("Session framerate adjusted from %1 to LTC's %2."),
 313                                                 Timecode::timecode_format_name(cur_timecode),
 314                                                 Timecode::timecode_format_name(tc_format))
 315                                         << endmsg;
 316                         }
 317                         _session->config.set_timecode_format (tc_format);
 318                 }
 319         } else {
 320                 /* only warn about TC mismatch */
 321                 if (ltc_timecode != tc_format) printed_timecode_warning = false;
 322                 if (a3e_timecode != cur_timecode) printed_timecode_warning = false;
 323
 324                 if (cur_timecode != tc_format && ! printed_timecode_warning) {
 325                         if (ceil(Timecode::timecode_to_frames_per_second(cur_timecode)) != ceil(Timecode::timecode_to_frames_per_second(tc_format))) {
 326                                 warning << string_compose(_("Session and LTC framerate mismatch: LTC:%1 Session:%2."),
 327                                                 Timecode::timecode_format_name(tc_format),
 328                                                 Timecode::timecode_format_name(cur_timecode))
 329                                         << endmsg;
 330                         }
 331                         printed_timecode_warning = true;
 332                 }
 333         }
 334         ltc_timecode = tc_format;
 335         a3e_timecode = cur_timecode;
 336
 337         if (Config->get_use_session_timecode_format() && _session) {
 338                 samples_per_timecode_frame = _session->samples_per_timecode_frame();
 339         } else {
 340                 samples_per_timecode_frame = ENGINE->sample_rate() / Timecode::timecode_to_frames_per_second (ltc_timecode);
 341         }
 342
 343         return fps_changed;
 344 }
 345
 346 void
 347 LTC_TransportMaster::process_ltc(samplepos_t const now)
 348 {
 349         LTCFrameExt sample;
 350         LTC_TV_STANDARD tv_standard = LTC_TV_625_50;
 351
 352         while (ltc_decoder_read (decoder, &sample)) {
 353
 354                 SMPTETimecode stime;
 355
 356                 ltc_frame_to_time (&stime, &sample.ltc, 0);
 357                 timecode.negative  = false;
 358                 timecode.subframes  = 0;
 359
 360                 /* set timecode.rate and timecode.drop: */
 361
 362                 const bool ltc_is_stationary = equal_ltc_sample_time (&prev_sample.ltc, &sample.ltc);
 363
 364                 if (detect_discontinuity (&sample, ceil(timecode.rate), !fps_detected)) {
 365
 366                         if (fps_detected) {
 367                                 ltc_detect_fps_cnt = ltc_detect_fps_max = 0;
 368                         }
 369
 370                         fps_detected = false;
 371                 }
 372
 373                 if (!ltc_is_stationary && detect_ltc_fps (stime.frame, (sample.ltc.dfbit)? true : false)) {
 374                         reset();
 375                         fps_detected=true;
 376                 }
 377
 378 #ifndef NDEBUG
 379                 if (DEBUG_ENABLED (DEBUG::LTC)) {
 380                         /* use fprintf for simpler correct formatting of times
 381                          */
 382                         fprintf (stderr, "LTC@%ld %02d:%02d:%02d%c%02d | %8lld %8lld%s\n",
 383                                  now,
 384                                  stime.hours,
 385                                  stime.mins,
 386                                  stime.secs,
 387                                  (sample.ltc.dfbit) ? '.' : ':',
 388                                  stime.frame,
 389                                  sample.off_start,
 390                                  sample.off_end,
 391                                  sample.reverse ? " R" : "  "
 392                                 );
 393                 }
 394 #endif
 395
 396                 /* when a full LTC sample is decoded, the timecode the LTC sample
 397                  * is referring has just passed.
 398                  * So we send the _next_ timecode which
 399                  * is expected to start at the end of the current sample
 400                  */
 401                 int fps_i = ceil(timecode.rate);
 402
 403                 switch(fps_i) {
 404                         case 30:
 405                                 if (timecode.drop) {
 406                                         tv_standard = LTC_TV_525_60;
 407                                 } else {
 408                                         tv_standard = LTC_TV_1125_60;
 409                                 }
 410                                 break;
 411                         case 25:
 412                                 tv_standard = LTC_TV_625_50;
 413                                 break;
 414                         default:
 415                                 tv_standard = LTC_TV_FILM_24; /* == LTC_TV_1125_60 == no offset, 24,30fps BGF */
 416                                 break;
 417                 }
 418
 419                 if (!sample.reverse) {
 420                         ltc_frame_increment(&sample.ltc, fps_i, tv_standard, 0);
 421                         ltc_frame_to_time(&stime, &sample.ltc, 0);
 422                         transport_direction = 1;
 423                         sample.off_start -= ltc_frame_alignment(samples_per_timecode_frame, tv_standard);
 424                         sample.off_end -= ltc_frame_alignment(samples_per_timecode_frame, tv_standard);
 425                 } else {
 426                         ltc_frame_decrement(&sample.ltc, fps_i, tv_standard, 0);
 427                         int off = sample.off_end - sample.off_start;
 428                         sample.off_start += off - ltc_frame_alignment(samples_per_timecode_frame, tv_standard);
 429                         sample.off_end += off - ltc_frame_alignment(samples_per_timecode_frame, tv_standard);
 430                         transport_direction = -1;
 431                 }
 432
 433                 timecode.hours   = stime.hours;
 434                 timecode.minutes = stime.mins;
 435                 timecode.seconds = stime.secs;
 436                 timecode.frames  = stime.frame;
 437
 438                 samplepos_t ltc_sample; // audio-sample corresponding to position of LTC frame
 439
 440                 if (_session && Config->get_use_session_timecode_format()) {
 441                         Timecode::timecode_to_sample (timecode, ltc_sample, true, false, (double)ENGINE->sample_rate(), _session->config.get_subframes_per_frame(), timecode_negative_offset, timecode_offset);
 442                 } else {
 443                         Timecode::timecode_to_sample (timecode, ltc_sample, true, false, (double)ENGINE->sample_rate(), 100, timecode_negative_offset, timecode_offset);
 444                 }
 445
 446                 ltc_sample += ltc_slave_latency.max;
 447
 448                 /* This LTC frame spans sample time between sample.off_start  .. sample.off_end
 449                  *
 450                  * NOTE: these sample times are NOT the ones that LTC is representing. They are
 451                  * derived our own audioengine's monotonic audio clock.
 452                  *
 453                  * So we expect the next frame to span sample.off_end+1 and ... <don't care for now>.
 454                  * That isn't the time we will necessarily receive the LTC frame, but the decoder
 455                  * should tell us that its span begins there.
 456                  *
 457                  */
 458
 459                 samplepos_t cur_timestamp = sample.off_end + 1;
 460                 double ltc_speed = current.speed;
 461
 462                 DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC S: %1 LS: %2  N: %3 L: %4\n", ltc_sample, current.position, cur_timestamp, current.timestamp));
 463
 464                 if (cur_timestamp <= current.timestamp || current.timestamp == 0) {
 465                         DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC speed: UNCHANGED: %1\n", current.speed));
 466                 } else {
 467                         ltc_speed = double (ltc_sample - current.position) / double (cur_timestamp - current.timestamp);
 468
 469                         /* provide a .1% deadzone to lock the speed */
 470                         if (fabs (ltc_speed - 1.0) <= 0.001) {
 471                                 ltc_speed = 1.0;
 472                         }
 473
 474                         if (fabs (ltc_speed) > 10.0) {
 475                                 ltc_speed = 0;
 476                         }
 477
 478                         DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC speed: %1\n", ltc_speed));
 479                 }
 480
 481                 current.update (ltc_sample, cur_timestamp, ltc_speed);
 482
 483         } /* end foreach decoded LTC sample */
 484 }
 485
 486 void
 487 LTC_TransportMaster::pre_process (ARDOUR::pframes_t nframes, samplepos_t now, boost::optional<samplepos_t> session_pos)
 488 {
 489         Sample* in = (Sample*) AudioEngine::instance()->port_engine().get_buffer (_port->port_handle(), nframes);
 490         sampleoffset_t skip = now - (monotonic_cnt + nframes);
 491         monotonic_cnt = now;
 492
 493         DEBUG_TRACE (DEBUG::LTC, string_compose ("pre-process - TID:%1 | latency: %2 | skip %3 | session ? %4| last %5 | dir %6 | sp %7\n",
 494                                                  pthread_name(), ltc_slave_latency.max, skip, (_session ? 'y' : 'n'), current.timestamp, transport_direction, current.speed));
 495
 496         if (current.timestamp == 0) {
 497                 if (delayedlocked < 10) {
 498                         ++delayedlocked;
 499                 }
 500
 501         } else if (current.speed != 0) {
 502
 503         }
 504
 505         DEBUG_TRACE (DEBUG::LTC, string_compose ("pre-process with audio clock time: %1\n", now));
 506
 507         /* if the audioengine failed to take the process lock, it won't
 508            call this method, and time will appear to skip. Reset the
 509            LTC decoder's state by giving it some silence.
 510         */
 511
 512         if (skip > 0) {
 513                 DEBUG_TRACE (DEBUG::LTC, string_compose("engine skipped %1 samples. Feeding silence to LTC parser.\n", skip));
 514                 if (skip >= 8192) skip = 8192;
 515                 unsigned char sound[8192];
 516                 memset (sound, 0x80, sizeof(char) * skip);
 517                 ltc_decoder_write (decoder, sound, nframes, now);
 518         } else if (skip != 0) {
 519                 /* this should never happen. it may if monotonic_cnt, now overflow on 64bit */
 520                 DEBUG_TRACE (DEBUG::LTC, string_compose("engine skipped %1 samples\n", skip));
 521                 reset();
 522         }
 523
 524         /* Now feed the incoming LTC signal into the decoder */
 525
 526         parse_ltc (nframes, in, now);
 527
 528         /* and pull out actual LTC frame data */
 529
 530         process_ltc (now);
 531
 532         if (current.timestamp == 0) {
 533                 DEBUG_TRACE (DEBUG::LTC, "last timestamp == 0\n");
 534                 return;
 535         } else if (current.speed != 0) {
 536                 DEBUG_TRACE (DEBUG::LTC, string_compose ("speed non-zero (%1)\n", current.speed));
 537                 if (delayedlocked > 1) {
 538                         delayedlocked--;
 539                 } else if (_current_delta == 0) {
 540                         delayedlocked = 0;
 541                 }
 542         }
 543
 544         if (abs (now - current.timestamp) > FLYWHEEL_TIMEOUT) {
 545                 DEBUG_TRACE (DEBUG::LTC, "flywheel timeout\n");
 546                 reset();
 547                 /* don't change position from last known */
 548
 549                 return;
 550         }
 551
 552         if (!sync_lock_broken && current.speed != 0 && delayedlocked == 0 && fabs(current.speed) != 1.0) {
 553                 sync_lock_broken = true;
 554                 DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC speed not locked based on %1\n", current.speed));
 555         }
 556
 557         if (session_pos) {
 558                 const samplepos_t current_pos = current.position + ((now - current.timestamp) * current.speed);
 559                 _current_delta = current_pos - *session_pos;
 560         } else {
 561                 _current_delta = 0;
 562         }
 563 }
 564
 565 Timecode::TimecodeFormat
 566 LTC_TransportMaster::apparent_timecode_format () const
 567 {
 568         if      (timecode.rate == 24 && !timecode.drop)
 569                 return timecode_24;
 570         else if (timecode.rate == 25 && !timecode.drop)
 571                 return timecode_25;
 572         else if (rint(timecode.rate * 100) == 2997 && !timecode.drop)
 573                 return (fr2997() ? timecode_2997000 : timecode_2997);
 574         else if (rint(timecode.rate * 100) == 2997 &&  timecode.drop)
 575                 return (fr2997() ? timecode_2997000drop : timecode_2997drop);
 576         else if (timecode.rate == 30 &&  timecode.drop)
 577                 return timecode_2997drop; // timecode_30drop; // LTC counting to 30 samples w/DF *means* 29.97 df
 578         else if (timecode.rate == 30 && !timecode.drop)
 579                 return timecode_30;
 580
 581         /* XXX - unknown timecode format */
 582         return _session->config.get_timecode_format();
 583 }
 584
 585 std::string
 586 LTC_TransportMaster::position_string() const
 587 {
 588         if (!_collect || current.timestamp == 0) {
 589                 return " --:--:--:--";
 590         }
 591         return Timecode::timecode_format_time(timecode);
 592 }
 593
 594 std::string
 595 LTC_TransportMaster::delta_string() const
 596 {
 597         char delta[80];
 598
 599         if (!_collect || current.timestamp == 0) {
 600                 snprintf (delta, sizeof(delta), "\u2012\u2012\u2012\u2012");
 601         } else if ((monotonic_cnt - current.timestamp) > 2 * samples_per_ltc_frame) {
 602                 snprintf (delta, sizeof(delta), "%s", _("flywheel"));
 603         } else {
 604                 snprintf (delta, sizeof(delta), "\u0394<span foreground=\"%s\" face=\"monospace\" >%s%s%lld</span>sm",
 605                                 sync_lock_broken ? "red" : "green",
 606                                 LEADINGZERO(::llabs(_current_delta)), PLUSMINUS(-_current_delta), ::llabs(_current_delta));
 607         }
 608
 609         return delta;
 610 }