initial (incomplete) framework for DiskIOPoint manipulation

[ardour.git] / libs / ardour / session_ltc.cc

diff --git a/libs/ardour/session_ltc.cc b/libs/ardour/session_ltc.cc
index d52d9e919a65b4bb71a0c60a1ba456c906bfb33c..8acb16dde30ea7f9247aac42958c45f36bbe0596 100644 (file)
--- a/libs/ardour/session_ltc.cc
+++ b/libs/ardour/session_ltc.cc
@@ -27,11 +27,10 @@
 #include "ardour/session.h"
 #include "ardour/slave.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
-using namespace MIDI;
 using namespace PBD;
 using namespace Timecode;
 
@@ -65,6 +64,7 @@ using namespace Timecode;
 void
 Session::ltc_tx_initialize()
 {
+       assert (!ltc_encoder && !ltc_enc_buf);
        ltc_enc_tcformat = config.get_timecode_format();
 
        ltc_tx_parse_offset();
@@ -85,8 +85,8 @@ Session::ltc_tx_initialize()
        ltc_prev_cycle = -1;
        ltc_tx_reset();
        ltc_tx_resync_latency();
-       Xrun.connect_same_thread (*this, boost::bind (&Session::ltc_tx_reset, this));
-       engine().GraphReordered.connect_same_thread (*this, boost::bind (&Session::ltc_tx_resync_latency, this));
+       Xrun.connect_same_thread (ltc_tx_connections, boost::bind (&Session::ltc_tx_reset, this));
+       engine().GraphReordered.connect_same_thread (ltc_tx_connections, boost::bind (&Session::ltc_tx_resync_latency, this));
        restarting = false;
 }
 
@@ -94,6 +94,7 @@ void
 Session::ltc_tx_cleanup()
 {
        DEBUG_TRACE (DEBUG::LTC, "LTC TX cleanup\n");
+       ltc_tx_connections.drop_connections ();
        free(ltc_enc_buf);
        ltc_enc_buf = NULL;
        ltc_encoder_free(ltc_encoder);
@@ -116,6 +117,7 @@ void
 Session::ltc_tx_reset()
 {
        DEBUG_TRACE (DEBUG::LTC, "LTC TX reset\n");
+       assert (ltc_encoder);
        ltc_enc_pos = -9999; // force re-start
        ltc_buf_len = 0;
        ltc_buf_off = 0;
@@ -169,6 +171,12 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
        pframes_t txf = 0;
        boost::shared_ptr<Port> ltcport = ltc_output_port();
 
+       if (!ltcport) {
+               assert (deletion_in_progress ());
+               return;
+       }
+
+       /* marks buffer as not written */
        Buffer& buf (ltcport->get_buffer (nframes));
 
        if (!ltc_encoder || !ltc_enc_buf) {
@@ -245,13 +253,26 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
        /* port latency compensation:
         * The _generated timecode_ is offset by the port-latency,
         * therefore the offset depends on the direction of transport.
+        *
+        * latency is compensated by adding it to the timecode to
+        * be generated. e.g. if the signal will reach the output in
+        * N samples time from now, generate the timecode for (now + N).
+        *
+        * sample-sync is achieved by further calculating the difference
+        * between the timecode and the session-transport and offsetting the
+        * buffer.
+        *
+        * The timecode is generated directly in the Session process callback
+        * using _transport_frame. It requires that the session has set the
+        * port's playback latency to worst_playback_latency() prior to
+        * calling ltc_tx_send_time_code_for_cycle().
         */
        framepos_t cycle_start_frame;
 
        if (current_speed < 0) {
-               cycle_start_frame = (start_frame - ltc_out_latency.max);
+               cycle_start_frame = (start_frame - ltc_out_latency.max + worst_playback_latency());
        } else if (current_speed > 0) {
-               cycle_start_frame = (start_frame + ltc_out_latency.max);
+               cycle_start_frame = (start_frame + ltc_out_latency.max - worst_playback_latency());
        } else {
                /* There is no need to compensate for latency when not rolling
                 * rather send the accurate NOW timecode
@@ -263,7 +284,7 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
        /* LTC TV standard offset */
        if (current_speed != 0) {
                /* ditto - send "NOW" if not rolling */
-               cycle_start_frame -= ltc_frame_alignment(frames_per_timecode_frame(), TV_STANDARD(cur_timecode));
+               cycle_start_frame -= ltc_frame_alignment(samples_per_timecode_frame(), TV_STANDARD(cur_timecode));
        }
 
        /* cycle-start may become negative due to latency compensation */
@@ -436,7 +457,7 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
 
 
        // (4) check if alignment matches
-       const double fptcf = frames_per_timecode_frame();
+       const double fptcf = samples_per_timecode_frame();
 
        /* maximum difference of bit alignment in audio-samples.
         *
@@ -470,8 +491,9 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
                                rint(ltc_enc_pos + ltc_enc_cnt - poff) - cycle_start_frame
                                ));
 
+       const framecnt_t wrap24h = 86400. * frame_rate();
        if (ltc_enc_pos < 0
-                       || (ltc_speed != 0 && fabs(ceil(ltc_enc_pos + ltc_enc_cnt - poff) - cycle_start_frame) > maxdiff)
+                       || (ltc_speed != 0 && fabs(fmod(ceil(ltc_enc_pos + ltc_enc_cnt - poff), wrap24h) - (cycle_start_frame % wrap24h)) > maxdiff)
                        ) {
 
                // (5) re-align
@@ -479,7 +501,7 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
 
                /* set frame to encode */
                SMPTETimecode tc;
-               tc.hours = tc_start.hours;
+               tc.hours = tc_start.hours % 24;
                tc.mins = tc_start.minutes;
                tc.secs = tc_start.seconds;
                tc.frame = tc_start.frames;
@@ -496,7 +518,7 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
 
                DEBUG_TRACE (DEBUG::LTC, string_compose("LTC TX4: now: %1 trs: %2 toff %3\n", cycle_start_frame, tc_sample_start, soff));
 
-               uint32_t cyc_off;
+               int32_t cyc_off;
                if (soff < 0 || soff >= fptcf) {
                        /* session framerate change between (2) and now */
                        ltc_tx_reset();
@@ -532,7 +554,7 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
                        restarting = true;
                }
 
-               if (cyc_off >= 0 && cyc_off <= nframes) {
+               if (cyc_off >= 0 && cyc_off <= (int32_t) nframes) {
                        /* offset in this cycle */
                        txf= rint(cyc_off / fabs(ltc_speed));
                        memset(out, 0, cyc_off * sizeof(Sample));
@@ -542,7 +564,7 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
                        return;
                }
 
-               ltc_enc_pos = tc_sample_start;
+               ltc_enc_pos = tc_sample_start % wrap24h;
 
                DEBUG_TRACE (DEBUG::LTC, string_compose("LTC TX5 restart @ %1 + %2 - %3 |  byte %4\n",
                                        ltc_enc_pos, ltc_enc_cnt, cyc_off, ltc_enc_byte));
@@ -565,7 +587,7 @@ Session::ltc_tx_send_time_code_for_cycle (framepos_t start_frame, framepos_t end
                 * To do better than this, resampling (or a rewrite of the
                 * encoder) is required.
                 */
-               ltc_speed -= ((ltc_enc_pos + ltc_enc_cnt - poff) - cycle_start_frame) / engine().sample_rate();
+               ltc_speed -= fmod(((ltc_enc_pos + ltc_enc_cnt - poff) - cycle_start_frame), wrap24h) / engine().sample_rate();
        }