audio: steamaudio: add acoustic pathing and knife-edge diffraction offload

Add support for acoustic pathing and knife-edge obstacle diffraction
to the Sound Open Firmware (SOF) Steam Audio component:
1. Implements 3-band diffraction IIR biquad filtering with RBJ shelf
   and peaking filters at Steam Audio standard band cutoffs
   (800 Hz, 2500 Hz, 8000 Hz).
2. Encodes diffracted audio into Higher-Order Ambisonics (HOA) soundfield
   arrival vectors up to Order 3.
3. Applies listener coordinate space rotation matrices to the Ambisonics
   soundfield representation.
4. Renders spatialized audio via head-fixed virtual spherical loudspeaker
   arrays into binaural stereo or multi-channel surround speakers.
5. Adds STEAMAUDIO_PARAM_PATHING_CONFIG (0x100A) IPC4 configuration
   handler and STEAMAUDIO_OUTPUT_PATHING (4) rendering mode.

Signed-off-by: Liam Girdwood <liam.r.girdwood@linux.intel.com>

Author: lrgirdwo

src/audio/steamaudio/steamaudio-generic.c

@@ -87,22 +87,22 @@ static inline float fast_acos(float x)
 }
 
 /* 3-Band Biquad Filter Computation */
-static void calc_biquad_coeffs(float gain_db, float freq, float sample_rate, int type, float coeffs[5])
+static void calc_biquad_coeffs(float linear_gain, float freq, float sample_rate, int type, float coeffs[5])
 {
 	float w0 = 2.0f * PI * freq / sample_rate;
 	float cos_w0 = fast_cos(w0);
 	float sin_w0 = fast_sin(w0);
 	float a = 1.0f; /* Q = 1.0 */
 	float alpha = sin_w0 / (2.0f * a);
-	float A = 1.0f;
-	if (gain_db != 0.0f)
-		A = 1.0f + gain_db * 0.115129f; /* 10^(dB/20) approx */
+
+	float g = sat_clamp(linear_gain, 0.0001f, 1.0f);
+	float A = fast_sqrt(g);
+	float sqrt_A = fast_sqrt(A);
 
 	float b0 = 1.0f, b1 = 0.0f, b2 = 0.0f, a0 = 1.0f, a1 = 0.0f, a2 = 0.0f;
 
 	if (type == 0) {
-		/* Low shelf (400 Hz) */
-		float sqrt_A = (A > 0.0f) ? (1.0f + 0.5f * (A - 1.0f)) : 1.0f;
+		/* Low shelf (800 Hz) */
 		b0 = A * ((A + 1.0f) - (A - 1.0f) * cos_w0 + 2.0f * sqrt_A * alpha);
 		b1 = 2.0f * A * ((A - 1.0f) - (A + 1.0f) * cos_w0);
 		b2 = A * ((A + 1.0f) - (A - 1.0f) * cos_w0 - 2.0f * sqrt_A * alpha);
@@ -118,8 +118,7 @@ static void calc_biquad_coeffs(float gain_db, float freq, float sample_rate, int
 		a1 = -2.0f * cos_w0;
 		a2 = 1.0f - alpha / A;
 	} else {
-		/* High shelf (15 kHz) */
-		float sqrt_A = (A > 0.0f) ? (1.0f + 0.5f * (A - 1.0f)) : 1.0f;
+		/* High shelf (8000 Hz) */
 		b0 = A * ((A + 1.0f) + (A - 1.0f) * cos_w0 + 2.0f * sqrt_A * alpha);
 		b1 = -2.0f * A * ((A - 1.0f) + (A + 1.0f) * cos_w0);
 		b2 = A * ((A + 1.0f) - (A - 1.0f) * cos_w0 - 2.0f * sqrt_A * alpha);
@@ -128,14 +127,22 @@ static void calc_biquad_coeffs(float gain_db, float freq, float sample_rate, int
 		a2 = (A + 1.0f) - (A - 1.0f) * cos_w0 - 2.0f * sqrt_A * alpha;
 	}
 
-	float inv_a0 = 1.0f / a0;
+	float inv_a0 = (a0 > 0.0001f) ? (1.0f / a0) : 1.0f;
 	coeffs[0] = b0 * inv_a0;
 	coeffs[1] = b1 * inv_a0;
 	coeffs[2] = b2 * inv_a0;
 	coeffs[3] = a1 * inv_a0;
 	coeffs[4] = a2 * inv_a0;
 }
 
+static inline float apply_biquad(float in, const float coeffs[5], float state[2])
+{
+	float out = coeffs[0] * in + state[0];
+	state[0] = coeffs[1] * in - coeffs[3] * out + state[1];
+	state[1] = coeffs[2] * in - coeffs[4] * out;
+	return out;
+}
+
 void steamaudio_dsp_init(struct steamaudio_comp_data *cd, uint32_t sample_rate)
 {
 	cd->sample_rate = sample_rate ? sample_rate : 48000;
@@ -151,9 +158,9 @@ void steamaudio_dsp_init(struct steamaudio_comp_data *cd, uint32_t sample_rate)
 	cd->direct.crossfade_remaining = 0;
 
 	for (int b = 0; b < STEAMAUDIO_NUM_EQ_BANDS; b++) {
-		float freq = (b == 0) ? 400.0f : ((b == 1) ? 2500.0f : 15000.0f);
-		calc_biquad_coeffs(0.0f, freq, (float)cd->sample_rate, b, cd->direct.coeffs[0][b]);
-		calc_biquad_coeffs(0.0f, freq, (float)cd->sample_rate, b, cd->direct.coeffs[1][b]);
+		float freq = (b == 0) ? 800.0f : ((b == 1) ? 2500.0f : 8000.0f);
+		calc_biquad_coeffs(1.0f, freq, (float)cd->sample_rate, b, cd->direct.coeffs[0][b]);
+		calc_biquad_coeffs(1.0f, freq, (float)cd->sample_rate, b, cd->direct.coeffs[1][b]);
 	}
 
 	/* Initialize Binaural */
@@ -189,6 +196,9 @@ void steamaudio_dsp_init(struct steamaudio_comp_data *cd, uint32_t sample_rate)
 	/* Initialize Virtual Surround Sound */
 	steamaudio_dsp_virtual_surround_init(&cd->virtual_surround, STEAMAUDIO_SPEAKER_LAYOUT_5_1, cd->sample_rate);
 
+	/* Initialize Acoustic Pathing */
+	steamaudio_dsp_pathing_init(&cd->pathing, 1, cd->sample_rate);
+
 	cd->output_mode = STEAMAUDIO_OUTPUT_BINAURAL;
 	memset(cd->in_channels, 0, sizeof(cd->in_channels));
 	memset(cd->out_channels, 0, sizeof(cd->out_channels));
@@ -721,7 +731,7 @@ void steamaudio_dsp_ambisonics_decode_binaural(struct steamaudio_ambisonics_stat
 		float sh[16];
 		eval_sh_basis(rx, ry, rz, (int)ambi->order, sh);
 
-		float az = fast_atan2(rx, rz);
+		float az = fast_atan2(vx, vz);
 		float sin_az = fast_sin(az);
 		float ild_l = (sin_az > 0.0f) ? (1.0f - 0.4f * sin_az) : 1.0f;
 		float ild_r = (sin_az < 0.0f) ? (1.0f + 0.4f * sin_az) : 1.0f;
@@ -738,6 +748,105 @@ void steamaudio_dsp_ambisonics_decode_binaural(struct steamaudio_ambisonics_stat
 	}
 }
 
+void steamaudio_dsp_pathing_init(struct steamaudio_pathing_state *pathing, uint32_t order, uint32_t sample_rate)
+{
+	memset(pathing, 0, sizeof(*pathing));
+	pathing->order = (order <= 3) ? order : 1;
+	pathing->num_channels = (pathing->order + 1) * (pathing->order + 1);
+	pathing->binaural = true;
+	pathing->eq_coeffs[0] = 1.0f;
+	pathing->eq_coeffs[1] = 1.0f;
+	pathing->eq_coeffs[2] = 1.0f;
+	pathing->sh_coeffs[0] = 1.0f;
+	pathing->rotation[0][0] = 1.0f;
+	pathing->rotation[1][1] = 1.0f;
+	pathing->rotation[2][2] = 1.0f;
+
+	calc_biquad_coeffs(1.0f, 800.0f, (float)sample_rate, 0, pathing->filter_coeffs[0]);
+	calc_biquad_coeffs(1.0f, 2500.0f, (float)sample_rate, 1, pathing->filter_coeffs[1]);
+	calc_biquad_coeffs(1.0f, 8000.0f, (float)sample_rate, 2, pathing->filter_coeffs[2]);
+}
+
+void steamaudio_dsp_pathing_set_params(struct steamaudio_pathing_state *pathing,
+				       const float eq[STEAMAUDIO_NUM_EQ_BANDS],
+				       const float sh[STEAMAUDIO_MAX_HOA_CHANNELS],
+				       uint32_t order, bool binaural,
+				       const float rot[3][3],
+				       uint32_t sample_rate)
+{
+	pathing->order = (order <= 3) ? order : 1;
+	pathing->num_channels = (pathing->order + 1) * (pathing->order + 1);
+	pathing->binaural = binaural;
+
+	for (int b = 0; b < STEAMAUDIO_NUM_EQ_BANDS; b++) {
+		pathing->eq_coeffs[b] = sat_clamp(eq[b], 0.0f, 1.0f);
+		int type = (b == 0) ? 0 : ((b == 1) ? 1 : 2);
+		float freq = (b == 0) ? 800.0f : ((b == 1) ? 2500.0f : 8000.0f);
+		calc_biquad_coeffs(pathing->eq_coeffs[b], freq, (float)sample_rate, type, pathing->filter_coeffs[b]);
+	}
+
+	for (int i = 0; i < pathing->num_channels; i++)
+		pathing->sh_coeffs[i] = sh[i];
+
+	if (rot) {
+		for (int r = 0; r < 3; r++)
+			for (int c = 0; c < 3; c++)
+				pathing->rotation[r][c] = rot[r][c];
+	}
+}
+
+void steamaudio_dsp_pathing_process(struct steamaudio_pathing_state *pathing,
+				    struct steamaudio_ambisonics_state *ambi,
+				    struct steamaudio_panning_state *panning,
+				    const float *in, float *out_l, float *out_r,
+				    float out_ch[STEAMAUDIO_MAX_SPEAKERS][256],
+				    uint32_t frames)
+{
+	float eq_buffer[256];
+	for (uint32_t i = 0; i < frames; i++) {
+		float s = in[i];
+		s = apply_biquad(s, pathing->filter_coeffs[0], pathing->filter_states[0]);
+		s = apply_biquad(s, pathing->filter_coeffs[1], pathing->filter_states[1]);
+		s = apply_biquad(s, pathing->filter_coeffs[2], pathing->filter_states[2]);
+		eq_buffer[i] = s;
+	}
+
+	float hoa_channels[STEAMAUDIO_MAX_HOA_CHANNELS][256];
+	int num_ch = pathing->num_channels;
+	for (int ch = 0; ch < num_ch; ch++) {
+		float coeff = pathing->sh_coeffs[ch];
+		for (uint32_t i = 0; i < frames; i++)
+			hoa_channels[ch][i] = eq_buffer[i] * coeff;
+	}
+
+	if (pathing->binaural) {
+		for (int r = 0; r < 3; r++)
+			for (int c = 0; c < 3; c++)
+				ambi->rotation[r][c] = pathing->rotation[r][c];
+		ambi->order = pathing->order;
+
+		steamaudio_dsp_ambisonics_decode_binaural(ambi,
+							  (const float (*)[256])hoa_channels,
+							  out_l, out_r, frames);
+	} else {
+		float dir[3] = { 0.0f, 0.0f, 1.0f };
+		if (num_ch >= 4) {
+			dir[0] = pathing->sh_coeffs[3];
+			dir[1] = pathing->sh_coeffs[1];
+			dir[2] = pathing->sh_coeffs[2];
+			float len = fast_sqrt(dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2]);
+			if (len > 0.0001f) {
+				float inv_len = 1.0f / len;
+				dir[0] *= inv_len; dir[1] *= inv_len; dir[2] *= inv_len;
+			}
+		}
+		steamaudio_dsp_panning_set_direction(panning, dir);
+		steamaudio_dsp_panning_process(panning, eq_buffer, out_ch, frames);
+		memcpy(out_l, out_ch[0], frames * sizeof(float));
+		memcpy(out_r, out_ch[1], frames * sizeof(float));
+	}
+}
+
 static inline void steamaudio_dsp_render(struct steamaudio_comp_data *cd, uint32_t frames)
 {
 	if (cd->output_mode == STEAMAUDIO_OUTPUT_SURROUND_PANNING) {
@@ -765,6 +874,11 @@ static inline void steamaudio_dsp_render(struct steamaudio_comp_data *cd, uint32
 								  cd->out_left, cd->out_right, frames);
 		}
 		process_reverb(cd, cd->in_scratch, cd->out_left, cd->out_right, frames);
+	} else if (cd->output_mode == STEAMAUDIO_OUTPUT_PATHING) {
+		steamaudio_dsp_pathing_process(&cd->pathing, &cd->ambisonics, &cd->panning,
+					       cd->in_scratch, cd->out_left, cd->out_right,
+					       cd->out_channels, frames);
+		process_reverb(cd, cd->in_scratch, cd->out_left, cd->out_right, frames);
 	} else {
 		process_direct_path(cd, cd->in_scratch, cd->out_left, frames);
 		memcpy(cd->in_scratch, cd->out_left, frames * sizeof(float));

src/audio/steamaudio/steamaudio-ipc4.c

@@ -140,6 +140,34 @@ __cold int steamaudio_set_config(struct processing_module *mod,
 		return 0;
 	}
 
+	case STEAMAUDIO_PARAM_PATHING_CONFIG: {
+		if (fragment_size < sizeof(struct sof_steamaudio_pathing_config))
+			return -EINVAL;
+
+		const struct sof_steamaudio_pathing_config *cfg =
+			(const struct sof_steamaudio_pathing_config *)fragment;
+
+		float eq[STEAMAUDIO_NUM_EQ_BANDS];
+		for (int b = 0; b < STEAMAUDIO_NUM_EQ_BANDS; b++)
+			eq[b] = cfg->eq_coeffs[b];
+
+		float sh[STEAMAUDIO_MAX_HOA_CHANNELS];
+		for (int i = 0; i < STEAMAUDIO_MAX_HOA_CHANNELS; i++)
+			sh[i] = cfg->sh_coeffs[i];
+
+		float rot[3][3];
+		for (int r = 0; r < 3; r++)
+			for (int c = 0; c < 3; c++)
+				rot[r][c] = cfg->listener_rotation[r][c];
+
+		steamaudio_dsp_pathing_set_params(&cd->pathing, eq, sh,
+						  cfg->order, (cfg->binaural != 0),
+						  rot, cd->sample_rate);
+		comp_dbg(dev, "steamaudio: pathing order=%u binaural=%u",
+			 cfg->order, cfg->binaural);
+		return 0;
+	}
+
 	case STEAMAUDIO_PARAM_BITSTREAM_MODE: {
 		if (fragment_size < sizeof(uint32_t))
 			return -EINVAL;
@@ -262,6 +290,25 @@ __cold int steamaudio_get_config(struct processing_module *mod,
 		return 0;
 	}
 
+	case STEAMAUDIO_PARAM_PATHING_CONFIG: {
+		if (fragment_size < sizeof(struct sof_steamaudio_pathing_config))
+			return -EINVAL;
+
+		struct sof_steamaudio_pathing_config *cfg = (struct sof_steamaudio_pathing_config *)fragment;
+		memset(cfg, 0, sizeof(*cfg));
+		cfg->comp_type = STEAMAUDIO_PARAM_PATHING_CONFIG;
+		for (int b = 0; b < STEAMAUDIO_NUM_EQ_BANDS; b++)
+			cfg->eq_coeffs[b] = cd->pathing.eq_coeffs[b];
+		for (int i = 0; i < STEAMAUDIO_MAX_HOA_CHANNELS; i++)
+			cfg->sh_coeffs[i] = cd->pathing.sh_coeffs[i];
+		cfg->order = cd->pathing.order;
+		cfg->binaural = cd->pathing.binaural ? 1 : 0;
+		for (int r = 0; r < 3; r++)
+			for (int c = 0; c < 3; c++)
+				cfg->listener_rotation[r][c] = cd->pathing.rotation[r][c];
+		return 0;
+	}
+
 	case STEAMAUDIO_PARAM_BVH_QUERY: {
 		if (fragment_size < sizeof(struct sof_steamaudio_bvh_query))
 			return -EINVAL;

src/audio/steamaudio/steamaudio.c

@@ -105,6 +105,7 @@ static int steamaudio_reset(struct processing_module *mod)
 		memset(cd->reverb.delay_buffers, 0, sizeof(cd->reverb.delay_buffers));
 		memset(cd->reverb.damp_states, 0, sizeof(cd->reverb.damp_states));
 		memset(cd->virtual_surround.delay_lines, 0, sizeof(cd->virtual_surround.delay_lines));
+		memset(cd->pathing.filter_states, 0, sizeof(cd->pathing.filter_states));
 		memset(cd->in_scratch, 0, sizeof(cd->in_scratch));
 		memset(cd->in_channels, 0, sizeof(cd->in_channels));
 		memset(cd->out_channels, 0, sizeof(cd->out_channels));

src/audio/steamaudio/steamaudio.h

@@ -35,6 +35,7 @@
 #define STEAMAUDIO_PARAM_PANNING_CONFIG     0x1007
 #define STEAMAUDIO_PARAM_VIRTUAL_SURROUND_CONFIG 0x1008
 #define STEAMAUDIO_PARAM_OUTPUT_MODE        0x1009
+#define STEAMAUDIO_PARAM_PATHING_CONFIG     0x100A
 
 enum steamaudio_speaker_layout {
 	STEAMAUDIO_SPEAKER_LAYOUT_STEREO = 0,
@@ -48,6 +49,7 @@ enum steamaudio_output_mode {
 	STEAMAUDIO_OUTPUT_SURROUND_PANNING = 1,
 	STEAMAUDIO_OUTPUT_VIRTUAL_SURROUND = 2,
 	STEAMAUDIO_OUTPUT_AMBISONICS = 3,
+	STEAMAUDIO_OUTPUT_PATHING = 4,
 };
 
 /* Bitstream Encapsulation Header */
@@ -140,6 +142,15 @@ struct __attribute__((packed)) sof_steamaudio_bvh_query {
 	uint32_t has_line_of_sight;
 };
 
+struct __attribute__((packed)) sof_steamaudio_pathing_config {
+	uint32_t comp_type;
+	float eq_coeffs[STEAMAUDIO_NUM_EQ_BANDS]; /* 3-band diffraction transmission EQ */
+	float sh_coeffs[STEAMAUDIO_MAX_HOA_CHANNELS]; /* Ambisonics SH arrival soundfield */
+	uint32_t order; /* Ambisonics order (0, 1, 2, or 3) */
+	uint32_t binaural; /* 1: Binaural headphone decode, 0: Panning decode */
+	float listener_rotation[3][3]; /* Listener coordinate space rotation */
+};
+
 /* Internal DSP Sub-Engine States */
 struct steamaudio_direct_state {
 	float coeffs[2][STEAMAUDIO_NUM_EQ_BANDS][5]; /* b0, b1, b2, a1, a2 */
@@ -199,6 +210,17 @@ struct steamaudio_virtual_surround_state {
 	float ild_gains[STEAMAUDIO_MAX_SPEAKERS][2];
 };
 
+struct steamaudio_pathing_state {
+	float eq_coeffs[STEAMAUDIO_NUM_EQ_BANDS];
+	float sh_coeffs[STEAMAUDIO_MAX_HOA_CHANNELS];
+	uint32_t order;
+	int num_channels;
+	bool binaural;
+	float rotation[3][3];
+	float filter_coeffs[STEAMAUDIO_NUM_EQ_BANDS][5];
+	float filter_states[STEAMAUDIO_NUM_EQ_BANDS][2];
+};
+
 /* BVH scene forward declaration */
 #define STEAMAUDIO_MAX_DSP_TRIANGLES 32
 #define STEAMAUDIO_MAX_DSP_BVH_NODES 64
@@ -269,6 +291,7 @@ struct steamaudio_comp_data {
 	struct steamaudio_ambisonics_state ambisonics;
 	struct steamaudio_panning_state panning;
 	struct steamaudio_virtual_surround_state virtual_surround;
+	struct steamaudio_pathing_state pathing;
 	struct dsp_scene scene;
 
 	/* Temporary scratch buffers for processing frames */
@@ -302,6 +325,20 @@ void steamaudio_dsp_ambisonics_decode_binaural(struct steamaudio_ambisonics_stat
 					       const float in_ch[STEAMAUDIO_MAX_HOA_CHANNELS][256],
 					       float *out_l, float *out_r, uint32_t frames);
 
+void steamaudio_dsp_pathing_init(struct steamaudio_pathing_state *pathing, uint32_t order, uint32_t sample_rate);
+void steamaudio_dsp_pathing_set_params(struct steamaudio_pathing_state *pathing,
+				       const float eq[STEAMAUDIO_NUM_EQ_BANDS],
+				       const float sh[STEAMAUDIO_MAX_HOA_CHANNELS],
+				       uint32_t order, bool binaural,
+				       const float rot[3][3],
+				       uint32_t sample_rate);
+void steamaudio_dsp_pathing_process(struct steamaudio_pathing_state *pathing,
+				    struct steamaudio_ambisonics_state *ambi,
+				    struct steamaudio_panning_state *panning,
+				    const float *in, float *out_l, float *out_r,
+				    float out_ch[STEAMAUDIO_MAX_SPEAKERS][256],
+				    uint32_t frames);
+
 /* IPC4 control callbacks */
 int steamaudio_set_config(struct processing_module *mod,
 			  uint32_t param_id,