diff --git a/drivers/media/test-drivers/vivid/vivid-core.h b/drivers/media/test-drivers/vivid/vivid-core.h
index cfb8e66083f6..0f854aaddbf0 100644
--- a/drivers/media/test-drivers/vivid/vivid-core.h
+++ b/drivers/media/test-drivers/vivid/vivid-core.h
@@ -399,10 +399,8 @@ struct vivid_dev {
 	/* thread for generating video capture stream */
 	struct task_struct		*kthread_vid_cap;
 	unsigned long			jiffies_vid_cap;
-	u64				cap_stream_start;
 	u64				cap_frame_period;
 	u64				cap_frame_eof_offset;
-	u32				cap_seq_offset;
 	u32				cap_seq_count;
 	bool				cap_seq_resync;
 	u32				vid_cap_seq_start;
@@ -418,9 +416,6 @@ struct vivid_dev {
 	/* Touch capture */
 	struct task_struct		*kthread_touch_cap;
 	unsigned long			jiffies_touch_cap;
-	u64				touch_cap_stream_start;
-	u32				touch_cap_seq_offset;
-	bool				touch_cap_seq_resync;
 	u32				touch_cap_seq_start;
 	u32				touch_cap_seq_count;
 	u32				touch_cap_with_seq_wrap_count;
@@ -474,9 +469,7 @@ struct vivid_dev {
 	/* thread for generating video output stream */
 	struct task_struct		*kthread_vid_out;
 	unsigned long			jiffies_vid_out;
-	u32				out_seq_offset;
 	u32				out_seq_count;
-	bool				out_seq_resync;
 	u32				vid_out_seq_start;
 	u32				vid_out_seq_count;
 	bool				vid_out_streaming;
@@ -510,7 +503,6 @@ struct vivid_dev {
 	/* thread for generating SDR stream */
 	struct task_struct		*kthread_sdr_cap;
 	unsigned long			jiffies_sdr_cap;
-	u32				sdr_cap_seq_offset;
 	u32				sdr_cap_seq_start;
 	u32				sdr_cap_seq_count;
 	u32				sdr_cap_with_seq_wrap_count;
diff --git a/drivers/media/test-drivers/vivid/vivid-kthread-cap.c b/drivers/media/test-drivers/vivid/vivid-kthread-cap.c
index 42048727d7ff..d8bb5b1fc1ed 100644
--- a/drivers/media/test-drivers/vivid/vivid-kthread-cap.c
+++ b/drivers/media/test-drivers/vivid/vivid-kthread-cap.c
@@ -553,12 +553,11 @@ static void vivid_cap_update_frame_period(struct vivid_dev *dev)
 }

 static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
-							 int dropped_bufs)
+							 int dropped_bufs, u64 f_time)
 {
 	struct vivid_buffer *vid_cap_buf = NULL;
 	struct vivid_buffer *vbi_cap_buf = NULL;
 	struct vivid_buffer *meta_cap_buf = NULL;
-	u64 f_time = 0;

 	dprintk(dev, 1, "Video Capture Thread Tick\n");

@@ -596,8 +595,6 @@ static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
 	if (!vid_cap_buf && !vbi_cap_buf && !meta_cap_buf)
 		goto update_mv;

-	f_time = ktime_get_ns() + dev->time_wrap_offset;
-
 	if (vid_cap_buf) {
 		v4l2_ctrl_request_setup(vid_cap_buf->vb.vb2_buf.req_obj.req,
 					&dev->ctrl_hdl_vid_cap);
@@ -664,12 +661,14 @@ static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
 static int vivid_thread_vid_cap(void *data)
 {
 	struct vivid_dev *dev = data;
+	u64 start_time;
 	u64 numerators_since_start;
 	u64 buffers_since_start;
-	u64 next_jiffies_since_start;
+	u64 f_time;
+	u32 seq_offset = 0;
+	unsigned long next_jiffies;
 	unsigned long jiffies_since_start;
 	unsigned long cur_jiffies;
-	unsigned wait_jiffies;
 	unsigned numerator;
 	unsigned denominator;
 	int dropped_bufs;
@@ -679,13 +678,12 @@ static int vivid_thread_vid_cap(void *data)
 	set_freezable();

 	/* Resets frame counters */
-	dev->cap_seq_offset = 0;
 	dev->cap_seq_count = 0;
 	dev->cap_seq_resync = false;
 	dev->jiffies_vid_cap = jiffies;
-	dev->cap_stream_start = ktime_get_ns();
+	start_time = ktime_get_ns();
 	if (dev->time_wrap)
-		dev->time_wrap_offset = dev->time_wrap - dev->cap_stream_start;
+		dev->time_wrap_offset = dev->time_wrap - start_time;
 	else
 		dev->time_wrap_offset = 0;
 	vivid_cap_update_frame_period(dev);
@@ -703,10 +701,9 @@ static int vivid_thread_vid_cap(void *data)
 		cur_jiffies = jiffies;
 		if (dev->cap_seq_resync) {
 			dev->jiffies_vid_cap = cur_jiffies;
-			dev->cap_seq_offset = dev->cap_seq_count + 1;
+			seq_offset = dev->cap_seq_count + 1;
 			dev->cap_seq_count = 0;
-			dev->cap_stream_start += dev->cap_frame_period *
-						 dev->cap_seq_offset;
+			start_time += dev->cap_frame_period * seq_offset;
 			vivid_cap_update_frame_period(dev);
 			dev->cap_seq_resync = false;
 		}
@@ -719,9 +716,10 @@ static int vivid_thread_vid_cap(void *data)
 		/* Calculate the number of jiffies since we started streaming */
 		jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
 		/* Get the number of buffers streamed since the start */
-		buffers_since_start = (u64)jiffies_since_start * denominator +
-				      (HZ * numerator) / 2;
+		buffers_since_start = (u64)jiffies_since_start * denominator;
 		do_div(buffers_since_start, HZ * numerator);
+		f_time = start_time + dev->time_wrap_offset +
+			buffers_since_start * dev->cap_frame_period;

 		/*
 		 * After more than 0xf0000000 (rounded down to a multiple of
@@ -731,16 +729,17 @@ static int vivid_thread_vid_cap(void *data)
 		 */
 		if (jiffies_since_start > JIFFIES_RESYNC) {
 			dev->jiffies_vid_cap = cur_jiffies;
-			dev->cap_seq_offset = buffers_since_start;
+			seq_offset = buffers_since_start;
 			buffers_since_start = 0;
 		}
-		dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
-		dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
+		dropped_bufs = buffers_since_start + seq_offset - dev->cap_seq_count;
+		dev->cap_seq_count = buffers_since_start + seq_offset;
 		dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
 		dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
 		dev->meta_cap_seq_count = dev->cap_seq_count - dev->meta_cap_seq_start;

-		vivid_thread_vid_cap_tick(dev, dropped_bufs);
+		vivid_thread_vid_cap_tick(dev, dropped_bufs, f_time);
+		mutex_unlock(&dev->mutex);

 		/*
 		 * Calculate the number of 'numerators' streamed since we started,
@@ -748,24 +747,15 @@ static int vivid_thread_vid_cap(void *data)
 		 */
 		numerators_since_start = ++buffers_since_start * numerator;

-		/* And the number of jiffies since we started */
-		jiffies_since_start = jiffies - dev->jiffies_vid_cap;
-
-		mutex_unlock(&dev->mutex);
-
 		/*
 		 * Calculate when that next buffer is supposed to start
 		 * in jiffies since we started streaming.
 		 */
-		next_jiffies_since_start = numerators_since_start * HZ +
-					   denominator / 2;
-		do_div(next_jiffies_since_start, denominator);
-		/* If it is in the past, then just schedule asap */
-		if (next_jiffies_since_start < jiffies_since_start)
-			next_jiffies_since_start = jiffies_since_start;
-
-		wait_jiffies = next_jiffies_since_start - jiffies_since_start;
-		while (time_is_after_jiffies(cur_jiffies + wait_jiffies) &&
+		next_jiffies = numerators_since_start * HZ + denominator - 1;
+		do_div(next_jiffies, denominator);
+		next_jiffies += dev->jiffies_vid_cap;
+
+		while (time_is_after_jiffies(next_jiffies) &&
 		       !kthread_should_stop())
 			schedule();
 	}
diff --git a/drivers/media/test-drivers/vivid/vivid-kthread-out.c b/drivers/media/test-drivers/vivid/vivid-kthread-out.c
index fac6208b51da..536688c7f503 100644
--- a/drivers/media/test-drivers/vivid/vivid-kthread-out.c
+++ b/drivers/media/test-drivers/vivid/vivid-kthread-out.c
@@ -41,7 +41,7 @@
 #include "vivid-kthread-out.h"
 #include "vivid-meta-out.h"

-static void vivid_thread_vid_out_tick(struct vivid_dev *dev)
+static void vivid_thread_vid_out_tick(struct vivid_dev *dev, u64 f_time)
 {
 	struct vivid_buffer *vid_out_buf = NULL;
 	struct vivid_buffer *vbi_out_buf = NULL;
@@ -95,8 +95,7 @@ static void vivid_thread_vid_out_tick(struct vivid_dev *dev)
 			 */
 			vid_out_buf->vb.sequence /= 2;
 		}
-		vid_out_buf->vb.vb2_buf.timestamp =
-			ktime_get_ns() + dev->time_wrap_offset;
+		vid_out_buf->vb.vb2_buf.timestamp = f_time;
 		vb2_buffer_done(&vid_out_buf->vb.vb2_buf, dev->dqbuf_error ?
 				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 		dprintk(dev, 2, "vid_out buffer %d done\n",
@@ -112,8 +111,7 @@ static void vivid_thread_vid_out_tick(struct vivid_dev *dev)
 			vivid_sliced_vbi_out_process(dev, vbi_out_buf);

 		vbi_out_buf->vb.sequence = dev->vbi_out_seq_count;
-		vbi_out_buf->vb.vb2_buf.timestamp =
-			ktime_get_ns() + dev->time_wrap_offset;
+		vbi_out_buf->vb.vb2_buf.timestamp = f_time;
 		vb2_buffer_done(&vbi_out_buf->vb.vb2_buf, dev->dqbuf_error ?
 				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 		dprintk(dev, 2, "vbi_out buffer %d done\n",
@@ -126,8 +124,7 @@ static void vivid_thread_vid_out_tick(struct vivid_dev *dev)
 					   &dev->ctrl_hdl_meta_out);
 		vivid_meta_out_process(dev, meta_out_buf);
 		meta_out_buf->vb.sequence = dev->meta_out_seq_count;
-		meta_out_buf->vb.vb2_buf.timestamp =
-			ktime_get_ns() + dev->time_wrap_offset;
+		meta_out_buf->vb.vb2_buf.timestamp = f_time;
 		vb2_buffer_done(&meta_out_buf->vb.vb2_buf, dev->dqbuf_error ?
 				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 		dprintk(dev, 2, "meta_out buffer %d done\n",
@@ -140,12 +137,14 @@ static void vivid_thread_vid_out_tick(struct vivid_dev *dev)
 static int vivid_thread_vid_out(void *data)
 {
 	struct vivid_dev *dev = data;
+	u64 start_time;
 	u64 numerators_since_start;
 	u64 buffers_since_start;
-	u64 next_jiffies_since_start;
+	u64 f_time, f_period;
+	u32 seq_offset = 0;
+	unsigned long next_jiffies;
 	unsigned long jiffies_since_start;
 	unsigned long cur_jiffies;
-	unsigned wait_jiffies;
 	unsigned numerator;
 	unsigned denominator;

@@ -154,15 +153,19 @@ static int vivid_thread_vid_out(void *data)
 	set_freezable();

 	/* Resets frame counters */
-	dev->out_seq_offset = 0;
 	dev->out_seq_count = 0;
 	dev->jiffies_vid_out = jiffies;
-	dev->out_seq_resync = false;
+	start_time = ktime_get_ns();
 	if (dev->time_wrap)
-		dev->time_wrap_offset = dev->time_wrap - ktime_get_ns();
+		dev->time_wrap_offset = dev->time_wrap - start_time;
 	else
 		dev->time_wrap_offset = 0;

+	f_period = (u64)dev->timeperframe_vid_out.numerator * 1000000000;
+	if (WARN_ON(dev->timeperframe_vid_out.denominator == 0))
+		dev->timeperframe_vid_out.denominator = 1;
+	do_div(f_period, dev->timeperframe_vid_out.denominator);
+
 	for (;;) {
 		try_to_freeze();
 		if (kthread_should_stop())
@@ -174,12 +177,6 @@ static int vivid_thread_vid_out(void *data)
 		}

 		cur_jiffies = jiffies;
-		if (dev->out_seq_resync) {
-			dev->jiffies_vid_out = cur_jiffies;
-			dev->out_seq_offset = dev->out_seq_count + 1;
-			dev->out_seq_count = 0;
-			dev->out_seq_resync = false;
-		}
 		numerator = dev->timeperframe_vid_out.numerator;
 		denominator = dev->timeperframe_vid_out.denominator;

@@ -189,9 +186,10 @@ static int vivid_thread_vid_out(void *data)
 		/* Calculate the number of jiffies since we started streaming */
 		jiffies_since_start = cur_jiffies - dev->jiffies_vid_out;
 		/* Get the number of buffers streamed since the start */
-		buffers_since_start = (u64)jiffies_since_start * denominator +
-				      (HZ * numerator) / 2;
+		buffers_since_start = (u64)jiffies_since_start * denominator;
 		do_div(buffers_since_start, HZ * numerator);
+		f_time = start_time + dev->time_wrap_offset +
+			buffers_since_start * f_period;

 		/*
 		 * After more than 0xf0000000 (rounded down to a multiple of
@@ -201,41 +199,32 @@ static int vivid_thread_vid_out(void *data)
 		 */
 		if (jiffies_since_start > JIFFIES_RESYNC) {
 			dev->jiffies_vid_out = cur_jiffies;
-			dev->out_seq_offset = buffers_since_start;
+			seq_offset = buffers_since_start;
 			buffers_since_start = 0;
 		}
-		dev->out_seq_count = buffers_since_start + dev->out_seq_offset;
+		dev->out_seq_count = buffers_since_start + seq_offset;
 		dev->vid_out_seq_count = dev->out_seq_count - dev->vid_out_seq_start;
 		dev->vbi_out_seq_count = dev->out_seq_count - dev->vbi_out_seq_start;
 		dev->meta_out_seq_count = dev->out_seq_count - dev->meta_out_seq_start;

-		vivid_thread_vid_out_tick(dev);
+		vivid_thread_vid_out_tick(dev, f_time);
 		mutex_unlock(&dev->mutex);

 		/*
 		 * Calculate the number of 'numerators' streamed since we started,
 		 * not including the current buffer.
 		 */
-		numerators_since_start = buffers_since_start * numerator;
+		numerators_since_start = ++buffers_since_start * numerator;

-		/* And the number of jiffies since we started */
-		jiffies_since_start = jiffies - dev->jiffies_vid_out;
-
-		/* Increase by the 'numerator' of one buffer */
-		numerators_since_start += numerator;
 		/*
 		 * Calculate when that next buffer is supposed to start
 		 * in jiffies since we started streaming.
 		 */
-		next_jiffies_since_start = numerators_since_start * HZ +
-					   denominator / 2;
-		do_div(next_jiffies_since_start, denominator);
-		/* If it is in the past, then just schedule asap */
-		if (next_jiffies_since_start < jiffies_since_start)
-			next_jiffies_since_start = jiffies_since_start;
-
-		wait_jiffies = next_jiffies_since_start - jiffies_since_start;
-		while (time_is_after_jiffies(cur_jiffies + wait_jiffies) &&
+		next_jiffies = numerators_since_start * HZ + denominator - 1;
+		do_div(next_jiffies, denominator);
+		next_jiffies += dev->jiffies_vid_out;
+
+		while (time_is_after_jiffies(next_jiffies) &&
 		       !kthread_should_stop())
 			schedule();
 	}
diff --git a/drivers/media/test-drivers/vivid/vivid-kthread-touch.c b/drivers/media/test-drivers/vivid/vivid-kthread-touch.c
index fa711ee36a3f..cd0c3938b6a1 100644
--- a/drivers/media/test-drivers/vivid/vivid-kthread-touch.c
+++ b/drivers/media/test-drivers/vivid/vivid-kthread-touch.c
@@ -11,7 +11,7 @@
 #include "vivid-touch-cap.h"

 static noinline_for_stack void vivid_thread_tch_cap_tick(struct vivid_dev *dev,
-							 int dropped_bufs)
+							 int dropped_bufs, u64 f_time)
 {
 	struct vivid_buffer *tch_cap_buf = NULL;

@@ -36,7 +36,7 @@ static noinline_for_stack void vivid_thread_tch_cap_tick(struct vivid_dev *dev,
 		dprintk(dev, 2, "touch_cap buffer %d done\n",
 			tch_cap_buf->vb.vb2_buf.index);

-		tch_cap_buf->vb.vb2_buf.timestamp = ktime_get_ns() + dev->time_wrap_offset;
+		tch_cap_buf->vb.vb2_buf.timestamp = f_time;
 	}
 	dev->dqbuf_error = false;
 }
@@ -44,12 +44,14 @@ static noinline_for_stack void vivid_thread_tch_cap_tick(struct vivid_dev *dev,
 static int vivid_thread_touch_cap(void *data)
 {
 	struct vivid_dev *dev = data;
+	u64 start_time;
 	u64 numerators_since_start;
 	u64 buffers_since_start;
-	u64 next_jiffies_since_start;
+	u64 f_time, f_period;
+	u32 seq_offset = 0;
+	unsigned long next_jiffies;
 	unsigned long jiffies_since_start;
 	unsigned long cur_jiffies;
-	unsigned int wait_jiffies;
 	unsigned int numerator;
 	unsigned int denominator;
 	int dropped_bufs;
@@ -59,15 +61,19 @@ static int vivid_thread_touch_cap(void *data)
 	set_freezable();

 	/* Resets frame counters */
-	dev->touch_cap_seq_offset = 0;
 	dev->touch_cap_seq_count = 0;
-	dev->touch_cap_seq_resync = false;
 	dev->jiffies_touch_cap = jiffies;
+	start_time = ktime_get_ns();
 	if (dev->time_wrap)
-		dev->time_wrap_offset = dev->time_wrap - ktime_get_ns();
+		dev->time_wrap_offset = dev->time_wrap - start_time;
 	else
 		dev->time_wrap_offset = 0;

+	f_period = (u64)dev->timeperframe_tch_cap.numerator * 1000000000;
+	if (WARN_ON(dev->timeperframe_tch_cap.denominator == 0))
+		dev->timeperframe_tch_cap.denominator = 1;
+	do_div(f_period, dev->timeperframe_tch_cap.denominator);
+
 	for (;;) {
 		try_to_freeze();
 		if (kthread_should_stop())
@@ -78,21 +84,16 @@ static int vivid_thread_touch_cap(void *data)
 			continue;
 		}
 		cur_jiffies = jiffies;
-		if (dev->touch_cap_seq_resync) {
-			dev->jiffies_touch_cap = cur_jiffies;
-			dev->touch_cap_seq_offset = dev->touch_cap_seq_count + 1;
-			dev->touch_cap_seq_count = 0;
-			dev->cap_seq_resync = false;
-		}
 		denominator = dev->timeperframe_tch_cap.denominator;
 		numerator = dev->timeperframe_tch_cap.numerator;

 		/* Calculate the number of jiffies since we started streaming */
 		jiffies_since_start = cur_jiffies - dev->jiffies_touch_cap;
 		/* Get the number of buffers streamed since the start */
-		buffers_since_start = (u64)jiffies_since_start * denominator +
-				      (HZ * numerator) / 2;
+		buffers_since_start = (u64)jiffies_since_start * denominator;
 		do_div(buffers_since_start, HZ * numerator);
+		f_time = start_time + dev->time_wrap_offset +
+			buffers_since_start * f_period;

 		/*
 		 * After more than 0xf0000000 (rounded down to a multiple of
@@ -102,15 +103,16 @@ static int vivid_thread_touch_cap(void *data)
 		 */
 		if (jiffies_since_start > JIFFIES_RESYNC) {
 			dev->jiffies_touch_cap = cur_jiffies;
-			dev->cap_seq_offset = buffers_since_start;
+			seq_offset = buffers_since_start;
 			buffers_since_start = 0;
 		}
-		dropped_bufs = buffers_since_start + dev->touch_cap_seq_offset - dev->touch_cap_seq_count;
-		dev->touch_cap_seq_count = buffers_since_start + dev->touch_cap_seq_offset;
+		dropped_bufs = buffers_since_start + seq_offset - dev->touch_cap_seq_count;
+		dev->touch_cap_seq_count = buffers_since_start + seq_offset;
 		dev->touch_cap_with_seq_wrap_count =
 			dev->touch_cap_seq_count - dev->touch_cap_seq_start;

-		vivid_thread_tch_cap_tick(dev, dropped_bufs);
+		vivid_thread_tch_cap_tick(dev, dropped_bufs, f_time);
+		mutex_unlock(&dev->mutex);

 		/*
 		 * Calculate the number of 'numerators' streamed
@@ -118,24 +120,15 @@ static int vivid_thread_touch_cap(void *data)
 		 */
 		numerators_since_start = ++buffers_since_start * numerator;

-		/* And the number of jiffies since we started */
-		jiffies_since_start = jiffies - dev->jiffies_touch_cap;
-
-		mutex_unlock(&dev->mutex);
-
 		/*
 		 * Calculate when that next buffer is supposed to start
 		 * in jiffies since we started streaming.
 		 */
-		next_jiffies_since_start = numerators_since_start * HZ +
-					   denominator / 2;
-		do_div(next_jiffies_since_start, denominator);
-		/* If it is in the past, then just schedule asap */
-		if (next_jiffies_since_start < jiffies_since_start)
-			next_jiffies_since_start = jiffies_since_start;
-
-		wait_jiffies = next_jiffies_since_start - jiffies_since_start;
-		while (time_is_after_jiffies(cur_jiffies + wait_jiffies) &&
+		next_jiffies = numerators_since_start * HZ + denominator - 1;
+		do_div(next_jiffies, denominator);
+		next_jiffies += dev->jiffies_touch_cap;
+
+		while (time_is_after_jiffies(next_jiffies) &&
 		       !kthread_should_stop())
 			schedule();
 	}
diff --git a/drivers/media/test-drivers/vivid/vivid-sdr-cap.c b/drivers/media/test-drivers/vivid/vivid-sdr-cap.c
index a81f26b76988..e0d4deb4b1a5 100644
--- a/drivers/media/test-drivers/vivid/vivid-sdr-cap.c
+++ b/drivers/media/test-drivers/vivid/vivid-sdr-cap.c
@@ -82,7 +82,7 @@ static const struct v4l2_frequency_band bands_fm[] = {
 	},
 };

-static void vivid_thread_sdr_cap_tick(struct vivid_dev *dev)
+static void vivid_thread_sdr_cap_tick(struct vivid_dev *dev, u64 f_time)
 {
 	struct vivid_buffer *sdr_cap_buf = NULL;

@@ -108,8 +108,7 @@ static void vivid_thread_sdr_cap_tick(struct vivid_dev *dev)
 		v4l2_ctrl_request_complete(sdr_cap_buf->vb.vb2_buf.req_obj.req,
 					   &dev->ctrl_hdl_sdr_cap);
 		vivid_sdr_cap_process(dev, sdr_cap_buf);
-		sdr_cap_buf->vb.vb2_buf.timestamp =
-			ktime_get_ns() + dev->time_wrap_offset;
+		sdr_cap_buf->vb.vb2_buf.timestamp = f_time;
 		vb2_buffer_done(&sdr_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
 				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 		dev->dqbuf_error = false;
@@ -119,9 +118,12 @@ static void vivid_thread_sdr_cap_tick(struct vivid_dev *dev)
 static int vivid_thread_sdr_cap(void *data)
 {
 	struct vivid_dev *dev = data;
+	u64 start_time;
+	u64 f_time;
 	u64 samples_since_start;
 	u64 buffers_since_start;
 	u64 next_jiffies_since_start;
+	u32 seq_offset = 0;
 	unsigned long jiffies_since_start;
 	unsigned long cur_jiffies;
 	unsigned wait_jiffies;
@@ -131,12 +133,12 @@ static int vivid_thread_sdr_cap(void *data)
 	set_freezable();

 	/* Resets frame counters */
-	dev->sdr_cap_seq_offset = 0;
 	dev->sdr_cap_seq_count = 0;
 	dev->jiffies_sdr_cap = jiffies;
 	dev->sdr_cap_seq_resync = false;
+	start_time = ktime_get_ns();
 	if (dev->time_wrap)
-		dev->time_wrap_offset = dev->time_wrap - ktime_get_ns();
+		dev->time_wrap_offset = dev->time_wrap - start_time;
 	else
 		dev->time_wrap_offset = 0;

@@ -153,7 +155,7 @@ static int vivid_thread_sdr_cap(void *data)
 		cur_jiffies = jiffies;
 		if (dev->sdr_cap_seq_resync) {
 			dev->jiffies_sdr_cap = cur_jiffies;
-			dev->sdr_cap_seq_offset = dev->sdr_cap_seq_count + 1;
+			seq_offset = dev->sdr_cap_seq_count + 1;
 			dev->sdr_cap_seq_count = 0;
 			dev->sdr_cap_seq_resync = false;
 		}
@@ -173,14 +175,15 @@ static int vivid_thread_sdr_cap(void *data)
 		 */
 		if (jiffies_since_start > JIFFIES_RESYNC) {
 			dev->jiffies_sdr_cap = cur_jiffies;
-			dev->sdr_cap_seq_offset = buffers_since_start;
+			seq_offset = buffers_since_start;
 			buffers_since_start = 0;
 		}
 		dev->sdr_cap_seq_count =
-			buffers_since_start + dev->sdr_cap_seq_offset;
+			buffers_since_start + seq_offset;
 		dev->sdr_cap_with_seq_wrap_count = dev->sdr_cap_seq_count - dev->sdr_cap_seq_start;
+		f_time = start_time + dev->time_wrap_offset;

-		vivid_thread_sdr_cap_tick(dev);
+		vivid_thread_sdr_cap_tick(dev, f_time);
 		mutex_unlock(&dev->mutex);

 		/*
