Skip to content

Commit a1606de

Browse files
piotrhoppeintelCopilot
authored and
lgirdwood
committed
audio: eq_fir: clarify FIR processing variable names
Replace abbreviated local variable names with descriptive names across the generic, HiFi2EP, and HiFi3 EQ FIR implementations. Clarify channel, sample, pointer, filter, and stride handling without changing processing behavior. Signed-off-by: Piotr Hoppe <piotr.hoppe@intel.com> Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
1 parent ba78fb4 commit a1606de

3 files changed

Lines changed: 343 additions & 307 deletions

File tree

‎src/audio/eq_fir/eq_fir_generic.c‎

Lines changed: 76 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -26,34 +26,37 @@ void eq_fir_s16(struct fir_state_32x16 fir[], const struct cir_buf_source *sourc
2626
struct cir_buf_sink *sink, size_t frames, unsigned int channels)
2727
{
2828
struct fir_state_32x16 *filter;
29-
int32_t z;
30-
const int16_t *x0;
31-
int16_t *y0;
32-
const int16_t *x = source->ptr;
33-
int16_t *y = sink->ptr;
34-
size_t nmax, n, i;
29+
int32_t filtered_sample;
30+
const int16_t *src_channel;
31+
int16_t *dst_channel;
32+
const int16_t *src = source->ptr;
33+
int16_t *dst = sink->ptr;
34+
size_t max_samples;
35+
size_t chunk_samples;
36+
size_t sample_index;
3537
size_t remaining_samples = frames * channels;
36-
unsigned int j;
38+
unsigned int channel;
3739

3840
while (remaining_samples) {
39-
nmax = cir_buf_samples_without_wrap_s16(x, source->buf_end);
40-
n = MIN(remaining_samples, nmax);
41-
nmax = cir_buf_samples_without_wrap_s16(y, sink->buf_end);
42-
n = MIN(n, nmax);
43-
for (j = 0; j < channels; j++) {
44-
x0 = x + j;
45-
y0 = y + j;
46-
filter = &fir[j];
47-
for (i = 0; i < n; i += channels) {
48-
z = fir_32x16(filter, *x0 << 16);
49-
*y0 = sat_int16(Q_SHIFT_RND(z, 31, 15));
50-
x0 += channels;
51-
y0 += channels;
41+
max_samples = cir_buf_samples_without_wrap_s16(src, source->buf_end);
42+
chunk_samples = MIN(remaining_samples, max_samples);
43+
max_samples = cir_buf_samples_without_wrap_s16(dst, sink->buf_end);
44+
chunk_samples = MIN(chunk_samples, max_samples);
45+
for (channel = 0; channel < channels; channel++) {
46+
src_channel = src + channel;
47+
dst_channel = dst + channel;
48+
filter = &fir[channel];
49+
for (sample_index = 0; sample_index < chunk_samples;
50+
sample_index += channels) {
51+
filtered_sample = fir_32x16(filter, *src_channel << 16);
52+
*dst_channel = sat_int16(Q_SHIFT_RND(filtered_sample, 31, 15));
53+
src_channel += channels;
54+
dst_channel += channels;
5255
}
5356
}
54-
remaining_samples -= n;
55-
x = source_cir_buf_wrap(x + n, source->buf_start, source->buf_end);
56-
y = cir_buf_wrap(y + n, sink->buf_start, sink->buf_end);
57+
remaining_samples -= chunk_samples;
58+
src = source_cir_buf_wrap(src + chunk_samples, source->buf_start, source->buf_end);
59+
dst = cir_buf_wrap(dst + chunk_samples, sink->buf_start, sink->buf_end);
5760
}
5861
}
5962
#endif /* CONFIG_FORMAT_S16LE */
@@ -63,34 +66,37 @@ void eq_fir_s24(struct fir_state_32x16 fir[], const struct cir_buf_source *sourc
6366
struct cir_buf_sink *sink, size_t frames, unsigned int channels)
6467
{
6568
struct fir_state_32x16 *filter;
66-
int32_t z;
67-
const int32_t *x0;
68-
int32_t *y0;
69-
const int32_t *x = source->ptr;
70-
int32_t *y = sink->ptr;
71-
size_t nmax, n, i;
69+
int32_t filtered_sample;
70+
const int32_t *src_channel;
71+
int32_t *dst_channel;
72+
const int32_t *src = source->ptr;
73+
int32_t *dst = sink->ptr;
74+
size_t max_samples;
75+
size_t chunk_samples;
76+
size_t sample_index;
7277
size_t remaining_samples = frames * channels;
73-
unsigned int j;
78+
unsigned int channel;
7479

7580
while (remaining_samples) {
76-
nmax = cir_buf_samples_without_wrap_s32(x, source->buf_end);
77-
n = MIN(remaining_samples, nmax);
78-
nmax = cir_buf_samples_without_wrap_s32(y, sink->buf_end);
79-
n = MIN(n, nmax);
80-
for (j = 0; j < channels; j++) {
81-
x0 = x + j;
82-
y0 = y + j;
83-
filter = &fir[j];
84-
for (i = 0; i < n; i += channels) {
85-
z = fir_32x16(filter, *x0 << 8);
86-
*y0 = sat_int24(Q_SHIFT_RND(z, 31, 23));
87-
x0 += channels;
88-
y0 += channels;
81+
max_samples = cir_buf_samples_without_wrap_s32(src, source->buf_end);
82+
chunk_samples = MIN(remaining_samples, max_samples);
83+
max_samples = cir_buf_samples_without_wrap_s32(dst, sink->buf_end);
84+
chunk_samples = MIN(chunk_samples, max_samples);
85+
for (channel = 0; channel < channels; channel++) {
86+
src_channel = src + channel;
87+
dst_channel = dst + channel;
88+
filter = &fir[channel];
89+
for (sample_index = 0; sample_index < chunk_samples;
90+
sample_index += channels) {
91+
filtered_sample = fir_32x16(filter, *src_channel << 8);
92+
*dst_channel = sat_int24(Q_SHIFT_RND(filtered_sample, 31, 23));
93+
src_channel += channels;
94+
dst_channel += channels;
8995
}
9096
}
91-
remaining_samples -= n;
92-
x = source_cir_buf_wrap(x + n, source->buf_start, source->buf_end);
93-
y = cir_buf_wrap(y + n, sink->buf_start, sink->buf_end);
97+
remaining_samples -= chunk_samples;
98+
src = source_cir_buf_wrap(src + chunk_samples, source->buf_start, source->buf_end);
99+
dst = cir_buf_wrap(dst + chunk_samples, sink->buf_start, sink->buf_end);
94100
}
95101
}
96102
#endif /* CONFIG_FORMAT_S24LE */
@@ -100,32 +106,35 @@ void eq_fir_s32(struct fir_state_32x16 fir[], const struct cir_buf_source *sourc
100106
struct cir_buf_sink *sink, size_t frames, unsigned int channels)
101107
{
102108
struct fir_state_32x16 *filter;
103-
const int32_t *x0;
104-
int32_t *y0;
105-
const int32_t *x = source->ptr;
106-
int32_t *y = sink->ptr;
107-
size_t nmax, n, i;
109+
const int32_t *src_channel;
110+
int32_t *dst_channel;
111+
const int32_t *src = source->ptr;
112+
int32_t *dst = sink->ptr;
113+
size_t max_samples;
114+
size_t chunk_samples;
115+
size_t sample_index;
108116
size_t remaining_samples = frames * channels;
109-
unsigned int j;
117+
unsigned int channel;
110118

111119
while (remaining_samples) {
112-
nmax = cir_buf_samples_without_wrap_s32(x, source->buf_end);
113-
n = MIN(remaining_samples, nmax);
114-
nmax = cir_buf_samples_without_wrap_s32(y, sink->buf_end);
115-
n = MIN(n, nmax);
116-
for (j = 0; j < channels; j++) {
117-
x0 = x + j;
118-
y0 = y + j;
119-
filter = &fir[j];
120-
for (i = 0; i < n; i += channels) {
121-
*y0 = fir_32x16(filter, *x0);
122-
x0 += channels;
123-
y0 += channels;
120+
max_samples = cir_buf_samples_without_wrap_s32(src, source->buf_end);
121+
chunk_samples = MIN(remaining_samples, max_samples);
122+
max_samples = cir_buf_samples_without_wrap_s32(dst, sink->buf_end);
123+
chunk_samples = MIN(chunk_samples, max_samples);
124+
for (channel = 0; channel < channels; channel++) {
125+
src_channel = src + channel;
126+
dst_channel = dst + channel;
127+
filter = &fir[channel];
128+
for (sample_index = 0; sample_index < chunk_samples;
129+
sample_index += channels) {
130+
*dst_channel = fir_32x16(filter, *src_channel);
131+
src_channel += channels;
132+
dst_channel += channels;
124133
}
125134
}
126-
remaining_samples -= n;
127-
x = source_cir_buf_wrap(x + n, source->buf_start, source->buf_end);
128-
y = cir_buf_wrap(y + n, sink->buf_start, sink->buf_end);
135+
remaining_samples -= chunk_samples;
136+
src = source_cir_buf_wrap(src + chunk_samples, source->buf_start, source->buf_end);
137+
dst = cir_buf_wrap(dst + chunk_samples, sink->buf_start, sink->buf_end);
129138
}
130139
}
131140
#endif /* CONFIG_FORMAT_S32LE */

0 commit comments

Comments
 (0)