Skip to content

Commit 306d94a

Browse files
softwareckisoftwarecki
committed
module: ctc: rework module to use sink/source api
Rework the google ctc audio processing module to only use the sink/source api to prepare sof for the full transition to pipeline 2.0. Signed-off-by: Adrian Warecki <adrian.warecki@intel.com>
1 parent b6c6a05 commit 306d94a

2 files changed

Lines changed: 132 additions & 102 deletions

File tree

‎src/audio/google/google_ctc_audio_processing.c‎

Lines changed: 128 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@
1212
#include <sof/audio/data_blob.h>
1313
#include <sof/audio/format.h>
1414
#include <sof/audio/pipeline.h>
15+
#include <sof/audio/sink_source_utils.h>
1516
#include <rtos/init.h>
1617

1718
#include <google_ctc_audio_processing.h>
@@ -58,50 +59,54 @@ static inline float convert_int32_to_float(int32_t data)
5859
static const int kChunkFrames = 48;
5960
static const int kMaxChannels = 2;
6061

61-
static void ctc_passthrough(const struct audio_stream *source,
62-
struct audio_stream *sink,
63-
struct input_stream_buffer *input_buffers,
64-
struct output_stream_buffer *output_buffers,
65-
uint32_t frames)
62+
static int ctc_passthrough(struct sof_source *source, struct sof_sink *sink, size_t frames)
6663
{
67-
int n_ch = audio_stream_get_channels(source);
68-
int samples = frames * n_ch;
69-
70-
audio_stream_copy(source, 0, sink, 0, samples);
71-
module_update_buffer_position(&input_buffers[0], &output_buffers[0], frames);
64+
return source_to_sink_copy(source, sink, true, frames * source_get_frame_bytes(source));
7265
}
7366

7467
#if CONFIG_FORMAT_S16LE
75-
static void ctc_s16_default(struct google_ctc_audio_processing_comp_data *cd,
76-
const struct audio_stream *source,
77-
struct audio_stream *sink,
78-
struct input_stream_buffer *input_buffers,
79-
struct output_stream_buffer *output_buffers,
80-
uint32_t frames)
68+
static int ctc_s16_default(struct google_ctc_audio_processing_comp_data *cd,
69+
struct sof_source *source,
70+
struct sof_sink *sink,
71+
size_t frames)
8172
{
82-
int n_ch = audio_stream_get_channels(source);
83-
int samples = frames * n_ch;
73+
unsigned int n_ch = source_get_channels(source);
74+
size_t samples = frames * n_ch;
75+
const int16_t *src, *src_start;
76+
int16_t *dest, *dest_start;
77+
size_t src_samples, dest_samples;
78+
size_t samples_to_process, samples_to_written;
79+
size_t written_samples = 0;
80+
int ret;
8481

85-
int16_t *src = audio_stream_get_rptr(source);
86-
int16_t *dest = audio_stream_get_wptr(sink);
82+
if (!cd->enabled)
83+
return ctc_passthrough(source, sink, frames);
8784

88-
int samples_to_process = MIN(samples, audio_stream_samples_without_wrap_s16(source, src));
89-
int samples_to_written = MIN(samples, audio_stream_samples_without_wrap_s16(sink, dest));
90-
int written_samples = 0;
85+
ret = source_get_data_s16(source, frames * source_get_frame_bytes(source),
86+
&src, &src_start, &src_samples);
87+
if (ret)
88+
return ret;
9189

92-
if (!cd->enabled) {
93-
ctc_passthrough(source, sink, input_buffers, output_buffers, frames);
94-
return;
90+
ret = sink_get_buffer_s16(sink, frames * sink_get_frame_bytes(sink),
91+
&dest, &dest_start, &dest_samples);
92+
if (ret) {
93+
source_release_data(source, 0);
94+
return ret;
9595
}
9696

97+
samples_to_process = MIN(samples, cir_buf_samples_without_wrap_s16(src,
98+
src_start + src_samples));
99+
samples_to_written = MIN(samples, cir_buf_samples_without_wrap_s16(dest,
100+
dest_start + dest_samples));
101+
97102
// writes previous processed samples to the output.
98103
while (cd->next_avail_output_samples < cd->chunk_frames * n_ch &&
99104
written_samples < samples_to_written) {
100105
dest[written_samples++] =
101106
convert_float_to_int16(cd->output[cd->next_avail_output_samples]);
102107
cd->next_avail_output_samples++;
103108
}
104-
for (int i = 0; i < samples_to_process; ++i) {
109+
for (size_t i = 0; i < samples_to_process; ++i) {
105110
cd->input[cd->input_samples++] = convert_int16_to_float(src[i]);
106111
if (cd->input_samples == cd->chunk_frames * n_ch) {
107112
GoogleCtcAudioProcessingProcess(cd->state, cd->input, cd->output,
@@ -117,46 +122,59 @@ static void ctc_s16_default(struct google_ctc_audio_processing_comp_data *cd,
117122
}
118123
}
119124
}
120-
if (written_samples > 0) {
121-
dest = audio_stream_wrap(sink, dest + written_samples);
122-
output_buffers->size += audio_stream_frame_bytes(sink) * written_samples / n_ch;
125+
126+
ret = source_release_data(source, samples_to_process * sizeof(int16_t));
127+
if (ret) {
128+
sink_commit_buffer(sink, 0);
129+
return ret;
123130
}
124-
src = audio_stream_wrap(source, src + samples_to_process);
125-
input_buffers->consumed += audio_stream_frame_bytes(source) * samples_to_process / n_ch;
131+
return sink_commit_buffer(sink, written_samples * sizeof(int16_t));
126132
}
127133
#endif
128134

129135
#if CONFIG_FORMAT_S24LE
130-
static void ctc_s24_default(struct google_ctc_audio_processing_comp_data *cd,
131-
const struct audio_stream *source,
132-
struct audio_stream *sink,
133-
struct input_stream_buffer *input_buffers,
134-
struct output_stream_buffer *output_buffers,
135-
uint32_t frames)
136+
static int ctc_s24_default(struct google_ctc_audio_processing_comp_data *cd,
137+
struct sof_source *source,
138+
struct sof_sink *sink,
139+
size_t frames)
136140
{
137-
int n_ch = audio_stream_get_channels(source);
138-
int samples = frames * n_ch;
141+
unsigned int n_ch = source_get_channels(source);
142+
size_t samples = frames * n_ch;
143+
const int32_t *src, *src_start;
144+
int32_t *dest, *dest_start;
145+
size_t src_samples, dest_samples;
146+
size_t samples_to_process, samples_to_written;
147+
size_t written_samples = 0;
148+
int ret;
139149

140-
int32_t *src = audio_stream_get_rptr(source);
141-
int32_t *dest = audio_stream_get_wptr(sink);
150+
if (!cd->enabled)
151+
return ctc_passthrough(source, sink, frames);
142152

143-
int samples_to_process = MIN(samples, audio_stream_samples_without_wrap_s24(source, src));
144-
int samples_to_written = MIN(samples, audio_stream_samples_without_wrap_s24(sink, dest));
145-
int written_samples = 0;
153+
ret = source_get_data_s32(source, frames * source_get_frame_bytes(source),
154+
&src, &src_start, &src_samples);
155+
if (ret)
156+
return ret;
146157

147-
if (!cd->enabled) {
148-
ctc_passthrough(source, sink, input_buffers, output_buffers, frames);
149-
return;
158+
ret = sink_get_buffer_s32(sink, frames * sink_get_frame_bytes(sink),
159+
&dest, &dest_start, &dest_samples);
160+
if (ret) {
161+
source_release_data(source, 0);
162+
return ret;
150163
}
151164

165+
samples_to_process = MIN(samples, cir_buf_samples_without_wrap_s32(src,
166+
src_start + src_samples));
167+
samples_to_written = MIN(samples, cir_buf_samples_without_wrap_s32(dest,
168+
dest_start + dest_samples));
169+
152170
// writes previous processed samples to the output.
153171
while (cd->next_avail_output_samples < cd->chunk_frames * n_ch &&
154172
written_samples < samples_to_written) {
155173
dest[written_samples++] =
156174
convert_float_to_int32(cd->output[cd->next_avail_output_samples]);
157175
cd->next_avail_output_samples++;
158176
}
159-
for (int i = 0; i < samples_to_process; ++i) {
177+
for (size_t i = 0; i < samples_to_process; ++i) {
160178
cd->input[cd->input_samples++] = convert_int32_to_float(src[i]);
161179
if (cd->input_samples == cd->chunk_frames * n_ch) {
162180
GoogleCtcAudioProcessingProcess(cd->state, cd->input, cd->output,
@@ -172,46 +190,59 @@ static void ctc_s24_default(struct google_ctc_audio_processing_comp_data *cd,
172190
}
173191
}
174192
}
175-
if (written_samples > 0) {
176-
dest = audio_stream_wrap(sink, dest + written_samples);
177-
output_buffers->size += audio_stream_frame_bytes(sink) * written_samples / n_ch;
193+
194+
ret = source_release_data(source, samples_to_process * sizeof(int32_t));
195+
if (ret) {
196+
sink_commit_buffer(sink, written_samples * sizeof(int32_t));
197+
return ret;
178198
}
179-
src = audio_stream_wrap(source, src + samples_to_process);
180-
input_buffers->consumed += audio_stream_frame_bytes(source) * samples_to_process / n_ch;
199+
return sink_commit_buffer(sink, written_samples * sizeof(int32_t));
181200
}
182201
#endif
183202

184203
#if CONFIG_FORMAT_S32LE
185-
static void ctc_s32_default(struct google_ctc_audio_processing_comp_data *cd,
186-
const struct audio_stream *source,
187-
struct audio_stream *sink,
188-
struct input_stream_buffer *input_buffers,
189-
struct output_stream_buffer *output_buffers,
190-
uint32_t frames)
204+
static int ctc_s32_default(struct google_ctc_audio_processing_comp_data *cd,
205+
struct sof_source *source,
206+
struct sof_sink *sink,
207+
size_t frames)
191208
{
192-
int n_ch = audio_stream_get_channels(source);
193-
int samples = frames * n_ch;
209+
unsigned int n_ch = source_get_channels(source);
210+
size_t samples = frames * n_ch;
211+
const int32_t *src, *src_start;
212+
int32_t *dest, *dest_start;
213+
size_t src_samples, dest_samples;
214+
size_t samples_to_process, samples_to_written;
215+
size_t written_samples = 0;
216+
int ret;
194217

195-
int32_t *src = audio_stream_get_rptr(source);
196-
int32_t *dest = audio_stream_get_wptr(sink);
218+
if (!cd->enabled)
219+
return ctc_passthrough(source, sink, frames);
197220

198-
int samples_to_process = MIN(samples, audio_stream_samples_without_wrap_s32(source, src));
199-
int samples_to_written = MIN(samples, audio_stream_samples_without_wrap_s32(sink, dest));
200-
int written_samples = 0;
221+
ret = source_get_data_s32(source, frames * source_get_frame_bytes(source),
222+
&src, &src_start, &src_samples);
223+
if (ret)
224+
return ret;
201225

202-
if (!cd->enabled) {
203-
ctc_passthrough(source, sink, input_buffers, output_buffers, frames);
204-
return;
226+
ret = sink_get_buffer_s32(sink, frames * sink_get_frame_bytes(sink),
227+
&dest, &dest_start, &dest_samples);
228+
if (ret) {
229+
source_release_data(source, 0);
230+
return ret;
205231
}
206232

233+
samples_to_process = MIN(samples, cir_buf_samples_without_wrap_s32(src,
234+
src_start + src_samples));
235+
samples_to_written = MIN(samples, cir_buf_samples_without_wrap_s32(dest,
236+
dest_start + dest_samples));
237+
207238
// writes previous processed samples to the output.
208239
while (cd->next_avail_output_samples < cd->chunk_frames * n_ch &&
209240
written_samples < samples_to_written) {
210241
dest[written_samples++] =
211242
convert_float_to_int32(cd->output[cd->next_avail_output_samples]);
212243
cd->next_avail_output_samples++;
213244
}
214-
for (int i = 0; i < samples_to_process; ++i) {
245+
for (size_t i = 0; i < samples_to_process; ++i) {
215246
cd->input[cd->input_samples++] = convert_int32_to_float(src[i]);
216247
if (cd->input_samples == cd->chunk_frames * n_ch) {
217248
GoogleCtcAudioProcessingProcess(cd->state, cd->input, cd->output,
@@ -227,12 +258,13 @@ static void ctc_s32_default(struct google_ctc_audio_processing_comp_data *cd,
227258
}
228259
}
229260
}
230-
if (written_samples > 0) {
231-
dest = audio_stream_wrap(sink, dest + written_samples);
232-
output_buffers->size += audio_stream_frame_bytes(sink) * written_samples / n_ch;
261+
262+
ret = source_release_data(source, samples_to_process * sizeof(int32_t));
263+
if (ret) {
264+
sink_commit_buffer(sink, written_samples * sizeof(int32_t));
265+
return ret;
233266
}
234-
src = audio_stream_wrap(source, src + samples_to_process);
235-
input_buffers->consumed += audio_stream_frame_bytes(source) * samples_to_process / n_ch;
267+
return sink_commit_buffer(sink, written_samples * sizeof(int32_t));
236268
}
237269
#endif
238270

@@ -345,20 +377,21 @@ static int ctc_prepare(struct processing_module *mod,
345377
{
346378
struct google_ctc_audio_processing_comp_data *cd = module_get_private_data(mod);
347379
struct comp_dev *dev = mod->dev;
348-
struct comp_buffer *source;
349-
int num_channels;
380+
struct sof_source *source;
381+
unsigned int num_channels;
350382
uint8_t *config;
351383
int config_size;
352384

353385
comp_info(mod->dev, "entry");
354386

355-
source = comp_dev_get_first_data_producer(dev);
356-
if (!source) {
357-
comp_err(dev, "no source buffer");
387+
if (!num_of_sources || !num_of_sinks) {
388+
comp_err(dev, "no source or sink buffer");
358389
return -ENOTCONN;
359390
}
360391

361-
switch (audio_stream_get_frm_fmt(&source->stream)) {
392+
source = sources[0];
393+
394+
switch (source_get_frm_fmt(source)) {
362395
#if CONFIG_FORMAT_S16LE
363396
case SOF_IPC_FRAME_S16_LE:
364397
cd->ctc_func = ctc_s16_default;
@@ -379,8 +412,8 @@ static int ctc_prepare(struct processing_module *mod,
379412
return -EINVAL;
380413
}
381414

382-
num_channels = audio_stream_get_channels(&source->stream);
383-
if (num_channels > kMaxChannels) {
415+
num_channels = source_get_channels(source);
416+
if (num_channels > (unsigned int)kMaxChannels) {
384417
comp_err(mod->dev, "invalid number of channels");
385418
return -EINVAL;
386419
}
@@ -394,7 +427,7 @@ static int ctc_prepare(struct processing_module *mod,
394427
config_size = 0;
395428
}
396429
cd->state = GoogleCtcAudioProcessingCreateWithConfig(cd->chunk_frames,
397-
audio_stream_get_rate(&source->stream),
430+
source_get_rate(source),
398431
config,
399432
config_size);
400433
if (!cd->state) {
@@ -423,16 +456,16 @@ static int ctc_reset(struct processing_module *mod)
423456
}
424457

425458
static int ctc_process(struct processing_module *mod,
426-
struct input_stream_buffer *input_buffers,
427-
int num_input_buffers,
428-
struct output_stream_buffer *output_buffers,
429-
int num_output_buffers)
459+
struct sof_source **sources,
460+
int num_of_sources,
461+
struct sof_sink **sinks,
462+
int num_of_sinks)
430463
{
431464
struct google_ctc_audio_processing_comp_data *cd = module_get_private_data(mod);
432-
struct audio_stream *source = input_buffers[0].data;
433-
struct audio_stream *sink = output_buffers[0].data;
434-
uint32_t frames = input_buffers[0].size;
435-
465+
struct sof_source *source = sources[0];
466+
struct sof_sink *sink = sinks[0];
467+
size_t frames = MIN(source_get_data_frames_available(source),
468+
sink_get_free_frames(sink));
436469
int ret;
437470

438471
comp_dbg(mod->dev, "entry");
@@ -443,14 +476,13 @@ static int ctc_process(struct processing_module *mod,
443476
return ret;
444477
}
445478

446-
cd->ctc_func(cd, source, sink, &input_buffers[0], &output_buffers[0], frames);
447-
return 0;
479+
return cd->ctc_func(cd, source, sink, frames);
448480
}
449481

450482
static const struct module_interface google_ctc_audio_processing_interface = {
451483
.init = ctc_init,
452484
.free = ctc_free,
453-
.process_audio_stream = ctc_process,
485+
.process = ctc_process,
454486
.prepare = ctc_prepare,
455487
.set_configuration = ctc_set_config,
456488
.get_configuration = ctc_get_config,

‎src/audio/google/google_ctc_audio_processing.h‎

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -22,12 +22,10 @@
2222

2323
struct google_ctc_audio_processing_comp_data;
2424

25-
typedef void (*ctc_func)(struct google_ctc_audio_processing_comp_data *cd,
26-
const struct audio_stream *source,
27-
struct audio_stream *sink,
28-
struct input_stream_buffer *input_buffers,
29-
struct output_stream_buffer *output_buffers,
30-
uint32_t frames);
25+
typedef int (*ctc_func)(struct google_ctc_audio_processing_comp_data *cd,
26+
struct sof_source *source,
27+
struct sof_sink *sink,
28+
size_t frames);
3129

3230
struct google_ctc_audio_processing_comp_data {
3331
float *input;

0 commit comments

Comments
 (0)