use a duration for the ttyrec frame time

2 files changed, 16 insertions, 14 deletions

diff --git a/src/cmd/play.rs b/src/cmd/play.rs
index 4e0048e..368e368 100644
--- a/src/cmd/play.rs
+++ b/src/cmd/play.rs
@@ -59,6 +59,7 @@ struct PlaySession {
     file: FileState,
     to_write: DumbDelayQueue<Vec<u8>>,
     // to_write: tokio::timer::delay_queue::DelayQueue<Vec<u8>>,
+    base_time: std::time::Instant,
 }
 
 impl PlaySession {
@@ -69,6 +70,7 @@ impl PlaySession {
             },
             to_write: DumbDelayQueue::new(),
             // to_write: tokio::timer::delay_queue::DelayQueue::new(),
+            base_time: std::time::Instant::now(),
         }
     }
 }
@@ -117,7 +119,8 @@ impl PlaySession {
             if let Some(frame) =
                 component_future::try_ready!(file.poll_read())
             {
-                self.to_write.insert_at(frame.data, frame.time);
+                self.to_write
+                    .insert_at(frame.data, self.base_time + frame.time);
             } else {
                 self.file = FileState::Eof;
             }
diff --git a/src/ttyrec.rs b/src/ttyrec.rs
index 77b95bc..c6f627e 100644
--- a/src/ttyrec.rs
+++ b/src/ttyrec.rs
@@ -3,15 +3,14 @@ use std::convert::TryFrom as _;
 use tokio::io::{AsyncRead as _, AsyncWrite as _};
 
 pub struct Frame {
-    pub time: std::time::Instant,
+    pub time: std::time::Duration,
     pub data: Vec<u8>,
 }
 
 impl Frame {
-    fn as_bytes(&self, base: std::time::Instant) -> Vec<u8> {
-        let dur = self.time - base;
-        let secs = u32::try_from(dur.as_secs()).unwrap();
-        let micros = dur.subsec_micros();
+    fn as_bytes(&self) -> Vec<u8> {
+        let secs = u32::try_from(self.time.as_secs()).unwrap();
+        let micros = self.time.subsec_micros();
         let len = u32::try_from(self.data.len()).unwrap();
         let mut bytes = vec![];
         bytes.extend(secs.to_le_bytes().iter());
@@ -54,14 +53,17 @@ impl File {
 
     pub fn write_frame(&mut self, data: &[u8]) -> Result<()> {
         let now = std::time::Instant::now();
-        if self.base_time.is_none() {
+        let base_time = if let Some(base_time) = &self.base_time {
+            *base_time
+        } else {
             self.base_time = Some(now);
-        }
+            now
+        };
 
         self.waiting += 1;
         self.wframe
             .send(Frame {
-                time: now,
+                time: now - base_time,
                 data: data.to_vec(),
             })
             .context(crate::error::WriteChannel)
@@ -74,9 +76,7 @@ impl File {
             if self.writing.is_empty() {
                 match self.rframe.poll().context(crate::error::ReadChannel)? {
                     futures::Async::Ready(Some(frame)) => {
-                        self.writing.extend(
-                            frame.as_bytes(self.base_time.unwrap()).iter(),
-                        );
+                        self.writing.extend(frame.as_bytes().iter());
                         self.waiting -= 1;
                     }
                     futures::Async::Ready(None) => unreachable!(),
@@ -153,10 +153,9 @@ impl File {
                     if self.base_time.is_none() {
                         self.base_time = Some(std::time::Instant::now());
                     }
-                    let dur = std::time::Duration::from_micros(u64::from(
+                    let time = std::time::Duration::from_micros(u64::from(
                         secs * 1_000_000 + usecs,
                     ));
-                    let time = self.base_time.unwrap() + dur;
 
                     self.read.push_back(Frame { time, data });