sink_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_SINK_API_H__
#define __MODULE_AUDIO_SINK_API_H__
 
#include <errno.h>
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
 
#include "audio_stream.h"
#include "format.h"
 
/* forward def */
struct sof_sink;
struct sof_audio_stream_params;
struct sof_ipc_stream_params;
struct processing_module;
 
struct sink_ops {
    size_t (*get_free_size)(struct sof_sink *sink);
 
    int (*get_buffer)(struct sof_sink *sink, size_t req_size,
              void **data_ptr, void **buffer_start, size_t *buffer_size);
 
    int (*commit_buffer)(struct sof_sink *sink, size_t commit_size);
 
    uint32_t (*get_lft)(struct sof_sink *sink);
 
    int (*get_state)(struct sof_sink *sink);
 
    int (*on_audio_format_set)(struct sof_sink *sink);
 
    int (*audio_set_ipc_params)(struct sof_sink *sink,
                    struct sof_ipc_stream_params *params, bool force_update);
 
    int (*set_alignment_constants)(struct sof_sink *sink,
                       const uint32_t byte_align,
                       const uint32_t frame_align_req);
 
    int (*set_size)(struct sof_sink *sink, size_t size);
 
    int (*on_bind)(struct sof_sink *sink, struct processing_module *module);
    int (*on_unbind)(struct sof_sink *sink);
};
 
struct sof_sink {
    const struct sink_ops *ops;   
    size_t requested_write_frag_size; 
    size_t num_of_bytes_processed;    
    size_t min_free_space;        
    struct processing_module *bound_module; /* a pointer module that is using sink API */
    struct sof_audio_stream_params *audio_stream_params; 
};
 
static inline size_t sink_get_free_size(struct sof_sink *sink)
{
    return sink->ops->get_free_size(sink);
}
 
static inline size_t sink_get_free_frames_aligned(struct sof_sink *sink)
{
    return (sink_get_free_size(sink) >> sink->audio_stream_params->align_shift_idx) *
        sink->audio_stream_params->align_frame_cnt;
}
 
static inline enum sof_ipc_frame sink_get_frm_fmt(struct sof_sink *sink)
{
    return sink->audio_stream_params->frame_fmt;
}
 
static inline uint32_t sink_get_channels(struct sof_sink *sink)
{
    return sink->audio_stream_params->channels;
}
 
size_t sink_get_frame_bytes(struct sof_sink *sink);
 
size_t sink_get_free_frames(struct sof_sink *sink);
 
int sink_get_buffer(struct sof_sink *sink, size_t req_size, void **data_ptr, void **buffer_start,
            size_t *buffer_size);
 
int sink_get_buffer_s16(struct sof_sink *sink, size_t req_size, int16_t **data_ptr,
            int16_t **buffer_start, size_t *buffer_samples);
 
int sink_get_buffer_s32(struct sof_sink *sink, size_t req_size, int32_t **data_ptr,
            int32_t **buffer_start, size_t *buffer_samples);
 
int sink_commit_buffer(struct sof_sink *sink, size_t commit_size);
 
int sink_set_frm_fmt(struct sof_sink *sink, enum sof_ipc_frame frame_fmt);
 
static inline enum sof_ipc_frame sink_get_valid_fmt(struct sof_sink *sink)
{
    return sink->audio_stream_params->valid_sample_fmt;
}
 
static inline uint32_t sink_get_rate(struct sof_sink *sink)
{
    return sink->audio_stream_params->rate;
}
 
static inline uint32_t sink_get_buffer_fmt(struct sof_sink *sink)
{
    return sink->audio_stream_params->buffer_fmt;
}
 
int sink_set_params(struct sof_sink *sink, struct sof_ipc_stream_params *params, bool force_update);
 
int sink_set_alignment_constants(struct sof_sink *sink,
                 const uint32_t byte_align,
                 const uint32_t frame_align_req);
 
int sink_set_size(struct sof_sink *sink, size_t size);
 
int sink_set_valid_fmt(struct sof_sink *sink, enum sof_ipc_frame valid_sample_fmt);
int sink_set_rate(struct sof_sink *sink, unsigned int rate);
int sink_set_channels(struct sof_sink *sink, unsigned int channels);
int sink_set_buffer_fmt(struct sof_sink *sink, uint32_t buffer_fmt);
int sink_set_overrun(struct sof_sink *sink, bool overrun_permitted);
int sink_set_params(struct sof_sink *sink, struct sof_ipc_stream_params *params, bool force_update);
 
static inline size_t sink_get_min_free_space(struct sof_sink *sink)
{
    return sink->min_free_space;
}
 
static inline uint32_t sink_get_id(struct sof_sink *sink)
{
    return sink->audio_stream_params->id;
}
 
static inline uint32_t sink_get_pipeline_id(struct sof_sink *sink)
{
    return sink->audio_stream_params->pipeline_id;
}
 
static inline int sink_get_state(struct sof_sink *sink)
{
    if (!sink->ops->get_state)
        return 0; /* COMP_STATE_NOT_EXIST */
 
    return sink->ops->get_state(sink);
}
 
static inline int sink_bind(struct sof_sink *sink, struct processing_module *module)
{
    int ret = 0;
 
    if (sink->bound_module)
        return -EBUSY;
 
    if (sink->ops->on_bind)
        ret = sink->ops->on_bind(sink, module);
 
    if (!ret)
        sink->bound_module = module;
 
    return ret;
}
 
static inline int sink_unbind(struct sof_sink *sink)
{
    int ret = 0;
 
    if (!sink->bound_module)
        return -EINVAL;
 
    if (sink->ops->on_unbind)
        ret = sink->ops->on_unbind(sink);
 
    if (!ret)
        sink->bound_module = NULL;
 
    return ret;
}
 
static inline struct processing_module *sink_get_bound_module(struct sof_sink *sink)
{
    return sink->bound_module;
}
 
static inline uint32_t sink_get_last_feeding_time(struct sof_sink *sink)
{
    return sink->ops->get_lft(sink);
}
 
#endif /* __MODULE_AUDIO_SINK_API_H__ */