kpb: check if draining speed should be controlled

mrajwa · lgirdwood · commit ec577bcc33dc · 2019-12-16T15:58:19.000Z
This patch checks if draining should be controlled
in terms of speed. Such condition may be necessary
if host buffer is smaller than KPB's history buffer.

Signed-off-by: Marcin Rajwa &lt;marcin.rajwa@linux.intel.com&gt;
diff --git a/src/audio/kpb.c b/src/audio/kpb.c
@@ -995,18 +995,26 @@ static void kpb_init_draining(struct comp_dev *dev, struct kpb_client *cli)
 
 		} while (buff != first_buff);
 
-		/* Calculate time in clock ticks each draining event shall
-		 * take place. This time will be used to synchronize us with
-		 * an end application interrupts.
+		/* Should we drain in synchronized mode (sync_draining_mode)?
+		 * Note! We have already verified host params during
+		 * kpb_prepare().
 		 */
-
-		drain_interval = (host_period_size / bytes_per_ms) *
-				 ticks_per_ms;
-		/* In draining intervals we will fill only two periods
-		 * and give host time to read it.
-		 * This way we are safe to not overflow host buffer.
-		 */
-		period_bytes_limit = host_period_size * 2;
+		if (kpb->hb_buffer_size > host_buffer_size) {
+			/* Calculate time in clock ticks each draining event
+			 * shall take place. This time will be used to
+			 * synchronize us with application interrupts.
+			 */
+			drain_interval = (host_period_size / bytes_per_ms) *
+					 ticks_per_ms;
+			period_bytes_limit = host_period_size;
+			trace_kpb_with_ids(dev, "kpb_init_draining(): sync_draining_mode selected with interval %d [uS].",
+					   drain_interval * 1000 / ticks_per_ms);
+		} else {
+			/* Unlimited draining */
+			drain_interval = 0;
+			period_bytes_limit = 0;
+			trace_kpb_with_ids(dev, "kpb_init_draining: unlimited draining speed selected.");
+		}
 
 		trace_kpb_with_ids(dev, "kpb_init_draining(), "
 				   "schedule draining task");
@@ -1019,6 +1027,7 @@ static void kpb_init_draining(struct comp_dev *dev, struct kpb_client *cli)
 		kpb->draining_task_data.drain_interval = drain_interval;
 		kpb->draining_task_data.pb_limit = period_bytes_limit;
 		kpb->draining_task_data.dev = dev;
+		kpb->draining_task_data.sync_mode_on = kpb->sync_draining_mode;
 
 		/* Set host-sink copy mode to blocking */
 		comp_set_attribute(kpb->host_sink->sink, COMP_ATTR_COPY_TYPE,
@@ -1063,6 +1072,7 @@ static enum task_state kpb_draining_task(void *arg)
 	size_t time_taken = 0;
 	size_t *rt_stream_update = &draining_data->buffered_while_draining;
 	struct comp_data *kpb = comp_get_drvdata(draining_data->dev);
+	bool sync_mode_on = &draining_data->sync_mode_on;
 
 	trace_kpb("kpb_draining_task(), start.");
 
@@ -1081,7 +1091,8 @@ static enum task_state kpb_draining_task(void *arg)
 		/* Are we ready to drain further or host still need some time
 		 * to read the data already provided?
 		 */
-		if (next_copy_time > platform_timer_get(platform_timer)) {
+		if (sync_mode_on &&
+		    next_copy_time > platform_timer_get(platform_timer)) {
 			period_bytes = 0;
 			period_copy_start = platform_timer_get(platform_timer);
 			continue;
@@ -1090,7 +1101,6 @@ static enum task_state kpb_draining_task(void *arg)
 		}
 
 		size_to_read = (uint32_t)buff->end_addr - (uint32_t)buff->r_ptr;
-
 		if (size_to_read > sink->free) {
 			if (sink->free >= history_depth)
 				size_to_copy = history_depth;
@@ -1124,7 +1134,7 @@ static enum task_state kpb_draining_task(void *arg)
 			comp_copy(sink->sink);
 		}
 
-		if (period_bytes >= period_bytes_limit) {
+		if (sync_mode_on && period_bytes >= period_bytes_limit) {
 			current_time = platform_timer_get(platform_timer);
 			time_taken = current_time - period_copy_start;
 			next_copy_time = current_time + drain_interval -
diff --git a/src/include/sof/audio/kpb.h b/src/include/sof/audio/kpb.h
@@ -121,6 +121,7 @@ struct dd {
 	size_t drain_interval;
 	size_t pb_limit; /**< Period bytes limit */
 	struct comp_dev *dev;
+	bool sync_mode_on;
 };
 
 #ifdef UNIT_TEST
