diff --git a/src/audio/asrc/asrc.c b/src/audio/asrc/asrc.c
index 2561c6a0de74..f9cb6c989f1b 100644
--- a/src/audio/asrc/asrc.c
+++ b/src/audio/asrc/asrc.c
@@ -45,6 +45,12 @@
 	trace_error_comp(TRACE_CLASS_SRC, comp_ptr,		\
 			 __e, ##__VA_ARGS__)
 
+typedef void (*asrc_proc_func)(struct comp_dev *dev,
+			       const struct audio_stream *source,
+			       struct audio_stream *sink,
+			       int *consumed,
+			       int *produced);
+
 /* asrc component private data */
 struct comp_data {
 	struct asrc_farrow *asrc_obj;	/* ASRC core data */
@@ -65,11 +71,7 @@ struct comp_data {
 	uint8_t *buf;		/* Samples buffer for input and output */
 	uint8_t *ibuf[PLATFORM_MAX_CHANNELS];	/* Input channels pointers */
 	uint8_t *obuf[PLATFORM_MAX_CHANNELS];	/* Output channels pointers */
-	void (*asrc_func)(struct comp_dev *dev,
-			  struct comp_buffer *source,
-			  struct comp_buffer *sink,
-			  int *consumed,
-			  int *produced);
+	asrc_proc_func asrc_func;		/* ASRC processing function */
 };
 
 /* In-line functions */
@@ -88,7 +90,8 @@ static inline void src_inc_wrap_s16(int16_t **ptr, int16_t *end, size_t size)
 
 /* A fast copy function for same in and out rate */
 static void src_copy_s32(struct comp_dev *dev,
-			 struct comp_buffer *source, struct comp_buffer *sink,
+			 const struct audio_stream *source,
+			 struct audio_stream *sink,
 			 int *n_read, int *n_written)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
@@ -145,7 +148,8 @@ static void src_copy_s32(struct comp_dev *dev,
 }
 
 static void src_copy_s16(struct comp_dev *dev,
-			 struct comp_buffer *source, struct comp_buffer *sink,
+			 const struct audio_stream *source,
+			 struct audio_stream *sink,
 			 int *n_read, int *n_written)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
@@ -385,17 +389,19 @@ static int asrc_prepare(struct comp_dev *dev)
 				struct comp_buffer, source_list);
 
 	/* get source data format and period bytes */
-	cd->source_format = sourceb->frame_fmt;
-	source_period_bytes = buffer_period_bytes(sourceb, cd->source_frames);
+	cd->source_format = sourceb->stream.frame_fmt;
+	source_period_bytes = audio_stream_period_bytes(&sourceb->stream,
+							cd->source_frames);
 
 	/* get sink data format and period bytes */
-	cd->sink_format = sinkb->frame_fmt;
-	sink_period_bytes = buffer_period_bytes(sinkb, cd->sink_frames);
-
-	if (sinkb->size < config->periods_sink * sink_period_bytes) {
-		trace_asrc_error_with_ids(dev, "asrc_prepare(), sink size=%d"
-					  " is insufficient, when periods=%d"
-					  ", period_bytes=%d", sinkb->size,
+	cd->sink_format = sinkb->stream.frame_fmt;
+	sink_period_bytes = audio_stream_period_bytes(&sinkb->stream,
+						      cd->sink_frames);
+
+	if (sinkb->stream.size < config->periods_sink * sink_period_bytes) {
+		trace_asrc_error_with_ids(dev,
+					  "asrc_prepare(), sink size=%d is insufficient, when periods=%d, period_bytes=%d",
+					  sinkb->stream.size,
 					  config->periods_sink,
 					  sink_period_bytes);
 		ret = -ENOMEM;
@@ -415,7 +421,7 @@ static int asrc_prepare(struct comp_dev *dev)
 	}
 
 	/* ASRC supports S16_LE, S24_4LE and S32_LE formats */
-	switch (sourceb->frame_fmt) {
+	switch (sourceb->stream.frame_fmt) {
 	case SOF_IPC_FRAME_S16_LE:
 		cd->asrc_func = src_copy_s16;
 		break;
@@ -435,7 +441,7 @@ static int asrc_prepare(struct comp_dev *dev)
 	/*
 	 * Allocate input and output data buffer
 	 */
-	frame_bytes = buffer_frame_bytes(sourceb);
+	frame_bytes = audio_stream_frame_bytes(&sourceb->stream);
 	cd->buf_size = (cd->source_frames_max + cd->sink_frames_max) *
 		frame_bytes;
 
@@ -449,8 +455,8 @@ static int asrc_prepare(struct comp_dev *dev)
 		goto err;
 	}
 
-	sample_bytes = frame_bytes / sourceb->channels;
-	for (i = 0; i < sourceb->channels; i++) {
+	sample_bytes = frame_bytes / sourceb->stream.channels;
+	for (i = 0; i < sourceb->stream.channels; i++) {
 		cd->ibuf[i] = cd->buf + i * sample_bytes;
 		cd->obuf[i] = cd->ibuf[i] + cd->source_frames_max * frame_bytes;
 	}
@@ -459,7 +465,7 @@ static int asrc_prepare(struct comp_dev *dev)
 	 * Get required size and allocate memory for ASRC
 	 */
 	sample_bits = sample_bytes * 8;
-	ret = asrc_get_required_size(&cd->asrc_size, sourceb->channels,
+	ret = asrc_get_required_size(&cd->asrc_size, sourceb->stream.channels,
 				     sample_bits);
 	if (ret) {
 		trace_asrc_error_with_ids(dev, "asrc_prepare(), get_required_size_bytes failed");
@@ -479,7 +485,7 @@ static int asrc_prepare(struct comp_dev *dev)
 	/*
 	 * Initialize ASRC
 	 */
-	ret = asrc_initialise(cd->asrc_obj, sourceb->channels,
+	ret = asrc_initialise(cd->asrc_obj, sourceb->stream.channels,
 			      cd->source_rate, cd->sink_rate,
 			      ASRC_IOF_INTERLEAVED, ASRC_IOF_INTERLEAVED,
 			      ASRC_BM_LINEAR, cd->frames, sample_bits,
@@ -529,8 +535,10 @@ static int asrc_copy(struct comp_dev *dev)
 	sink = list_first_item(&dev->bsink_list, struct comp_buffer,
 			       source_list);
 
-	frames_src = source->avail / buffer_frame_bytes(source);
-	frames_snk = sink->free / buffer_frame_bytes(sink);
+	frames_src = source->stream.avail /
+		     audio_stream_frame_bytes(&source->stream);
+	frames_snk = sink->stream.free /
+		     audio_stream_frame_bytes(&sink->stream);
 
 	cd->source_frames = MIN(frames_src, cd->source_frames_max);
 	cd->sink_frames = ceil_divide(cd->source_frames * cd->sink_rate,
@@ -549,7 +557,8 @@ static int asrc_copy(struct comp_dev *dev)
 	}
 
 	if (cd->source_frames && cd->sink_frames)
-		cd->asrc_func(dev, source, sink, &consumed, &produced);
+		cd->asrc_func(dev, &source->stream, &sink->stream, &consumed,
+			      &produced);
 
 	tracev_asrc_with_ids(dev, "asrc_copy(), consumed = %u,  produced = %u",
 			     consumed, produced);
@@ -559,11 +568,11 @@ static int asrc_copy(struct comp_dev *dev)
 	 */
 	if (consumed > 0)
 		comp_update_buffer_consume(source, consumed *
-					   buffer_frame_bytes(source));
+				audio_stream_frame_bytes(&source->stream));
 
 	if (produced > 0)
 		comp_update_buffer_produce(sink, produced *
-					   buffer_frame_bytes(sink));
+				audio_stream_frame_bytes(&sink->stream));
 
 	return 0;
 }
diff --git a/src/audio/buffer.c b/src/audio/buffer.c
index 48d7d1a6b948..adac9ce3d886 100644
--- a/src/audio/buffer.c
+++ b/src/audio/buffer.c
@@ -40,8 +40,8 @@ struct comp_buffer *buffer_alloc(uint32_t size, uint32_t caps, uint32_t align)
 		return NULL;
 	}
 
-	buffer->addr = rballoc_align(0, caps, size, align);
-	if (!buffer->addr) {
+	buffer->stream.addr = rballoc_align(0, caps, size, align);
+	if (!buffer->stream.addr) {
 		rfree(buffer);
 		trace_buffer_error("buffer_alloc() error: "
 				   "could not alloc size = %u "
@@ -86,21 +86,21 @@ int buffer_set_size(struct comp_buffer *buffer, uint32_t size)
 		return -EINVAL;
 	}
 
-	if (size == buffer->size)
+	if (size == buffer->stream.size)
 		return 0;
 
-	new_ptr = rbrealloc(buffer->addr, 0, buffer->caps, size);
+	new_ptr = rbrealloc(buffer->stream.addr, 0, buffer->caps, size);
 
 	/* we couldn't allocate bigger chunk */
-	if (!new_ptr && size > buffer->size) {
+	if (!new_ptr && size > buffer->stream.size) {
 		trace_buffer_error_with_ids(buffer, "resize error: can't alloc %u bytes type %u",
-					    buffer->size, buffer->caps);
+					    buffer->stream.size, buffer->caps);
 		return -ENOMEM;
 	}
 
 	/* use bigger chunk, else just use the old chunk but set smaller */
 	if (new_ptr)
-		buffer->addr = new_ptr;
+		buffer->stream.addr = new_ptr;
 
 	buffer_init(buffer, size, buffer->caps);
 
@@ -124,7 +124,7 @@ void buffer_free(struct comp_buffer *buffer)
 
 	list_item_del(&buffer->source_list);
 	list_item_del(&buffer->sink_list);
-	rfree(buffer->addr);
+	rfree(buffer->stream.addr);
 	rfree(buffer);
 }
 
@@ -134,8 +134,9 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 	struct buffer_cb_transact cb_data = {
 		.buffer = buffer,
 		.transaction_amount = bytes,
-		.transaction_begin_address = buffer->w_ptr,
+		.transaction_begin_address = buffer->stream.w_ptr,
 	};
+	char *addr;
 
 	/* return if no bytes */
 	if (!bytes) {
@@ -150,42 +151,24 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 
 	irq_local_disable(flags);
 
-	buffer->w_ptr = (char *)buffer->w_ptr + bytes;
-
-	/* check for pointer wrap */
-	if (buffer->w_ptr >= buffer->end_addr)
-		buffer->w_ptr = (char *)buffer->addr +
-			((char *)buffer->w_ptr - (char *)buffer->end_addr);
-
-	/* "overwrite" old data in circular wrap case */
-	if (bytes > buffer->free)
-		buffer->r_ptr = buffer->w_ptr;
-
-	/* calculate available bytes */
-	if (buffer->r_ptr < buffer->w_ptr)
-		buffer->avail = (char *)buffer->w_ptr - (char *)buffer->r_ptr;
-	else if (buffer->r_ptr == buffer->w_ptr)
-		buffer->avail = buffer->size; /* full */
-	else
-		buffer->avail = buffer->size -
-			((char *)buffer->r_ptr - (char *)buffer->w_ptr);
-
-	/* calculate free bytes */
-	buffer->free = buffer->size - buffer->avail;
+	audio_stream_produce(&buffer->stream, bytes);
 
 	notifier_event(buffer, NOTIFIER_ID_BUFFER_PRODUCE,
 		       NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data));
 
 	irq_local_enable(flags);
 
+	addr = buffer->stream.addr;
+
 	tracev_buffer_with_ids(buffer,
 			       "comp_update_buffer_produce(), ((buffer->avail << 16) | buffer->free) = %08x, ((buffer->id << 16) | buffer->size) = %08x",
-			       (buffer->avail << 16) | buffer->free,
-			       (buffer->id << 16) | buffer->size);
+			       (buffer->stream.avail << 16) |
+			       buffer->stream.free,
+			       (buffer->id << 16) | buffer->stream.size);
 	tracev_buffer_with_ids(buffer,
 			       "comp_update_buffer_produce(), ((buffer->r_ptr - buffer->addr) << 16 | (buffer->w_ptr - buffer->addr)) = %08x",
-			       ((char *)buffer->r_ptr - (char *)buffer->addr) << 16 |
-			       ((char *)buffer->w_ptr - (char *)buffer->addr));
+			       ((char *)buffer->stream.r_ptr - addr) << 16 |
+			       ((char *)buffer->stream.w_ptr - addr));
 }
 
 void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes)
@@ -194,8 +177,9 @@ void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes)
 	struct buffer_cb_transact cb_data = {
 		.buffer = buffer,
 		.transaction_amount = bytes,
-		.transaction_begin_address = buffer->r_ptr,
+		.transaction_begin_address = buffer->stream.r_ptr,
 	};
+	char *addr;
 
 	/* return if no bytes */
 	if (!bytes) {
@@ -210,34 +194,20 @@ void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes)
 
 	irq_local_disable(flags);
 
-	buffer->r_ptr = (char *)buffer->r_ptr + bytes;
-
-	/* check for pointer wrap */
-	if (buffer->r_ptr >= buffer->end_addr)
-		buffer->r_ptr = (char *)buffer->addr +
-			((char *)buffer->r_ptr - (char *)buffer->end_addr);
-
-	/* calculate available bytes */
-	if (buffer->r_ptr < buffer->w_ptr)
-		buffer->avail = (char *)buffer->w_ptr - (char *)buffer->r_ptr;
-	else if (buffer->r_ptr == buffer->w_ptr)
-		buffer->avail = 0; /* empty */
-	else
-		buffer->avail = buffer->size -
-			((char *)buffer->r_ptr - (char *)buffer->w_ptr);
-
-	/* calculate free bytes */
-	buffer->free = buffer->size - buffer->avail;
+	audio_stream_consume(&buffer->stream, bytes);
 
 	notifier_event(buffer, NOTIFIER_ID_BUFFER_CONSUME,
 		       NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data));
 
 	irq_local_enable(flags);
 
+	addr = buffer->stream.addr;
+
 	tracev_buffer_with_ids(buffer,
 			       "comp_update_buffer_consume(), (buffer->avail << 16) | buffer->free = %08x, (buffer->id << 16) | buffer->size = %08x, (buffer->r_ptr - buffer->addr) << 16 | (buffer->w_ptr - buffer->addr)) = %08x",
-			       (buffer->avail << 16) | buffer->free,
-			       (buffer->id << 16) | buffer->size,
-			       ((char *)buffer->r_ptr - (char *)buffer->addr) << 16 |
-			       ((char *)buffer->w_ptr - (char *)buffer->addr));
+			       (buffer->stream.avail << 16) |
+			       buffer->stream.free,
+			       (buffer->id << 16) | buffer->stream.size,
+			       ((char *)buffer->stream.r_ptr - addr) << 16 |
+			       ((char *)buffer->stream.w_ptr - addr));
 }
diff --git a/src/audio/component.c b/src/audio/component.c
index 51a76a04ce20..edc5f1d14699 100644
--- a/src/audio/component.c
+++ b/src/audio/component.c
@@ -215,9 +215,10 @@ int comp_get_copy_limits(struct comp_dev *dev, struct comp_copy_limits *cl)
 	cl->sink = list_first_item(&dev->bsink_list, struct comp_buffer,
 				   source_list);
 
-	cl->frames = buffer_avail_frames(cl->source, cl->sink);
-	cl->source_frame_bytes = buffer_frame_bytes(cl->source);
-	cl->sink_frame_bytes = buffer_frame_bytes(cl->sink);
+	cl->frames = audio_stream_avail_frames(&cl->source->stream,
+					       &cl->sink->stream);
+	cl->source_frame_bytes = audio_stream_frame_bytes(&cl->source->stream);
+	cl->sink_frame_bytes = audio_stream_frame_bytes(&cl->sink->stream);
 	cl->source_bytes = cl->frames * cl->source_frame_bytes;
 	cl->sink_bytes = cl->frames * cl->sink_frame_bytes;
 
diff --git a/src/audio/dai.c b/src/audio/dai.c
index 6a5104951dc0..8f80c2760cf7 100644
--- a/src/audio/dai.c
+++ b/src/audio/dai.c
@@ -82,6 +82,7 @@ static void dai_dma_cb(void *arg, enum notify_id type, void *data)
 	struct comp_dev *dev = arg;
 	struct dai_data *dd = comp_get_drvdata(dev);
 	uint32_t bytes = next->elem.size;
+	uint32_t sink_bytes;
 	uint32_t samples = bytes / sample_bytes(dd->frame_fmt);
 	void *buffer_ptr;
 
@@ -108,19 +109,20 @@ static void dai_dma_cb(void *arg, enum notify_id type, void *data)
 		return;
 	}
 
+	sink_bytes = samples *
+		     audio_stream_sample_bytes(&dd->local_buffer->stream);
+
 	if (dev->direction == SOF_IPC_STREAM_PLAYBACK) {
-		dma_buffer_copy_to(dd->local_buffer, samples *
-				   buffer_sample_bytes(dd->local_buffer),
-				   dd->dma_buffer, bytes, dd->process, samples);
+		dma_buffer_copy_to(dd->local_buffer, sink_bytes,
+				   dd->dma_buffer, bytes,
+				   dd->process, samples);
 
-		buffer_ptr = dd->local_buffer->r_ptr;
+		buffer_ptr = dd->local_buffer->stream.r_ptr;
 	} else {
 		dma_buffer_copy_from(dd->dma_buffer, bytes, dd->local_buffer,
-				     samples *
-				     buffer_sample_bytes(dd->local_buffer),
-				     dd->process, samples);
+				     sink_bytes, dd->process, samples);
 
-		buffer_ptr = dd->local_buffer->w_ptr;
+		buffer_ptr = dd->local_buffer->stream.w_ptr;
 	}
 
 	/* update host position (in bytes offset) for drivers */
@@ -128,7 +130,8 @@ static void dai_dma_cb(void *arg, enum notify_id type, void *data)
 	if (dd->dai_pos) {
 		dd->dai_pos_blks += bytes;
 		*dd->dai_pos = dd->dai_pos_blks +
-			(char *)buffer_ptr - (char *)dd->dma_buffer->addr;
+			       (char *)buffer_ptr -
+			       (char *)dd->dma_buffer->stream.addr;
 	}
 }
 
@@ -223,12 +226,12 @@ static int dai_playback_params(struct comp_dev *dev, uint32_t period_bytes,
 {
 	struct dai_data *dd = comp_get_drvdata(dev);
 	struct dma_sg_config *config = &dd->config;
+	uint32_t local_fmt = dd->local_buffer->stream.frame_fmt;
 	uint32_t fifo;
 	int err;
 
 	/* set processing function */
-	dd->process = pcm_get_conversion_function(dd->local_buffer->frame_fmt,
-						  dd->frame_fmt);
+	dd->process = pcm_get_conversion_function(local_fmt, dd->frame_fmt);
 
 	/* set up DMA configuration */
 	config->direction = DMA_DIR_MEM_TO_DEV;
@@ -258,7 +261,7 @@ static int dai_playback_params(struct comp_dev *dev, uint32_t period_bytes,
 				   config->direction,
 				   period_count,
 				   period_bytes,
-				   (uintptr_t)(dd->dma_buffer->addr),
+				   (uintptr_t)(dd->dma_buffer->stream.addr),
 				   fifo);
 		if (err < 0) {
 			trace_dai_error_with_ids(dev, "dai_playback_params() "
@@ -276,12 +279,12 @@ static int dai_capture_params(struct comp_dev *dev, uint32_t period_bytes,
 {
 	struct dai_data *dd = comp_get_drvdata(dev);
 	struct dma_sg_config *config = &dd->config;
+	uint32_t local_fmt = dd->local_buffer->stream.frame_fmt;
 	uint32_t fifo;
 	int err;
 
 	/* set processing function */
-	dd->process = pcm_get_conversion_function(dd->frame_fmt,
-						  dd->local_buffer->frame_fmt);
+	dd->process = pcm_get_conversion_function(dd->frame_fmt, local_fmt);
 
 	/* set up DMA configuration */
 	config->direction = DMA_DIR_DEV_TO_MEM;
@@ -322,7 +325,7 @@ static int dai_capture_params(struct comp_dev *dev, uint32_t period_bytes,
 				   config->direction,
 				   period_count,
 				   period_bytes,
-				   (uintptr_t)(dd->dma_buffer->addr),
+				   (uintptr_t)(dd->dma_buffer->stream.addr),
 				   fifo);
 		if (err < 0) {
 			trace_dai_error_with_ids(dev, "dai_capture_params() "
@@ -403,7 +406,8 @@ static int dai_params(struct comp_dev *dev,
 	dd->frame_fmt = dconfig->frame_fmt;
 
 	/* calculate frame size */
-	frame_size = frame_bytes(dd->frame_fmt, dd->local_buffer->channels);
+	frame_size = frame_bytes(dd->frame_fmt,
+				 dd->local_buffer->stream.channels);
 
 	/* calculate period size */
 	period_bytes = dev->frames * frame_size;
@@ -473,7 +477,8 @@ static int dai_prepare(struct comp_dev *dev)
 
 	/* TODO: not sure what this wb is for? */
 	/* write back buffer contents from cache */
-	dcache_writeback_region(dd->dma_buffer->addr, dd->dma_buffer->size);
+	dcache_writeback_region(dd->dma_buffer->stream.addr,
+				dd->dma_buffer->stream.size);
 
 	/* dma reconfig not required if XRUN handling */
 	if (dd->xrun) {
@@ -645,15 +650,15 @@ static int dai_copy(struct comp_dev *dev)
 
 	/* calculate minimum size to copy */
 	if (dev->direction == SOF_IPC_STREAM_PLAYBACK) {
-		src_samples = dd->local_buffer->avail /
-			buffer_sample_bytes(dd->local_buffer);
+		src_samples = dd->local_buffer->stream.avail /
+			audio_stream_sample_bytes(&dd->local_buffer->stream);
 		sink_samples = free_bytes / sample_bytes(dd->frame_fmt);
 		copy_bytes = MIN(src_samples, sink_samples) *
 			sample_bytes(dd->frame_fmt);
 	} else {
 		src_samples = avail_bytes / sample_bytes(dd->frame_fmt);
-		sink_samples = dd->local_buffer->free /
-			buffer_sample_bytes(dd->local_buffer);
+		sink_samples = dd->local_buffer->stream.free /
+			audio_stream_sample_bytes(&dd->local_buffer->stream);
 		copy_bytes = MIN(src_samples, sink_samples) *
 			sample_bytes(dd->frame_fmt);
 	}
diff --git a/src/audio/detect_test.c b/src/audio/detect_test.c
index e9f43c10721e..178ce74ea496 100644
--- a/src/audio/detect_test.c
+++ b/src/audio/detect_test.c
@@ -88,7 +88,7 @@ struct comp_data {
 	struct kpb_client client_data;
 
 	void (*detect_func)(struct comp_dev *dev,
-			    struct comp_buffer *source, uint32_t frames);
+			    const struct audio_stream *source, uint32_t frames);
 };
 
 static inline bool detector_is_sample_width_supported(enum sof_ipc_frame sf)
@@ -118,7 +118,7 @@ static inline bool detector_is_sample_width_supported(enum sof_ipc_frame sf)
 	return ret;
 }
 
-static void notify_host(struct comp_dev *dev)
+static void notify_host(const struct comp_dev *dev)
 {
 	struct sof_ipc_comp_event event;
 
@@ -135,7 +135,7 @@ static void notify_host(struct comp_dev *dev)
 	ipc_platform_send_msg();
 }
 
-static void notify_kpb(struct comp_dev *dev)
+static void notify_kpb(const struct comp_dev *dev)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 
@@ -157,14 +157,15 @@ static void notify_kpb(struct comp_dev *dev)
 		       sizeof(cd->event_data));
 }
 
-static void detect_test_notify(struct comp_dev *dev)
+static void detect_test_notify(const struct comp_dev *dev)
 {
 	notify_host(dev);
 	notify_kpb(dev);
 }
 
 static void default_detect_test(struct comp_dev *dev,
-				struct comp_buffer *source, uint32_t frames)
+				const struct audio_stream *source,
+				uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	void *src;
@@ -186,8 +187,8 @@ static void default_detect_test(struct comp_dev *dev,
 	/* perform detection within current period */
 	for (sample = 0; sample < count && !cd->detected; ++sample) {
 		src = (valid_bits == 16U) ?
-		      buffer_read_frag_s16(source, sample) :
-		      buffer_read_frag_s32(source, sample);
+		      audio_stream_read_frag_s16(source, sample) :
+		      audio_stream_read_frag_s32(source, sample);
 		if (valid_bits > 16U) {
 			diff = abs(*(int32_t *)src) - abs(cd->activation);
 		} else {
@@ -400,16 +401,16 @@ static int test_keyword_params(struct comp_dev *dev,
 				  sink_list);
 
 	/* TODO: remove in the future */
-	sourceb->channels = 1;
+	sourceb->stream.channels = 1;
 
-	if (sourceb->channels != 1) {
+	if (sourceb->stream.channels != 1) {
 		trace_keyword_error_with_ids(dev, "test_keyword_params() "
 					     "error: only single-channel "
 					     "supported");
 		return -EINVAL;
 	}
 
-	if (!detector_is_sample_width_supported(sourceb->frame_fmt)) {
+	if (!detector_is_sample_width_supported(sourceb->stream.frame_fmt)) {
 		trace_keyword_error_with_ids(dev, "test_keyword_params() "
 					     "error: only 16-bit format "
 					     "supported");
@@ -419,7 +420,7 @@ static int test_keyword_params(struct comp_dev *dev,
 	/* calculate the length of the preamble */
 	if (cd->config.preamble_time) {
 		cd->keyphrase_samples = cd->config.preamble_time *
-					(sourceb->rate / 1000);
+					(sourceb->stream.rate / 1000);
 	} else {
 		cd->keyphrase_samples = KEYPHRASE_DEFAULT_PREAMBLE_LENGTH;
 	}
@@ -755,11 +756,12 @@ static int test_keyword_copy(struct comp_dev *dev)
 				 struct comp_buffer, sink_list);
 
 	/* copy and perform detection */
-	cd->detect_func(dev, source,
-			source->avail / buffer_frame_bytes(source));
+	cd->detect_func(dev, &source->stream,
+			source->stream.avail /
+			audio_stream_frame_bytes(&source->stream));
 
 	/* calc new available */
-	comp_update_buffer_consume(source, source->avail);
+	comp_update_buffer_consume(source, source->stream.avail);
 
 	return 0;
 }
diff --git a/src/audio/eq_fir/eq_fir.c b/src/audio/eq_fir/eq_fir.c
index 1954b35e0637..182911e15e08 100644
--- a/src/audio/eq_fir/eq_fir.c
+++ b/src/audio/eq_fir/eq_fir.c
@@ -70,8 +70,8 @@ struct comp_data {
 	size_t fir_delay_size;			/**< allocated size */
 	bool config_ready;			/**< set when fully received */
 	void (*eq_fir_func)(struct fir_state_32x16 fir[],
-			    struct comp_buffer *source,
-			    struct comp_buffer *sink,
+			    const struct audio_stream *source,
+			    struct audio_stream *sink,
 			    int frames, int nch);
 };
 
@@ -149,7 +149,7 @@ static inline int set_fir_func(struct comp_dev *dev)
 	sourceb = list_first_item(&dev->bsource_list, struct comp_buffer,
 				  sink_list);
 
-	switch (sourceb->frame_fmt) {
+	switch (sourceb->stream.frame_fmt) {
 #if CONFIG_FORMAT_S16LE
 	case SOF_IPC_FRAME_S16_LE:
 		trace_eq_with_ids(dev, "set_fir_func(), SOF_IPC_FRAME_S16_LE");
@@ -181,21 +181,21 @@ static inline int set_fir_func(struct comp_dev *dev)
 
 #if CONFIG_FORMAT_S16LE
 static void eq_fir_s16_passthrough(struct fir_state_32x16 fir[],
-				   struct comp_buffer *source,
-				   struct comp_buffer *sink,
+				   const struct audio_stream *source,
+				   struct audio_stream *sink,
 				   int frames, int nch)
 {
-	buffer_copy_s16(source, sink, frames * nch);
+	audio_stream_copy_s16(source, sink, frames * nch);
 }
 #endif /* CONFIG_FORMAT_S16LE */
 
 #if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE
 static void eq_fir_s32_passthrough(struct fir_state_32x16 fir[],
-				   struct comp_buffer *source,
-				   struct comp_buffer *sink,
+				   const struct audio_stream *source,
+				   struct audio_stream *sink,
 				   int frames, int nch)
 {
-	buffer_copy_s32(source, sink, frames * nch);
+	audio_stream_copy_s32(source, sink, frames * nch);
 }
 #endif /* CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE */
 
@@ -209,7 +209,7 @@ static inline int set_pass_func(struct comp_dev *dev)
 	sourceb = list_first_item(&dev->bsource_list, struct comp_buffer,
 				  sink_list);
 
-	switch (sourceb->frame_fmt) {
+	switch (sourceb->stream.frame_fmt) {
 #if CONFIG_FORMAT_S16LE
 	case SOF_IPC_FRAME_S16_LE:
 		trace_eq_with_ids(dev, "set_pass_func(), SOF_IPC_FRAME_S16_LE");
@@ -711,7 +711,7 @@ static int eq_fir_copy(struct comp_dev *dev)
 		eq_fir_free_parameters(&cd->config);
 		cd->config = cd->config_new;
 		cd->config_new = NULL;
-		ret = eq_fir_setup(cd, sourceb->channels);
+		ret = eq_fir_setup(cd, sourceb->stream.channels);
 		if (ret < 0) {
 			trace_eq_error_with_ids(dev, "eq_fir_copy(), failed FIR setup");
 			return ret;
@@ -733,8 +733,8 @@ static int eq_fir_copy(struct comp_dev *dev)
 		n = (cl.frames >> 1) << 1;
 
 		/* Run EQ function */
-		cd->eq_fir_func(cd->fir, cl.source, cl.sink, n,
-				cl.source->channels);
+		cd->eq_fir_func(cd->fir, &cl.source->stream, &cl.sink->stream,
+				n, cl.source->stream.channels);
 
 		/* calc new free and available */
 		comp_update_buffer_consume(cl.source,
@@ -770,19 +770,20 @@ static int eq_fir_prepare(struct comp_dev *dev)
 				struct comp_buffer, source_list);
 
 	/* get source data format */
-	cd->source_format = sourceb->frame_fmt;
+	cd->source_format = sourceb->stream.frame_fmt;
 
 	/* get sink data format and period bytes */
-	cd->sink_format = sinkb->frame_fmt;
-	sink_period_bytes = buffer_period_bytes(sinkb, dev->frames);
+	cd->sink_format = sinkb->stream.frame_fmt;
+	sink_period_bytes = audio_stream_period_bytes(&sinkb->stream,
+						      dev->frames);
 
 	/* Rewrite params format for this component to match the host side. */
 	if (dev->direction == SOF_IPC_STREAM_PLAYBACK)
-		sourceb->frame_fmt = cd->source_format;
+		sourceb->stream.frame_fmt = cd->source_format;
 	else
-		sinkb->frame_fmt = cd->sink_format;
+		sinkb->stream.frame_fmt = cd->sink_format;
 
-	if (sinkb->size < config->periods_sink * sink_period_bytes) {
+	if (sinkb->stream.size < config->periods_sink * sink_period_bytes) {
 		trace_eq_error_with_ids(dev, "eq_fir_prepare() error: "
 					"sink buffer size is insufficient");
 		ret = -ENOMEM;
@@ -791,7 +792,7 @@ static int eq_fir_prepare(struct comp_dev *dev)
 
 	/* Initialize EQ */
 	if (cd->config && cd->config_ready) {
-		ret = eq_fir_setup(cd, sourceb->channels);
+		ret = eq_fir_setup(cd, sourceb->stream.channels);
 		if (ret < 0) {
 			trace_eq_error_with_ids(dev, "eq_fir_prepare() error: "
 						"eq_fir_setup failed.");
diff --git a/src/audio/eq_fir/fir.c b/src/audio/eq_fir/fir.c
index 4ce2c1d9099c..e021e8bcb8d4 100644
--- a/src/audio/eq_fir/fir.c
+++ b/src/audio/eq_fir/fir.c
@@ -62,8 +62,8 @@ void fir_init_delay(struct fir_state_32x16 *fir, int32_t **data)
 }
 
 #if CONFIG_FORMAT_S16LE
-void eq_fir_s16(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s16(struct fir_state_32x16 fir[], const struct audio_stream *source,
+		struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *filter;
 	int16_t *x;
@@ -77,8 +77,8 @@ void eq_fir_s16(struct fir_state_32x16 fir[], struct comp_buffer *source,
 		filter = &fir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s16(source, idx);
-			y = buffer_write_frag_s16(sink, idx);
+			x = audio_stream_read_frag_s16(source, idx);
+			y = audio_stream_write_frag_s16(sink, idx);
 			z = fir_32x16(filter, *x << 16);
 			*y = sat_int16(Q_SHIFT_RND(z, 31, 15));
 			idx += nch;
@@ -88,8 +88,8 @@ void eq_fir_s16(struct fir_state_32x16 fir[], struct comp_buffer *source,
 #endif /* CONFIG_FORMAT_S16LE */
 
 #if CONFIG_FORMAT_S24LE
-void eq_fir_s24(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s24(struct fir_state_32x16 fir[], const struct audio_stream *source,
+		struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *filter;
 	int32_t *x;
@@ -103,8 +103,8 @@ void eq_fir_s24(struct fir_state_32x16 fir[], struct comp_buffer *source,
 		filter = &fir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s32(source, idx);
-			y = buffer_write_frag_s32(sink, idx);
+			x = audio_stream_read_frag_s32(source, idx);
+			y = audio_stream_write_frag_s32(sink, idx);
 			z = fir_32x16(filter, *x << 8);
 			*y = sat_int24(Q_SHIFT_RND(z, 31, 23));
 			idx += nch;
@@ -114,8 +114,8 @@ void eq_fir_s24(struct fir_state_32x16 fir[], struct comp_buffer *source,
 #endif /* CONFIG_FORMAT_S24LE */
 
 #if CONFIG_FORMAT_S32LE
-void eq_fir_s32(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s32(struct fir_state_32x16 fir[], const struct audio_stream *source,
+		struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *filter;
 	int32_t *x;
@@ -128,8 +128,8 @@ void eq_fir_s32(struct fir_state_32x16 fir[], struct comp_buffer *source,
 		filter = &fir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s32(source, idx);
-			y = buffer_write_frag_s32(sink, idx);
+			x = audio_stream_read_frag_s32(source, idx);
+			y = audio_stream_write_frag_s32(sink, idx);
 			*y = fir_32x16(filter, *x);
 			idx += nch;
 		}
diff --git a/src/audio/eq_fir/fir_hifi2ep.c b/src/audio/eq_fir/fir_hifi2ep.c
index ad89e178eb7d..ab6473b319c0 100644
--- a/src/audio/eq_fir/fir_hifi2ep.c
+++ b/src/audio/eq_fir/fir_hifi2ep.c
@@ -83,8 +83,8 @@ void fir_get_lrshifts(struct fir_state_32x16 *fir, int *lshift,
  * sample per call.
  */
 void eq_fir_2x_s32_hifiep(struct fir_state_32x16 fir[],
-			  struct comp_buffer *source,
-			  struct comp_buffer *sink,
+			  const struct audio_stream *source,
+			  struct audio_stream *sink,
 			  int frames, int nch)
 {
 	struct fir_state_32x16 *f;
@@ -124,8 +124,9 @@ void eq_fir_2x_s32_hifiep(struct fir_state_32x16 fir[],
 }
 
 /* FIR for any number of frames */
-void eq_fir_s32_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		       struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s32_hifiep(struct fir_state_32x16 fir[],
+		       const struct audio_stream *source,
+		       struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	int32_t *src = (int32_t *)source->r_ptr;
@@ -160,9 +161,8 @@ void eq_fir_s32_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
 
 #if CONFIG_FORMAT_S24LE
 void eq_fir_2x_s24_hifiep(struct fir_state_32x16 fir[],
-			  struct comp_buffer *source,
-			  struct comp_buffer *sink,
-			  int frames, int nch)
+			  const struct audio_stream *source,
+			  struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	int32_t *src = (int32_t *)source->r_ptr;
@@ -205,8 +205,9 @@ void eq_fir_2x_s24_hifiep(struct fir_state_32x16 fir[],
 }
 
 /* FIR for any number of frames */
-void eq_fir_s24_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		       struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s24_hifiep(struct fir_state_32x16 fir[],
+		       const struct audio_stream *source,
+		       struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	int32_t *src = (int32_t *)source->r_ptr;
@@ -243,9 +244,8 @@ void eq_fir_s24_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
 
 #if CONFIG_FORMAT_S16LE
 void eq_fir_2x_s16_hifiep(struct fir_state_32x16 fir[],
-			  struct comp_buffer *source,
-			  struct comp_buffer *sink,
-			  int frames, int nch)
+			  const struct audio_stream *source,
+			  struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	int16_t *src = (int16_t *)source->r_ptr;
@@ -288,8 +288,9 @@ void eq_fir_2x_s16_hifiep(struct fir_state_32x16 fir[],
 }
 
 /* FIR for any number of frames */
-void eq_fir_s16_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		       struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s16_hifiep(struct fir_state_32x16 fir[],
+		       const struct audio_stream *source,
+		       struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	int16_t *src = (int16_t *)source->r_ptr;
diff --git a/src/audio/eq_fir/fir_hifi3.c b/src/audio/eq_fir/fir_hifi3.c
index 0be8febf41e6..88170ea2ce5a 100644
--- a/src/audio/eq_fir/fir_hifi3.c
+++ b/src/audio/eq_fir/fir_hifi3.c
@@ -83,8 +83,8 @@ void fir_get_lrshifts(struct fir_state_32x16 *fir, int *lshift,
  * sample per call.
  */
 void eq_fir_2x_s32_hifi3(struct fir_state_32x16 fir[],
-			 struct comp_buffer *source, struct comp_buffer *sink,
-			 int frames, int nch)
+			 const struct audio_stream *source,
+			 struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	ae_int32x2 d0 = 0;
@@ -142,8 +142,9 @@ void eq_fir_2x_s32_hifi3(struct fir_state_32x16 fir[],
 }
 
 /* FIR for any number of frames */
-void eq_fir_s32_hifi3(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		      struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s32_hifi3(struct fir_state_32x16 fir[],
+		      const struct audio_stream *source,
+		      struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	ae_int32x2 in = 0;
@@ -200,8 +201,8 @@ void eq_fir_s32_hifi3(struct fir_state_32x16 fir[], struct comp_buffer *source,
 
 #if CONFIG_FORMAT_S24LE
 void eq_fir_2x_s24_hifi3(struct fir_state_32x16 fir[],
-			 struct comp_buffer *source, struct comp_buffer *sink,
-			 int frames, int nch)
+			 const struct audio_stream *source,
+			 struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	ae_int32x2 d0 = 0;
@@ -264,8 +265,9 @@ void eq_fir_2x_s24_hifi3(struct fir_state_32x16 fir[],
 	}
 }
 
-void eq_fir_s24_hifi3(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		      struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s24_hifi3(struct fir_state_32x16 fir[],
+		      const struct audio_stream *source,
+		      struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	ae_int32 in;
@@ -327,8 +329,8 @@ void eq_fir_s24_hifi3(struct fir_state_32x16 fir[], struct comp_buffer *source,
 
 #if CONFIG_FORMAT_S16LE
 void eq_fir_2x_s16_hifi3(struct fir_state_32x16 fir[],
-			 struct comp_buffer *source, struct comp_buffer *sink,
-			 int frames, int nch)
+			 const struct audio_stream *source,
+			 struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	ae_int16x4 d0 = AE_ZERO16();
@@ -395,8 +397,9 @@ void eq_fir_2x_s16_hifi3(struct fir_state_32x16 fir[],
 	}
 }
 
-void eq_fir_s16_hifi3(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		      struct comp_buffer *sink, int frames, int nch)
+void eq_fir_s16_hifi3(struct fir_state_32x16 fir[],
+		      const struct audio_stream *source,
+		      struct audio_stream *sink, int frames, int nch)
 {
 	struct fir_state_32x16 *f;
 	ae_f16x4 d = AE_ZERO16();
diff --git a/src/audio/eq_iir/eq_iir.c b/src/audio/eq_iir/eq_iir.c
index ad029c5fa4b1..dd9e5dcdbaa7 100644
--- a/src/audio/eq_iir/eq_iir.c
+++ b/src/audio/eq_iir/eq_iir.c
@@ -57,10 +57,7 @@ struct comp_data {
 	enum sof_ipc_frame sink_format;		/**< sink frame format */
 	int64_t *iir_delay;			/**< pointer to allocated RAM */
 	size_t iir_delay_size;			/**< allocated size */
-	void (*eq_iir_func)(struct comp_dev *dev,
-			    struct comp_buffer *source,
-			    struct comp_buffer *sink,
-			    uint32_t frames);
+	eq_iir_func eq_iir_func;		/**< processing function */
 };
 
 #if CONFIG_FORMAT_S16LE
@@ -68,9 +65,9 @@ struct comp_data {
  * EQ IIR algorithm code
  */
 
-static void eq_iir_s16_default(struct comp_dev *dev,
-			       struct comp_buffer *source,
-			       struct comp_buffer *sink,
+static void eq_iir_s16_default(const struct comp_dev *dev,
+			       const struct audio_stream *source,
+			       struct audio_stream *sink,
 			       uint32_t frames)
 
 {
@@ -88,8 +85,8 @@ static void eq_iir_s16_default(struct comp_dev *dev,
 		filter = &cd->iir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s16(source, idx);
-			y = buffer_write_frag_s16(sink, idx);
+			x = audio_stream_read_frag_s16(source, idx);
+			y = audio_stream_write_frag_s16(sink, idx);
 			z = iir_df2t(filter, *x << 16);
 			*y = sat_int16(Q_SHIFT_RND(z, 31, 15));
 			idx += nch;
@@ -99,9 +96,9 @@ static void eq_iir_s16_default(struct comp_dev *dev,
 #endif /* CONFIG_FORMAT_S16LE */
 
 #if CONFIG_FORMAT_S24LE
-static void eq_iir_s24_default(struct comp_dev *dev,
-			       struct comp_buffer *source,
-			       struct comp_buffer *sink,
+static void eq_iir_s24_default(const struct comp_dev *dev,
+			       const struct audio_stream *source,
+			       struct audio_stream *sink,
 			       uint32_t frames)
 
 {
@@ -119,8 +116,8 @@ static void eq_iir_s24_default(struct comp_dev *dev,
 		filter = &cd->iir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s32(source, idx);
-			y = buffer_write_frag_s32(sink, idx);
+			x = audio_stream_read_frag_s32(source, idx);
+			y = audio_stream_write_frag_s32(sink, idx);
 			z = iir_df2t(filter, *x << 8);
 			*y = sat_int24(Q_SHIFT_RND(z, 31, 23));
 			idx += nch;
@@ -130,9 +127,9 @@ static void eq_iir_s24_default(struct comp_dev *dev,
 #endif /* CONFIG_FORMAT_S24LE */
 
 #if CONFIG_FORMAT_S32LE
-static void eq_iir_s32_default(struct comp_dev *dev,
-			       struct comp_buffer *source,
-			       struct comp_buffer *sink,
+static void eq_iir_s32_default(const struct comp_dev *dev,
+			       const struct audio_stream *source,
+			       struct audio_stream *sink,
 			       uint32_t frames)
 
 {
@@ -149,8 +146,8 @@ static void eq_iir_s32_default(struct comp_dev *dev,
 		filter = &cd->iir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s32(source, idx);
-			y = buffer_write_frag_s32(sink, idx);
+			x = audio_stream_read_frag_s32(source, idx);
+			y = audio_stream_write_frag_s32(sink, idx);
 			*y = iir_df2t(filter, *x);
 			idx += nch;
 		}
@@ -159,9 +156,9 @@ static void eq_iir_s32_default(struct comp_dev *dev,
 #endif /* CONFIG_FORMAT_S32LE */
 
 #if CONFIG_FORMAT_S32LE && CONFIG_FORMAT_S16LE
-static void eq_iir_s32_16_default(struct comp_dev *dev,
-				  struct comp_buffer *source,
-				  struct comp_buffer *sink,
+static void eq_iir_s32_16_default(const struct comp_dev *dev,
+				  const struct audio_stream *source,
+				  struct audio_stream *sink,
 				  uint32_t frames)
 
 {
@@ -179,8 +176,8 @@ static void eq_iir_s32_16_default(struct comp_dev *dev,
 		filter = &cd->iir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s32(source, idx);
-			y = buffer_write_frag_s16(sink, idx);
+			x = audio_stream_read_frag_s32(source, idx);
+			y = audio_stream_write_frag_s16(sink, idx);
 			z = iir_df2t(filter, *x);
 			*y = sat_int16(Q_SHIFT_RND(z, 31, 15));
 			idx += nch;
@@ -190,9 +187,9 @@ static void eq_iir_s32_16_default(struct comp_dev *dev,
 #endif /* CONFIG_FORMAT_S32LE && CONFIG_FORMAT_S16LE */
 
 #if CONFIG_FORMAT_S32LE && CONFIG_FORMAT_S24LE
-static void eq_iir_s32_24_default(struct comp_dev *dev,
-				  struct comp_buffer *source,
-				  struct comp_buffer *sink,
+static void eq_iir_s32_24_default(const struct comp_dev *dev,
+				  const struct audio_stream *source,
+				  struct audio_stream *sink,
 				  uint32_t frames)
 
 {
@@ -210,8 +207,8 @@ static void eq_iir_s32_24_default(struct comp_dev *dev,
 		filter = &cd->iir[ch];
 		idx = ch;
 		for (i = 0; i < frames; i++) {
-			x = buffer_read_frag_s32(source, idx);
-			y = buffer_write_frag_s32(sink, idx);
+			x = audio_stream_read_frag_s32(source, idx);
+			y = audio_stream_write_frag_s32(sink, idx);
 			z = iir_df2t(filter, *x);
 			*y = sat_int24(Q_SHIFT_RND(z, 31, 23));
 			idx += nch;
@@ -221,29 +218,29 @@ static void eq_iir_s32_24_default(struct comp_dev *dev,
 #endif /* CONFIG_FORMAT_S32LE && CONFIG_FORMAT_S24LE */
 
 #if CONFIG_FORMAT_S16LE
-static void eq_iir_s16_pass(struct comp_dev *dev,
-			    struct comp_buffer *source,
-			    struct comp_buffer *sink,
+static void eq_iir_s16_pass(const struct comp_dev *dev,
+			    const struct audio_stream *source,
+			    struct audio_stream *sink,
 			    uint32_t frames)
 {
-	buffer_copy_s16(source, sink, frames * source->channels);
+	audio_stream_copy_s16(source, sink, frames * source->channels);
 }
 #endif /* CONFIG_FORMAT_S16LE */
 
 #if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE
-static void eq_iir_s32_pass(struct comp_dev *dev,
-			    struct comp_buffer *source,
-			    struct comp_buffer *sink,
+static void eq_iir_s32_pass(const struct comp_dev *dev,
+			    const struct audio_stream *source,
+			    struct audio_stream *sink,
 			    uint32_t frames)
 {
-	buffer_copy_s32(source, sink, frames * source->channels);
+	audio_stream_copy_s32(source, sink, frames * source->channels);
 }
 #endif /* CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE */
 
 #if CONFIG_FORMAT_S16LE && CONFIG_FORMAT_S32LE
-static void eq_iir_s32_s16_pass(struct comp_dev *dev,
-				struct comp_buffer *source,
-				struct comp_buffer *sink,
+static void eq_iir_s32_s16_pass(const struct comp_dev *dev,
+				const struct audio_stream *source,
+				struct audio_stream *sink,
 				uint32_t frames)
 {
 	int32_t *x;
@@ -252,17 +249,17 @@ static void eq_iir_s32_s16_pass(struct comp_dev *dev,
 	int n = frames * source->channels;
 
 	for (i = 0; i < n; i++) {
-		x = buffer_read_frag_s32(source, i);
-		y = buffer_write_frag_s16(sink, i);
+		x = audio_stream_read_frag_s32(source, i);
+		y = audio_stream_write_frag_s16(sink, i);
 		*y = sat_int16(Q_SHIFT_RND(*x, 31, 15));
 	}
 }
 #endif /* CONFIG_FORMAT_S16LE && CONFIG_FORMAT_S32LE */
 
 #if CONFIG_FORMAT_S24LE && CONFIG_FORMAT_S32LE
-static void eq_iir_s32_s24_pass(struct comp_dev *dev,
-				struct comp_buffer *source,
-				struct comp_buffer *sink,
+static void eq_iir_s32_s24_pass(const struct comp_dev *dev,
+				const struct audio_stream *source,
+				struct audio_stream *sink,
 				uint32_t frames)
 {
 	int32_t *x;
@@ -271,8 +268,8 @@ static void eq_iir_s32_s24_pass(struct comp_dev *dev,
 	int n = frames * source->channels;
 
 	for (i = 0; i < n; i++) {
-		x = buffer_read_frag_s32(source, i);
-		y = buffer_write_frag_s16(sink, i);
+		x = audio_stream_read_frag_s32(source, i);
+		y = audio_stream_write_frag_s16(sink, i);
 		*y = sat_int24(Q_SHIFT_RND(*x, 31, 23));
 	}
 }
@@ -769,7 +766,7 @@ static int eq_iir_copy(struct comp_dev *dev)
 		eq_iir_free_parameters(&cd->config);
 		cd->config = cd->config_new;
 		cd->config_new = NULL;
-		ret = eq_iir_setup(cd, sourceb->channels);
+		ret = eq_iir_setup(cd, sourceb->stream.channels);
 		if (ret < 0) {
 			trace_eq_error_with_ids(dev, "eq_iir_copy(), failed IIR setup");
 			return ret;
@@ -784,7 +781,7 @@ static int eq_iir_copy(struct comp_dev *dev)
 	}
 
 	/* Run EQ function */
-	cd->eq_iir_func(dev, cl.source, cl.sink, cl.frames);
+	cd->eq_iir_func(dev, &cl.source->stream, &cl.sink->stream, cl.frames);
 
 	/* calc new free and available */
 	comp_update_buffer_consume(cl.source, cl.source_bytes);
@@ -818,21 +815,22 @@ static int eq_iir_prepare(struct comp_dev *dev)
 				struct comp_buffer, source_list);
 
 	/* get source data format */
-	cd->source_format = sourceb->frame_fmt;
+	cd->source_format = sourceb->stream.frame_fmt;
 
 	/* get sink data format and period bytes */
-	cd->sink_format = sinkb->frame_fmt;
-	sink_period_bytes = buffer_period_bytes(sinkb, dev->frames);
+	cd->sink_format = sinkb->stream.frame_fmt;
+	sink_period_bytes = audio_stream_period_bytes(&sinkb->stream,
+						      dev->frames);
 
 	/* Rewrite params format for this component to match the host side. */
 	if (dev->direction == SOF_IPC_STREAM_PLAYBACK)
-		sourceb->frame_fmt = cd->source_format;
+		sourceb->stream.frame_fmt = cd->source_format;
 	else
-		sinkb->frame_fmt = cd->sink_format;
+		sinkb->stream.frame_fmt = cd->sink_format;
 
-	if (sinkb->size < config->periods_sink * sink_period_bytes) {
-		trace_eq_error_with_ids(dev, "eq_iir_prepare(), sink buffer size %d"
-					" is insufficient", sinkb->size);
+	if (sinkb->stream.size < config->periods_sink * sink_period_bytes) {
+		trace_eq_error_with_ids(dev, "eq_iir_prepare(), sink buffer size %d is insufficient",
+					sinkb->stream.size);
 		ret = -ENOMEM;
 		goto err;
 	}
@@ -841,7 +839,7 @@ static int eq_iir_prepare(struct comp_dev *dev)
 	trace_eq_with_ids(dev, "eq_iir_prepare(), source_format=%d, sink_format=%d",
 			  cd->source_format, cd->sink_format);
 	if (cd->config) {
-		ret = eq_iir_setup(cd, sourceb->channels);
+		ret = eq_iir_setup(cd, sourceb->stream.channels);
 		if (ret < 0) {
 			trace_eq_error_with_ids(dev, "eq_iir_prepare(), setup failed.");
 			goto err;
diff --git a/src/audio/host.c b/src/audio/host.c
index 081b4808db04..94bab8456159 100644
--- a/src/audio/host.c
+++ b/src/audio/host.c
@@ -143,14 +143,16 @@ static void host_update_position(struct comp_dev *dev, uint32_t bytes)
 	struct host_data *hd = comp_get_drvdata(dev);
 	uint32_t samples;
 
-	samples = bytes / buffer_sample_bytes(hd->local_buffer);
+	samples = bytes / audio_stream_sample_bytes(&hd->local_buffer->stream);
 
 	if (dev->direction == SOF_IPC_STREAM_PLAYBACK)
-		dma_buffer_copy_from(hd->dma_buffer, bytes, hd->local_buffer,
-				     bytes, hd->process, samples);
+		dma_buffer_copy_from(hd->dma_buffer, bytes,
+				     hd->local_buffer, bytes,
+				     hd->process, samples);
 	else
-		dma_buffer_copy_to(hd->local_buffer, bytes, hd->dma_buffer,
-				   bytes, hd->process, samples);
+		dma_buffer_copy_to(hd->local_buffer, bytes,
+				   hd->dma_buffer, bytes,
+				   hd->process, samples);
 
 	dev->position += bytes;
 
@@ -270,7 +272,8 @@ static int create_local_elems(struct comp_dev *dev, uint32_t buffer_count,
 	}
 
 	err = dma_sg_alloc(elem_array, SOF_MEM_ZONE_RUNTIME, dir, buffer_count,
-			   buffer_bytes, (uintptr_t)(hd->dma_buffer->addr), 0);
+			   buffer_bytes,
+			   (uintptr_t)(hd->dma_buffer->stream.addr), 0);
 	if (err < 0) {
 		trace_host_error_with_ids(dev, "create_local_elems() error: "
 					  "dma_sg_alloc() failed");
@@ -510,7 +513,8 @@ static int host_params(struct comp_dev *dev,
 						   struct comp_buffer,
 						   sink_list);
 
-	period_bytes = dev->frames * buffer_frame_bytes(hd->local_buffer);
+	period_bytes = dev->frames *
+		       audio_stream_frame_bytes(&hd->local_buffer->stream);
 	if (!period_bytes) {
 		trace_host_error_with_ids(dev, "host_params() error: invalid "
 					  "period_bytes");
@@ -563,8 +567,10 @@ static int host_params(struct comp_dev *dev,
 		return err;
 
 	/* set up DMA configuration - copy in sample bytes. */
-	config->src_width = buffer_sample_bytes(hd->local_buffer);
-	config->dest_width = buffer_sample_bytes(hd->local_buffer);
+	config->src_width =
+		audio_stream_sample_bytes(&hd->local_buffer->stream);
+	config->dest_width =
+		audio_stream_sample_bytes(&hd->local_buffer->stream);
 	config->cyclic = 0;
 	config->irq_disabled = pipeline_is_timer_driven(dev->pipeline);
 	config->is_scheduling_source = comp_is_scheduling_source(dev);
@@ -603,8 +609,9 @@ static int host_params(struct comp_dev *dev,
 	}
 
 	/* set processing function */
-	hd->process = pcm_get_conversion_function(hd->local_buffer->frame_fmt,
-						  hd->local_buffer->frame_fmt);
+	hd->process =
+		pcm_get_conversion_function(hd->local_buffer->stream.frame_fmt,
+					    hd->local_buffer->stream.frame_fmt);
 
 	return 0;
 }
@@ -698,9 +705,9 @@ static uint32_t host_buffer_get_copy_bytes(struct comp_dev *dev)
 	if (hd->copy_type == COMP_COPY_ONE_SHOT) {
 		/* calculate minimum size to copy */
 		if (dev->direction == SOF_IPC_STREAM_PLAYBACK)
-			copy_bytes = hd->local_buffer->free;
+			copy_bytes = hd->local_buffer->stream.free;
 		else
-			copy_bytes = hd->local_buffer->avail;
+			copy_bytes = hd->local_buffer->stream.avail;
 
 		/* copy_bytes should be aligned to minimum possible chunk of
 		 * data to be copied by dma.
@@ -725,9 +732,11 @@ static uint32_t host_buffer_get_copy_bytes(struct comp_dev *dev)
 
 		/* calculate minimum size to copy */
 		if (dev->direction == SOF_IPC_STREAM_PLAYBACK)
-			copy_bytes = MIN(avail_bytes, hd->local_buffer->free);
+			copy_bytes = MIN(avail_bytes,
+					 hd->local_buffer->stream.free);
 		else
-			copy_bytes = MIN(hd->local_buffer->avail, free_bytes);
+			copy_bytes = MIN(hd->local_buffer->stream.avail,
+					 free_bytes);
 
 		/* copy_bytes should be aligned to minimum possible chunk of
 		 * data to be copied by dma.
@@ -758,7 +767,7 @@ static int host_copy(struct comp_dev *dev)
 
 	/* update first transfer manually */
 	if (!dev->position && flags & COMP_COPY_ONE_SHOT)
-		host_one_shot_cb(dev, hd->dma_buffer->size);
+		host_one_shot_cb(dev, hd->dma_buffer->stream.size);
 
 	copy_bytes = host_buffer_get_copy_bytes(dev);
 	if (!copy_bytes) {
diff --git a/src/audio/kpb.c b/src/audio/kpb.c
index 09fb9bbb9111..1ecab5d9ac53 100644
--- a/src/audio/kpb.c
+++ b/src/audio/kpb.c
@@ -69,19 +69,20 @@ static void kpb_event_handler(void *arg, enum notify_id type, void *event_data);
 static int kpb_register_client(struct comp_data *kpb, struct kpb_client *cli);
 static void kpb_init_draining(struct comp_dev *dev, struct kpb_client *cli);
 static enum task_state kpb_draining_task(void *arg);
-static int kpb_buffer_data(struct comp_dev *dev, struct comp_buffer *source,
-			   size_t size);
+static int kpb_buffer_data(struct comp_dev *dev,
+			   const struct comp_buffer *source, size_t size);
 static size_t kpb_allocate_history_buffer(struct comp_data *kpb);
 static void kpb_clear_history_buffer(struct hb *buff);
 static void kpb_free_history_buffer(struct hb *buff);
 static inline bool kpb_is_sample_width_supported(uint32_t sampling_width);
-static void kpb_copy_samples(struct comp_buffer *sink,
-			     struct comp_buffer *source, size_t size,
+static void kpb_copy_samples(struct audio_stream *sink,
+			     const struct audio_stream *source, size_t size,
 			     size_t sample_width);
-static void kpb_drain_samples(void *source, struct comp_buffer *sink,
+static void kpb_drain_samples(void *source, struct audio_stream *sink,
 			      size_t size, size_t sample_width);
-static void kpb_buffer_samples(struct comp_buffer *source, uint32_t start,
-			       void *sink, size_t size, size_t sample_width);
+static void kpb_buffer_samples(const struct audio_stream *source,
+			       uint32_t start, void *sink, size_t size,
+			       size_t sample_width);
 static void kpb_reset_history_buffer(struct hb *buff);
 static inline bool validate_host_params(size_t host_period_size,
 					size_t host_buffer_size,
@@ -568,7 +569,7 @@ static int kpb_copy(struct comp_dev *dev)
 				 sink_list);
 
 	/* Validate source */
-	if (!source || !source->r_ptr) {
+	if (!source || !source->stream.r_ptr) {
 		trace_kpb_error_with_ids(dev, "kpb_copy(): "
 					 "invalid source pointers.");
 		ret = -EINVAL;
@@ -581,30 +582,29 @@ static int kpb_copy(struct comp_dev *dev)
 		sink = kpb->sel_sink;
 
 		/* Validate sink */
-		if (!sink || !sink->w_ptr) {
+		if (!sink || !sink->stream.w_ptr) {
 			trace_kpb_error_with_ids(dev, "kpb_copy(): invalid "
 						 "selector sink pointers.");
 			ret = -EINVAL;
 			goto out;
 		}
 
-		copy_bytes = MIN(sink->free, source->avail);
+		copy_bytes = MIN(sink->stream.free, source->stream.avail);
 		if (!copy_bytes) {
-			trace_kpb_error_with_ids(dev, "kpb_copy() error: "
-						 "nothing to copy "
-						 "sink->free %d "
-						 "source->avail %d",
-						 sink->free, source->avail);
+			trace_kpb_error_with_ids(dev, "kpb_copy() error: nothing to copy sink->free %d source->avail %d",
+						 sink->stream.free,
+						 source->stream.avail);
 			ret = PPL_STATUS_PATH_STOP;
 			goto out;
 		}
 
-		kpb_copy_samples(sink, source, copy_bytes, sample_width);
+		kpb_copy_samples(&sink->stream, &source->stream, copy_bytes,
+				 sample_width);
 
 		/* Buffer source data internally in history buffer for future
 		 * use by clients.
 		 */
-		if (source->avail <= kpb->kpb_buffer_size) {
+		if (source->stream.avail <= kpb->kpb_buffer_size) {
 			ret = kpb_buffer_data(dev, source, copy_bytes);
 			if (ret) {
 				trace_kpb_error_with_ids(dev, "kpb_copy(): "
@@ -631,25 +631,24 @@ static int kpb_copy(struct comp_dev *dev)
 		sink = kpb->host_sink;
 
 		/* Validate sink */
-		if (!sink || !sink->w_ptr) {
+		if (!sink || !sink->stream.w_ptr) {
 			trace_kpb_error_with_ids(dev, "kpb_copy(): "
 						 "invalid host sink pointers.");
 			ret = -EINVAL;
 			goto out;
 		}
 
-		copy_bytes = MIN(sink->free, source->avail);
+		copy_bytes = MIN(sink->stream.free, source->stream.avail);
 		if (!copy_bytes) {
-			trace_kpb_error_with_ids(dev, "kpb_copy() error: "
-						 "nothing to copy "
-						 "sink->free %d "
-						 "source->avail %d",
-						 sink->free, source->avail);
+			trace_kpb_error_with_ids(dev, "kpb_copy() error: nothing to copy sink->free %d source->avail %d",
+						 sink->stream.free,
+						 source->stream.avail);
 			ret = PPL_STATUS_PATH_STOP;
 			goto out;
 		}
 
-		kpb_copy_samples(sink, source, copy_bytes, sample_width);
+		kpb_copy_samples(&sink->stream, &source->stream, copy_bytes,
+				 sample_width);
 
 		comp_update_buffer_produce(sink, copy_bytes);
 		comp_update_buffer_consume(source, copy_bytes);
@@ -659,8 +658,9 @@ static int kpb_copy(struct comp_dev *dev)
 		/* In draining state we only buffer data in internal,
 		 * history buffer.
 		 */
-		if (source->avail <= kpb->kpb_buffer_size) {
-			ret = kpb_buffer_data(dev, source, source->avail);
+		if (source->stream.avail <= kpb->kpb_buffer_size) {
+			ret = kpb_buffer_data(dev, source,
+					      source->stream.avail);
 			if (ret) {
 				trace_kpb_error_with_ids(dev, "kpb_copy(): "
 							 "internal buffering "
@@ -668,7 +668,8 @@ static int kpb_copy(struct comp_dev *dev)
 				goto out;
 			}
 
-			comp_update_buffer_consume(source, source->avail);
+			comp_update_buffer_consume(source,
+						   source->stream.avail);
 		} else {
 			trace_kpb_error_with_ids(dev, "kpb_copy(): "
 						 "too much data to buffer.");
@@ -695,8 +696,8 @@ static int kpb_copy(struct comp_dev *dev)
  * \param[in] source pointer to the buffer source.
  *
  */
-static int kpb_buffer_data(struct comp_dev *dev, struct comp_buffer *source,
-			   size_t size)
+static int kpb_buffer_data(struct comp_dev *dev,
+			   const struct comp_buffer *source, size_t size)
 {
 	int ret = 0;
 	size_t size_to_copy = size;
@@ -751,7 +752,7 @@ static int kpb_buffer_data(struct comp_dev *dev, struct comp_buffer *source,
 			 * in this buffer, copy what's available and continue
 			 * with next buffer.
 			 */
-			kpb_buffer_samples(source, offset, buff->w_ptr,
+			kpb_buffer_samples(&source->stream, offset, buff->w_ptr,
 					   space_avail, sample_width);
 			/* Update write pointer & requested copy size */
 			buff->w_ptr = (char *)buff->w_ptr + space_avail;
@@ -765,7 +766,7 @@ static int kpb_buffer_data(struct comp_dev *dev, struct comp_buffer *source,
 			 * available in this buffer. In this scenario simply
 			 * copy what was requested.
 			 */
-			kpb_buffer_samples(source, offset, buff->w_ptr,
+			kpb_buffer_samples(&source->stream, offset, buff->w_ptr,
 					   size_to_copy, sample_width);
 			/* Update write pointer & requested copy size */
 			buff->w_ptr = (char *)buff->w_ptr + size_to_copy;
@@ -1096,11 +1097,11 @@ 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)
+		if (size_to_read > sink->stream.free) {
+			if (sink->stream.free >= history_depth)
 				size_to_copy = history_depth;
 			else
-				size_to_copy = sink->free;
+				size_to_copy = sink->stream.free;
 		} else {
 			if (size_to_read > history_depth) {
 				size_to_copy = history_depth;
@@ -1110,7 +1111,7 @@ static enum task_state kpb_draining_task(void *arg)
 			}
 		}
 
-		kpb_drain_samples(buff->r_ptr, sink, size_to_copy,
+		kpb_drain_samples(buff->r_ptr, &sink->stream, size_to_copy,
 				  sample_width);
 
 		buff->r_ptr = (char *)buff->r_ptr + (uint32_t)size_to_copy;
@@ -1186,8 +1187,8 @@ static enum task_state kpb_draining_task(void *arg)
  *
  * \return none.
  */
-static void kpb_drain_samples(void *source, struct comp_buffer *sink,
-			       size_t size, size_t sample_width)
+static void kpb_drain_samples(void *source, struct audio_stream *sink,
+			      size_t size, size_t sample_width)
 {
 	void *dst;
 	void *src = source;
@@ -1201,7 +1202,7 @@ static void kpb_drain_samples(void *source, struct comp_buffer *sink,
 			switch (sample_width) {
 #if CONFIG_FORMAT_S16LE
 			case 16:
-				dst = buffer_write_frag_s16(sink, j);
+				dst = audio_stream_write_frag_s16(sink, j);
 				*((int16_t *)dst) = *((int16_t *)src);
 				src = ((int16_t *)src) + 1;
 				break;
@@ -1209,7 +1210,7 @@ static void kpb_drain_samples(void *source, struct comp_buffer *sink,
 #if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE
 			case 24:
 			case 32:
-				dst = buffer_write_frag_s32(sink, j);
+				dst = audio_stream_write_frag_s32(sink, j);
 				*((int32_t *)dst) = *((int32_t *)src);
 				src = ((int32_t *)src) + 1;
 				break;
@@ -1232,8 +1233,9 @@ static void kpb_drain_samples(void *source, struct comp_buffer *sink,
  * \param[in] size Requested copy size in bytes.
  * \param[in] sample_width Sample size.
  */
-static void kpb_buffer_samples(struct comp_buffer *source, uint32_t start,
-			       void *sink, size_t size, size_t sample_width)
+static void kpb_buffer_samples(const struct audio_stream *source,
+			       uint32_t start, void *sink, size_t size,
+			       size_t sample_width)
 {
 	void *src;
 	void *dst = sink;
@@ -1247,14 +1249,14 @@ static void kpb_buffer_samples(struct comp_buffer *source, uint32_t start,
 		for (channel = 0; channel < KPB_NR_OF_CHANNELS; channel++) {
 			switch (sample_width) {
 			case 16:
-				src = buffer_read_frag_s16(source, j);
+				src = audio_stream_read_frag_s16(source, j);
 				*((int16_t *)dst) = *((int16_t *)src);
 				dst = ((int16_t *)dst) + 1;
 				break;
 #if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE
 			case 24:
 			case 32:
-				src = buffer_read_frag_s32(source, j);
+				src = audio_stream_read_frag_s32(source, j);
 				*((int32_t *)dst) = *((int32_t *)src);
 				dst = ((int32_t *)dst) + 1;
 				break;
@@ -1329,8 +1331,8 @@ static inline bool kpb_is_sample_width_supported(uint32_t sampling_width)
  *
  * \return none.
  */
-static void kpb_copy_samples(struct comp_buffer *sink,
-			     struct comp_buffer *source, size_t size,
+static void kpb_copy_samples(struct audio_stream *sink,
+			     const struct audio_stream *source, size_t size,
 			     size_t sample_width)
 {
 	void *dst;
@@ -1345,8 +1347,8 @@ static void kpb_copy_samples(struct comp_buffer *sink,
 			switch (sample_width) {
 #if CONFIG_FORMAT_S16LE
 			case 16:
-				dst = buffer_write_frag_s16(sink, j);
-				src = buffer_read_frag_s16(source, j);
+				dst = audio_stream_write_frag_s16(sink, j);
+				src = audio_stream_read_frag_s16(source, j);
 				*((int16_t *)dst) = *((int16_t *)src);
 				break;
 #endif /* CONFIG_FORMAT_S16LE */
@@ -1354,8 +1356,8 @@ static void kpb_copy_samples(struct comp_buffer *sink,
 			case 24:
 				/* FALLTHROUGH */
 			case 32:
-				dst = buffer_write_frag_s32(sink, j);
-				src = buffer_read_frag_s32(source, j);
+				dst = audio_stream_write_frag_s32(sink, j);
+				src = audio_stream_read_frag_s32(source, j);
 				*((int32_t *)dst) = *((int32_t *)src);
 				break;
 #endif /* CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE*/
diff --git a/src/audio/mixer.c b/src/audio/mixer.c
index f6304103bc0d..15cfa11b5de8 100644
--- a/src/audio/mixer.c
+++ b/src/audio/mixer.c
@@ -49,14 +49,15 @@
 
 /* mixer component private data */
 struct mixer_data {
-	void (*mix_func)(struct comp_dev *dev, struct comp_buffer *sink,
-		struct comp_buffer **sources, uint32_t count, uint32_t frames);
+	void (*mix_func)(struct comp_dev *dev, struct audio_stream *sink,
+			 const struct audio_stream **sources, uint32_t count,
+			 uint32_t frames);
 };
 
 #if CONFIG_FORMAT_S16LE
 /* Mix n 16 bit PCM source streams to one sink stream */
-static void mix_n_s16(struct comp_dev *dev, struct comp_buffer *sink,
-		      struct comp_buffer **sources, uint32_t num_sources,
+static void mix_n_s16(struct comp_dev *dev, struct audio_stream *sink,
+		      const struct audio_stream **sources, uint32_t num_sources,
 		      uint32_t frames)
 {
 	int16_t *src;
@@ -72,11 +73,12 @@ static void mix_n_s16(struct comp_dev *dev, struct comp_buffer *sink,
 			val = 0;
 
 			for (j = 0; j < num_sources; j++) {
-				src = buffer_read_frag_s16(sources[j], frag);
+				src = audio_stream_read_frag_s16(sources[j],
+								 frag);
 				val += *src;
 			}
 
-			dest = buffer_write_frag_s16(sink, frag);
+			dest = audio_stream_write_frag_s16(sink, frag);
 
 			/* Saturate to 16 bits */
 			*dest = sat_int16(val);
@@ -89,8 +91,8 @@ static void mix_n_s16(struct comp_dev *dev, struct comp_buffer *sink,
 
 #if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE
 /* Mix n 32 bit PCM source streams to one sink stream */
-static void mix_n_s32(struct comp_dev *dev, struct comp_buffer *sink,
-		      struct comp_buffer **sources, uint32_t num_sources,
+static void mix_n_s32(struct comp_dev *dev, struct audio_stream *sink,
+		      const struct audio_stream **sources, uint32_t num_sources,
 		      uint32_t frames)
 {
 	int32_t *src;
@@ -106,11 +108,12 @@ static void mix_n_s32(struct comp_dev *dev, struct comp_buffer *sink,
 			val = 0;
 
 			for (j = 0; j < num_sources; j++) {
-				src = buffer_read_frag_s32(sources[j], frag);
+				src = audio_stream_read_frag_s32(sources[j],
+								 frag);
 				val += *src;
 			}
 
-			dest = buffer_write_frag_s32(sink, frag);
+			dest = audio_stream_write_frag_s32(sink, frag);
 
 			/* Saturate to 32 bits */
 			*dest = sat_int32(val);
@@ -183,14 +186,14 @@ static int mixer_params(struct comp_dev *dev,
 							source_list);
 
 	/* calculate period size based on config */
-	period_bytes = dev->frames * buffer_frame_bytes(sinkb);
+	period_bytes = dev->frames * audio_stream_frame_bytes(&sinkb->stream);
 	if (period_bytes == 0) {
 		trace_mixer_error_with_ids(dev, "mixer_params() error: "
 					   "period_bytes = 0");
 		return -EINVAL;
 	}
 
-	if (sinkb->size < config->periods_sink * period_bytes) {
+	if (sinkb->stream.size < config->periods_sink * period_bytes) {
 		trace_mixer_error_with_ids(dev, "mixer_params() error: "
 					   "sink buffer size is insufficient");
 		return -ENOMEM;
@@ -271,6 +274,7 @@ static int mixer_copy(struct comp_dev *dev)
 	struct mixer_data *md = comp_get_drvdata(dev);
 	struct comp_buffer *sink;
 	struct comp_buffer *sources[PLATFORM_MAX_STREAMS];
+	const struct audio_stream *sources_stream[PLATFORM_MAX_STREAMS];
 	struct comp_buffer *source;
 	struct list_item *blist;
 	int32_t i = 0;
@@ -291,8 +295,11 @@ static int mixer_copy(struct comp_dev *dev)
 		source = container_of(blist, struct comp_buffer, sink_list);
 
 		/* only mix the sources with the same state with mixer */
-		if (source->source->state == dev->state)
-			sources[num_mix_sources++] = source;
+		if (source->source->state == dev->state) {
+			sources[num_mix_sources] = source;
+			sources_stream[num_mix_sources] = &source->stream;
+			num_mix_sources++;
+		}
 
 		/* too many sources ? */
 		if (num_mix_sources == PLATFORM_MAX_STREAMS - 1)
@@ -305,19 +312,21 @@ static int mixer_copy(struct comp_dev *dev)
 
 	/* check for underruns */
 	for (i = 0; i < num_mix_sources; i++)
-		frames = MIN(frames, buffer_avail_frames(sources[i], sink));
+		frames = MIN(frames,
+			     audio_stream_avail_frames(sources_stream[i],
+						       &sink->stream));
 
 	/* Every source has the same format, so calculate bytes based
 	 * on the first one.
 	 */
-	source_bytes = frames * buffer_frame_bytes(sources[0]);
-	sink_bytes = frames * buffer_frame_bytes(sink);
+	source_bytes = frames * audio_stream_frame_bytes(sources_stream[0]);
+	sink_bytes = frames * audio_stream_frame_bytes(&sink->stream);
 
 	tracev_mixer_with_ids(dev, "mixer_copy(), source_bytes = 0x%x, "
 			      "sink_bytes = 0x%x",  source_bytes, sink_bytes);
 
 	/* mix streams */
-	md->mix_func(dev, sink, sources, i, frames);
+	md->mix_func(dev, &sink->stream, sources_stream, i, frames);
 
 	/* update source buffer pointers */
 	for (i = --num_mix_sources; i >= 0; i--)
@@ -373,7 +382,7 @@ static int mixer_prepare(struct comp_dev *dev)
 	/* does mixer already have active source streams ? */
 	if (dev->state != COMP_STATE_ACTIVE) {
 		/* currently inactive so setup mixer */
-		switch (sink->frame_fmt) {
+		switch (sink->stream.frame_fmt) {
 #if CONFIG_FORMAT_S16LE
 		case SOF_IPC_FRAME_S16_LE:
 			md->mix_func = mix_n_s16;
diff --git a/src/audio/mux/mux.c b/src/audio/mux/mux.c
index efff040731b7..c3c75c1742fc 100644
--- a/src/audio/mux/mux.c
+++ b/src/audio/mux/mux.c
@@ -153,8 +153,8 @@ static int mux_params(struct comp_dev *dev,
 	sinkb = list_first_item(&dev->bsink_list, struct comp_buffer,
 				  source_list);
 
-	cd->config.num_channels = sinkb->channels;
-	cd->config.frame_format = sinkb->frame_fmt;
+	cd->config.num_channels = sinkb->stream.channels;
+	cd->config.frame_format = sinkb->stream.frame_fmt;
 
 	return 0;
 }
@@ -261,6 +261,7 @@ static int demux_copy(struct comp_dev *dev)
 	uint32_t i = 0;
 	uint32_t frames = -1;
 	uint32_t source_bytes;
+	uint32_t avail;
 	uint32_t sinks_bytes[MUX_MAX_STREAMS] = { 0 };
 
 	tracev_mux_with_ids(dev, "demux_copy()");
@@ -289,14 +290,17 @@ static int demux_copy(struct comp_dev *dev)
 	for (i = 0; i < MUX_MAX_STREAMS; i++) {
 		if (!sinks[i])
 			continue;
-		frames = MIN(frames, buffer_avail_frames(source, sinks[i]));
+		avail = audio_stream_avail_frames(&source->stream,
+						  &sinks[i]->stream);
+		frames = MIN(frames, avail);
 	}
 
-	source_bytes = frames * buffer_frame_bytes(source);
+	source_bytes = frames * audio_stream_frame_bytes(&source->stream);
 	for (i = 0; i < MUX_MAX_STREAMS; i++) {
 		if (!sinks[i])
 			continue;
-		sinks_bytes[i] = frames * buffer_frame_bytes(sinks[i]);
+		sinks_bytes[i] = frames *
+				 audio_stream_frame_bytes(&sinks[i]->stream);
 	}
 
 	/* produce output, one sink at a time */
@@ -304,7 +308,8 @@ static int demux_copy(struct comp_dev *dev)
 		if (!sinks[i])
 			continue;
 
-		cd->demux(dev, sinks[i], source, frames, &cd->config.streams[i]);
+		cd->demux(dev, &sinks[i]->stream, &source->stream, frames,
+			  &cd->config.streams[i]);
 	}
 
 	/* update components */
@@ -325,6 +330,7 @@ static int mux_copy(struct comp_dev *dev)
 	struct comp_buffer *sink;
 	struct comp_buffer *source;
 	struct comp_buffer *sources[MUX_MAX_STREAMS] = { NULL };
+	const struct audio_stream *sources_stream[MUX_MAX_STREAMS] = { NULL };
 	struct list_item *clist;
 	uint32_t num_sources = 0;
 	uint32_t i = 0;
@@ -341,6 +347,7 @@ static int mux_copy(struct comp_dev *dev)
 			num_sources++;
 			i = get_stream_index(cd, source->pipeline_id);
 			sources[i] = source;
+			sources_stream[i] = &source->stream;
 		}
 	}
 
@@ -358,19 +365,22 @@ static int mux_copy(struct comp_dev *dev)
 	for (i = 0; i < MUX_MAX_STREAMS; i++) {
 		if (!sources[i])
 			continue;
-		frames = MIN(frames, buffer_avail_frames(sources[i], sink));
+		frames = MIN(frames,
+			     audio_stream_avail_frames(sources_stream[i],
+						       &sink->stream));
 	}
 
 	for (i = 0; i < MUX_MAX_STREAMS; i++) {
 		if (!sources[i])
 			continue;
 		sources_bytes[i] = frames *
-				   buffer_frame_bytes(sources[i]);
+				   audio_stream_frame_bytes(sources_stream[i]);
 	}
-	sink_bytes = frames * buffer_frame_bytes(sink);
+	sink_bytes = frames * audio_stream_frame_bytes(&sink->stream);
 
 	/* produce output */
-	cd->mux(dev, sink, &sources[0], frames, &cd->config.streams[0]);
+	cd->mux(dev, &sink->stream, &sources_stream[0], frames,
+		&cd->config.streams[0]);
 
 	/* update components */
 	comp_update_buffer_produce(sink, sink_bytes);
diff --git a/src/audio/mux/mux_generic.c b/src/audio/mux/mux_generic.c
index 9ba2a4efa35f..32803cc9dcbe 100644
--- a/src/audio/mux/mux_generic.c
+++ b/src/audio/mux/mux_generic.c
@@ -27,7 +27,7 @@
  * \param[in] offset Offset in source buffer.
  * \param[in] mask Routing bitmask for calculating output sample.
  */
-UT_STATIC inline int32_t calc_sample_s16le(struct comp_buffer *source,
+UT_STATIC inline int32_t calc_sample_s16le(const struct audio_stream *source,
 					   uint8_t num_ch, uint32_t offset,
 					   uint8_t mask)
 {
@@ -40,7 +40,8 @@ UT_STATIC inline int32_t calc_sample_s16le(struct comp_buffer *source,
 
 	for (in_ch = 0; in_ch < num_ch; in_ch++) {
 		if (mask & BIT(in_ch)) {
-			src = buffer_read_frag_s16(source, offset + in_ch);
+			src = audio_stream_read_frag_s16(source,
+							 offset + in_ch);
 			sample += *src;
 		}
 	}
@@ -60,13 +61,14 @@ UT_STATIC inline int32_t calc_sample_s16le(struct comp_buffer *source,
  * \param[in] frames Number of frames to process.
  * \param[in] data Parameters describing channel count and routing.
  */
-static void demux_s16le(struct comp_dev *dev, struct comp_buffer *sink,
-			struct comp_buffer *source, uint32_t frames,
+static void demux_s16le(const struct comp_dev *dev, struct audio_stream *sink,
+			const struct audio_stream *source, uint32_t frames,
 			struct mux_stream_data *data)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int32_t sample;
 	int16_t *dst;
+	uint32_t dst_idx;
 	uint8_t i;
 	uint8_t out_ch;
 
@@ -78,8 +80,8 @@ static void demux_s16le(struct comp_dev *dev, struct comp_buffer *sink,
 						   data->mask[out_ch]);
 
 			/* saturate to 16 bits */
-			dst = buffer_write_frag_s16(sink,
-				i * data->num_channels + out_ch);
+			dst_idx = i * data->num_channels + out_ch;
+			dst = audio_stream_write_frag_s16(sink, dst_idx);
 			*dst = sat_int16(sample);
 		}
 	}
@@ -99,16 +101,17 @@ static void demux_s16le(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in] data Array of parameters describing channel count and routing for
  *		   each stream.
  */
-static void mux_s16le(struct comp_dev *dev, struct comp_buffer *sink,
-		      struct comp_buffer **sources, uint32_t frames,
+static void mux_s16le(const struct comp_dev *dev, struct audio_stream *sink,
+		      const struct audio_stream **sources, uint32_t frames,
 		      struct mux_stream_data *data)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
-	struct comp_buffer *source;
+	const struct audio_stream *source;
 	uint8_t i;
 	uint8_t j;
 	uint8_t out_ch;
 	int16_t *dst;
+	uint32_t dst_idx;
 	int32_t sample;
 
 	for (i = 0; i < frames; i++) {
@@ -125,8 +128,8 @@ static void mux_s16le(struct comp_dev *dev, struct comp_buffer *sink,
 						i * data[j].num_channels,
 						data[j].mask[out_ch]);
 			}
-			dst = buffer_write_frag_s16(sink,
-				i * data->num_channels + out_ch);
+			dst_idx = i * data->num_channels + out_ch;
+			dst = audio_stream_write_frag_s16(sink, dst_idx);
 			*dst = sat_int16(sample);
 		}
 	}
@@ -142,7 +145,7 @@ static void mux_s16le(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in] offset Offset in source buffer.
  * \param[in] mask Routing bitmask for calculating output sample.
  */
-UT_STATIC inline int32_t calc_sample_s24le(struct comp_buffer *source,
+UT_STATIC inline int32_t calc_sample_s24le(const struct audio_stream *source,
 					   uint8_t num_ch, uint32_t offset,
 					   uint8_t mask)
 {
@@ -155,7 +158,8 @@ UT_STATIC inline int32_t calc_sample_s24le(struct comp_buffer *source,
 
 	for (in_ch = 0; in_ch < num_ch; in_ch++) {
 		if (mask & BIT(in_ch)) {
-			src = buffer_read_frag_s32(source, offset + in_ch);
+			src = audio_stream_read_frag_s32(source,
+							 offset + in_ch);
 			sample += sign_extend_s24(*src);
 		}
 	}
@@ -175,13 +179,14 @@ UT_STATIC inline int32_t calc_sample_s24le(struct comp_buffer *source,
  * \param[in] frames Number of frames to process.
  * \param[in] data Parameters describing channel count and routing.
  */
-static void demux_s24le(struct comp_dev *dev, struct comp_buffer *sink,
-			struct comp_buffer *source, uint32_t frames,
+static void demux_s24le(const struct comp_dev *dev, struct audio_stream *sink,
+			const struct audio_stream *source, uint32_t frames,
 			struct mux_stream_data *data)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int32_t sample;
 	int32_t *dst;
+	uint32_t dst_idx;
 	uint8_t i;
 	uint8_t out_ch;
 
@@ -193,8 +198,8 @@ static void demux_s24le(struct comp_dev *dev, struct comp_buffer *sink,
 						   data->mask[out_ch]);
 
 			/* saturate to 24 bits */
-			dst = buffer_write_frag_s32(sink,
-				i * data->num_channels + out_ch);
+			dst_idx = i * data->num_channels + out_ch;
+			dst = audio_stream_write_frag_s32(sink, dst_idx);
 			*dst = sat_int24(sample);
 		}
 	}
@@ -214,16 +219,17 @@ static void demux_s24le(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in] data Array of parameters describing channel count and routing for
  *		   each stream.
  */
-static void mux_s24le(struct comp_dev *dev, struct comp_buffer *sink,
-		      struct comp_buffer **sources, uint32_t frames,
+static void mux_s24le(const struct comp_dev *dev, struct audio_stream *sink,
+		      const struct audio_stream **sources, uint32_t frames,
 		      struct mux_stream_data *data)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
-	struct comp_buffer *source;
+	const struct audio_stream *source;
 	uint8_t i;
 	uint8_t j;
 	uint8_t out_ch;
 	int32_t *dst;
+	uint32_t dst_idx;
 	int32_t sample;
 
 	for (i = 0; i < frames; i++) {
@@ -239,8 +245,8 @@ static void mux_s24le(struct comp_dev *dev, struct comp_buffer *sink,
 						i * data[j].num_channels,
 						data[j].mask[out_ch]);
 			}
-			dst = buffer_write_frag_s32(sink,
-				i * data->num_channels + out_ch);
+			dst_idx = i * data->num_channels + out_ch;
+			dst = audio_stream_write_frag_s32(sink, dst_idx);
 			*dst = sat_int24(sample);
 		}
 	}
@@ -256,7 +262,7 @@ static void mux_s24le(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in] offset Offset in source buffer.
  * \param[in] mask Routing bitmask for calculating output sample.
  */
-UT_STATIC inline int64_t calc_sample_s32le(struct comp_buffer *source,
+UT_STATIC inline int64_t calc_sample_s32le(const struct audio_stream *source,
 					   uint8_t num_ch, uint32_t offset,
 					   uint8_t mask)
 {
@@ -269,7 +275,8 @@ UT_STATIC inline int64_t calc_sample_s32le(struct comp_buffer *source,
 
 	for (in_ch = 0; in_ch < num_ch; in_ch++) {
 		if (mask & BIT(in_ch)) {
-			src = buffer_read_frag_s32(source, offset + in_ch);
+			src = audio_stream_read_frag_s32(source,
+							 offset + in_ch);
 			sample += *src;
 		}
 	}
@@ -289,13 +296,14 @@ UT_STATIC inline int64_t calc_sample_s32le(struct comp_buffer *source,
  * \param[in] frames Number of frames to process.
  * \param[in] data Parameters describing channel count and routing.
  */
-static void demux_s32le(struct comp_dev *dev, struct comp_buffer *sink,
-			struct comp_buffer *source, uint32_t frames,
+static void demux_s32le(const struct comp_dev *dev, struct audio_stream *sink,
+			const struct audio_stream *source, uint32_t frames,
 			struct mux_stream_data *data)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int64_t sample;
 	int32_t *dst;
+	uint32_t dst_idx;
 	uint8_t i;
 	uint8_t out_ch;
 
@@ -307,8 +315,8 @@ static void demux_s32le(struct comp_dev *dev, struct comp_buffer *sink,
 						   data->mask[out_ch]);
 
 			/* saturate to 32 bits */
-			dst = buffer_write_frag_s32(sink,
-				i * data->num_channels + out_ch);
+			dst_idx = i * data->num_channels + out_ch;
+			dst = audio_stream_write_frag_s32(sink, dst_idx);
 			*dst = sat_int32(sample);
 		}
 	}
@@ -328,16 +336,17 @@ static void demux_s32le(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in] data Array of parameters describing channel count and routing for
  *		   each stream.
  */
-static void mux_s32le(struct comp_dev *dev, struct comp_buffer *sink,
-		      struct comp_buffer **sources, uint32_t frames,
+static void mux_s32le(const struct comp_dev *dev, struct audio_stream *sink,
+		      const struct audio_stream **sources, uint32_t frames,
 		      struct mux_stream_data *data)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
-	struct comp_buffer *source;
+	const struct audio_stream *source;
 	uint8_t i;
 	uint8_t j;
 	uint8_t out_ch;
 	int32_t *dst;
+	uint32_t dst_idx;
 	int64_t sample;
 
 	for (i = 0; i < frames; i++) {
@@ -353,8 +362,8 @@ static void mux_s32le(struct comp_dev *dev, struct comp_buffer *sink,
 						i * data[j].num_channels,
 						data[j].mask[out_ch]);
 			}
-			dst = buffer_write_frag_s32(sink,
-				i * data->num_channels + out_ch);
+			dst_idx = i * data->num_channels + out_ch;
+			dst = audio_stream_write_frag_s32(sink, dst_idx);
 			*dst = sat_int32(sample);
 		}
 	}
diff --git a/src/audio/pcm_converter/pcm_converter_generic.c b/src/audio/pcm_converter/pcm_converter_generic.c
index 1b3206a21519..5a0acb4a3bfa 100644
--- a/src/audio/pcm_converter/pcm_converter_generic.c
+++ b/src/audio/pcm_converter/pcm_converter_generic.c
@@ -24,8 +24,8 @@
 
 #if CONFIG_FORMAT_S16LE && CONFIG_FORMAT_S24LE
 
-static void pcm_convert_s16_to_s24(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s16_to_s24(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	uint32_t buff_frag = 0;
 	int16_t *src;
@@ -33,15 +33,15 @@ static void pcm_convert_s16_to_s24(const struct comp_buffer *source,
 	uint32_t i;
 
 	for (i = 0; i < samples; i++) {
-		src = buffer_read_frag_s16(source, buff_frag);
-		dst = buffer_write_frag_s32(sink, buff_frag);
+		src = audio_stream_read_frag_s16(source, buff_frag);
+		dst = audio_stream_write_frag_s32(sink, buff_frag);
 		*dst = *src << 8;
 		buff_frag++;
 	}
 }
 
-static void pcm_convert_s24_to_s16(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s24_to_s16(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	uint32_t buff_frag = 0;
 	int32_t *src;
@@ -49,8 +49,8 @@ static void pcm_convert_s24_to_s16(const struct comp_buffer *source,
 	uint32_t i;
 
 	for (i = 0; i < samples; i++) {
-		src = buffer_read_frag_s32(source, buff_frag);
-		dst = buffer_write_frag_s16(sink, buff_frag);
+		src = audio_stream_read_frag_s32(source, buff_frag);
+		dst = audio_stream_write_frag_s16(sink, buff_frag);
 		*dst = sat_int16(Q_SHIFT_RND(sign_extend_s24(*src), 23, 15));
 		buff_frag++;
 	}
@@ -60,8 +60,8 @@ static void pcm_convert_s24_to_s16(const struct comp_buffer *source,
 
 #if CONFIG_FORMAT_S16LE && CONFIG_FORMAT_S32LE
 
-static void pcm_convert_s16_to_s32(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s16_to_s32(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	uint32_t buff_frag = 0;
 	int16_t *src;
@@ -69,15 +69,15 @@ static void pcm_convert_s16_to_s32(const struct comp_buffer *source,
 	uint32_t i;
 
 	for (i = 0; i < samples; i++) {
-		src = buffer_read_frag_s16(source, buff_frag);
-		dst = buffer_write_frag_s32(sink, buff_frag);
+		src = audio_stream_read_frag_s16(source, buff_frag);
+		dst = audio_stream_write_frag_s32(sink, buff_frag);
 		*dst = *src << 16;
 		buff_frag++;
 	}
 }
 
-static void pcm_convert_s32_to_s16(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s32_to_s16(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	uint32_t buff_frag = 0;
 	int32_t *src;
@@ -85,8 +85,8 @@ static void pcm_convert_s32_to_s16(const struct comp_buffer *source,
 	uint32_t i;
 
 	for (i = 0; i < samples; i++) {
-		src = buffer_read_frag_s32(source, buff_frag);
-		dst = buffer_write_frag_s16(sink, buff_frag);
+		src = audio_stream_read_frag_s32(source, buff_frag);
+		dst = audio_stream_write_frag_s16(sink, buff_frag);
 		*dst = sat_int16(Q_SHIFT_RND(*src, 31, 15));
 		buff_frag++;
 	}
@@ -96,8 +96,8 @@ static void pcm_convert_s32_to_s16(const struct comp_buffer *source,
 
 #if CONFIG_FORMAT_S24LE && CONFIG_FORMAT_S32LE
 
-static void pcm_convert_s24_to_s32(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s24_to_s32(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	uint32_t buff_frag = 0;
 	int32_t *src;
@@ -105,15 +105,15 @@ static void pcm_convert_s24_to_s32(const struct comp_buffer *source,
 	uint32_t i;
 
 	for (i = 0; i < samples; i++) {
-		src = buffer_read_frag_s32(source, buff_frag);
-		dst = buffer_write_frag_s32(sink, buff_frag);
+		src = audio_stream_read_frag_s32(source, buff_frag);
+		dst = audio_stream_write_frag_s32(sink, buff_frag);
 		*dst = *src << 8;
 		buff_frag++;
 	}
 }
 
-static void pcm_convert_s32_to_s24(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s32_to_s24(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	uint32_t buff_frag = 0;
 	int32_t *src;
@@ -121,8 +121,8 @@ static void pcm_convert_s32_to_s24(const struct comp_buffer *source,
 	uint32_t i;
 
 	for (i = 0; i < samples; i++) {
-		src = buffer_read_frag_s32(source, buff_frag);
-		dst = buffer_write_frag_s32(sink, buff_frag);
+		src = audio_stream_read_frag_s32(source, buff_frag);
+		dst = audio_stream_write_frag_s32(sink, buff_frag);
 		*dst = sat_int24(Q_SHIFT_RND(*src, 31, 23));
 		buff_frag++;
 	}
@@ -132,13 +132,13 @@ static void pcm_convert_s32_to_s24(const struct comp_buffer *source,
 
 const struct pcm_func_map pcm_func_map[] = {
 #if CONFIG_FORMAT_S16LE
-	{ SOF_IPC_FRAME_S16_LE, SOF_IPC_FRAME_S16_LE, buffer_copy_s16 },
+	{ SOF_IPC_FRAME_S16_LE, SOF_IPC_FRAME_S16_LE, audio_stream_copy_s16 },
 #endif /* CONFIG_FORMAT_S16LE */
 #if CONFIG_FORMAT_S24LE
-	{ SOF_IPC_FRAME_S24_4LE, SOF_IPC_FRAME_S24_4LE, buffer_copy_s32 },
+	{ SOF_IPC_FRAME_S24_4LE, SOF_IPC_FRAME_S24_4LE, audio_stream_copy_s32 },
 #endif /* CONFIG_FORMAT_S24LE */
 #if CONFIG_FORMAT_S32LE
-	{ SOF_IPC_FRAME_S32_LE, SOF_IPC_FRAME_S32_LE, buffer_copy_s32 },
+	{ SOF_IPC_FRAME_S32_LE, SOF_IPC_FRAME_S32_LE, audio_stream_copy_s32 },
 #endif /* CONFIG_FORMAT_S32LE */
 #if CONFIG_FORMAT_S16LE && CONFIG_FORMAT_S24LE
 	{ SOF_IPC_FRAME_S16_LE, SOF_IPC_FRAME_S24_4LE, pcm_convert_s16_to_s24 },
@@ -156,4 +156,4 @@ const struct pcm_func_map pcm_func_map[] = {
 
 const size_t pcm_func_count = ARRAY_SIZE(pcm_func_map);
 
-#endif /* PCM_CONVERTER_GENERIC */
+#endif
diff --git a/src/audio/pcm_converter/pcm_converter_hifi3.c b/src/audio/pcm_converter/pcm_converter_hifi3.c
index ecf836d4e7ba..57581b2bca97 100644
--- a/src/audio/pcm_converter/pcm_converter_hifi3.c
+++ b/src/audio/pcm_converter/pcm_converter_hifi3.c
@@ -26,7 +26,7 @@
  * \brief Sets buffer to be circular using HiFi3 functions.
  * \param[in,out] buffer Circular buffer.
  */
-static void pcm_converter_setup_circular(const struct comp_buffer *source)
+static void pcm_converter_setup_circular(const struct audio_stream *source)
 {
 	AE_SETCBEGIN0(source->addr);
 	AE_SETCEND0(source->end_addr);
@@ -40,8 +40,8 @@ static void pcm_converter_setup_circular(const struct comp_buffer *source)
  * \param[in,out] sink Destination buffer.
  * \param[in] samples Number of samples to process.
  */
-static void pcm_convert_s16_to_s24(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s16_to_s24(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	ae_int16 *in = (ae_int16 *)source->r_ptr;
 	ae_int32 *out = (ae_int32 *)sink->w_ptr;
@@ -137,8 +137,8 @@ static ae_int32x2 pcm_shift_s24_to_s16(ae_int32x2 sample)
  * \param[in,out] sink Destination buffer.
  * \param[in] samples Number of samples to process.
  */
-static void pcm_convert_s24_to_s16(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s24_to_s16(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	ae_int32x2 *in = (ae_int32x2 *)source->r_ptr;
 	ae_int16x4 *out = (ae_int16x4 *)sink->w_ptr;
@@ -239,8 +239,8 @@ static void pcm_convert_s24_to_s16(const struct comp_buffer *source,
  * \param[in,out] sink Destination buffer.
  * \param[in] samples Number of samples to process.
  */
-static void pcm_convert_s16_to_s32(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s16_to_s32(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	ae_int16 *in = (ae_int16 *)source->r_ptr;
 	ae_int32 *out = (ae_int32 *)sink->w_ptr;
@@ -316,8 +316,8 @@ static void pcm_convert_s16_to_s32(const struct comp_buffer *source,
  * \param[in,out] sink Destination buffer.
  * \param[in] samples Number of samples to process.
  */
-static void pcm_convert_s32_to_s16(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s32_to_s16(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	ae_int32x2 *in = (ae_int32x2 *)source->r_ptr;
 	ae_int16x4 *out = (ae_int16x4 *)sink->w_ptr;
@@ -414,8 +414,8 @@ static void pcm_convert_s32_to_s16(const struct comp_buffer *source,
  * \param[in,out] sink Destination buffer.
  * \param[in] samples Number of samples to process.
  */
-static void pcm_convert_s24_to_s32(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s24_to_s32(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	ae_int32x2 *in = (ae_int32x2 *)source->r_ptr;
 	ae_int32x2 *out = (ae_int32x2 *)sink->w_ptr;
@@ -497,8 +497,8 @@ static ae_int32x2 pcm_shift_s32_to_s24(ae_int32x2 sample)
  * \param[in,out] sink Destination buffer.
  * \param[in] samples Number of samples to process.
  */
-static void pcm_convert_s32_to_s24(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
+static void pcm_convert_s32_to_s24(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples)
 {
 	ae_int32x2 *in = (ae_int32x2 *)source->r_ptr;
 	ae_int32x2 *out = (ae_int32x2 *)sink->w_ptr;
@@ -589,4 +589,4 @@ const struct pcm_func_map pcm_func_map[] = {
 
 const size_t pcm_func_count = ARRAY_SIZE(pcm_func_map);
 
-#endif /* PCM_CONVERTER_HIFI3 */
+#endif
diff --git a/src/audio/pipeline.c b/src/audio/pipeline.c
index c198af3f3ce8..e38ff36fe987 100644
--- a/src/audio/pipeline.c
+++ b/src/audio/pipeline.c
@@ -280,10 +280,10 @@ static void pipeline_update_buffer_pcm_params(struct comp_buffer *buffer,
 
 	params = data;
 
-	params->frame_fmt = buffer->frame_fmt;
 	params->buffer_fmt = buffer->buffer_fmt;
-	params->rate = buffer->rate;
-	params->channels = buffer->channels;
+	params->frame_fmt = buffer->stream.frame_fmt;
+	params->rate = buffer->stream.rate;
+	params->channels = buffer->stream.channels;
 	for (i = 0; i < SOF_IPC_MAX_CHANNELS; i++)
 		params->chmap[i] = buffer->chmap[i];
 }
@@ -306,10 +306,10 @@ static void pipeline_set_params(struct comp_dev *comp,
 	list_for_item(clist, buffer_list) {
 		buffer = buffer_from_list(clist, struct comp_buffer, dir);
 
-		buffer->frame_fmt = params->params.frame_fmt;
 		buffer->buffer_fmt = params->params.buffer_fmt;
-		buffer->rate = params->params.rate;
-		buffer->channels = params->params.channels;
+		buffer->stream.frame_fmt = params->params.frame_fmt;
+		buffer->stream.rate = params->params.rate;
+		buffer->stream.channels = params->params.channels;
 		for (i = 0; i < SOF_IPC_MAX_CHANNELS; i++)
 			buffer->chmap[i] = params->params.chmap[i];
 	}
diff --git a/src/audio/selector/selector.c b/src/audio/selector/selector.c
index bc64342a0a96..d34588754863 100644
--- a/src/audio/selector/selector.c
+++ b/src/audio/selector/selector.c
@@ -175,9 +175,9 @@ static int selector_params(struct comp_dev *dev,
 
 	/* rewrite channels number for other components */
 	if (dev->direction == SOF_IPC_STREAM_PLAYBACK)
-		sinkb->channels = cd->config.out_channels_count;
+		sinkb->stream.channels = cd->config.out_channels_count;
 	else
-		sourceb->channels = cd->config.in_channels_count;
+		sourceb->stream.channels = cd->config.in_channels_count;
 
 	return PPL_STATUS_PATH_STOP;
 }
@@ -334,9 +334,9 @@ static int selector_copy(struct comp_dev *dev)
 	sink = list_first_item(&dev->bsink_list, struct comp_buffer,
 			       source_list);
 
-	frames = buffer_avail_frames(source, sink);
-	source_bytes = frames * buffer_frame_bytes(source);
-	sink_bytes = frames * buffer_frame_bytes(sink);
+	frames = audio_stream_avail_frames(&source->stream, &sink->stream);
+	source_bytes = frames * audio_stream_frame_bytes(&source->stream);
+	sink_bytes = frames * audio_stream_frame_bytes(&sink->stream);
 
 	tracev_selector_with_ids(dev, "selector_copy(), "
 				 "source_bytes = 0x%x, "
@@ -344,7 +344,7 @@ static int selector_copy(struct comp_dev *dev)
 				 source_bytes, sink_bytes);
 
 	/* copy selected channels from in to out */
-	cd->sel_func(dev, sink, source, frames);
+	cd->sel_func(dev, &sink->stream, &source->stream, frames);
 
 	/* calculate new free and available */
 	comp_update_buffer_produce(sink, sink_bytes);
@@ -382,12 +382,14 @@ static int selector_prepare(struct comp_dev *dev)
 				source_list);
 
 	/* get source data format and period bytes */
-	cd->source_format = sourceb->frame_fmt;
-	cd->source_period_bytes = buffer_period_bytes(sourceb, dev->frames);
+	cd->source_format = sourceb->stream.frame_fmt;
+	cd->source_period_bytes =
+		audio_stream_period_bytes(&sourceb->stream, dev->frames);
 
 	/* get sink data format and period bytes */
-	cd->sink_format = sinkb->frame_fmt;
-	cd->sink_period_bytes = buffer_period_bytes(sinkb, dev->frames);
+	cd->sink_format = sinkb->stream.frame_fmt;
+	cd->sink_period_bytes =
+		audio_stream_period_bytes(&sinkb->stream, dev->frames);
 
 	/* There is an assumption that sink component will report out
 	 * proper number of channels [1] for selector to actually
@@ -395,12 +397,12 @@ static int selector_prepare(struct comp_dev *dev)
 	 */
 	trace_selector_with_ids(dev,
 				"selector_prepare(): sourceb->schannels = %u",
-				sourceb->channels);
+				sourceb->stream.channels);
 	trace_selector_with_ids(dev,
 				"selector_prepare(): sinkb->channels = %u",
-				sinkb->channels);
+				sinkb->stream.channels);
 
-	if (sinkb->size < config->periods_sink * cd->sink_period_bytes) {
+	if (sinkb->stream.size < config->periods_sink * cd->sink_period_bytes) {
 		trace_selector_error_with_ids(dev, "selector_prepare() error: "
 					      "sink buffer size is insufficient");
 		ret = -ENOMEM;
diff --git a/src/audio/selector/selector_generic.c b/src/audio/selector/selector_generic.c
index 2ad7ce3625a2..0560df5b03b0 100644
--- a/src/audio/selector/selector_generic.c
+++ b/src/audio/selector/selector_generic.c
@@ -26,8 +26,8 @@
  * \param[in,out] source Source buffer.
  * \param[in] frames Number of frames to process.
  */
-static void sel_s16le_1ch(struct comp_dev *dev, struct comp_buffer *sink,
-			  struct comp_buffer *source, uint32_t frames)
+static void sel_s16le_1ch(struct comp_dev *dev, struct audio_stream *sink,
+			  const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int16_t *src;
@@ -37,8 +37,8 @@ static void sel_s16le_1ch(struct comp_dev *dev, struct comp_buffer *sink,
 	uint32_t nch = cd->config.in_channels_count;
 
 	for (i = cd->config.sel_channel; i < frames * nch; i += nch) {
-		src = buffer_read_frag_s16(source, i);
-		dest = buffer_write_frag_s16(sink, j++);
+		src = audio_stream_read_frag_s16(source, i);
+		dest = audio_stream_write_frag_s16(sink, j++);
 		*dest = *src;
 	}
 }
@@ -50,8 +50,8 @@ static void sel_s16le_1ch(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in,out] source Source buffer.
  * \param[in] frames Number of frames to process.
  */
-static void sel_s16le_nch(struct comp_dev *dev, struct comp_buffer *sink,
-			  struct comp_buffer *source, uint32_t frames)
+static void sel_s16le_nch(struct comp_dev *dev, struct audio_stream *sink,
+			  const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int16_t *src;
@@ -63,8 +63,8 @@ static void sel_s16le_nch(struct comp_dev *dev, struct comp_buffer *sink,
 	for (i = 0; i < frames; i++) {
 		for (channel = 0; channel < cd->config.in_channels_count;
 		     channel++) {
-			src = buffer_read_frag_s16(source, j);
-			dest = buffer_write_frag_s16(sink, j);
+			src = audio_stream_read_frag_s16(source, j);
+			dest = audio_stream_write_frag_s16(sink, j);
 			*dest = *src;
 			j++;
 		}
@@ -80,8 +80,8 @@ static void sel_s16le_nch(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in,out] source Source buffer.
  * \param[in] frames Number of frames to process.
  */
-static void sel_s32le_1ch(struct comp_dev *dev, struct comp_buffer *sink,
-			  struct comp_buffer *source, uint32_t frames)
+static void sel_s32le_1ch(struct comp_dev *dev, struct audio_stream *sink,
+			  const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int32_t *src;
@@ -91,8 +91,8 @@ static void sel_s32le_1ch(struct comp_dev *dev, struct comp_buffer *sink,
 	uint32_t nch = cd->config.in_channels_count;
 
 	for (i = cd->config.sel_channel; i < frames * nch; i += nch) {
-		src = buffer_read_frag_s32(source, i);
-		dest = buffer_write_frag_s32(sink, j++);
+		src = audio_stream_read_frag_s32(source, i);
+		dest = audio_stream_write_frag_s32(sink, j++);
 		*dest = *src;
 	}
 }
@@ -104,8 +104,8 @@ static void sel_s32le_1ch(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in,out] source Source buffer.
  * \param[in] frames Number of frames to process.
  */
-static void sel_s32le_nch(struct comp_dev *dev, struct comp_buffer *sink,
-			  struct comp_buffer *source, uint32_t frames)
+static void sel_s32le_nch(struct comp_dev *dev, struct audio_stream *sink,
+			  const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int32_t *src;
@@ -117,8 +117,8 @@ static void sel_s32le_nch(struct comp_dev *dev, struct comp_buffer *sink,
 	for (i = 0; i < frames; i++) {
 		for (channel = 0; channel < cd->config.in_channels_count;
 		     channel++) {
-			src = buffer_read_frag_s32(source, j);
-			dest = buffer_write_frag_s32(sink, j);
+			src = audio_stream_read_frag_s32(source, j);
+			dest = audio_stream_write_frag_s32(sink, j);
 			*dest = *src;
 			j++;
 		}
diff --git a/src/audio/src/src.c b/src/audio/src/src.c
index 031d59a3732a..277524172e87 100644
--- a/src/audio/src/src.c
+++ b/src/audio/src/src.c
@@ -78,8 +78,8 @@ struct comp_data {
 	int sink_frames;
 	int sample_container_bytes;
 	void (*src_func)(struct comp_dev *dev,
-			 struct comp_buffer *source,
-			 struct comp_buffer *sink,
+			 const struct audio_stream *source,
+			 struct audio_stream *sink,
 			 int *consumed,
 			 int *produced);
 	void (*polyphase_func)(struct src_stage_prm *s);
@@ -306,17 +306,17 @@ int src_polyphase_init(struct polyphase_src *src, struct src_param *p,
 }
 
 /* Fallback function */
-static void src_fallback(struct comp_dev *dev, struct comp_buffer *source,
-			 struct comp_buffer *sink, int *n_read, int *n_written)
+static void src_fallback(struct comp_dev *dev,
+			 const struct audio_stream *source,
+			 struct audio_stream *sink, int *n_read, int *n_written)
 {
 	*n_read = 0;
 	*n_written = 0;
 }
 
 /* Normal 2 stage SRC */
-static void src_2s(struct comp_dev *dev,
-		   struct comp_buffer *source, struct comp_buffer *sink,
-		   int *n_read, int *n_written)
+static void src_2s(struct comp_dev *dev, const struct audio_stream *source,
+		   struct audio_stream *sink, int *n_read, int *n_written)
 {
 	struct src_stage_prm s1;
 	struct src_stage_prm s2;
@@ -410,9 +410,8 @@ static void src_2s(struct comp_dev *dev,
 }
 
 /* 1 stage SRC for simple conversions */
-static void src_1s(struct comp_dev *dev,
-		   struct comp_buffer *source, struct comp_buffer *sink,
-		   int *n_read, int *n_written)
+static void src_1s(struct comp_dev *dev, const struct audio_stream *source,
+		   struct audio_stream *sink, int *n_read, int *n_written)
 {
 	struct src_stage_prm s1;
 	struct comp_data *cd = comp_get_drvdata(dev);
@@ -437,13 +436,14 @@ static void src_1s(struct comp_dev *dev,
 
 /* A fast copy function for same in and out rate */
 static void src_copy_s32(struct comp_dev *dev,
-			 struct comp_buffer *source, struct comp_buffer *sink,
+			 const struct audio_stream *source,
+			 struct audio_stream *sink,
 			 int *n_read, int *n_written)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int frames = cd->param.blk_in;
 
-	buffer_copy_s32(source, sink, frames * source->channels);
+	audio_stream_copy_s32(source, sink, frames * source->channels);
 
 	*n_read = frames;
 	*n_written = frames;
@@ -451,13 +451,14 @@ static void src_copy_s32(struct comp_dev *dev,
 
 #if CONFIG_FORMAT_S16LE
 static void src_copy_s16(struct comp_dev *dev,
-			 struct comp_buffer *source, struct comp_buffer *sink,
+			 const struct audio_stream *source,
+			 struct audio_stream *sink,
 			 int *n_read, int *n_written)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int frames = cd->param.blk_in;
 
-	buffer_copy_s16(source, sink, frames * source->channels);
+	audio_stream_copy_s16(source, sink, frames * source->channels);
 
 	*n_read = frames;
 	*n_written = frames;
@@ -561,16 +562,16 @@ static int src_params(struct comp_dev *dev,
 	 */
 	if (src->source_rate == 0) {
 		/* params rate is source rate */
-		cd->source_rate = sourceb->rate;
+		cd->source_rate = sourceb->stream.rate;
 		cd->sink_rate = src->sink_rate;
 		/* re-write our params with output rate for next component */
-		sinkb->rate = cd->sink_rate;
+		sinkb->stream.rate = cd->sink_rate;
 	} else {
 		/* params rate is sink rate */
 		cd->source_rate = src->source_rate;
-		cd->sink_rate = sinkb->rate;
+		cd->sink_rate = sinkb->stream.rate;
 		/* re-write our params with output rate for next component */
-		sourceb->rate = cd->source_rate;
+		sourceb->stream.rate = cd->source_rate;
 	}
 
 	cd->source_frames = dev->frames * cd->source_rate /
@@ -583,9 +584,10 @@ static int src_params(struct comp_dev *dev,
 			   cd->source_rate, cd->sink_rate);
 	trace_src_with_ids(dev,
 			   "src_params(), sourceb->channels = %u, sinkb->channels = %u, dev->frames = %u",
-			   sourceb->channels, sinkb->channels, dev->frames);
+			   sourceb->stream.channels,
+			   sinkb->stream.channels, dev->frames);
 	err = src_buffer_lengths(&cd->param, cd->source_rate, cd->sink_rate,
-				 sourceb->channels, cd->source_frames);
+				 sourceb->stream.channels, cd->source_frames);
 	if (err < 0) {
 		trace_src_error_with_ids(dev, "src_params() error: "
 					 "src_buffer_lengths() failed");
@@ -685,8 +687,8 @@ static int src_trigger(struct comp_dev *dev, int cmd)
 }
 
 static int src_get_copy_limits(struct comp_data *cd,
-			       struct comp_buffer *source,
-			       struct comp_buffer *sink)
+			       const struct comp_buffer *source,
+			       const struct comp_buffer *sink)
 {
 	struct src_param *sp;
 	struct src_stage *s1;
@@ -704,20 +706,24 @@ static int src_get_copy_limits(struct comp_data *cd,
 	 */
 	if (s2->filter_length > 1) {
 		/* Two polyphase filters case */
-		frames_snk = sink->free / buffer_frame_bytes(sink);
+		frames_snk = sink->stream.free /
+			     audio_stream_frame_bytes(&sink->stream);
 		frames_snk = MIN(frames_snk, cd->sink_frames + s2->blk_out);
 		sp->stage2_times = frames_snk / s2->blk_out;
-		frames_src = source->avail / buffer_frame_bytes(source);
+		frames_src = source->stream.avail /
+			     audio_stream_frame_bytes(&source->stream);
 		frames_src = MIN(frames_src, cd->source_frames + s1->blk_in);
 		sp->stage1_times = frames_src / s1->blk_in;
 		sp->blk_in = sp->stage1_times * s1->blk_in;
 		sp->blk_out = sp->stage2_times * s2->blk_out;
 	} else {
 		/* Single polyphase filter case */
-		frames_snk = sink->free / buffer_frame_bytes(sink);
+		frames_snk = sink->stream.free /
+			     audio_stream_frame_bytes(&sink->stream);
 		frames_snk = MIN(frames_snk, cd->sink_frames + s1->blk_out);
 		sp->stage1_times = frames_snk / s1->blk_out;
-		frames_src = source->avail / buffer_frame_bytes(source);
+		frames_src = source->stream.avail /
+			     audio_stream_frame_bytes(&source->stream);
 		frames_snk = MIN(frames_src, cd->source_frames + s1->blk_in);
 		sp->stage1_times = MIN(sp->stage1_times,
 				       frames_src / s1->blk_in);
@@ -759,7 +765,7 @@ static int src_copy(struct comp_dev *dev)
 		return PPL_STATUS_PATH_STOP;
 	}
 
-	cd->src_func(dev, source, sink, &consumed, &produced);
+	cd->src_func(dev, &source->stream, &sink->stream, &consumed, &produced);
 
 	tracev_src_with_ids(dev, "src_copy(), consumed = %u,  produced = %u",
 			    consumed, produced);
@@ -768,12 +774,12 @@ static int src_copy(struct comp_dev *dev)
 	 * functions must not be called with 0 consumed/produced.
 	 */
 	if (consumed > 0)
-		comp_update_buffer_consume(source, consumed *
-					   buffer_frame_bytes(source));
+		comp_update_buffer_consume(source,
+			consumed * audio_stream_frame_bytes(&source->stream));
 
 	if (produced > 0)
-		comp_update_buffer_produce(sink, produced *
-					   buffer_frame_bytes(sink));
+		comp_update_buffer_produce(sink,
+			produced * audio_stream_frame_bytes(&sink->stream));
 
 	/* produced no data */
 	return 0;
@@ -805,14 +811,16 @@ static int src_prepare(struct comp_dev *dev)
 				struct comp_buffer, source_list);
 
 	/* get source data format and period bytes */
-	cd->source_format = sourceb->frame_fmt;
-	source_period_bytes = buffer_period_bytes(sourceb, dev->frames);
+	cd->source_format = sourceb->stream.frame_fmt;
+	source_period_bytes = audio_stream_period_bytes(&sourceb->stream,
+							dev->frames);
 
 	/* get sink data format and period bytes */
-	cd->sink_format = sinkb->frame_fmt;
-	sink_period_bytes = buffer_period_bytes(sinkb, dev->frames);
+	cd->sink_format = sinkb->stream.frame_fmt;
+	sink_period_bytes = audio_stream_period_bytes(&sinkb->stream,
+						      dev->frames);
 
-	if (sinkb->size < config->periods_sink * sink_period_bytes) {
+	if (sinkb->stream.size < config->periods_sink * sink_period_bytes) {
 		trace_src_error_with_ids(dev, "src_prepare() error: "
 					  "sink buffer size is insufficient");
 		ret = -ENOMEM;
diff --git a/src/audio/tone.c b/src/audio/tone.c
index 6fa32ce65eeb..476359103e1b 100644
--- a/src/audio/tone.c
+++ b/src/audio/tone.c
@@ -101,7 +101,7 @@ struct comp_data {
 	uint32_t frame_bytes;
 	uint32_t rate;
 	struct tone_state sg[PLATFORM_MAX_CHANNELS];
-	void (*tone_func)(struct comp_dev *dev, struct comp_buffer *sink,
+	void (*tone_func)(struct comp_dev *dev, struct audio_stream *sink,
 			  uint32_t frames);
 };
 
@@ -119,7 +119,7 @@ static inline void tone_circ_inc_wrap(int32_t **ptr, int32_t *end, size_t size)
 		*ptr = (int32_t *)((size_t)*ptr - size);
 }
 
-static void tone_s32_default(struct comp_dev *dev, struct comp_buffer *sink,
+static void tone_s32_default(struct comp_dev *dev, struct audio_stream *sink,
 			     uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
@@ -461,11 +461,12 @@ static int tone_params(struct comp_dev *dev,
 	if (config->frame_fmt != SOF_IPC_FRAME_S32_LE)
 		return -EINVAL;
 
-	sourceb->frame_fmt = config->frame_fmt;
-	sinkb->frame_fmt = config->frame_fmt;
+	sourceb->stream.frame_fmt = config->frame_fmt;
+	sinkb->stream.frame_fmt = config->frame_fmt;
 
 	/* calculate period size based on config */
-	cd->period_bytes = dev->frames * buffer_frame_bytes(sourceb);
+	cd->period_bytes = dev->frames *
+			   audio_stream_frame_bytes(&sourceb->stream);
 
 	return 0;
 }
@@ -656,9 +657,9 @@ static int tone_copy(struct comp_dev *dev)
 	/* Test that sink has enough free frames. Then run once to maintain
 	 * low latency and steady load for tones.
 	 */
-	if (sink->free >= cd->period_bytes) {
+	if (sink->stream.free >= cd->period_bytes) {
 		/* create tone */
-		cd->tone_func(dev, sink, dev->frames);
+		cd->tone_func(dev, &sink->stream, dev->frames);
 
 		/* calc new free and available */
 		comp_update_buffer_produce(sink, cd->period_bytes);
@@ -690,7 +691,7 @@ static int tone_prepare(struct comp_dev *dev)
 	sourceb = list_first_item(&dev->bsource_list, struct comp_buffer,
 				  sink_list);
 
-	cd->channels = sourceb->channels;
+	cd->channels = sourceb->stream.channels;
 	trace_tone_with_ids(dev, "tone_prepare(), "
 			    "cd->channels = %u, "
 			    "cd->rate = %u",
diff --git a/src/audio/volume/volume.c b/src/audio/volume/volume.c
index b05c793c17bf..73e14a296dde 100644
--- a/src/audio/volume/volume.c
+++ b/src/audio/volume/volume.c
@@ -618,7 +618,7 @@ static int volume_copy(struct comp_dev *dev)
 			       c.source_bytes, c.sink_bytes);
 
 	/* copy and scale volume */
-	cd->scale_vol(dev, c.sink, c.source, c.frames);
+	cd->scale_vol(dev, &c.sink->stream, &c.source->stream, c.frames);
 
 	/* calculate new free and available */
 	comp_update_buffer_produce(c.sink, c.sink_bytes);
@@ -658,9 +658,10 @@ static int volume_prepare(struct comp_dev *dev)
 				struct comp_buffer, source_list);
 
 	/* get sink period bytes */
-	sink_period_bytes = buffer_period_bytes(sinkb, dev->frames);
+	sink_period_bytes = audio_stream_period_bytes(&sinkb->stream,
+						      dev->frames);
 
-	if (sinkb->size < config->periods_sink * sink_period_bytes) {
+	if (sinkb->stream.size < config->periods_sink * sink_period_bytes) {
 		trace_volume_error_with_ids(dev, "volume_prepare() error: "
 					    "sink buffer size is insufficient");
 		ret = -ENOMEM;
@@ -686,7 +687,7 @@ static int volume_prepare(struct comp_dev *dev)
 	 * for entire topology specified time.
 	 */
 	cd->ramp_started = false;
-	cd->channels = sinkb->channels;
+	cd->channels = sinkb->stream.channels;
 	for (i = 0; i < cd->channels; i++) {
 		cd->volume[i] = cd->vol_min;
 		volume_set_chan(dev, i, cd->tvolume[i], false);
diff --git a/src/audio/volume/volume_generic.c b/src/audio/volume/volume_generic.c
index 03af8963f3e0..89c11b7e3637 100644
--- a/src/audio/volume/volume_generic.c
+++ b/src/audio/volume/volume_generic.c
@@ -51,8 +51,8 @@ static inline int32_t vol_mult_s24_to_s24(int32_t x, int32_t vol)
  * Copy and scale volume from 24/32 bit source buffer
  * to 24/32 bit destination buffer.
  */
-static void vol_s24_to_s24(struct comp_dev *dev, struct comp_buffer *sink,
-			   struct comp_buffer *source, uint32_t frames)
+static void vol_s24_to_s24(struct comp_dev *dev, struct audio_stream *sink,
+			   const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int32_t *src;
@@ -64,8 +64,8 @@ static void vol_s24_to_s24(struct comp_dev *dev, struct comp_buffer *sink,
 	/* Samples are Q1.23 --> Q1.23 and volume is Q8.16 */
 	for (i = 0; i < frames; i++) {
 		for (channel = 0; channel < sink->channels; channel++) {
-			src = buffer_read_frag_s32(source, buff_frag);
-			dest = buffer_write_frag_s32(sink, buff_frag);
+			src = audio_stream_read_frag_s32(source, buff_frag);
+			dest = audio_stream_write_frag_s32(sink, buff_frag);
 
 			*dest = vol_mult_s24_to_s24(*src, cd->volume[channel]);
 
@@ -86,8 +86,8 @@ static void vol_s24_to_s24(struct comp_dev *dev, struct comp_buffer *sink,
  * Copy and scale volume from 32 bit source buffer
  * to 32 bit destination buffer.
  */
-static void vol_s32_to_s32(struct comp_dev *dev, struct comp_buffer *sink,
-			   struct comp_buffer *source, uint32_t frames)
+static void vol_s32_to_s32(struct comp_dev *dev, struct audio_stream *sink,
+			   const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int32_t *src;
@@ -99,8 +99,8 @@ static void vol_s32_to_s32(struct comp_dev *dev, struct comp_buffer *sink,
 	/* Samples are Q1.31 --> Q1.31 and volume is Q8.16 */
 	for (i = 0; i < frames; i++) {
 		for (channel = 0; channel < sink->channels; channel++) {
-			src = buffer_read_frag_s32(source, buff_frag);
-			dest = buffer_write_frag_s32(sink, buff_frag);
+			src = audio_stream_read_frag_s32(source, buff_frag);
+			dest = audio_stream_write_frag_s32(sink, buff_frag);
 
 			*dest = q_multsr_sat_32x32
 				(*src, cd->volume[channel],
@@ -123,8 +123,8 @@ static void vol_s32_to_s32(struct comp_dev *dev, struct comp_buffer *sink,
  * Copy and scale volume from 16 bit source buffer
  * to 16 bit destination buffer.
  */
-static void vol_s16_to_s16(struct comp_dev *dev, struct comp_buffer *sink,
-			   struct comp_buffer *source, uint32_t frames)
+static void vol_s16_to_s16(struct comp_dev *dev, struct audio_stream *sink,
+			   const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	int16_t *src;
@@ -136,8 +136,8 @@ static void vol_s16_to_s16(struct comp_dev *dev, struct comp_buffer *sink,
 	/* Samples are Q1.15 --> Q1.15 and volume is Q8.16 */
 	for (i = 0; i < frames; i++) {
 		for (channel = 0; channel < sink->channels; channel++) {
-			src = buffer_read_frag_s16(source, buff_frag);
-			dest = buffer_write_frag_s16(sink, buff_frag);
+			src = audio_stream_read_frag_s16(source, buff_frag);
+			dest = audio_stream_write_frag_s16(sink, buff_frag);
 
 			*dest = q_multsr_sat_32x32_16
 				(*src, cd->volume[channel],
diff --git a/src/audio/volume/volume_hifi3.c b/src/audio/volume/volume_hifi3.c
index 31161bd2c5f1..12c5ad8c1f04 100644
--- a/src/audio/volume/volume_hifi3.c
+++ b/src/audio/volume/volume_hifi3.c
@@ -26,7 +26,7 @@
  * \brief Sets buffer to be circular using HiFi3 functions.
  * \param[in,out] buffer Circular buffer.
  */
-static void vol_setup_circular(struct comp_buffer *buffer)
+static void vol_setup_circular(const struct audio_stream *buffer)
 {
 	AE_SETCBEGIN0(buffer->addr);
 	AE_SETCEND0(buffer->end_addr);
@@ -40,8 +40,9 @@ static void vol_setup_circular(struct comp_buffer *buffer)
  * \param[in,out] source Source buffer.
  * \param[in] frames Number of frames to process.
  */
-static void vol_s24_to_s24_s32(struct comp_dev *dev, struct comp_buffer *sink,
-			       struct comp_buffer *source, uint32_t frames)
+static void vol_s24_to_s24_s32(struct comp_dev *dev, struct audio_stream *sink,
+			       const struct audio_stream *source,
+			       uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	ae_f64 mult;
@@ -100,8 +101,9 @@ static void vol_s24_to_s24_s32(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in,out] source Source buffer.
  * \param[in] frames Number of frames to process.
  */
-static void vol_s32_to_s24_s32(struct comp_dev *dev, struct comp_buffer *sink,
-			       struct comp_buffer *source, uint32_t frames)
+static void vol_s32_to_s24_s32(struct comp_dev *dev, struct audio_stream *sink,
+			       const struct audio_stream *source,
+			       uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	ae_f64 mult;
@@ -160,8 +162,8 @@ static void vol_s32_to_s24_s32(struct comp_dev *dev, struct comp_buffer *sink,
  * \param[in,out] source Source buffer.
  * \param[in] frames Number of frames to process.
  */
-static void vol_s16_to_s16(struct comp_dev *dev, struct comp_buffer *sink,
-			   struct comp_buffer *source, uint32_t frames)
+static void vol_s16_to_s16(struct comp_dev *dev, struct audio_stream *sink,
+			   const struct audio_stream *source, uint32_t frames)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	ae_f64 mult;
diff --git a/src/include/sof/audio/audio_stream.h b/src/include/sof/audio/audio_stream.h
new file mode 100644
index 000000000000..ff3d70247568
--- /dev/null
+++ b/src/include/sof/audio/audio_stream.h
@@ -0,0 +1,258 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright(c) 2020 Intel Corporation. All rights reserved.
+ *
+ * Author: Karol Trzcinski <karolx.trzcinski@linux.intel.com>
+ */
+
+/**
+ * audio_stream is kind of circular buffer with information about data format
+ * and buffer size. Audio processing functions should work on this component.
+ * This component is not responsible for memory menagement for himself,
+ * it is a role of highly coupled comp_buffer or dma component as usual.
+ */
+
+#ifndef __SOF_AUDIO_AUDIO_STREAM_H__
+#define __SOF_AUDIO_AUDIO_STREAM_H__
+
+#include <sof/audio/format.h>
+#include <sof/debug/panic.h>
+#include <sof/math/numbers.h>
+#include <sof/lib/alloc.h>
+#include <sof/lib/cache.h>
+#include <config.h>
+#include <stdint.h>
+
+/* audio circular stream */
+struct audio_stream {
+	/* runtime data */
+	uint32_t size;	/* runtime buffer size in bytes (period multiple) */
+	uint32_t avail;		/* available bytes for reading */
+	uint32_t free;		/* free bytes for writing */
+	void *w_ptr;		/* buffer write pointer */
+	void *r_ptr;		/* buffer read position */
+	void *addr;		/* buffer base address */
+	void *end_addr;		/* buffer end address */
+
+	/* runtime stream params */
+	uint32_t frame_fmt;	/**< enum sof_ipc_frame */
+	uint32_t rate;
+	uint16_t channels;
+};
+
+#define audio_stream_read_frag(buffer, idx, size) \
+	audio_stream_get_frag(buffer, buffer->r_ptr, idx, size)
+
+#define audio_stream_read_frag_s16(buffer, idx) \
+	audio_stream_get_frag(buffer, buffer->r_ptr, idx, sizeof(int16_t))
+
+#define audio_stream_read_frag_s32(buffer, idx) \
+	audio_stream_get_frag(buffer, buffer->r_ptr, idx, sizeof(int32_t))
+
+#define audio_stream_write_frag(buffer, idx, size) \
+	audio_stream_get_frag(buffer, buffer->w_ptr, idx, size)
+
+#define audio_stream_write_frag_s16(buffer, idx) \
+	audio_stream_get_frag(buffer, buffer->w_ptr, idx, sizeof(int16_t))
+
+#define audio_stream_write_frag_s32(buffer, idx) \
+	audio_stream_get_frag(buffer, buffer->w_ptr, idx, sizeof(int32_t))
+
+#define audio_stream_get_frag(buffer, ptr, idx, sample_size) \
+	audio_stream_wrap(buffer, (char *)(ptr) + ((idx) * (sample_size)))
+
+static inline void *audio_stream_wrap(const struct audio_stream *buffer,
+				      void *ptr)
+{
+	if (ptr >= buffer->end_addr)
+		ptr = (char *)buffer->addr +
+			((char *)ptr - (char *)buffer->end_addr);
+
+	return ptr;
+}
+
+/* get the max number of bytes that can be copied between sink and source */
+static inline int audio_stream_can_copy_bytes(const struct audio_stream *source,
+					      const struct audio_stream *sink,
+					      uint32_t bytes)
+{
+	/* check for underrun */
+	if (source->avail < bytes)
+		return -1;
+
+	/* check for overrun */
+	if (sink->free < bytes)
+		return 1;
+
+	/* we are good to copy */
+	return 0;
+}
+
+static inline uint32_t
+audio_stream_get_copy_bytes(const struct audio_stream *source,
+			    const struct audio_stream *sink)
+{
+	if (source->avail > sink->free)
+		return sink->free;
+	else
+		return source->avail;
+}
+
+/**
+ * Calculates period size in bytes based on component stream's parameters.
+ * @param buf Component buffer.
+ * @return Period size in bytes.
+ */
+static inline uint32_t audio_stream_frame_bytes(const struct audio_stream *buf)
+{
+	return frame_bytes(buf->frame_fmt, buf->channels);
+}
+
+/**
+ * Calculates sample size in bytes based on component stream's parameters.
+ * @param buf Component buffer.
+ * @return Size of sample in bytes.
+ */
+static inline uint32_t audio_stream_sample_bytes(const struct audio_stream *buf)
+{
+	return sample_bytes(buf->frame_fmt);
+}
+
+/**
+ * Calculates period size in bytes based on component stream's parameters.
+ * @param buf Component buffer.
+ * @param frames Number of processing frames.
+ * @return Period size in bytes.
+ */
+static inline uint32_t audio_stream_period_bytes(const struct audio_stream *buf,
+						 uint32_t frames)
+{
+	return frames * audio_stream_frame_bytes(buf);
+}
+
+static inline uint32_t
+audio_stream_avail_frames(const struct audio_stream *source,
+			  const struct audio_stream *sink)
+{
+	uint32_t src_frames = source->avail / audio_stream_frame_bytes(source);
+	uint32_t sink_frames = sink->free / audio_stream_frame_bytes(sink);
+
+	return MIN(src_frames, sink_frames);
+}
+
+/* called only by a comp_buffer procedures */
+static inline void audio_stream_produce(struct audio_stream *buffer,
+					uint32_t bytes)
+{
+	buffer->w_ptr = audio_stream_wrap(buffer,
+					  (char *)buffer->w_ptr + bytes);
+
+	/* "overwrite" old data in circular wrap case */
+	if (bytes > buffer->free)
+		buffer->r_ptr = buffer->w_ptr;
+
+	/* calculate available bytes */
+	if (buffer->r_ptr < buffer->w_ptr)
+		buffer->avail = (char *)buffer->w_ptr - (char *)buffer->r_ptr;
+	else if (buffer->r_ptr == buffer->w_ptr)
+		buffer->avail = buffer->size; /* full */
+	else
+		buffer->avail = buffer->size -
+			((char *)buffer->r_ptr - (char *)buffer->w_ptr);
+
+	/* calculate free bytes */
+	buffer->free = buffer->size - buffer->avail;
+}
+
+/* called only by a comp_buffer procedures */
+static inline void audio_stream_consume(struct audio_stream *buffer,
+					uint32_t bytes)
+{
+	buffer->r_ptr = audio_stream_wrap(buffer,
+					  (char *)buffer->r_ptr + bytes);
+
+	/* calculate available bytes */
+	if (buffer->r_ptr < buffer->w_ptr)
+		buffer->avail = (char *)buffer->w_ptr - (char *)buffer->r_ptr;
+	else if (buffer->r_ptr == buffer->w_ptr)
+		buffer->avail = 0; /* empty */
+	else
+		buffer->avail = buffer->size -
+			((char *)buffer->r_ptr - (char *)buffer->w_ptr);
+
+	/* calculate free bytes */
+	buffer->free = buffer->size - buffer->avail;
+}
+
+static inline void audio_stream_reset(struct audio_stream *buffer)
+{
+	/* reset read and write pointer to buffer bas */
+	buffer->w_ptr = buffer->addr;
+	buffer->r_ptr = buffer->addr;
+
+	/* free space is buffer size */
+	buffer->free = buffer->size;
+
+	/* there are no avail samples at reset */
+	buffer->avail = 0;
+}
+
+static inline void audio_stream_init(struct audio_stream *buffer,
+				     void *buff_addr, uint32_t size)
+{
+	buffer->size = size;
+	buffer->addr = buff_addr;
+	buffer->end_addr = (char *)buffer->addr + size;
+	audio_stream_reset(buffer);
+}
+
+static inline void audio_stream_copy(const struct audio_stream *source,
+				     struct audio_stream *sink, uint32_t bytes)
+{
+	void *src = source->r_ptr;
+	void *snk = sink->w_ptr;
+	uint32_t bytes_src;
+	uint32_t bytes_snk;
+	uint32_t bytes_copied;
+	int ret;
+
+	while (bytes) {
+		bytes_src = (char *)source->end_addr - (char *)src;
+		bytes_snk = (char *)sink->end_addr - (char *)snk;
+		bytes_copied = MIN(bytes, MIN(bytes_src, bytes_snk));
+
+		ret = memcpy_s(snk, bytes_snk, src, bytes_copied);
+		assert(!ret);
+
+		bytes -= bytes_copied;
+		src = (char *)src + bytes_copied;
+		snk = (char *)snk + bytes_copied;
+
+		src = audio_stream_wrap(source, src);
+		snk = audio_stream_wrap(sink, snk);
+	}
+}
+
+#if CONFIG_FORMAT_S16LE
+
+static inline void audio_stream_copy_s16(const struct audio_stream *source,
+					 struct audio_stream *sink,
+					 uint32_t samples)
+{
+	audio_stream_copy(source, sink, samples * sizeof(int16_t));
+}
+
+#endif /* CONFIG_FORMAT_S16LE */
+
+#if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE || CONFIG_FORMAT_FLOAT
+
+static inline void audio_stream_copy_s32(const struct audio_stream *source,
+					 struct audio_stream *sink,
+					 uint32_t samples)
+{
+	audio_stream_copy(source, sink, samples * sizeof(int32_t));
+}
+
+#endif /* CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE || CONFIG_FORMAT_FLOAT */
+
+#endif /* __SOF_AUDIO_AUDIO_STREAM_H__ */
diff --git a/src/include/sof/audio/buffer.h b/src/include/sof/audio/buffer.h
index ad039243768d..790713bc84d4 100644
--- a/src/include/sof/audio/buffer.h
+++ b/src/include/sof/audio/buffer.h
@@ -8,6 +8,7 @@
 #ifndef __SOF_AUDIO_BUFFER_H__
 #define __SOF_AUDIO_BUFFER_H__
 
+#include <sof/audio/audio_stream.h>
 #include <sof/audio/pipeline.h>
 #include <sof/math/numbers.h>
 #include <sof/common.h>
@@ -55,16 +56,8 @@ struct comp_dev;
 
 /* audio component buffer - connects 2 audio components together in pipeline */
 struct comp_buffer {
-
-	/* runtime data */
-	uint32_t size;	/* runtime buffer size in bytes (period multiple) */
-	uint32_t alloc_size;	/* allocated size in bytes */
-	uint32_t avail;		/* available bytes for reading */
-	uint32_t free;		/* free bytes for writing */
-	void *w_ptr;		/* buffer write pointer */
-	void *r_ptr;		/* buffer read position */
-	void *addr;		/* buffer base address */
-	void *end_addr;		/* buffer end address */
+	/* data buffer */
+	struct audio_stream stream;
 
 	/* configuration */
 	uint32_t id;
@@ -80,10 +73,7 @@ struct comp_buffer {
 	struct list_item sink_list;	/* list in comp buffers */
 
 	/* runtime stream params */
-	uint32_t frame_fmt;	/**< enum sof_ipc_frame */
 	uint32_t buffer_fmt;	/**< enum sof_ipc_buffer_format */
-	uint32_t rate;
-	uint16_t channels;
 	uint16_t chmap[SOF_IPC_MAX_CHANNELS];	/**< channel map - SOF_CHMAP_ */
 };
 
@@ -125,23 +115,6 @@ struct buffer_cb_free {
 		buffer->cb_type = type;	\
 	} while (0)
 
-#define buffer_read_frag(buffer, idx, size) \
-	buffer_get_frag(buffer, buffer->r_ptr, idx, size)
-
-#define buffer_read_frag_s16(buffer, idx) \
-	buffer_get_frag(buffer, buffer->r_ptr, idx, sizeof(int16_t))
-
-#define buffer_read_frag_s32(buffer, idx) \
-	buffer_get_frag(buffer, buffer->r_ptr, idx, sizeof(int32_t))
-
-#define buffer_write_frag(buffer, idx, size) \
-	buffer_get_frag(buffer, buffer->w_ptr, idx, size)
-
-#define buffer_write_frag_s16(buffer, idx) \
-	buffer_get_frag(buffer, buffer->w_ptr, idx, sizeof(int16_t))
-
-#define buffer_write_frag_s32(buffer, idx) \
-	buffer_get_frag(buffer, buffer->w_ptr, idx, sizeof(int32_t))
 
 typedef void (*cache_buff_op)(struct comp_buffer *, void *);
 
@@ -159,37 +132,12 @@ void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes);
 
 static inline void buffer_zero(struct comp_buffer *buffer)
 {
-	tracev_buffer_with_ids(buffer, "buffer_zero()");
+	tracev_buffer_with_ids(buffer, "stream_zero()");
 
-	bzero(buffer->addr, buffer->size);
+	bzero(buffer->stream.addr, buffer->stream.size);
 	if (buffer->caps & SOF_MEM_CAPS_DMA)
-		dcache_writeback_region(buffer->addr, buffer->size);
-}
-
-/* get the max number of bytes that can be copied between sink and source */
-static inline int comp_buffer_can_copy_bytes(struct comp_buffer *source,
-					     struct comp_buffer *sink,
-					     uint32_t bytes)
-{
-	/* check for underrun */
-	if (source->avail < bytes)
-		return -1;
-
-	/* check for overrun */
-	if (sink->free < bytes)
-		return 1;
-
-	/* we are good to copy */
-	return 0;
-}
-
-static inline uint32_t comp_buffer_get_copy_bytes(struct comp_buffer *source,
-						  struct comp_buffer *sink)
-{
-	if (source->avail > sink->free)
-		return sink->free;
-	else
-		return source->avail;
+		dcache_writeback_region(buffer->stream.addr,
+					buffer->stream.size);
 }
 
 static inline void comp_buffer_cache_wtb_inv(struct comp_buffer *buffer,
@@ -219,149 +167,20 @@ static inline cache_buff_op comp_buffer_cache_op(int cmd)
 
 static inline void buffer_reset_pos(struct comp_buffer *buffer, void *data)
 {
-	/* reset read and write pointer to buffer bas */
-	buffer->w_ptr = buffer->addr;
-	buffer->r_ptr = buffer->addr;
-
-	/* free space is buffer size */
-	buffer->free = buffer->size;
-
-	/* there are no avail samples at reset */
-	buffer->avail = 0;
+	/* reset rw pointers and avail/free bytes counters */
+	audio_stream_reset(&buffer->stream);
 
 	/* clear buffer contents */
 	buffer_zero(buffer);
 }
 
-static inline void *buffer_get_frag(const struct comp_buffer *buffer,
-				    const void *ptr, uint32_t idx,
-				    uint32_t size)
-{
-	void *current = (char *)ptr + (idx * size);
-
-	/* check for pointer wrap */
-	if (current >= buffer->end_addr)
-		current = (char *)buffer->addr +
-			((char *)current - (char *)buffer->end_addr);
-
-	return current;
-}
-
-/**
- * Calculates period size in bytes based on component buffer's parameters.
- * @param buf Component buffer.
- * @return Period size in bytes.
- */
-static inline uint32_t buffer_frame_bytes(struct comp_buffer *buf)
-{
-	return frame_bytes(buf->frame_fmt, buf->channels);
-}
-
-/**
- * Calculates sample size in bytes based on component buffer's parameters.
- * @param dev Component buffer.
- * @return Size of sample in bytes.
- */
-static inline uint32_t buffer_sample_bytes(struct comp_buffer *buf)
-{
-	return sample_bytes(buf->frame_fmt);
-}
-
-/**
- * Calculates period size in bytes based on component buffer's parameters.
- * @param dev Component buffer.
- * @param frames Number of processing frames.
- * @return Period size in bytes.
- */
-static inline uint32_t buffer_period_bytes(struct comp_buffer *buf,
-					   uint32_t frames)
-{
-	return frames * buffer_frame_bytes(buf);
-}
-
-static inline uint32_t buffer_avail_frames(struct comp_buffer *source,
-					   struct comp_buffer *sink)
-{
-	uint32_t src_frames = source->avail / buffer_frame_bytes(source);
-	uint32_t sink_frames = sink->free / buffer_frame_bytes(sink);
-
-	return MIN(src_frames, sink_frames);
-}
-
-/**
- * Returns frame format based on component device's type.
- * @param dev Component device.
- * @return Frame format.
- */
-static inline enum sof_ipc_frame buffer_frame_fmt(struct comp_buffer *buf)
-{
-	return buf->frame_fmt;
-}
-
 static inline void buffer_init(struct comp_buffer *buffer, uint32_t size,
 			       uint32_t caps)
 {
-	buffer->alloc_size = size;
-	buffer->size = size;
 	buffer->caps = caps;
-	buffer->w_ptr = buffer->addr;
-	buffer->r_ptr = buffer->addr;
-	buffer->end_addr = (char *)buffer->addr + size;
-	buffer->free = size;
-	buffer->avail = 0;
-	buffer_zero(buffer);
-}
 
-static inline void buffer_copy(const struct comp_buffer *source,
-			       struct comp_buffer *sink, uint32_t bytes)
-{
-	void *src = source->r_ptr;
-	void *snk = sink->w_ptr;
-	uint32_t bytes_src;
-	uint32_t bytes_snk;
-	uint32_t bytes_copied;
-	int ret;
-
-	while (bytes) {
-		bytes_src = (char *)source->end_addr - (char *)src;
-		bytes_snk = (char *)sink->end_addr - (char *)snk;
-		bytes_copied = MIN(bytes, MIN(bytes_src, bytes_snk));
-
-		ret = memcpy_s(snk, bytes_snk, src, bytes_copied);
-		assert(!ret);
-
-		bytes -= bytes_copied;
-		src = (char *)src + bytes_copied;
-		snk = (char *)snk + bytes_copied;
-
-		if (src >= source->end_addr)
-			src = (char *)source->addr +
-				((char *)src - (char *)source->end_addr);
-
-		if (snk >= sink->end_addr)
-			snk = (char *)sink->addr +
-				((char *)snk - (char *)sink->end_addr);
-	}
-}
-
-#if CONFIG_FORMAT_S16LE
-
-static inline void buffer_copy_s16(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
-{
-	buffer_copy(source, sink, samples * sizeof(int16_t));
+	/* addr should be set in alloc function */
+	audio_stream_init(&buffer->stream, buffer->stream.addr, size);
 }
 
-#endif /* CONFIG_FORMAT_S16LE */
-
-#if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE
-
-static inline void buffer_copy_s32(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples)
-{
-	buffer_copy(source, sink, samples * sizeof(int32_t));
-}
-
-#endif /* CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE */
-
 #endif /* __SOF_AUDIO_BUFFER_H__ */
diff --git a/src/include/sof/audio/component.h b/src/include/sof/audio/component.h
index 2ae9e9104f58..d688107bb477 100644
--- a/src/include/sof/audio/component.h
+++ b/src/include/sof/audio/component.h
@@ -677,15 +677,17 @@ static inline void comp_underrun(struct comp_dev *dev,
 				 struct comp_buffer *source,
 				 uint32_t copy_bytes)
 {
+	int32_t bytes = (int32_t)source->stream.avail - copy_bytes;
+
 	trace_comp_error_with_ids(dev, "comp_underrun() error: "
 				  "dev->comp.id = %u, "
 				  "source->avail = %u, "
 				  "copy_bytes = %u",
 				  dev->comp.id,
-				  source->avail,
+				  source->stream.avail,
 				  copy_bytes);
 
-	pipeline_xrun(dev->pipeline, dev, (int32_t)source->avail - copy_bytes);
+	pipeline_xrun(dev->pipeline, dev, bytes);
 }
 
 /**
@@ -697,11 +699,12 @@ static inline void comp_underrun(struct comp_dev *dev,
 static inline void comp_overrun(struct comp_dev *dev, struct comp_buffer *sink,
 				uint32_t copy_bytes)
 {
-	trace_comp_error("comp_overrun() error: dev->comp.id = %u, sink->free "
-			 "= %u, copy_bytes = %u", dev->comp.id, sink->free,
-			 copy_bytes);
+	int32_t bytes = (int32_t)copy_bytes - sink->stream.free;
+
+	trace_comp_error("comp_overrun() error: dev->comp.id = %u, sink->free = %u, copy_bytes = %u",
+			 dev->comp.id, sink->stream.free, copy_bytes);
 
-	pipeline_xrun(dev->pipeline, dev, (int32_t)copy_bytes - sink->free);
+	pipeline_xrun(dev->pipeline, dev, bytes);
 }
 
 /**
diff --git a/src/include/sof/audio/eq_fir/fir.h b/src/include/sof/audio/eq_fir/fir.h
index 9f16a736e5ab..fdf9abcf0fdd 100644
--- a/src/include/sof/audio/eq_fir/fir.h
+++ b/src/include/sof/audio/eq_fir/fir.h
@@ -39,18 +39,18 @@ int fir_init_coef(struct fir_state_32x16 *fir,
 void fir_init_delay(struct fir_state_32x16 *fir, int32_t **data);
 
 #if CONFIG_FORMAT_S16LE
-void eq_fir_s16(struct fir_state_32x16 *fir, struct comp_buffer *source,
-		struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s16(struct fir_state_32x16 *fir, const struct audio_stream *source,
+		struct audio_stream *sink, int frames, int nch);
 #endif /* CONFIG_FORMAT_S16LE */
 
 #if CONFIG_FORMAT_S24LE
-void eq_fir_s24(struct fir_state_32x16 *fir, struct comp_buffer *source,
-		struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s24(struct fir_state_32x16 *fir, const struct audio_stream *source,
+		struct audio_stream *sink, int frames, int nch);
 #endif /* CONFIG_FORMAT_S24LE */
 
 #if CONFIG_FORMAT_S32LE
-void eq_fir_s32(struct fir_state_32x16 *fir, struct comp_buffer *source,
-		struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s32(struct fir_state_32x16 *fir, const struct audio_stream *source,
+		struct audio_stream *sink, int frames, int nch);
 #endif /* CONFIG_FORMAT_S32LE */
 
 /* The next functions are inlined to optmize execution speed */
diff --git a/src/include/sof/audio/eq_fir/fir_hifi2ep.h b/src/include/sof/audio/eq_fir/fir_hifi2ep.h
index e57603cb56a9..ba78f133ca36 100644
--- a/src/include/sof/audio/eq_fir/fir_hifi2ep.h
+++ b/src/include/sof/audio/eq_fir/fir_hifi2ep.h
@@ -39,28 +39,31 @@ int fir_init_coef(struct fir_state_32x16 *fir,
 
 void fir_init_delay(struct fir_state_32x16 *fir, int32_t **data);
 
-void eq_fir_s16_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		       struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s16_hifiep(struct fir_state_32x16 fir[],
+		       const struct audio_stream *source,
+		       struct audio_stream *sink, int frames, int nch);
 
 void eq_fir_2x_s16_hifiep(struct fir_state_32x16 fir[],
-			  struct comp_buffer *source,
-			  struct comp_buffer *sink,
+			  const struct audio_stream *source,
+			  struct audio_stream *sink,
 			  int frames, int nch);
 
-void eq_fir_s24_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		       struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s24_hifiep(struct fir_state_32x16 fir[],
+		       const struct audio_stream *source,
+		       struct audio_stream *sink, int frames, int nch);
 
 void eq_fir_2x_s24_hifiep(struct fir_state_32x16 fir[],
-			  struct comp_buffer *source,
-			  struct comp_buffer *sink,
+			  const struct audio_stream *source,
+			  struct audio_stream *sink,
 			  int frames, int nch);
 
-void eq_fir_s32_hifiep(struct fir_state_32x16 fir[], struct comp_buffer *source,
-		       struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s32_hifiep(struct fir_state_32x16 fir[],
+		       const struct audio_stream *source,
+		       struct audio_stream *sink, int frames, int nch);
 
 void eq_fir_2x_s32_hifiep(struct fir_state_32x16 fir[],
-			  struct comp_buffer *source,
-			  struct comp_buffer *sink,
+			  const struct audio_stream *source,
+			  struct audio_stream *sink,
 			  int frames, int nch);
 
 /* Setup circular buffer for FIR input data delay */
diff --git a/src/include/sof/audio/eq_fir/fir_hifi3.h b/src/include/sof/audio/eq_fir/fir_hifi3.h
index c70f9b150dfd..c584272a2ea5 100644
--- a/src/include/sof/audio/eq_fir/fir_hifi3.h
+++ b/src/include/sof/audio/eq_fir/fir_hifi3.h
@@ -39,30 +39,33 @@ int fir_init_coef(struct fir_state_32x16 *fir,
 void fir_init_delay(struct fir_state_32x16 *fir, int32_t **data);
 
 #if CONFIG_FORMAT_S16LE
-void eq_fir_s16_hifi3(struct fir_state_32x16 *fir, struct comp_buffer *source,
-		      struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s16_hifi3(struct fir_state_32x16 *fir,
+		      const struct audio_stream *source,
+		      struct audio_stream *sink, int frames, int nch);
 
 void eq_fir_2x_s16_hifi3(struct fir_state_32x16 *fir,
-			 struct comp_buffer *source, struct comp_buffer *sink,
-			 int frames, int nch);
+			 const struct audio_stream *source,
+			 struct audio_stream *sink, int frames, int nch);
 #endif /* CONFIG_FORMAT_S16LE */
 
 #if CONFIG_FORMAT_S24LE
-void eq_fir_s24_hifi3(struct fir_state_32x16 *fir, struct comp_buffer *source,
-		      struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s24_hifi3(struct fir_state_32x16 *fir,
+		      const struct audio_stream *source,
+		      struct audio_stream *sink, int frames, int nch);
 
 void eq_fir_2x_s24_hifi3(struct fir_state_32x16 *fir,
-			 struct comp_buffer *source, struct comp_buffer *sink,
-			 int frames, int nch);
+			 const struct audio_stream *source,
+			 struct audio_stream *sink, int frames, int nch);
 #endif /* CONFIG_FORMAT_S24LE */
 
 #if CONFIG_FORMAT_S32LE
-void eq_fir_s32_hifi3(struct fir_state_32x16 *fir, struct comp_buffer *source,
-		      struct comp_buffer *sink, int frames, int nch);
+void eq_fir_s32_hifi3(struct fir_state_32x16 *fir,
+		      const struct audio_stream *source,
+		      struct audio_stream *sink, int frames, int nch);
 
 void eq_fir_2x_s32_hifi3(struct fir_state_32x16 *fir,
-			 struct comp_buffer *source, struct comp_buffer *sink,
-			 int frames, int nch);
+			 const struct audio_stream *source,
+			 struct audio_stream *sink, int frames, int nch);
 #endif /* CONFIG_FORMAT_S32LE */
 
 /* Setup circular buffer for FIR input data delay */
@@ -73,7 +76,7 @@ static inline void fir_core_setup_circular(struct fir_state_32x16 *fir)
 }
 
 /* Setup circular for component buffer */
-static inline void fir_comp_setup_circular(struct comp_buffer *buffer)
+static inline void fir_comp_setup_circular(const struct audio_stream *buffer)
 {
 	AE_SETCBEGIN0(buffer->addr);
 	AE_SETCEND0(buffer->end_addr);
diff --git a/src/include/sof/audio/eq_iir/eq_iir.h b/src/include/sof/audio/eq_iir/eq_iir.h
index efdc76c6a561..ac17190843d5 100644
--- a/src/include/sof/audio/eq_iir/eq_iir.h
+++ b/src/include/sof/audio/eq_iir/eq_iir.h
@@ -12,23 +12,20 @@
 
 #include <stdint.h>
 
-struct comp_buffer;
+struct audio_stream;
 struct comp_dev;
 
+/** \brief Type definition for processing function select return value. */
+typedef void (*eq_iir_func)(const struct comp_dev *dev,
+			    const struct audio_stream *source,
+			    struct audio_stream *sink,
+			    uint32_t frames);
+
 /** \brief IIR EQ processing functions map item. */
 struct eq_iir_func_map {
 	uint8_t source;				/**< source frame format */
 	uint8_t sink;				/**< sink frame format */
-	void (*func)(struct comp_dev *dev,	/**< EQ processing function */
-		     struct comp_buffer *source,
-		     struct comp_buffer *sink,
-		     uint32_t frames);
+	eq_iir_func func;			/**< processing function */
 };
 
-/** \brief Type definition for processing function select return value. */
-typedef void (*eq_iir_func)(struct comp_dev *dev,
-			    struct comp_buffer *source,
-			    struct comp_buffer *sink,
-			    uint32_t frames);
-
 #endif /* __SOF_AUDIO_EQ_IIR_EQ_IIR_H__ */
diff --git a/src/include/sof/audio/mux.h b/src/include/sof/audio/mux.h
index a91a005e5cf8..0dd74fb76e43 100644
--- a/src/include/sof/audio/mux.h
+++ b/src/include/sof/audio/mux.h
@@ -61,12 +61,12 @@ struct mux_stream_data {
 	uint8_t reserved[(20 - PLATFORM_MAX_CHANNELS - 1) % 4]; // padding to ensure proper alignment of following instances
 };
 
-typedef void(*demux_func)(struct comp_dev *dev, struct comp_buffer *sink,
-			struct comp_buffer *source, uint32_t frames,
-			struct mux_stream_data *data);
-typedef void(*mux_func)(struct comp_dev *dev, struct comp_buffer *sink,
-			  struct comp_buffer **sources, uint32_t frames,
+typedef void(*demux_func)(const struct comp_dev *dev, struct audio_stream *sink,
+			  const struct audio_stream *source, uint32_t frames,
 			  struct mux_stream_data *data);
+typedef void(*mux_func)(const struct comp_dev *dev, struct audio_stream *sink,
+			const struct audio_stream **sources, uint32_t frames,
+			struct mux_stream_data *data);
 
 struct sof_mux_config {
 	uint16_t frame_format;
@@ -102,17 +102,17 @@ demux_func demux_get_processing_function(struct comp_dev *dev);
 void sys_comp_mux_init(void);
 
 #if CONFIG_FORMAT_S16LE
-int32_t calc_sample_s16le(struct comp_buffer *source,
+int32_t calc_sample_s16le(const struct audio_stream *source,
 			  uint8_t num_ch, uint32_t offset,
 			  uint8_t mask);
 #endif /* CONFIG_FORMAT_S16LE */
 #if CONFIG_FORMAT_S24LE
-int32_t calc_sample_s24le(struct comp_buffer *source,
+int32_t calc_sample_s24le(const struct audio_stream *source,
 			  uint8_t num_ch, uint32_t offset,
 			  uint8_t mask);
 #endif /* CONFIG_FORMAT_S24LE */
 #if CONFIG_FORMAT_S32LE
-int64_t calc_sample_s32le(struct comp_buffer *source,
+int64_t calc_sample_s32le(const struct audio_stream *source,
 			  uint8_t num_ch, uint32_t offset,
 			  uint8_t mask);
 #endif /* CONFIG_FORMAT_S32LE */
diff --git a/src/include/sof/audio/pcm_converter.h b/src/include/sof/audio/pcm_converter.h
index fc89de9e1c2f..04fef6325f94 100644
--- a/src/include/sof/audio/pcm_converter.h
+++ b/src/include/sof/audio/pcm_converter.h
@@ -19,7 +19,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-struct comp_buffer;
+struct audio_stream;
 
 #define PCM_CONVERTER_GENERIC
 
@@ -42,8 +42,8 @@ struct comp_buffer;
  * \param sink output buffer, write pointer is not modified
  * \param samples number of samples to convert
  */
-typedef void (*pcm_converter_func)(const struct comp_buffer *source,
-				   struct comp_buffer *sink, uint32_t samples);
+typedef void (*pcm_converter_func)(const struct audio_stream *source,
+				   struct audio_stream *sink, uint32_t samples);
 
 /** \brief PCM conversion functions map. */
 struct pcm_func_map {
diff --git a/src/include/sof/audio/selector.h b/src/include/sof/audio/selector.h
index 134a7c2880d8..a24717e6b54b 100644
--- a/src/include/sof/audio/selector.h
+++ b/src/include/sof/audio/selector.h
@@ -53,6 +53,10 @@ struct comp_dev;
 #define SEL_SINK_2CH 2
 #define SEL_SINK_4CH 4
 
+/** \brief selector processing function interface */
+typedef void (*sel_func)(struct comp_dev *dev, struct audio_stream *sink,
+			 const struct audio_stream *source, uint32_t frames);
+
 /** \brief Selector component private data. */
 struct comp_data {
 	uint32_t source_period_bytes;	/**< source number of period bytes */
@@ -60,25 +64,19 @@ struct comp_data {
 	enum sof_ipc_frame source_format;	/**< source frame format */
 	enum sof_ipc_frame sink_format;		/**< sink frame format */
 	struct sof_sel_config config;	/**< component configuration data */
-	/**< channel selector processing function */
-	void (*sel_func)(struct comp_dev *dev, struct comp_buffer *sink,
-			 struct comp_buffer *source, uint32_t frames);
+	sel_func sel_func;	/**< channel selector processing function */
 };
 
 /** \brief Selector processing functions map. */
 struct comp_func_map {
 	uint16_t source;	/**< source frame format */
 	uint32_t out_channels;	/**< number of output stream channels */
-	/**< selector processing function */
-	void (*sel_func)(struct comp_dev *dev, struct comp_buffer *sink,
-			 struct comp_buffer *source, uint32_t frames);
+	sel_func sel_func;	/**< selector processing function */
 };
 
 /** \brief Map of formats with dedicated processing functions. */
 extern const struct comp_func_map func_map[];
 
-typedef void (*sel_func)(struct comp_dev *, struct comp_buffer *,
-			 struct comp_buffer *, uint32_t);
 
 /**
  * \brief Retrieves selector processing function.
diff --git a/src/include/sof/audio/volume.h b/src/include/sof/audio/volume.h
index b71c09da4f45..64eab0fc32a6 100644
--- a/src/include/sof/audio/volume.h
+++ b/src/include/sof/audio/volume.h
@@ -96,6 +96,12 @@ struct sof_ipc_ctrl_value_chan;
 /** \brief Volume minimum value. */
 #define VOL_MIN		0
 
+/**
+ * \brief volume processing function interface
+ */
+typedef void (*vol_scale_func)(struct comp_dev *dev, struct audio_stream *sink,
+			       const struct audio_stream *source,
+			       uint32_t frames);
 /**
  * \brief Volume component private data.
  *
@@ -115,17 +121,13 @@ struct comp_data {
 	bool muted[SOF_IPC_MAX_CHANNELS];	/**< set if channel is muted */
 	bool vol_ramp_active;			/**< set if volume is ramped */
 	bool ramp_started;			/**< control ramp launch */
-	/**< volume processing function */
-	void (*scale_vol)(struct comp_dev *dev, struct comp_buffer *sink,
-			  struct comp_buffer *source, uint32_t frames);
+	vol_scale_func scale_vol;	/**< volume processing function */
 };
 
 /** \brief Volume processing functions map. */
 struct comp_func_map {
 	uint16_t frame_fmt;	/**< frame format */
-	/**< volume processing function */
-	void (*func)(struct comp_dev *dev, struct comp_buffer *sink,
-		     struct comp_buffer *source, uint32_t frames);
+	vol_scale_func func;	/**< volume processing function */
 };
 
 /** \brief Map of formats with dedicated processing functions. */
@@ -134,14 +136,11 @@ extern const struct comp_func_map func_map[];
 /** \brief Number of processing functions. */
 extern const size_t func_count;
 
-typedef void (*scale_vol)(struct comp_dev *, struct comp_buffer *,
-			  struct comp_buffer *, uint32_t);
-
 /**
  * \brief Retrievies volume processing function.
  * \param[in,out] dev Volume base component device.
  */
-static inline scale_vol vol_get_processing_function(struct comp_dev *dev)
+static inline vol_scale_func vol_get_processing_function(struct comp_dev *dev)
 {
 	struct comp_buffer *sinkb;
 	int i;
@@ -151,7 +150,7 @@ static inline scale_vol vol_get_processing_function(struct comp_dev *dev)
 
 	/* map the volume function for source and sink buffers */
 	for (i = 0; i < func_count; i++) {
-		if (sinkb->frame_fmt != func_map[i].frame_fmt)
+		if (sinkb->stream.frame_fmt != func_map[i].frame_fmt)
 			continue;
 
 		return func_map[i].func;
diff --git a/src/include/sof/drivers/ipc.h b/src/include/sof/drivers/ipc.h
index d35a9d6e5074..0f3c61b5b0b0 100644
--- a/src/include/sof/drivers/ipc.h
+++ b/src/include/sof/drivers/ipc.h
@@ -150,7 +150,7 @@ void ipc_schedule_process(struct ipc *ipc);
 
 int ipc_stream_send_position(struct comp_dev *cdev,
 		struct sof_ipc_stream_posn *posn);
-int ipc_send_comp_notification(struct comp_dev *cdev,
+int ipc_send_comp_notification(const struct comp_dev *cdev,
 			       struct sof_ipc_comp_event *event);
 int ipc_stream_send_xrun(struct comp_dev *cdev,
 	struct sof_ipc_stream_posn *posn);
diff --git a/src/include/sof/lib/dma.h b/src/include/sof/lib/dma.h
index e4dd14e0c8dd..065a5edf0962 100644
--- a/src/include/sof/lib/dma.h
+++ b/src/include/sof/lib/dma.h
@@ -222,6 +222,10 @@ struct dma_info {
 	size_t num_dmas;
 };
 
+struct audio_stream;
+typedef void (*dma_process_func)(const struct audio_stream *source,
+				 struct audio_stream *sink, uint32_t frames);
+
 /**
  * \brief API to initialize a platform DMA controllers.
  *
@@ -607,19 +611,19 @@ static inline uint32_t dma_sg_get_size(struct dma_sg_elem_array *ea)
 	return size;
 }
 
+struct audio_stream;
+typedef void (*dma_process)(const struct audio_stream *,
+			    struct audio_stream *, uint32_t);
+
 /* copies data from DMA buffer using provided processing function */
 void dma_buffer_copy_from(struct comp_buffer *source, uint32_t source_bytes,
 			  struct comp_buffer *sink, uint32_t sink_bytes,
-			  void (*process)(const struct comp_buffer *,
-					  struct comp_buffer *, uint32_t),
-			  uint32_t samples);
+			  dma_process_func process, uint32_t samples);
 
 /* copies data to DMA buffer using provided processing function */
 void dma_buffer_copy_to(struct comp_buffer *source, uint32_t source_bytes,
 			struct comp_buffer *sink, uint32_t sink_bytes,
-			void (*process)(const struct comp_buffer *,
-					struct comp_buffer *, uint32_t),
-			uint32_t samples);
+			dma_process_func process, uint32_t samples);
 
 /* generic DMA DSP <-> Host copier */
 
diff --git a/src/include/sof/lib/notifier.h b/src/include/sof/lib/notifier.h
index d8273ef183c0..1fe44802ee76 100644
--- a/src/include/sof/lib/notifier.h
+++ b/src/include/sof/lib/notifier.h
@@ -35,7 +35,7 @@ struct notify {
 };
 
 struct notify_data {
-	void *caller;
+	const void *caller;
 	enum notify_id type;
 	uint32_t data_size;
 	void *data;
@@ -56,7 +56,7 @@ void notifier_unregister(void *receiver, void *caller, enum notify_id type);
 void notifier_unregister_all(void *receiver, void *caller);
 
 void notifier_notify_remote(void);
-void notifier_event(void *caller, enum notify_id type, uint32_t core_mask,
+void notifier_event(const void *caller, enum notify_id type, uint32_t core_mask,
 		    void *data, uint32_t data_size);
 
 void init_system_notify(struct sof *sof);
diff --git a/src/ipc/handler.c b/src/ipc/handler.c
index 7155cc590690..0f447efb5b04 100644
--- a/src/ipc/handler.c
+++ b/src/ipc/handler.c
@@ -416,7 +416,7 @@ int ipc_stream_send_position(struct comp_dev *cdev,
 }
 
 /* send component notification */
-int ipc_send_comp_notification(struct comp_dev *cdev,
+int ipc_send_comp_notification(const struct comp_dev *cdev,
 			       struct sof_ipc_comp_event *event)
 {
 	event->rhdr.hdr.cmd = SOF_IPC_GLB_COMP_MSG |
diff --git a/src/lib/dma.c b/src/lib/dma.c
index 33d6c487eeb7..30a6aa581b77 100644
--- a/src/lib/dma.c
+++ b/src/lib/dma.c
@@ -5,6 +5,7 @@
 // Author: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
 
 #include <sof/atomic.h>
+#include <sof/audio/audio_stream.h>
 #include <sof/audio/buffer.h>
 #include <sof/lib/alloc.h>
 #include <sof/lib/cache.h>
@@ -187,64 +188,54 @@ void dma_sg_free(struct dma_sg_elem_array *elem_array)
 
 void dma_buffer_copy_from(struct comp_buffer *source, uint32_t source_bytes,
 			  struct comp_buffer *sink, uint32_t sink_bytes,
-			  void (*process)(const struct comp_buffer *,
-					  struct comp_buffer *, uint32_t),
-			  uint32_t samples)
+			  dma_process_func process, uint32_t samples)
 {
 	uint32_t head = source_bytes;
 	uint32_t tail = 0;
+	struct audio_stream *istream = &source->stream;
 
 	/* source buffer contains data copied by DMA */
-	if ((char *)source->r_ptr + source_bytes > (char *)source->end_addr) {
-		head = (char *)source->end_addr - (char *)source->r_ptr;
+	if ((char *)istream->r_ptr + source_bytes > (char *)istream->end_addr) {
+		head = (char *)istream->end_addr - (char *)istream->r_ptr;
 		tail = source_bytes - head;
 	}
 
-	dcache_invalidate_region(source->r_ptr, head);
+	dcache_invalidate_region(istream->r_ptr, head);
 	if (tail)
-		dcache_invalidate_region(source->addr, tail);
+		dcache_invalidate_region(istream->addr, tail);
 
 	/* process data */
-	process(source, sink, samples);
+	process(istream, &sink->stream, samples);
 
-	source->r_ptr = (char *)source->r_ptr + source_bytes;
-
-	/* check for pointer wrap */
-	if (source->r_ptr >= source->end_addr)
-		source->r_ptr = (char *)source->addr +
-			((char *)source->r_ptr - (char *)source->end_addr);
+	istream->r_ptr = (char *)istream->r_ptr + source_bytes;
+	istream->r_ptr = audio_stream_wrap(istream, istream->r_ptr);
 
 	comp_update_buffer_produce(sink, sink_bytes);
 }
 
 void dma_buffer_copy_to(struct comp_buffer *source, uint32_t source_bytes,
 			struct comp_buffer *sink, uint32_t sink_bytes,
-			void (*process)(const struct comp_buffer *,
-					struct comp_buffer *, uint32_t),
-			uint32_t samples)
+			dma_process_func process, uint32_t samples)
 {
 	uint32_t head = sink_bytes;
 	uint32_t tail = 0;
+	struct audio_stream *ostream = &sink->stream;
 
 	/* process data */
-	process(source, sink, samples);
+	process(&source->stream, ostream, samples);
 
 	/* sink buffer contains data meant to copied to DMA */
-	if ((char *)sink->w_ptr + sink_bytes > (char *)sink->end_addr) {
-		head = (char *)sink->end_addr - (char *)sink->w_ptr;
+	if ((char *)ostream->w_ptr + sink_bytes > (char *)ostream->end_addr) {
+		head = (char *)ostream->end_addr - (char *)ostream->w_ptr;
 		tail = sink_bytes - head;
 	}
 
-	dcache_writeback_region(sink->w_ptr, head);
+	dcache_writeback_region(ostream->w_ptr, head);
 	if (tail)
-		dcache_writeback_region(sink->addr, tail);
-
-	sink->w_ptr = (char *)sink->w_ptr + sink_bytes;
+		dcache_writeback_region(ostream->addr, tail);
 
-	/* check for pointer wrap */
-	if (sink->w_ptr >= sink->end_addr)
-		sink->w_ptr = (char *)sink->addr +
-			((char *)sink->w_ptr - (char *)sink->end_addr);
+	ostream->w_ptr = (char *)ostream->w_ptr + sink_bytes;
+	ostream->w_ptr = audio_stream_wrap(ostream, ostream->w_ptr);
 
 	comp_update_buffer_consume(source, source_bytes);
 }
diff --git a/src/lib/notifier.c b/src/lib/notifier.c
index 3abe08d8bd56..c09fd6d2d9e2 100644
--- a/src/lib/notifier.c
+++ b/src/lib/notifier.c
@@ -95,7 +95,7 @@ void notifier_unregister_all(void *receiver, void *caller)
 		notifier_unregister(receiver, caller, i);
 }
 
-static void notifier_notify(void *caller, enum notify_id type, void *data)
+static void notifier_notify(const void *caller, enum notify_id type, void *data)
 {
 	struct notify *notify = *arch_notify_get();
 	struct list_item *wlist;
@@ -127,7 +127,7 @@ void notifier_notify_remote(void)
 	platform_shared_commit(notify_data, sizeof(*notify_data));
 }
 
-void notifier_event(void *caller, enum notify_id type, uint32_t core_mask,
+void notifier_event(const void *caller, enum notify_id type, uint32_t core_mask,
 		    void *data, uint32_t data_size)
 {
 	struct notify_data *notify_data;
diff --git a/test/cmocka/src/audio/buffer/buffer_copy.c b/test/cmocka/src/audio/buffer/buffer_copy.c
index f51e5a63c31b..13c4d40c083e 100644
--- a/test/cmocka/src/audio/buffer/buffer_copy.c
+++ b/test/cmocka/src/audio/buffer/buffer_copy.c
@@ -20,6 +20,8 @@
 
 static void test_audio_buffer_copy_underrun(void **state)
 {
+	int copy_bytes;
+
 	(void)state;
 
 	struct sof_ipc_buffer test_buf_desc = {
@@ -33,9 +35,11 @@ static void test_audio_buffer_copy_underrun(void **state)
 	assert_non_null(snk);
 
 	comp_update_buffer_produce(src, 10);
+	copy_bytes =
+		audio_stream_can_copy_bytes(&src->stream, &snk->stream, 16);
 
-	assert_int_equal(src->avail, 10);
-	assert_int_equal(comp_buffer_can_copy_bytes(src, snk, 16), -1);
+	assert_int_equal(src->stream.avail, 10);
+	assert_int_equal(copy_bytes, -1);
 
 	buffer_free(src);
 	buffer_free(snk);
@@ -43,6 +47,8 @@ static void test_audio_buffer_copy_underrun(void **state)
 
 static void test_audio_buffer_copy_overrun(void **state)
 {
+	int copy_bytes;
+
 	(void)state;
 
 	struct sof_ipc_buffer test_buf_desc = {
@@ -57,10 +63,12 @@ static void test_audio_buffer_copy_overrun(void **state)
 
 	comp_update_buffer_produce(src, 16);
 	comp_update_buffer_produce(snk, 246);
+	copy_bytes =
+		audio_stream_can_copy_bytes(&src->stream, &snk->stream, 16);
 
-	assert_int_equal(src->avail, 16);
-	assert_int_equal(snk->free, 10);
-	assert_int_equal(comp_buffer_can_copy_bytes(src, snk, 16), 1);
+	assert_int_equal(src->stream.avail, 16);
+	assert_int_equal(snk->stream.free, 10);
+	assert_int_equal(copy_bytes, 1);
 
 	buffer_free(src);
 	buffer_free(snk);
@@ -68,6 +76,8 @@ static void test_audio_buffer_copy_overrun(void **state)
 
 static void test_audio_buffer_copy_success(void **state)
 {
+	int copy_bytes;
+
 	(void)state;
 
 	struct sof_ipc_buffer test_buf_desc = {
@@ -81,9 +91,10 @@ static void test_audio_buffer_copy_success(void **state)
 	assert_non_null(snk);
 
 	comp_update_buffer_produce(src, 10);
+	copy_bytes = audio_stream_can_copy_bytes(&src->stream, &snk->stream, 0);
 
-	assert_int_equal(src->avail, 10);
-	assert_int_equal(comp_buffer_can_copy_bytes(src, snk, 0), 0);
+	assert_int_equal(src->stream.avail, 10);
+	assert_int_equal(copy_bytes, 0);
 
 	buffer_free(src);
 	buffer_free(snk);
@@ -91,6 +102,8 @@ static void test_audio_buffer_copy_success(void **state)
 
 static void test_audio_buffer_copy_fit_space_constraint(void **state)
 {
+	int copy_bytes;
+
 	(void)state;
 
 	struct sof_ipc_buffer test_buf_desc = {
@@ -105,10 +118,11 @@ static void test_audio_buffer_copy_fit_space_constraint(void **state)
 
 	comp_update_buffer_produce(src, 16);
 	comp_update_buffer_produce(snk, 246);
+	copy_bytes = audio_stream_get_copy_bytes(&src->stream, &snk->stream);
 
-	assert_int_equal(src->avail, 16);
-	assert_int_equal(snk->free, 10);
-	assert_int_equal(comp_buffer_get_copy_bytes(src, snk), 10);
+	assert_int_equal(src->stream.avail, 16);
+	assert_int_equal(snk->stream.free, 10);
+	assert_int_equal(copy_bytes, 10);
 
 	buffer_free(src);
 	buffer_free(snk);
@@ -116,6 +130,8 @@ static void test_audio_buffer_copy_fit_space_constraint(void **state)
 
 static void test_audio_buffer_copy_fit_no_space_constraint(void **state)
 {
+	int copy_bytes;
+
 	(void)state;
 
 	struct sof_ipc_buffer test_buf_desc = {
@@ -129,9 +145,10 @@ static void test_audio_buffer_copy_fit_no_space_constraint(void **state)
 	assert_non_null(snk);
 
 	comp_update_buffer_produce(src, 16);
+	copy_bytes = audio_stream_get_copy_bytes(&src->stream, &snk->stream);
 
-	assert_int_equal(src->avail, 16);
-	assert_int_equal(comp_buffer_get_copy_bytes(src, snk), 16);
+	assert_int_equal(src->stream.avail, 16);
+	assert_int_equal(copy_bytes, 16);
 
 	buffer_free(src);
 	buffer_free(snk);
diff --git a/test/cmocka/src/audio/buffer/buffer_new.c b/test/cmocka/src/audio/buffer/buffer_new.c
index 4319eb0417be..f538acb862ab 100644
--- a/test/cmocka/src/audio/buffer/buffer_new.c
+++ b/test/cmocka/src/audio/buffer/buffer_new.c
@@ -27,9 +27,9 @@ static void test_audio_buffer_new(void **state)
 	struct comp_buffer *buf = buffer_new(&test_buf_desc);
 
 	assert_non_null(buf);
-	assert_int_equal(buf->avail, 0);
-	assert_int_equal(buf->free, 256);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
+	assert_int_equal(buf->stream.avail, 0);
+	assert_int_equal(buf->stream.free, 256);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
 
 	buffer_free(buf);
 }
diff --git a/test/cmocka/src/audio/buffer/buffer_wrap.c b/test/cmocka/src/audio/buffer/buffer_wrap.c
index 1b09bf7e1ec8..2c1010c7fcf7 100644
--- a/test/cmocka/src/audio/buffer/buffer_wrap.c
+++ b/test/cmocka/src/audio/buffer/buffer_wrap.c
@@ -27,33 +27,33 @@ static void test_audio_buffer_write_fill_10_bytes_and_write_5(void **state)
 	struct comp_buffer *buf = buffer_new(&test_buf_desc);
 
 	assert_non_null(buf);
-	assert_int_equal(buf->avail, 0);
-	assert_int_equal(buf->free, 10);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
+	assert_int_equal(buf->stream.avail, 0);
+	assert_int_equal(buf->stream.free, 10);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
 
 	uint8_t bytes[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
-	memcpy(buf->w_ptr, &bytes, 10);
+	memcpy(buf->stream.w_ptr, &bytes, 10);
 	comp_update_buffer_produce(buf, 10);
 
-	assert_int_equal(buf->avail, 10);
-	assert_int_equal(buf->free, 0);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
+	assert_int_equal(buf->stream.avail, 10);
+	assert_int_equal(buf->stream.free, 0);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
 
 	uint8_t more_bytes[5] = {10, 11, 12, 13, 14};
 
-	memcpy(buf->w_ptr, &more_bytes, 5);
+	memcpy(buf->stream.w_ptr, &more_bytes, 5);
 	comp_update_buffer_produce(buf, 5);
 
 	uint8_t ref_1[5] = {5, 6, 7, 8, 9};
 	uint8_t ref_2[5] = {10, 11, 12, 13, 14};
 
-	assert_int_equal(buf->avail, 10);
-	assert_int_equal(buf->free, 0);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
-	assert_int_equal(memcmp(buf->r_ptr, &ref_1, 5), 0);
+	assert_int_equal(buf->stream.avail, 10);
+	assert_int_equal(buf->stream.free, 0);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
+	assert_int_equal(memcmp(buf->stream.r_ptr, &ref_1, 5), 0);
 	comp_update_buffer_consume(buf, 5);
-	assert_int_equal(memcmp(buf->r_ptr, &ref_2, 5), 0);
+	assert_int_equal(memcmp(buf->stream.r_ptr, &ref_2, 5), 0);
 
 	buffer_free(buf);
 }
diff --git a/test/cmocka/src/audio/buffer/buffer_write.c b/test/cmocka/src/audio/buffer/buffer_write.c
index a1851a85ddbe..10496fe059d4 100644
--- a/test/cmocka/src/audio/buffer/buffer_write.c
+++ b/test/cmocka/src/audio/buffer/buffer_write.c
@@ -28,26 +28,26 @@ static void test_audio_buffer_write_10_bytes_out_of_256_and_read_back
 	struct comp_buffer *buf = buffer_new(&test_buf_desc);
 
 	assert_non_null(buf);
-	assert_int_equal(buf->avail, 0);
-	assert_int_equal(buf->free, 256);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
+	assert_int_equal(buf->stream.avail, 0);
+	assert_int_equal(buf->stream.free, 256);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
 
 	uint8_t bytes[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
-	memcpy(buf->w_ptr, &bytes, 10);
+	memcpy(buf->stream.w_ptr, &bytes, 10);
 	comp_update_buffer_produce(buf, 10);
 
-	assert_int_equal(buf->avail, 10);
-	assert_int_equal(buf->free, 246);
-	assert_ptr_equal(buf->w_ptr, (char *)buf->r_ptr + 10);
+	assert_int_equal(buf->stream.avail, 10);
+	assert_int_equal(buf->stream.free, 246);
+	assert_ptr_equal(buf->stream.w_ptr, (char *)buf->stream.r_ptr + 10);
 
-	assert_int_equal(memcmp(buf->r_ptr, &bytes, 10), 0);
+	assert_int_equal(memcmp(buf->stream.r_ptr, &bytes, 10), 0);
 
 	comp_update_buffer_consume(buf, 10);
 
-	assert_int_equal(buf->avail, 0);
-	assert_int_equal(buf->free, 256);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
+	assert_int_equal(buf->stream.avail, 0);
+	assert_int_equal(buf->stream.free, 256);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
 
 	buffer_free(buf);
 }
@@ -63,18 +63,18 @@ static void test_audio_buffer_fill_10_bytes(void **state)
 	struct comp_buffer *buf = buffer_new(&test_buf_desc);
 
 	assert_non_null(buf);
-	assert_int_equal(buf->avail, 0);
-	assert_int_equal(buf->free, 10);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
+	assert_int_equal(buf->stream.avail, 0);
+	assert_int_equal(buf->stream.free, 10);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
 
 	uint8_t bytes[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
-	memcpy(buf->w_ptr, &bytes, 10);
+	memcpy(buf->stream.w_ptr, &bytes, 10);
 	comp_update_buffer_produce(buf, 10);
 
-	assert_int_equal(buf->avail, 10);
-	assert_int_equal(buf->free, 0);
-	assert_ptr_equal(buf->w_ptr, buf->r_ptr);
+	assert_int_equal(buf->stream.avail, 10);
+	assert_int_equal(buf->stream.free, 0);
+	assert_ptr_equal(buf->stream.w_ptr, buf->stream.r_ptr);
 
 	buffer_free(buf);
 }
diff --git a/test/cmocka/src/audio/kpb/kpb_buffer.c b/test/cmocka/src/audio/kpb/kpb_buffer.c
index b677896ef7e1..a8be1a2a26d8 100644
--- a/test/cmocka/src/audio/kpb/kpb_buffer.c
+++ b/test/cmocka/src/audio/kpb/kpb_buffer.c
@@ -137,7 +137,7 @@ static int buffering_test_setup(void **state)
 	sink = mock_comp_buffer(state, KPB_SINK_BUFFER);
 
 	/* Fiil source buffer with test data */
-	r_ptr = (unsigned char *)source->r_ptr;
+	r_ptr = (unsigned char *)source->stream.r_ptr;
 	for (i = 0; i < test_case_data->history_buffer_size; i++)
 		(*r_ptr++) = pattern;
 
@@ -161,12 +161,12 @@ static struct comp_buffer *mock_comp_buffer(void **state,
 
 	switch (buff_type) {
 	case KPB_SOURCE_BUFFER:
-		buffer->avail = test_case_data->period_bytes;
-		buffer->r_ptr = source_data;
+		buffer->stream.avail = test_case_data->period_bytes;
+		buffer->stream.r_ptr = source_data;
 		break;
 	case KPB_SINK_BUFFER:
-		buffer->free = test_case_data->period_bytes;
-		buffer->w_ptr = sink_data;
+		buffer->stream.free = test_case_data->period_bytes;
+		buffer->stream.w_ptr = sink_data;
 		break;
 	}
 
diff --git a/test/cmocka/src/audio/mixer/mixer_test.c b/test/cmocka/src/audio/mixer/mixer_test.c
index 71f178777c91..9cb6fe5683ee 100644
--- a/test/cmocka/src/audio/mixer/mixer_test.c
+++ b/test/cmocka/src/audio/mixer/mixer_test.c
@@ -116,8 +116,8 @@ static void destroy_comp(struct comp_driver *drv, struct comp_dev *dev)
 
 static void init_buffer_pcm_params(struct comp_buffer *buf, int num_chans)
 {
-	buf->channels = num_chans;
-	buf->frame_fmt = SOF_IPC_FRAME_S32_LE;
+	buf->stream.channels = num_chans;
+	buf->stream.frame_fmt = SOF_IPC_FRAME_S32_LE;
 }
 
 static void create_sources(struct mix_test_case *tc)
@@ -262,7 +262,7 @@ static void test_audio_mixer_copy(void **state)
 	struct mix_test_case *tc = *((struct mix_test_case **)state);
 
 	for (src_idx = 0; src_idx < tc->num_sources; ++src_idx) {
-		uint32_t *samples = tc->sources[src_idx].buf->addr;
+		uint32_t *samples = tc->sources[src_idx].buf->stream.addr;
 
 		for (smp = 0; smp < MIX_TEST_SAMPLES; ++smp) {
 			double rad = M_PI / (180.0 / (smp * (src_idx + 1)));
@@ -270,8 +270,8 @@ static void test_audio_mixer_copy(void **state)
 			samples[smp] = ((sin(rad) + 1) / 2) * (0xFFFFFFFF / 2);
 		}
 
-		tc->sources[src_idx].buf->avail =
-			tc->sources[src_idx].buf->size;
+		tc->sources[src_idx].buf->stream.avail =
+			tc->sources[src_idx].buf->stream.size;
 	}
 
 	mixer_drv_mock.ops.copy(mixer_dev_mock);
@@ -282,14 +282,15 @@ static void test_audio_mixer_copy(void **state)
 		for (src_idx = 0; src_idx < tc->num_sources; ++src_idx) {
 			assert_non_null(tc->sources[src_idx].buf);
 
-			uint32_t *samples = tc->sources[src_idx].buf->addr;
+			uint32_t *samples =
+				tc->sources[src_idx].buf->stream.addr;
 
 			sum += samples[smp];
 		}
 
 		sum = sat_int32(sum);
 
-		uint32_t *out_samples = post_mixer_buf->addr;
+		uint32_t *out_samples = post_mixer_buf->stream.addr;
 
 		assert_int_equal(out_samples[smp], sum);
 	}
diff --git a/test/cmocka/src/audio/mux/demux_copy.c b/test/cmocka/src/audio/mux/demux_copy.c
index a2ee0a2dd3ed..27d459eb3a42 100644
--- a/test/cmocka/src/audio/mux/demux_copy.c
+++ b/test/cmocka/src/audio/mux/demux_copy.c
@@ -125,9 +125,9 @@ static void prepare_sinks(struct test_data *td, size_t sample_size)
 						i,
 						td->format,
 						PLATFORM_MAX_CHANNELS);
-		td->sinks[i]->free = sample_size * PLATFORM_MAX_CHANNELS;
+		td->sinks[i]->stream.free = sample_size * PLATFORM_MAX_CHANNELS;
 		td->outputs[i] = malloc(sample_size * PLATFORM_MAX_CHANNELS);
-		td->sinks[i]->w_ptr = td->outputs[i];
+		td->sinks[i]->stream.w_ptr = td->outputs[i];
 	}
 }
 
@@ -137,12 +137,12 @@ static void prepare_source(struct test_data *td, size_t sample_size)
 					MUX_MAX_STREAMS + 1,
 					td->format,
 					PLATFORM_MAX_CHANNELS);
-	td->source->avail = sample_size * PLATFORM_MAX_CHANNELS;
+	td->source->stream.avail = sample_size * PLATFORM_MAX_CHANNELS;
 
 	if (td->format == SOF_IPC_FRAME_S16_LE)
-		td->source->r_ptr = input_16b;
+		td->source->stream.r_ptr = input_16b;
 	else
-		td->source->r_ptr = input_32b;
+		td->source->stream.r_ptr = input_32b;
 }
 
 static int setup_test_case(void **state)
diff --git a/test/cmocka/src/audio/mux/mux_copy.c b/test/cmocka/src/audio/mux/mux_copy.c
index 55bb24ccc54e..f095f282cb53 100644
--- a/test/cmocka/src/audio/mux/mux_copy.c
+++ b/test/cmocka/src/audio/mux/mux_copy.c
@@ -134,9 +134,9 @@ static void prepare_sink(struct test_data *td, size_t sample_size)
 				    MUX_MAX_STREAMS + 1,
 				    td->format,
 				    PLATFORM_MAX_CHANNELS);
-	td->sink->free = sample_size * PLATFORM_MAX_CHANNELS;
+	td->sink->stream.free = sample_size * PLATFORM_MAX_CHANNELS;
 	td->output = malloc(sample_size * PLATFORM_MAX_CHANNELS);
-	td->sink->w_ptr = td->output;
+	td->sink->stream.w_ptr = td->output;
 }
 
 static void prepare_sources(struct test_data *td, size_t sample_size)
@@ -148,12 +148,13 @@ static void prepare_sources(struct test_data *td, size_t sample_size)
 						    i,
 						    td->format,
 						    PLATFORM_MAX_CHANNELS);
-		td->sources[i]->avail = sample_size * PLATFORM_MAX_CHANNELS;
+		td->sources[i]->stream.avail = sample_size *
+					       PLATFORM_MAX_CHANNELS;
 
 		if (td->format == SOF_IPC_FRAME_S16_LE)
-			td->sources[i]->r_ptr = input_16b[i];
+			td->sources[i]->stream.r_ptr = input_16b[i];
 		else
-			td->sources[i]->r_ptr = input_32b[i];
+			td->sources[i]->stream.r_ptr = input_32b[i];
 	}
 }
 
diff --git a/test/cmocka/src/audio/mux/mux_generic_calc_sample_s16le.c b/test/cmocka/src/audio/mux/mux_generic_calc_sample_s16le.c
index 252947313b23..0c857767787c 100644
--- a/test/cmocka/src/audio/mux/mux_generic_calc_sample_s16le.c
+++ b/test/cmocka/src/audio/mux/mux_generic_calc_sample_s16le.c
@@ -74,7 +74,7 @@ static void test_calc_sample(void **state)
 {
 	struct test_data *td = *((struct test_data **)state);
 
-	int32_t ret =  calc_sample_s16le(td->buffer,
+	int32_t ret =  calc_sample_s16le(&td->buffer->stream,
 					 td->channels,
 					 0,
 					 td->mask);
@@ -88,7 +88,7 @@ static int setup(void **state)
 	int ch;
 
 	td->buffer = calloc(1, sizeof(struct comp_buffer));
-	td->buffer->r_ptr = td->input;
+	td->buffer->stream.r_ptr = td->input;
 
 	td->expected_result = 0;
 
diff --git a/test/cmocka/src/audio/mux/mux_generic_calc_sample_s24le.c b/test/cmocka/src/audio/mux/mux_generic_calc_sample_s24le.c
index 23c26b7ba43b..6a506d13472b 100644
--- a/test/cmocka/src/audio/mux/mux_generic_calc_sample_s24le.c
+++ b/test/cmocka/src/audio/mux/mux_generic_calc_sample_s24le.c
@@ -76,7 +76,7 @@ static void test_calc_sample(void **state)
 {
 	struct test_data *td = *((struct test_data **)state);
 
-	int32_t ret =  calc_sample_s24le(td->buffer,
+	int32_t ret =  calc_sample_s24le(&td->buffer->stream,
 					 td->channels,
 					 0,
 					 td->mask);
@@ -90,7 +90,7 @@ static int setup(void **state)
 	int ch;
 
 	td->buffer = calloc(1, sizeof(struct comp_buffer));
-	td->buffer->r_ptr = td->input;
+	td->buffer->stream.r_ptr = td->input;
 
 	td->expected_result = 0;
 
diff --git a/test/cmocka/src/audio/mux/mux_generic_calc_sample_s32le.c b/test/cmocka/src/audio/mux/mux_generic_calc_sample_s32le.c
index dcd5d275e65e..9c4879aa5dc2 100644
--- a/test/cmocka/src/audio/mux/mux_generic_calc_sample_s32le.c
+++ b/test/cmocka/src/audio/mux/mux_generic_calc_sample_s32le.c
@@ -76,7 +76,7 @@ static void test_calc_sample(void **state)
 {
 	struct test_data *td = *((struct test_data **)state);
 
-	int64_t ret =  calc_sample_s32le(td->buffer,
+	int64_t ret =  calc_sample_s32le(&td->buffer->stream,
 					 td->channels,
 					 0,
 					 td->mask);
@@ -90,7 +90,7 @@ static int setup(void **state)
 	int ch;
 
 	td->buffer = calloc(1, sizeof(struct comp_buffer));
-	td->buffer->r_ptr = td->input;
+	td->buffer->stream.r_ptr = td->input;
 
 	td->expected_result = 0;
 
diff --git a/test/cmocka/src/audio/mux/util.h b/test/cmocka/src/audio/mux/util.h
index b46aeeb6f960..ca04d7fa9af8 100644
--- a/test/cmocka/src/audio/mux/util.h
+++ b/test/cmocka/src/audio/mux/util.h
@@ -25,10 +25,10 @@ static inline struct comp_buffer *create_test_sink(struct comp_dev *dev,
 	/* alloc sink and set default parameters */
 	buffer->sink = calloc(1, sizeof(struct comp_dev));
 	buffer->sink->state = COMP_STATE_PREPARE;
-	buffer->frame_fmt = frame_fmt;
-	buffer->channels = channels;
-	buffer->free = 0;
-	buffer->avail = 0;
+	buffer->stream.frame_fmt = frame_fmt;
+	buffer->stream.channels = channels;
+	buffer->stream.free = 0;
+	buffer->stream.avail = 0;
 	buffer->pipeline_id = pipeline_id;
 
 	return buffer;
@@ -53,10 +53,10 @@ static inline struct comp_buffer *create_test_source(struct comp_dev *dev,
 	/* alloc source and set default parameters */
 	buffer->source = calloc(1, sizeof(struct comp_dev));
 	buffer->source->state = COMP_STATE_PREPARE;
-	buffer->frame_fmt = frame_fmt;
-	buffer->channels = channels;
-	buffer->free = 0;
-	buffer->avail = 0;
+	buffer->stream.frame_fmt = frame_fmt;
+	buffer->stream.channels = channels;
+	buffer->stream.free = 0;
+	buffer->stream.avail = 0;
 	buffer->pipeline_id = pipeline_id;
 
 	return buffer;
diff --git a/test/cmocka/src/audio/selector/selector_test.c b/test/cmocka/src/audio/selector/selector_test.c
index ffb945670ce7..ab4ca441df13 100644
--- a/test/cmocka/src/audio/selector/selector_test.c
+++ b/test/cmocka/src/audio/selector/selector_test.c
@@ -15,10 +15,10 @@
 
 struct sel_test_state {
 	struct comp_dev *dev;
-	struct comp_buffer *sink;
-	struct comp_buffer *source;
-	void (*verify)(struct comp_dev *dev, struct comp_buffer *sink,
-		       struct comp_buffer *source);
+	struct audio_stream *sink;
+	struct audio_stream *source;
+	void (*verify)(struct comp_dev *dev, struct audio_stream *sink,
+		       struct audio_stream *source);
 };
 
 struct sel_test_parameters {
@@ -29,8 +29,8 @@ struct sel_test_parameters {
 	uint32_t buffer_size_ms;
 	uint32_t source_format;
 	uint32_t sink_format;
-	void (*verify)(struct comp_dev *dev, struct comp_buffer *sink,
-		       struct comp_buffer *source);
+	void (*verify)(struct comp_dev *dev, struct audio_stream *sink,
+		       struct audio_stream *source);
 };
 
 static int setup(void **state)
@@ -39,6 +39,7 @@ static int setup(void **state)
 	struct sel_test_state *sel_state;
 	struct comp_data *cd;
 	uint32_t size = 0;
+	void *pbuff;
 
 	/* allocate new state */
 	sel_state = test_malloc(sizeof(*sel_state));
@@ -64,20 +65,19 @@ static int setup(void **state)
 	sel_state->sink = test_malloc(sizeof(*sel_state->sink));
 	sel_state->sink->frame_fmt = parameters->sink_format;
 	sel_state->sink->channels = parameters->out_channels;
-	size = parameters->frames * buffer_frame_bytes(sel_state->sink);
-
-	sel_state->sink->addr = test_calloc(parameters->buffer_size_ms,
-					    size);
-	buffer_init(sel_state->sink, parameters->buffer_size_ms * size, 0);
+	size = parameters->frames * audio_stream_frame_bytes(sel_state->sink);
+	pbuff = test_calloc(parameters->buffer_size_ms, size);
+	audio_stream_init(sel_state->sink, pbuff,
+			  parameters->buffer_size_ms * size);
 
 	/* allocate new source buffer */
 	sel_state->source = test_malloc(sizeof(*sel_state->source));
 	sel_state->source->frame_fmt = parameters->source_format;
 	sel_state->source->channels = parameters->in_channels;
-	size = parameters->frames * buffer_frame_bytes(sel_state->source);
-	sel_state->source->addr = test_calloc(parameters->buffer_size_ms,
-					      size);
-	buffer_init(sel_state->source, parameters->buffer_size_ms * size, 0);
+	size = parameters->frames * audio_stream_frame_bytes(sel_state->source);
+	pbuff = test_calloc(parameters->buffer_size_ms, size);
+	audio_stream_init(sel_state->source, pbuff,
+			  parameters->buffer_size_ms * size);
 
 	/* assigns verification function */
 	sel_state->verify = parameters->verify;
@@ -116,8 +116,9 @@ static void fill_source_s16(struct sel_test_state *sel_state)
 
 }
 
-static void verify_s16le_Xch_to_1ch(struct comp_dev *dev, struct comp_buffer *sink,
-			      struct comp_buffer *source)
+static void verify_s16le_Xch_to_1ch(struct comp_dev *dev,
+				    struct audio_stream *sink,
+				    struct audio_stream *source)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	const uint16_t *src = (uint16_t *)source->r_ptr;
@@ -140,8 +141,9 @@ static void verify_s16le_Xch_to_1ch(struct comp_dev *dev, struct comp_buffer *si
 	}
 }
 
-static void verify_s16le_2ch_to_2ch(struct comp_dev *dev, struct comp_buffer *sink,
-			      struct comp_buffer *source)
+static void verify_s16le_2ch_to_2ch(struct comp_dev *dev,
+				    struct audio_stream *sink,
+				    struct audio_stream *source)
 {
 	const uint16_t *src = (uint16_t *)source->r_ptr;
 	const uint16_t *dst = (uint16_t *)sink->w_ptr;
@@ -158,8 +160,9 @@ static void verify_s16le_2ch_to_2ch(struct comp_dev *dev, struct comp_buffer *si
 	}
 }
 
-static void verify_s16le_4ch_to_4ch(struct comp_dev *dev, struct comp_buffer *sink,
-			      struct comp_buffer *source)
+static void verify_s16le_4ch_to_4ch(struct comp_dev *dev,
+				    struct audio_stream *sink,
+				    struct audio_stream *source)
 {
 	const uint16_t *src = (uint16_t *)source->r_ptr;
 	const uint16_t *dst = (uint16_t *)sink->w_ptr;
@@ -188,8 +191,9 @@ static void fill_source_s32(struct sel_test_state *sel_state)
 		src[i] = i << 16;
 }
 
-static void verify_s32le_Xch_to_1ch(struct comp_dev *dev, struct comp_buffer *sink,
-			      struct comp_buffer *source)
+static void verify_s32le_Xch_to_1ch(struct comp_dev *dev,
+				    struct audio_stream *sink,
+				    struct audio_stream *source)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	const uint32_t *src = (uint32_t *)source->r_ptr;
@@ -212,8 +216,9 @@ static void verify_s32le_Xch_to_1ch(struct comp_dev *dev, struct comp_buffer *si
 	}
 }
 
-static void verify_s32le_2ch_to_2ch(struct comp_dev *dev, struct comp_buffer *sink,
-			      struct comp_buffer *source)
+static void verify_s32le_2ch_to_2ch(struct comp_dev *dev,
+				    struct audio_stream *sink,
+				    struct audio_stream *source)
 {
 	const uint32_t *src = (uint32_t *)source->r_ptr;
 	const uint32_t *dst = (uint32_t *)sink->w_ptr;
@@ -230,8 +235,9 @@ static void verify_s32le_2ch_to_2ch(struct comp_dev *dev, struct comp_buffer *si
 	}
 }
 
-static void verify_s32le_4ch_to_4ch(struct comp_dev *dev, struct comp_buffer *sink,
-			      struct comp_buffer *source)
+static void verify_s32le_4ch_to_4ch(struct comp_dev *dev,
+				    struct audio_stream *sink,
+				    struct audio_stream *source)
 {
 	const uint32_t *src = (uint32_t *)source->r_ptr;
 	const uint32_t *dst = (uint32_t *)sink->w_ptr;
diff --git a/test/cmocka/src/audio/volume/volume_process.c b/test/cmocka/src/audio/volume/volume_process.c
index 6b2ee6678d74..45a71af6644a 100644
--- a/test/cmocka/src/audio/volume/volume_process.c
+++ b/test/cmocka/src/audio/volume/volume_process.c
@@ -77,12 +77,13 @@ static int setup(void **state)
 
 	/* allocate new sink buffer */
 	vol_state->sink = test_malloc(sizeof(*vol_state->sink));
-	vol_state->sink->frame_fmt = parameters->sink_format;
-	vol_state->sink->channels = parameters->channels;
-	size = parameters->frames * buffer_frame_bytes(vol_state->sink);
+	vol_state->sink->stream.frame_fmt = parameters->sink_format;
+	vol_state->sink->stream.channels = parameters->channels;
+	size = parameters->frames *
+	       audio_stream_frame_bytes(&vol_state->sink->stream);
 
-	vol_state->sink->addr = test_calloc(parameters->buffer_size_ms,
-					    size);
+	vol_state->sink->stream.addr = test_calloc(parameters->buffer_size_ms,
+						   size);
 	buffer_init(vol_state->sink, parameters->buffer_size_ms * size, 0);
 
 	list_item_prepend(&vol_state->sink->source_list,
@@ -90,11 +91,12 @@ static int setup(void **state)
 
 	/* allocate new source buffer */
 	vol_state->source = test_malloc(sizeof(*vol_state->source));
-	vol_state->source->frame_fmt = parameters->source_format;
-	vol_state->source->channels = parameters->channels;
-	size = parameters->frames * buffer_frame_bytes(vol_state->source);
-	vol_state->source->addr = test_calloc(parameters->buffer_size_ms,
-					      size);
+	vol_state->source->stream.frame_fmt = parameters->source_format;
+	vol_state->source->stream.channels = parameters->channels;
+	size = parameters->frames *
+	       audio_stream_frame_bytes(&vol_state->source->stream);
+	vol_state->source->stream.addr = test_calloc(parameters->buffer_size_ms,
+						     size);
 	buffer_init(vol_state->source, parameters->buffer_size_ms * size, 0);
 
 	list_item_prepend(&vol_state->source->sink_list,
@@ -121,9 +123,9 @@ static int teardown(void **state)
 	/* free everything */
 	test_free(cd);
 	test_free(vol_state->dev);
-	test_free(vol_state->sink->addr);
+	test_free(vol_state->sink->stream.addr);
 	test_free(vol_state->sink);
-	test_free(vol_state->source->addr);
+	test_free(vol_state->source->stream.addr);
 	test_free(vol_state->source);
 	test_free(vol_state);
 
@@ -134,11 +136,11 @@ static int teardown(void **state)
 static void fill_source_s16(struct vol_test_state *vol_state)
 {
 	int64_t val;
-	int16_t *src = (int16_t *)vol_state->source->r_ptr;
+	int16_t *src = (int16_t *)vol_state->source->stream.r_ptr;
 	int i;
 	int sign = 1;
 
-	for (i = 0; i < vol_state->source->size / sizeof(int16_t); i++) {
+	for (i = 0; i < vol_state->source->stream.size / sizeof(int16_t); i++) {
 		val = (INT16_MIN + (i >> 1)) * sign;
 		val = (val > INT16_MAX) ? INT16_MAX : val;
 		src[i] = (int16_t)val;
@@ -150,16 +152,16 @@ static void verify_s16_to_s16(struct comp_dev *dev, struct comp_buffer *sink,
 			      struct comp_buffer *source)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
-	const int16_t *src = (int16_t *)source->r_ptr;
-	const int16_t *dst = (int16_t *)sink->w_ptr;
+	const int16_t *src = (int16_t *)source->stream.r_ptr;
+	const int16_t *dst = (int16_t *)sink->stream.w_ptr;
 	double processed;
-	int channels = sink->channels;
+	int channels = sink->stream.channels;
 	int channel;
 	int delta;
 	int i;
 	int16_t sample;
 
-	for (i = 0; i < sink->size / sizeof(uint16_t); i += channels) {
+	for (i = 0; i < sink->stream.size / sizeof(uint16_t); i += channels) {
 		for (channel = 0; channel < channels; channel++) {
 			processed = src[i + channel] *
 				(double)cd->volume[channel] /
@@ -183,11 +185,11 @@ static void verify_s16_to_s16(struct comp_dev *dev, struct comp_buffer *sink,
 static void fill_source_s24(struct vol_test_state *vol_state)
 {
 	int64_t val;
-	int32_t *src = (int32_t *)vol_state->source->r_ptr;
+	int32_t *src = (int32_t *)vol_state->source->stream.r_ptr;
 	int i;
 	int sign = 1;
 
-	for (i = 0; i < vol_state->source->size / sizeof(int32_t); i++) {
+	for (i = 0; i < vol_state->source->stream.size / sizeof(int32_t); i++) {
 		val = (INT24_MIN + (i >> 1)) * sign;
 		val = (val > INT24_MAX) ? INT24_MAX : val;
 		src[i] = (int32_t)val;
@@ -200,18 +202,18 @@ static void verify_s24_to_s24_s32(struct comp_dev *dev,
 				  struct comp_buffer *source)
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
-	const int32_t *src = (int32_t *)source->r_ptr;
-	const int32_t *dst = (int32_t *)sink->w_ptr;
+	const int32_t *src = (int32_t *)source->stream.r_ptr;
+	const int32_t *dst = (int32_t *)sink->stream.w_ptr;
 	double processed;
 	int32_t dst_sample;
 	int32_t sample;
-	int channels = sink->channels;
+	int channels = sink->stream.channels;
 	int channel;
 	int delta;
 	int i;
 	int shift = 8;
 
-	for (i = 0; i < sink->size / sizeof(uint32_t); i += channels) {
+	for (i = 0; i < sink->stream.size / sizeof(uint32_t); i += channels) {
 		for (channel = 0; channel < channels; channel++) {
 			processed = (src[i + channel] << 8) *
 				(double)cd->volume[channel] /
@@ -240,11 +242,11 @@ static void verify_s24_to_s24_s32(struct comp_dev *dev,
 static void fill_source_s32(struct vol_test_state *vol_state)
 {
 	int64_t val;
-	int32_t *src = (int32_t *)vol_state->source->r_ptr;
+	int32_t *src = (int32_t *)vol_state->source->stream.r_ptr;
 	int i;
 	int sign = 1;
 
-	for (i = 0; i < vol_state->source->size / sizeof(int32_t); i++) {
+	for (i = 0; i < vol_state->source->stream.size / sizeof(int32_t); i++) {
 		val = (INT32_MIN + (i >> 1)) * sign;
 		val = (val > INT32_MAX) ? INT32_MAX : val;
 		src[i] = (int32_t)val;
@@ -258,17 +260,17 @@ static void verify_s32_to_s24_s32(struct comp_dev *dev,
 {
 	struct comp_data *cd = comp_get_drvdata(dev);
 	double processed;
-	const int32_t *src = (int32_t *)source->r_ptr;
-	const int32_t *dst = (int32_t *)sink->w_ptr;
+	const int32_t *src = (int32_t *)source->stream.r_ptr;
+	const int32_t *dst = (int32_t *)sink->stream.w_ptr;
 	int32_t dst_sample;
 	int32_t sample;
-	int channels = sink->channels;
+	int channels = sink->stream.channels;
 	int channel;
 	int delta;
 	int i;
 	int shift = 0;
 
-	for (i = 0; i < sink->size / sizeof(uint32_t); i += channels) {
+	for (i = 0; i < sink->stream.size / sizeof(uint32_t); i += channels) {
 		for (channel = 0; channel < channels; channel++) {
 			processed = src[i + channel] *
 				    (double)cd->volume[channel] /
@@ -387,7 +389,7 @@ static void test_audio_vol(void **state)
 	struct vol_test_state *vol_state = *state;
 	struct comp_data *cd = comp_get_drvdata(vol_state->dev);
 
-	switch (vol_state->sink->frame_fmt) {
+	switch (vol_state->sink->stream.frame_fmt) {
 	case SOF_IPC_FRAME_S16_LE:
 		fill_source_s16(vol_state);
 		break;
@@ -400,8 +402,8 @@ static void test_audio_vol(void **state)
 		break;
 	}
 
-	cd->scale_vol(vol_state->dev, vol_state->sink, vol_state->source,
-		      vol_state->dev->frames);
+	cd->scale_vol(vol_state->dev, &vol_state->sink->stream,
+		      &vol_state->source->stream, vol_state->dev->frames);
 
 	vol_state->verify(vol_state->dev, vol_state->sink, vol_state->source);
 }
diff --git a/test/cmocka/src/notifier_mocks.c b/test/cmocka/src/notifier_mocks.c
index 970812055982..07557bbca1cc 100644
--- a/test/cmocka/src/notifier_mocks.c
+++ b/test/cmocka/src/notifier_mocks.c
@@ -13,7 +13,7 @@
 
 struct callback_handle {
 	void *receiver;
-	void *caller;
+	const void *caller;
 	void (*cb)(void *arg, enum notify_id, void *data);
 	struct list_item list;
 };
@@ -34,7 +34,7 @@ struct notify **arch_notify_get(void)
 	return &_notify;
 }
 
-void notifier_event(void *caller, enum notify_id type, uint32_t core_mask,
+void notifier_event(const void *caller, enum notify_id type, uint32_t core_mask,
 		    void *data, uint32_t data_size)
 {
 	struct notify *notify = *arch_notify_get();
diff --git a/tools/testbench/file.c b/tools/testbench/file.c
index 1a54cadf9825..d332aa57af3b 100644
--- a/tools/testbench/file.c
+++ b/tools/testbench/file.c
@@ -39,7 +39,8 @@ static inline void buffer_check_wrap_16(int16_t **ptr, int16_t *end,
  * Read 32-bit samples from file
  * currently only supports txt files
  */
-static int read_samples_32(struct comp_dev *dev, struct comp_buffer *sink,
+static int read_samples_32(struct comp_dev *dev,
+			   const struct audio_stream *sink,
 			   int n, int fmt, int nch)
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
@@ -117,7 +118,8 @@ static int read_samples_32(struct comp_dev *dev, struct comp_buffer *sink,
  * Read 16-bit samples from file
  * currently only supports txt files
  */
-static int read_samples_16(struct comp_dev *dev, struct comp_buffer *sink,
+static int read_samples_16(struct comp_dev *dev,
+			   const struct audio_stream *sink,
 			   int n, int nch)
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
@@ -175,7 +177,7 @@ static int read_samples_16(struct comp_dev *dev, struct comp_buffer *sink,
  * Write 16-bit samples from file
  * currently only supports txt files
  */
-static int write_samples_16(struct comp_dev *dev, struct comp_buffer *source,
+static int write_samples_16(struct comp_dev *dev, struct audio_stream *source,
 			    int n, int nch)
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
@@ -230,7 +232,7 @@ static int write_samples_16(struct comp_dev *dev, struct comp_buffer *source,
  * Write 32-bit samples from file
  * currently only supports txt files
  */
-static int write_samples_32(struct comp_dev *dev, struct comp_buffer *source,
+static int write_samples_32(struct comp_dev *dev, struct audio_stream *source,
 			    int n, int fmt, int nch)
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
@@ -301,8 +303,8 @@ static int write_samples_32(struct comp_dev *dev, struct comp_buffer *source,
 }
 
 /* function for processing 32-bit samples */
-static int file_s32_default(struct comp_dev *dev, struct comp_buffer *sink,
-			    struct comp_buffer *source, uint32_t frames)
+static int file_s32_default(struct comp_dev *dev, struct audio_stream *sink,
+			    struct audio_stream *source, uint32_t frames)
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
 	int nch = source->channels;
@@ -329,8 +331,8 @@ static int file_s32_default(struct comp_dev *dev, struct comp_buffer *sink,
 }
 
 /* function for processing 16-bit samples */
-static int file_s16(struct comp_dev *dev, struct comp_buffer *sink,
-		    struct comp_buffer *source, uint32_t frames)
+static int file_s16(struct comp_dev *dev, struct audio_stream *sink,
+		    struct audio_stream *source, uint32_t frames)
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
 	int nch = source->channels;
@@ -355,8 +357,8 @@ static int file_s16(struct comp_dev *dev, struct comp_buffer *sink,
 }
 
 /* function for processing 24-bit samples */
-static int file_s24(struct comp_dev *dev, struct comp_buffer *sink,
-		    struct comp_buffer *source, uint32_t frames)
+static int file_s24(struct comp_dev *dev, struct audio_stream *sink,
+		    struct audio_stream *source, uint32_t frames)
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
 	int nch = source->channels;
@@ -490,11 +492,11 @@ static int file_params(struct comp_dev *dev,
 {
 	struct file_comp_data *cd = comp_get_drvdata(dev);
 	struct sof_ipc_comp_config *config = COMP_GET_CONFIG(dev);
-	struct comp_buffer *sourceb;
+	struct audio_stream *sourceb;
 
 	/* file component source buffer */
-	sourceb = list_first_item(&dev->bsource_list, struct comp_buffer,
-				  sink_list);
+	sourceb = &list_first_item(&dev->bsource_list, struct comp_buffer,
+				  sink_list)->stream;
 
 	/* for file endpoint set the following from topology config */
 	if (cd->fs.mode == FILE_WRITE) {
@@ -565,10 +567,12 @@ static int file_copy(struct comp_dev *dev)
 					 source_list);
 
 		/* test sink has enough free frames */
-		snk_frames = buffer->free / buffer_frame_bytes(buffer);
+		snk_frames = buffer->stream.free /
+			     audio_stream_frame_bytes(&buffer->stream);
 		if (snk_frames > 0 && !cd->fs.reached_eof) {
 			/* read PCM samples from file */
-			ret = cd->file_func(dev, buffer, NULL, snk_frames);
+			ret = cd->file_func(dev, &buffer->stream, NULL,
+					    snk_frames);
 
 			/* update sink buffer pointers */
 			bytes = cd->sample_container_bytes;
@@ -583,10 +587,12 @@ static int file_copy(struct comp_dev *dev)
 					 struct comp_buffer, sink_list);
 
 		/* test source has enough free frames */
-		src_frames = buffer->avail / buffer_frame_bytes(buffer);
+		src_frames = buffer->stream.avail /
+			     audio_stream_frame_bytes(&buffer->stream);
 		if (src_frames > 0) {
 			/* write PCM samples into file */
-			ret = cd->file_func(dev, NULL, buffer, src_frames);
+			ret = cd->file_func(dev, NULL, &buffer->stream,
+					    src_frames);
 
 			/* update source buffer pointers */
 			bytes = cd->sample_container_bytes;
@@ -636,7 +642,7 @@ static int file_prepare(struct comp_dev *dev)
 	switch (config->frame_fmt) {
 	case(SOF_IPC_FRAME_S16_LE):
 		ret = buffer_set_size(buffer, dev->frames * 2 *
-			periods * buffer->channels);
+			periods * buffer->stream.channels);
 		if (ret < 0) {
 			fprintf(stderr, "error: file buffer size set\n");
 			return ret;
@@ -648,7 +654,7 @@ static int file_prepare(struct comp_dev *dev)
 		break;
 	case(SOF_IPC_FRAME_S24_4LE):
 		ret = buffer_set_size(buffer, dev->frames * 4 *
-			periods * buffer->channels);
+			periods * buffer->stream.channels);
 		if (ret < 0) {
 			fprintf(stderr, "error: file buffer size set\n");
 			return ret;
@@ -660,7 +666,7 @@ static int file_prepare(struct comp_dev *dev)
 		break;
 	case(SOF_IPC_FRAME_S32_LE):
 		ret = buffer_set_size(buffer, dev->frames * 4 *
-			periods * buffer->channels);
+			periods * buffer->stream.channels);
 		if (ret < 0) {
 			fprintf(stderr, "error: file buffer size set\n");
 			return ret;
diff --git a/tools/testbench/include/testbench/file.h b/tools/testbench/include/testbench/file.h
index d83d15295fd0..3eb1fa9b880f 100644
--- a/tools/testbench/include/testbench/file.h
+++ b/tools/testbench/include/testbench/file.h
@@ -41,8 +41,8 @@ struct file_comp_data {
 	uint32_t rate;
 	struct file_state fs;
 	int sample_container_bytes;
-	int (*file_func)(struct comp_dev *dev, struct comp_buffer *sink,
-			 struct comp_buffer *source, uint32_t frames);
+	int (*file_func)(struct comp_dev *dev, struct audio_stream *sink,
+			 struct audio_stream *source, uint32_t frames);
 
 };
 
diff --git a/tools/testbench/testbench.c b/tools/testbench/testbench.c
index c5f341cf4d70..0b343c211c6c 100644
--- a/tools/testbench/testbench.c
+++ b/tools/testbench/testbench.c
@@ -110,7 +110,7 @@ static void free_comps(void)
 			rfree(icd);
 			break;
 		case COMP_TYPE_BUFFER:
-			rfree(icd->cb->addr);
+			rfree(icd->cb->stream.addr);
 			rfree(icd->cb);
 			list_item_del(&icd->list);
 			rfree(icd);