Rewrite latency calculations

dagargo · dagargo · commit fd850e6e516d · 2025-08-24T16:13:47.000+02:00
diff --git a/src/engine.c b/src/engine.c
@@ -155,11 +155,12 @@ set_usb_input_data_blks (struct ow_engine *engine)
     }
 
   pthread_spin_lock (&engine->lock);
-  engine->o2h_latency =
-    engine->context->read_space (engine->context->o2h_audio);
-  if (engine->o2h_latency > engine->o2h_max_latency)
+  engine->latency_o2h =
+    engine->context->read_space (engine->context->o2h_audio) /
+    engine->o2h_frame_size;
+  if (engine->latency_o2h > engine->latency_o2h_max)
     {
-      engine->o2h_max_latency = engine->o2h_latency;
+      engine->latency_o2h_max = engine->latency_o2h;
     }
   pthread_spin_unlock (&engine->lock);
 }
@@ -234,17 +235,17 @@ set_usb_output_data_blks (struct ow_engine *engine)
 	  debug_print (2, "h2o: Clearing buffer and stopping...");
 	  memset (engine->h2o_transfer_buf, 0, engine->h2o_transfer_size);
 	  engine->reading_at_h2o_end = 0;
-	  engine->h2o_max_latency = 0;
+	  engine->latency_h2o_max = engine->latency_h2o_min;
 	  goto set_blocks;
 	}
       return;
     }
 
   pthread_spin_lock (&engine->lock);
-  engine->h2o_latency = rsh2o;
-  if (engine->h2o_latency > engine->h2o_max_latency)
+  engine->latency_h2o = rsh2o / engine->h2o_frame_size;
+  if (engine->latency_h2o > engine->latency_h2o_max)
     {
-      engine->h2o_max_latency = engine->h2o_latency;
+      engine->latency_h2o_max = engine->latency_h2o;
     }
   pthread_spin_unlock (&engine->lock);
 
@@ -282,6 +283,11 @@ set_usb_output_data_blks (struct ow_engine *engine)
 	     engine->h2o_data.src_ratio, engine->h2o_data.output_frames_gen,
 	     engine->frames_per_transfer);
 	}
+
+      // Any maximum value is invalid at this point
+      pthread_spin_lock (&engine->lock);
+      engine->latency_o2h_max = engine->latency_o2h_min;
+      pthread_spin_unlock (&engine->lock);
     }
   else
     {
@@ -478,8 +484,8 @@ ow_engine_init_mem (struct ow_engine *engine,
   debug_print (2, "h2o: audio transfer size: %zu B",
 	       engine->h2o_transfer_size);
 
-  engine->o2h_min_latency = engine->frames_per_transfer;
-  engine->h2o_min_latency = engine->frames_per_transfer;
+  engine->latency_o2h_min = engine->frames_per_transfer;
+  engine->latency_h2o_min = engine->frames_per_transfer;
 
   engine->usb.audio_frames_counter = 0;
   engine->usb.xfr_audio_in_data_len =
@@ -787,11 +793,12 @@ run_audio (void *data)
 
       debug_print (1, "Booting or clearing engine...");
 
-      engine->h2o_latency = 0;
-      engine->h2o_max_latency = 0;
+      engine->latency_h2o = engine->latency_h2o_min;
+      engine->latency_h2o_max = engine->latency_h2o_min;
+      engine->latency_o2h = engine->latency_o2h_min;
+      engine->latency_o2h_max = engine->latency_o2h_min;
+
       engine->reading_at_h2o_end = engine->context->dll ? 0 : 1;
-      engine->o2h_latency = 0;
-      engine->o2h_max_latency = 0;
 
       pthread_spin_lock (&engine->lock);
       if (engine->status <= OW_ENGINE_STATUS_STOP)
diff --git a/src/engine.h b/src/engine.h
@@ -171,13 +171,13 @@ struct ow_engine
   unsigned int blocks_per_transfer;
   unsigned int frames_per_transfer;
   pthread_spinlock_t lock;
-  //Latencies are measured in bytes
-  size_t o2h_latency;
-  size_t o2h_min_latency;
-  size_t o2h_max_latency;
-  size_t h2o_latency;
-  size_t h2o_min_latency;
-  size_t h2o_max_latency;
+  //Latencies are measured in frames
+  size_t latency_o2h;
+  size_t latency_o2h_min;
+  size_t latency_o2h_max;
+  size_t latency_h2o;
+  size_t latency_h2o_min;
+  size_t latency_h2o_max;
   pthread_t thread;
   size_t h2o_transfer_size;
   size_t o2h_transfer_size;
diff --git a/src/jclient.c b/src/jclient.c
@@ -66,39 +66,38 @@ jclient_set_latency_cb (jack_latency_callback_mode_t mode, void *cb_data)
 {
   jack_latency_range_t range;
   struct jclient *jclient = cb_data;
-  uint32_t latency, min_latency, max_latency;
   struct ow_engine *engine = ow_resampler_get_engine (jclient->resampler);
   const struct ow_device_desc *desc = &ow_engine_get_device (engine)->desc;
+  struct ow_resampler_state *state =
+    ow_resampler_get_state (jclient->resampler);
 
   debug_print (2, "JACK latency request");
 
   if (mode == JackPlaybackLatency)
     {
-      ow_resampler_get_o2h_latency (jclient->resampler, &latency,
-				    &min_latency, &max_latency);
-      debug_print (2, "o2h latency: [ %d, %d ]", min_latency, max_latency);
+      debug_print (2, "o2h latency: [ %d, %d ]", state->f_latency_o2h_min,
+		   state->f_latency_o2h_max);
 
       for (int i = 0; i < desc->outputs; i++)
 	{
 	  jack_port_get_latency_range (jclient->input_ports[0], mode, &range);
-	  range.min += min_latency;
-	  range.max += max_latency;
+	  range.min += state->f_latency_o2h_min;
+	  range.max += state->f_latency_o2h_max;
 	  jack_port_set_latency_range (jclient->output_ports[i], mode,
 				       &range);
 	}
     }
   else if (mode == JackCaptureLatency)
     {
-      ow_resampler_get_h2o_latency (jclient->resampler, &latency,
-				    &min_latency, &max_latency);
-      debug_print (2, "h2o latency: [ %d, %d ]", min_latency, max_latency);
+      debug_print (2, "h2o latency: [ %d, %d ]", state->f_latency_h2o_min,
+		   state->f_latency_h2o_max);
 
       for (int i = 0; i < desc->inputs; i++)
 	{
 	  jack_port_get_latency_range (jclient->output_ports[0], mode,
 				       &range);
-	  range.min += min_latency;
-	  range.max += max_latency;
+	  range.min += state->f_latency_h2o_min;
+	  range.max += state->f_latency_h2o_max;
 	  jack_port_set_latency_range (jclient->input_ports[i], mode, &range);
 	}
     }
diff --git a/src/main-service.c b/src/main-service.c
@@ -370,7 +370,7 @@ handle_get_state ()
 	  struct ow_engine *engine = ow_resampler_get_engine (resampler);
 	  const struct ow_device *device = ow_engine_get_device (engine);
 	  const gchar *name = ow_engine_get_overbridge_name (engine);
-	  ow_resampler_get_state (resampler, &state);
+	  ow_resampler_get_state_copy (resampler, &state);
 	  message_state_builder_add_device (builder, i, name, device, &state);
 	}
 
diff --git a/src/message.c b/src/message.c
@@ -74,17 +74,17 @@ message_state_builder_add_device (JsonBuilder *builder, guint32 id,
   json_builder_set_member_name (builder, STATE_DEVICE_STATUS);
   json_builder_add_int_value (builder, state->status);
   json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_O2H);
-  json_builder_add_double_value (builder, state->latency_o2h);
+  json_builder_add_double_value (builder, state->t_latency_o2h);
   json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_O2H_MAX);
-  json_builder_add_double_value (builder, state->latency_o2h_max);
+  json_builder_add_double_value (builder, state->t_latency_o2h_max);
   json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_O2H_MIN);
-  json_builder_add_double_value (builder, state->latency_o2h_min);
+  json_builder_add_double_value (builder, state->t_latency_o2h_min);
   json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_H2O);
-  json_builder_add_double_value (builder, state->latency_h2o);
+  json_builder_add_double_value (builder, state->t_latency_h2o);
   json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_H2O_MAX);
-  json_builder_add_double_value (builder, state->latency_h2o_max);
+  json_builder_add_double_value (builder, state->t_latency_h2o_max);
   json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_H2O_MIN);
-  json_builder_add_double_value (builder, state->latency_h2o_min);
+  json_builder_add_double_value (builder, state->t_latency_h2o_min);
   json_builder_set_member_name (builder, STATE_DEVICE_RATIO_O2H);
   json_builder_add_double_value (builder, state->ratio_o2h);
   json_builder_set_member_name (builder, STATE_DEVICE_RATIO_H2O);
@@ -184,8 +184,8 @@ message_state_reader_get_device (JsonReader *reader, guint index)
   static gchar h2o_latency[OW_LABEL_MAX_LEN];
   const gchar *name, *device_name;
 
-  state.latency_o2h = 0;
-  state.latency_h2o = 0;
+  state.t_latency_o2h = 0;
+  state.t_latency_h2o = 0;
   state.ratio_o2h = 0;
   state.ratio_o2h = 0;
 
@@ -256,7 +256,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)
 
   if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_O2H))
     {
-      state.latency_o2h = json_reader_get_double_value (reader);
+      state.t_latency_o2h = json_reader_get_double_value (reader);
       json_reader_end_member (reader);
     }
   else
@@ -266,7 +266,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)
 
   if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_O2H_MAX))
     {
-      state.latency_o2h_max = json_reader_get_double_value (reader);
+      state.t_latency_o2h_max = json_reader_get_double_value (reader);
       json_reader_end_member (reader);
     }
   else
@@ -276,7 +276,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)
 
   if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_O2H_MIN))
     {
-      state.latency_o2h_min = json_reader_get_double_value (reader);
+      state.t_latency_o2h_min = json_reader_get_double_value (reader);
       json_reader_end_member (reader);
     }
   else
@@ -296,7 +296,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)
 
   if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_H2O))
     {
-      state.latency_h2o = json_reader_get_double_value (reader);
+      state.t_latency_h2o = json_reader_get_double_value (reader);
       json_reader_end_member (reader);
     }
   else
@@ -306,7 +306,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)
 
   if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_H2O_MAX))
     {
-      state.latency_h2o_max = json_reader_get_double_value (reader);
+      state.t_latency_h2o_max = json_reader_get_double_value (reader);
       json_reader_end_member (reader);
     }
   else
@@ -316,7 +316,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)
 
   if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_H2O_MIN))
     {
-      state.latency_h2o_min = json_reader_get_double_value (reader);
+      state.t_latency_h2o_min = json_reader_get_double_value (reader);
       json_reader_end_member (reader);
     }
   else
@@ -334,22 +334,22 @@ message_state_reader_get_device (JsonReader *reader, guint index)
       goto end;
     }
 
-  if (state.latency_o2h >= 0)
+  if (state.t_latency_o2h >= 0)
     {
       g_snprintf (o2h_latency, OW_LABEL_MAX_LEN,
-		  "%.1f [%.1f, %.1f] ms", state.latency_o2h,
-		  state.latency_o2h_min, state.latency_o2h_max);
+		  "%.1f [%.1f, %.1f] ms", state.t_latency_o2h,
+		  state.t_latency_o2h_min, state.t_latency_o2h_max);
     }
   else
     {
       o2h_latency[0] = '\0';
     }
 
-  if (state.latency_h2o >= 0)
+  if (state.t_latency_h2o >= 0)
     {
       g_snprintf (h2o_latency, OW_LABEL_MAX_LEN,
-		  "%.1f [%.1f, %.1f] ms", state.latency_h2o,
-		  state.latency_h2o_min, state.latency_h2o_max);
+		  "%.1f [%.1f, %.1f] ms", state.t_latency_h2o,
+		  state.t_latency_h2o_min, state.t_latency_h2o_max);
     }
   else
     {
diff --git a/src/overwitch.h b/src/overwitch.h
@@ -170,14 +170,22 @@ struct ow_device
 struct ow_resampler_state
 {
   ow_resampler_status_t status;
-  double latency_o2h;
-  double latency_o2h_min;
-  double latency_o2h_max;
-  double latency_h2o;
-  double latency_h2o_min;
-  double latency_h2o_max;
   double ratio_o2h;
   double ratio_h2o;
+  //Time latency members
+  double t_latency_o2h;
+  double t_latency_o2h_min;
+  double t_latency_o2h_max;
+  double t_latency_h2o;
+  double t_latency_h2o_min;
+  double t_latency_h2o_max;
+  //Frame latency members
+  uint32_t f_latency_o2h;
+  uint32_t f_latency_o2h_min;
+  uint32_t f_latency_o2h_max;
+  uint32_t f_latency_h2o;
+  uint32_t f_latency_h2o_min;
+  uint32_t f_latency_h2o_max;
 };
 
 typedef void (*ow_hotplug_callback_t) (struct ow_device * device);
@@ -256,9 +264,6 @@ void ow_resampler_wait (struct ow_resampler *resampler);
 
 void ow_resampler_destroy (struct ow_resampler *resampler);
 
-void ow_resampler_get_state (struct ow_resampler *resampler,
-			     struct ow_resampler_state *state);
-
 void ow_resampler_clear_buffers (struct ow_resampler *resampler);
 
 void ow_resampler_reset (struct ow_resampler *resampler);
@@ -300,10 +305,10 @@ float *ow_resampler_get_h2o_audio_buffer (struct ow_resampler *resampler);
 struct ow_resampler_reporter *ow_resampler_get_reporter (struct ow_resampler
 							 *);
 
-void ow_resampler_get_h2o_latency (struct ow_resampler *resampler, uint32_t *,
-				   uint32_t *, uint32_t *);
+double ow_resampler_get_target_delay_ms (struct ow_resampler *resampler);
 
-void ow_resampler_get_o2h_latency (struct ow_resampler *resampler, uint32_t *,
-				   uint32_t *, uint32_t *);
+struct ow_resampler_state *ow_resampler_get_state (struct ow_resampler
+						   *resampler);
 
-double ow_resampler_get_target_delay_ms (struct ow_resampler *resampler);
+void ow_resampler_get_state_copy (struct ow_resampler *resampler,
+				  struct ow_resampler_state *state);
diff --git a/src/resampler.c b/src/resampler.c
diff --git a/src/resampler.h b/src/resampler.h
diff --git a/test/tests.c b/test/tests.c

Original file line number	Diff line number	Diff line change
`@@ -66,39 +66,38 @@ jclient_set_latency_cb (jack_latency_callback_mode_t mode, void *cb_data)`
`66`	`66`	`{`
`67`	`67`	`jack_latency_range_t range;`
`68`	`68`	`struct jclient *jclient = cb_data;`
`69`		`- uint32_t latency, min_latency, max_latency;`
`70`	`69`	`struct ow_engine *engine = ow_resampler_get_engine (jclient->resampler);`
`71`	`70`	`const struct ow_device_desc *desc = &ow_engine_get_device (engine)->desc;`
	`71`	`+ struct ow_resampler_state *state =`
	`72`	`+ ow_resampler_get_state (jclient->resampler);`
`72`	`73`
`73`	`74`	`debug_print (2, "JACK latency request");`
`74`	`75`
`75`	`76`	`if (mode == JackPlaybackLatency)`
`76`	`77`	`{`
`77`		`- ow_resampler_get_o2h_latency (jclient->resampler, &latency,`
`78`		`- &min_latency, &max_latency);`
`79`		`- debug_print (2, "o2h latency: [ %d, %d ]", min_latency, max_latency);`
	`78`	`+ debug_print (2, "o2h latency: [ %d, %d ]", state->f_latency_o2h_min,`
	`79`	`+ state->f_latency_o2h_max);`
`80`	`80`
`81`	`81`	`for (int i = 0; i < desc->outputs; i++)`
`82`	`82`	`{`
`83`	`83`	`jack_port_get_latency_range (jclient->input_ports[0], mode, &range);`
`84`		`- range.min += min_latency;`
`85`		`- range.max += max_latency;`
	`84`	`+ range.min += state->f_latency_o2h_min;`
	`85`	`+ range.max += state->f_latency_o2h_max;`
`86`	`86`	`jack_port_set_latency_range (jclient->output_ports[i], mode,`
`87`	`87`	`&range);`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`else if (mode == JackCaptureLatency)`
`91`	`91`	`{`
`92`		`- ow_resampler_get_h2o_latency (jclient->resampler, &latency,`
`93`		`- &min_latency, &max_latency);`
`94`		`- debug_print (2, "h2o latency: [ %d, %d ]", min_latency, max_latency);`
	`92`	`+ debug_print (2, "h2o latency: [ %d, %d ]", state->f_latency_h2o_min,`
	`93`	`+ state->f_latency_h2o_max);`
`95`	`94`
`96`	`95`	`for (int i = 0; i < desc->inputs; i++)`
`97`	`96`	`{`
`98`	`97`	`jack_port_get_latency_range (jclient->output_ports[0], mode,`
`99`	`98`	`&range);`
`100`		`- range.min += min_latency;`
`101`		`- range.max += max_latency;`
	`99`	`+ range.min += state->f_latency_h2o_min;`
	`100`	`+ range.max += state->f_latency_h2o_max;`
`102`	`101`	`jack_port_set_latency_range (jclient->input_ports[i], mode, &range);`
`103`	`102`	`}`
`104`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -370,7 +370,7 @@ handle_get_state ()`
`370`	`370`	`struct ow_engine *engine = ow_resampler_get_engine (resampler);`
`371`	`371`	`const struct ow_device *device = ow_engine_get_device (engine);`
`372`	`372`	`const gchar *name = ow_engine_get_overbridge_name (engine);`
`373`		`- ow_resampler_get_state (resampler, &state);`
	`373`	`+ ow_resampler_get_state_copy (resampler, &state);`
`374`	`374`	`message_state_builder_add_device (builder, i, name, device, &state);`
`375`	`375`	`}`
`376`	`376`
Original file line number	Diff line number	Diff line change
`@@ -74,17 +74,17 @@ message_state_builder_add_device (JsonBuilder *builder, guint32 id,`
`74`	`74`	`json_builder_set_member_name (builder, STATE_DEVICE_STATUS);`
`75`	`75`	`json_builder_add_int_value (builder, state->status);`
`76`	`76`	`json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_O2H);`
`77`		`- json_builder_add_double_value (builder, state->latency_o2h);`
	`77`	`+ json_builder_add_double_value (builder, state->t_latency_o2h);`
`78`	`78`	`json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_O2H_MAX);`
`79`		`- json_builder_add_double_value (builder, state->latency_o2h_max);`
	`79`	`+ json_builder_add_double_value (builder, state->t_latency_o2h_max);`
`80`	`80`	`json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_O2H_MIN);`
`81`		`- json_builder_add_double_value (builder, state->latency_o2h_min);`
	`81`	`+ json_builder_add_double_value (builder, state->t_latency_o2h_min);`
`82`	`82`	`json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_H2O);`
`83`		`- json_builder_add_double_value (builder, state->latency_h2o);`
	`83`	`+ json_builder_add_double_value (builder, state->t_latency_h2o);`
`84`	`84`	`json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_H2O_MAX);`
`85`		`- json_builder_add_double_value (builder, state->latency_h2o_max);`
	`85`	`+ json_builder_add_double_value (builder, state->t_latency_h2o_max);`
`86`	`86`	`json_builder_set_member_name (builder, STATE_DEVICE_LATENCY_H2O_MIN);`
`87`		`- json_builder_add_double_value (builder, state->latency_h2o_min);`
	`87`	`+ json_builder_add_double_value (builder, state->t_latency_h2o_min);`
`88`	`88`	`json_builder_set_member_name (builder, STATE_DEVICE_RATIO_O2H);`
`89`	`89`	`json_builder_add_double_value (builder, state->ratio_o2h);`
`90`	`90`	`json_builder_set_member_name (builder, STATE_DEVICE_RATIO_H2O);`
`@@ -184,8 +184,8 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`184`	`184`	`static gchar h2o_latency[OW_LABEL_MAX_LEN];`
`185`	`185`	`const gchar name, device_name;`
`186`	`186`
`187`		`- state.latency_o2h = 0;`
`188`		`- state.latency_h2o = 0;`
	`187`	`+ state.t_latency_o2h = 0;`
	`188`	`+ state.t_latency_h2o = 0;`
`189`	`189`	`state.ratio_o2h = 0;`
`190`	`190`	`state.ratio_o2h = 0;`
`191`	`191`
`@@ -256,7 +256,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`256`	`256`
`257`	`257`	`if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_O2H))`
`258`	`258`	`{`
`259`		`- state.latency_o2h = json_reader_get_double_value (reader);`
	`259`	`+ state.t_latency_o2h = json_reader_get_double_value (reader);`
`260`	`260`	`json_reader_end_member (reader);`
`261`	`261`	`}`
`262`	`262`	`else`
`@@ -266,7 +266,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`266`	`266`
`267`	`267`	`if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_O2H_MAX))`
`268`	`268`	`{`
`269`		`- state.latency_o2h_max = json_reader_get_double_value (reader);`
	`269`	`+ state.t_latency_o2h_max = json_reader_get_double_value (reader);`
`270`	`270`	`json_reader_end_member (reader);`
`271`	`271`	`}`
`272`	`272`	`else`
`@@ -276,7 +276,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`276`	`276`
`277`	`277`	`if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_O2H_MIN))`
`278`	`278`	`{`
`279`		`- state.latency_o2h_min = json_reader_get_double_value (reader);`
	`279`	`+ state.t_latency_o2h_min = json_reader_get_double_value (reader);`
`280`	`280`	`json_reader_end_member (reader);`
`281`	`281`	`}`
`282`	`282`	`else`
`@@ -296,7 +296,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`296`	`296`
`297`	`297`	`if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_H2O))`
`298`	`298`	`{`
`299`		`- state.latency_h2o = json_reader_get_double_value (reader);`
	`299`	`+ state.t_latency_h2o = json_reader_get_double_value (reader);`
`300`	`300`	`json_reader_end_member (reader);`
`301`	`301`	`}`
`302`	`302`	`else`
`@@ -306,7 +306,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`306`	`306`
`307`	`307`	`if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_H2O_MAX))`
`308`	`308`	`{`
`309`		`- state.latency_h2o_max = json_reader_get_double_value (reader);`
	`309`	`+ state.t_latency_h2o_max = json_reader_get_double_value (reader);`
`310`	`310`	`json_reader_end_member (reader);`
`311`	`311`	`}`
`312`	`312`	`else`
`@@ -316,7 +316,7 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`316`	`316`
`317`	`317`	`if (json_reader_read_member (reader, STATE_DEVICE_LATENCY_H2O_MIN))`
`318`	`318`	`{`
`319`		`- state.latency_h2o_min = json_reader_get_double_value (reader);`
	`319`	`+ state.t_latency_h2o_min = json_reader_get_double_value (reader);`
`320`	`320`	`json_reader_end_member (reader);`
`321`	`321`	`}`
`322`	`322`	`else`
`@@ -334,22 +334,22 @@ message_state_reader_get_device (JsonReader *reader, guint index)`
`334`	`334`	`goto end;`
`335`	`335`	`}`
`336`	`336`
`337`		`- if (state.latency_o2h >= 0)`
	`337`	`+ if (state.t_latency_o2h >= 0)`
`338`	`338`	`{`
`339`	`339`	`g_snprintf (o2h_latency, OW_LABEL_MAX_LEN,`
`340`		`- "%.1f [%.1f, %.1f] ms", state.latency_o2h,`
`341`		`- state.latency_o2h_min, state.latency_o2h_max);`
	`340`	`+ "%.1f [%.1f, %.1f] ms", state.t_latency_o2h,`
	`341`	`+ state.t_latency_o2h_min, state.t_latency_o2h_max);`
`342`	`342`	`}`
`343`	`343`	`else`
`344`	`344`	`{`
`345`	`345`	`o2h_latency[0] = '\0';`
`346`	`346`	`}`
`347`	`347`
`348`		`- if (state.latency_h2o >= 0)`
	`348`	`+ if (state.t_latency_h2o >= 0)`
`349`	`349`	`{`
`350`	`350`	`g_snprintf (h2o_latency, OW_LABEL_MAX_LEN,`
`351`		`- "%.1f [%.1f, %.1f] ms", state.latency_h2o,`
`352`		`- state.latency_h2o_min, state.latency_h2o_max);`
	`351`	`+ "%.1f [%.1f, %.1f] ms", state.t_latency_h2o,`
	`352`	`+ state.t_latency_h2o_min, state.t_latency_h2o_max);`
`353`	`353`	`}`
`354`	`354`	`else`
`355`	`355`	`{`