mfcc_comp.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2022-2026 Intel Corporation.
 *
 * Author: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
 */
 
#ifndef __SOF_AUDIO_MFCC_MFCC_COMP_H__
#define __SOF_AUDIO_MFCC_MFCC_COMP_H__
 
#include <sof/audio/module_adapter/module/generic.h>
#include <sof/audio/data_blob.h>
#include <sof/math/auditory.h>
#include <sof/math/dct.h>
#include <sof/math/fft.h>
#include <sof/audio/mfcc/mfcc_vad.h>
#include <sof/ipc/msg.h>
#include <stddef.h>
#include <stdint.h>
 
/* __XCC__ is both for xt_xcc and xt_clang */
#if defined(__XCC__)
# include <xtensa/config/core-isa.h>
# if XCHAL_HAVE_HIFI4 || XCHAL_HAVE_HIFI5
#  define MFCC_HIFI4
# elif XCHAL_HAVE_HIFI3
#  define MFCC_HIFI3
# else
#  define MFCC_GENERIC
# endif
#else
# define MFCC_GENERIC
#endif
 
#define MFCC_MAGIC 0x6d666363 /* ASCII for "mfcc" */
#define MFCC_FFT_BITS   32
#define MFCC_MAX_SAMPLE_RATE 64000 /* Max sample rate in Hz, limited by int16_t Mel scale */

#define MFCC_CTRL_INDEX_VAD 0

struct mfcc_data_header {
    uint32_t magic;     
    uint32_t frame_number;  
    int32_t reserved;   
    int32_t energy;     
    int32_t noise_energy;   
    int32_t vad_flag;   
};
 
struct mfcc_buffer {
    int16_t *addr;
    int16_t *end_addr;
    int16_t *r_ptr;
    int16_t *w_ptr;
    int s_avail; 
    int s_free; 
    int s_length; 
};
 
struct mfcc_pre_emph {
    int16_t coef;
    int16_t delay;
    int enable;
};

typedef void (*mfcc_source_func)(struct sof_source *source, struct mfcc_buffer *buf,
                 struct mfcc_pre_emph *emph, int frames, int source_channel);
 
struct mfcc_fft {
    struct icomplex32 *fft_buf; 
    struct icomplex32 *fft_out; 
    struct fft_plan *fft_plan;
    int fft_fill_start_idx; 
    int fft_size;
    int fft_padded_size;
    int fft_hop_size;
    int fft_buf_size;
    int half_fft_size;
    size_t fft_buffer_size; 
};
 
struct mfcc_cepstral_lifter {
    struct mat_matrix_16b *matrix;
    int16_t cepstral_lifter;
    int num_ceps;
};
 
struct mfcc_state {
    struct mfcc_buffer buf; 
    struct mfcc_pre_emph emph; 
    struct mfcc_fft fft; 
    struct dct_plan_16 dct; 
    struct psy_mel_filterbank melfb; 
    struct mfcc_cepstral_lifter lifter; 
    struct mat_matrix_16b *mel_spectra; 
    struct mat_matrix_16b *cepstral_coef; 
    int32_t *power_spectra; 
    int32_t *mel_log_32; 
    int32_t mmax; 
    int16_t buf_avail;
    int16_t *buffers;
    int16_t *prev_data; 
    int16_t *window; 
    int16_t *triangles;
    int source_channel;
    int buffer_size;
    int prev_data_size;
    int low_freq;
    int high_freq;
    int sample_rate;
    bool mel_only; 
    bool waiting_fill; 
    bool prev_samples_valid;
    bool header_pending; 
    struct mfcc_data_header header; 
    size_t sample_buffers_size; 
    int32_t *out_data_ptr; 
    int out_remain; 
    int32_t *out_stage; 
    int out_stage_size; 
    uint32_t hop_count; 
    int vad_silence_count; 
    int16_t dtx_trailing_silence; 
    int16_t dtx_silence_interval; 
    int dtx_silence_counter; 
};
 
/* MFCC component private data */
struct mfcc_comp_data {
    struct mfcc_state state;
    struct mfcc_vad_state vad;
    struct comp_data_blob_handler *model_handler;
    struct sof_mfcc_config *config;
    struct ipc_msg *msg;        
    int max_frames;
    enum sof_ipc_frame source_format;   
    bool vad_prev;          
    mfcc_source_func source_func;   
};
 
static inline int mfcc_buffer_samples_without_wrap(struct mfcc_buffer *buffer, int16_t *ptr)
{
    return buffer->end_addr - ptr;
}
 
static inline int16_t *mfcc_buffer_wrap(struct mfcc_buffer *buffer, int16_t *ptr)
{
    if (ptr >= buffer->end_addr)
        ptr -= buffer->s_length;
 
    return ptr;
}
 
int mfcc_setup(struct processing_module *mod, int max_frames, int rate, int channels);
 
void mfcc_free_buffers(struct processing_module *mod);
 
void mfcc_fill_prev_samples(struct mfcc_buffer *buf, int16_t *prev_data,
                int prev_data_length);
 
void mfcc_fill_fft_buffer(struct mfcc_state *state);
 
void mfcc_apply_window(struct mfcc_state *state, int input_shift);

int mfcc_stft_process(struct processing_module *mod, struct mfcc_comp_data *cd);

int mfcc_process_output(struct processing_module *mod, struct mfcc_comp_data *cd,
            struct sof_source **sources, struct sof_sink **sinks,
            int num_ceps, int frames);
 
#if CONFIG_FORMAT_S16LE
void mfcc_source_copy_s16(struct sof_source *source, struct mfcc_buffer *buf,
              struct mfcc_pre_emph *emph, int frames, int source_channel);
#endif
 
#if CONFIG_FORMAT_S24LE
void mfcc_source_copy_s24(struct sof_source *source, struct mfcc_buffer *buf,
              struct mfcc_pre_emph *emph, int frames, int source_channel);
#endif
 
#if CONFIG_FORMAT_S32LE
void mfcc_source_copy_s32(struct sof_source *source, struct mfcc_buffer *buf,
              struct mfcc_pre_emph *emph, int frames, int source_channel);
#endif
 
#if CONFIG_IPC_MAJOR_4
int mfcc_ipc_notification_init(struct processing_module *mod);
 
void mfcc_send_vad_notification(struct processing_module *mod, uint32_t val);
 
int mfcc_get_config(struct processing_module *mod,
            uint32_t config_id, uint32_t *data_offset_size,
            uint8_t *fragment, size_t fragment_size);
 
int mfcc_set_config(struct processing_module *mod, uint32_t config_id,
            enum module_cfg_fragment_position pos, uint32_t data_offset_size,
            const uint8_t *fragment, size_t fragment_size, uint8_t *response,
            size_t response_size);
 
#else
static inline int mfcc_ipc_notification_init(struct processing_module *mod)
{
    return 0;
}
 
static inline void mfcc_send_vad_notification(struct processing_module *mod, uint32_t val)
{
}
 
static inline int mfcc_get_config(struct processing_module *mod,
                  uint32_t config_id, uint32_t *data_offset_size,
                  uint8_t *fragment, size_t fragment_size)
{
    struct sof_ipc_ctrl_data *cdata = (struct sof_ipc_ctrl_data *)fragment;
    struct mfcc_comp_data *cd = module_get_private_data(mod);
 
    return comp_data_blob_get_cmd(cd->model_handler, cdata, fragment_size);
}
 
static inline int mfcc_set_config(struct processing_module *mod, uint32_t config_id,
                  enum module_cfg_fragment_position pos, uint32_t data_offset_size,
                  const uint8_t *fragment, size_t fragment_size, uint8_t *response,
                  size_t response_size)
{
    struct mfcc_comp_data *cd = module_get_private_data(mod);
 
    return comp_data_blob_set(cd->model_handler, pos, data_offset_size,
                  fragment, fragment_size);
}
#endif
 
#ifdef UNIT_TEST
void sys_comp_module_mfcc_interface_init(void);
#endif
 
#endif /* __SOF_AUDIO_MFCC_MFCC_COMP_H__ */