source_api.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2023 Intel Corporation. All rights reserved.
 *
 */
 
#ifndef __MODULE_AUDIO_SOURCE_API_H__
#define __MODULE_AUDIO_SOURCE_API_H__
 
#include <errno.h>
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
 
#include <sof/math/numbers.h>
 
#include "audio_stream.h"
#include "format.h"
 
 /* forward def */
struct sof_source;
struct sof_audio_stream_params;
struct sof_ipc_stream_params;
struct processing_module;
 
struct source_ops {
    size_t (*get_data_available)(struct sof_source *source);
 
    int (*get_data)(struct sof_source *source, size_t req_size,
            void const **data_ptr, void const **buffer_start, size_t *buffer_size);
 
    int (*release_data)(struct sof_source *source, size_t free_size);
 
    int (*get_state)(struct sof_source *source);
 
    int (*on_audio_format_set)(struct sof_source *source);
 
    int (*audio_set_ipc_params)(struct sof_source *source,
                    struct sof_ipc_stream_params *params, bool force_update);
 
    int (*set_alignment_constants)(struct sof_source *source,
                       const uint32_t byte_align,
                       const uint32_t frame_align_req);
 
    int (*set_size)(struct sof_source *source, size_t size);
 
    int (*on_bind)(struct sof_source *source, struct processing_module *module);
    int (*on_unbind)(struct sof_source *source);
};
 
struct sof_source {
    const struct source_ops *ops;
    size_t requested_read_frag_size; /* keeps size of data obtained by get_data() */
    size_t num_of_bytes_processed;   /* processed bytes counter */
    size_t min_available;        /* minimum data available required by the module using
                      * source
                      * it is module's IBS as declared in module bind IPC
                      */
    struct processing_module *bound_module; /* a pointer module that is using source API */
    struct sof_audio_stream_params *audio_stream_params;
};
 
static inline size_t source_get_data_available(struct sof_source *source)
{
    return source->ops->get_data_available(source);
}
 
static inline size_t source_get_aligned_frames_available(struct sof_source *source)
{
    return (source_get_data_available(source) >> source->audio_stream_params->align_shift_idx) *
        source->audio_stream_params->align_frame_cnt;
}
 
static inline enum sof_ipc_frame source_get_frm_fmt(struct sof_source *source)
{
    return source->audio_stream_params->frame_fmt;
}
 
static inline unsigned int source_get_channels(struct sof_source *source)
{
    return source->audio_stream_params->channels;
}
 
size_t source_get_frame_bytes(struct sof_source *source);
 
size_t source_get_data_frames_available(struct sof_source *source);
 
int source_get_data(struct sof_source *source, size_t req_size, void const **data_ptr,
            void const **buffer_start, size_t *buffer_size);
 
int source_get_data_s16(struct sof_source *source, size_t req_size, int16_t const **data_ptr,
            int16_t const **buffer_start, size_t *buffer_samples);
 
int source_get_data_s32(struct sof_source *source, size_t req_size, int32_t const **data_ptr,
            int32_t const **buffer_start, size_t *buffer_samples);
 
int source_release_data(struct sof_source *source, size_t free_size);
 
int source_set_size(struct sof_source *source, size_t size);
 
static inline enum sof_ipc_frame source_get_valid_fmt(struct sof_source *source)
{
    return source->audio_stream_params->valid_sample_fmt;
}
 
static inline unsigned int source_get_rate(struct sof_source *source)
{
    return source->audio_stream_params->rate;
}
 
static inline uint32_t source_get_buffer_fmt(struct sof_source *source)
{
    return source->audio_stream_params->buffer_fmt;
}
 
static inline size_t source_get_min_available(struct sof_source *source)
{
    return source->min_available;
}
 
static inline uint32_t source_get_id(struct sof_source *source)
{
    return source->audio_stream_params->id;
}
 
static inline uint32_t source_get_pipeline_id(struct sof_source *source)
{
    return source->audio_stream_params->pipeline_id;
}
 
static inline int source_bind(struct sof_source *source, struct processing_module *module)
{
    int ret = 0;
 
    if (source->bound_module)
        return -EBUSY;
 
    if (source->ops->on_bind)
        ret = source->ops->on_bind(source, module);
 
    if (!ret)
        source->bound_module = module;
 
    return ret;
}
 
static inline int source_unbind(struct sof_source *source)
{
    int ret = 0;
 
    if (!source->bound_module)
        return -EINVAL;
 
    if (source->ops->on_unbind)
        ret = source->ops->on_unbind(source);
 
    if (!ret)
        source->bound_module = NULL;
 
    return ret;
}
 
static inline struct processing_module *source_get_bound_module(struct sof_source *source)
{
    return source->bound_module;
}
 
static inline enum sof_audio_buffer_state source_get_state(const struct sof_source *source)
{
    return source->audio_stream_params->state;
}
 
static inline int source_get_comp_state(struct sof_source *source)
{
    if (!source->ops->get_state)
        return 0; /* COMP_STATE_NOT_EXIST */
 
    return source->ops->get_state(source);
}
 
static inline uint32_t source_align_frames_round_up(struct sof_source *source, uint32_t frames)
{
    uint16_t align = source->audio_stream_params->align_frame_cnt;
 
    if (align <= 1)
        return frames;
 
    return ROUND_UP(frames, align);
}
 
static inline uint32_t source_align_frames_round_down(struct sof_source *source, uint32_t frames)
{
    uint16_t align = source->audio_stream_params->align_frame_cnt;
 
    if (align <= 1)
        return frames;
 
    return ROUND_DOWN(frames, align);
}
 
static inline uint32_t source_align_frames_round_nearest(struct sof_source *source, uint32_t frames)
{
    uint16_t align = source->audio_stream_params->align_frame_cnt;
 
    if (!align)
        return frames;
 
    return ROUND_DOWN(frames + (align >> 1), align);
}
 
#endif /* __MODULE_AUDIO_SOURCE_API_H__ */