audio_buffer.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2023 Intel Corporation. All rights reserved.
 *
 */
#ifndef __SOF_AUDIO_BUFFER__
#define __SOF_AUDIO_BUFFER__
 
#include <sof/common.h>
#include <ipc/topology.h>
#include <sof/coherent.h>
#include <sof/audio/sink_api.h>
#include <sof/audio/source_api.h>
 
#define BUFFER_TYPE_LEGACY_BUFFER 1 
#define BUFFER_TYPE_RING_BUFFER 2   
/* forward def */
struct sof_audio_buffer;
 
struct audio_buffer_ops {
    void (*free)(struct sof_audio_buffer *buffer);
 
    void (*reset)(struct sof_audio_buffer *buffer);
 
    int (*on_audio_format_set)(struct sof_audio_buffer *buffer);
 
    int (*audio_set_ipc_params)(struct sof_audio_buffer *buffer,
                    struct sof_ipc_stream_params *params, bool force_update);
 
    int (*set_alignment_constants)(struct sof_audio_buffer *buffer,
                       const uint32_t byte_align,
                       const uint32_t frame_align_req);
};
 
struct mod_alloc_ctx;
 
struct sof_audio_buffer {
    CORE_CHECK_STRUCT_FIELD;
 
    uint32_t buffer_type;   
    bool is_shared;     
#if CONFIG_PIPELINE_2_0
    struct sof_audio_buffer *secondary_buffer_sink;
 
    struct sof_audio_buffer *secondary_buffer_source;
 
#endif /* CONFIG_PIPELINE_2_0 */
 
    struct sof_audio_stream_params *audio_stream_params;
 
    /* private: */
    struct sof_source _source_api;  
    struct sof_sink _sink_api;      
    /* virtual methods */
    const struct audio_buffer_ops *ops; 
    bool walking;       
    struct mod_alloc_ctx *alloc;    
};
 
#if CONFIG_PIPELINE_2_0
int audio_buffer_attach_secondary_buffer(struct sof_audio_buffer *buffer, bool at_input,
                     struct sof_audio_buffer *secondary_buffer);
 
int audio_buffer_sync_secondary_buffer(struct sof_audio_buffer *buffer, size_t limit);
 
static inline
struct sof_sink *audio_buffer_get_sink(struct sof_audio_buffer *buffer)
{
    CORE_CHECK_STRUCT(buffer);
    return buffer->secondary_buffer_sink ?
            audio_buffer_get_sink(buffer->secondary_buffer_sink) :
            &buffer->_sink_api;
}
 
static inline
struct sof_source *audio_buffer_get_source(struct sof_audio_buffer *buffer)
{
    CORE_CHECK_STRUCT(buffer);
    return buffer->secondary_buffer_source ?
            audio_buffer_get_source(buffer->secondary_buffer_source) :
            &buffer->_source_api;
}
 
#else /* CONFIG_PIPELINE_2_0 */
 
static inline
struct sof_sink *audio_buffer_get_sink(struct sof_audio_buffer *buffer)
{
    CORE_CHECK_STRUCT(buffer);
    return &buffer->_sink_api;
}
 
static inline
struct sof_source *audio_buffer_get_source(struct sof_audio_buffer *buffer)
{
    CORE_CHECK_STRUCT(buffer);
    return &buffer->_source_api;
}
 
#endif /* CONFIG_PIPELINE_2_0 */
 
static inline bool audio_buffer_is_shared(struct sof_audio_buffer *buffer)
{
    return buffer->is_shared;
}
 
static inline bool audio_buffer_hw_params_configured(struct sof_audio_buffer *buffer)
{
    return buffer->audio_stream_params->state != AUDIOBUF_STATE_INITIAL;
}
 
static inline void audio_buffer_set_hw_params_configured(struct sof_audio_buffer *buffer)
{
    buffer->audio_stream_params->state = AUDIOBUF_STATE_READY;
}
 
static inline void audio_buffer_reset_params(struct sof_audio_buffer *buffer)
{
    buffer->audio_stream_params->state = AUDIOBUF_STATE_INITIAL;
}
 
static inline enum sof_audio_buffer_state audio_buffer_get_state(
    const struct sof_audio_buffer *buffer)
{
    return buffer->audio_stream_params->state;
}
 
static inline void audio_buffer_set_state(struct sof_audio_buffer *buffer,
                      enum sof_audio_buffer_state state)
{
    buffer->audio_stream_params->state = state;
}
 
static inline void audio_buffer_set_eos(struct sof_audio_buffer *buffer)
{
    buffer->audio_stream_params->state = AUDIOBUF_STATE_END_OF_STREAM;
}
 
static inline uint16_t audio_buffer_get_chmap(struct sof_audio_buffer *buffer, size_t index)
{
    return buffer->audio_stream_params->chmap[index];
}
 
static inline void audio_buffer_set_chmap(struct sof_audio_buffer *buffer, size_t index,
                      uint16_t value)
{
    buffer->audio_stream_params->chmap[index] = value;
}
 
static inline
struct sof_audio_stream_params *audio_buffer_get_stream_params(struct sof_audio_buffer *buffer)
{
    return buffer->audio_stream_params;
}
 
static inline struct sof_audio_buffer *sof_audio_buffer_from_sink(struct sof_sink *sink)
{
    return container_of(sink, struct sof_audio_buffer, _sink_api);
}
 
static inline struct sof_audio_buffer *sof_audio_buffer_from_source(struct sof_source *source)
{
    return container_of(source, struct sof_audio_buffer, _source_api);
}
 
void audio_buffer_init(struct sof_audio_buffer *buffer, uint32_t buffer_type, bool is_shared,
               const struct source_ops *source_ops, const struct sink_ops *sink_ops,
               const struct audio_buffer_ops *audio_buffer_ops,
               struct sof_audio_stream_params *audio_stream_params);
 
void audio_buffer_free(struct sof_audio_buffer *buffer);
 
static inline
void audio_buffer_reset(struct sof_audio_buffer *buffer)
{
    if (buffer->ops->reset)
        buffer->ops->reset(buffer);
 
#if CONFIG_PIPELINE_2_0
    if (buffer->secondary_buffer_sink && buffer->secondary_buffer_sink->ops->reset)
        buffer->secondary_buffer_sink->ops->reset(buffer->secondary_buffer_sink);
 
    if (buffer->secondary_buffer_source && buffer->secondary_buffer_source->ops->reset)
        buffer->secondary_buffer_source->ops->reset(buffer->secondary_buffer_source);
#endif
}
 
/* Audio-buffer wrappers for the source-sink API */
 
int audio_buffer_source_set_ipc_params(struct sof_source *source,
                       struct sof_ipc_stream_params *params, bool force_update);
 
int audio_buffer_source_on_audio_format_set(struct sof_source *source);
 
int audio_buffer_source_set_alignment_constants(struct sof_source *source,
                        const uint32_t byte_align,
                        const uint32_t frame_align_req);
 
int audio_buffer_sink_set_ipc_params(struct sof_sink *sink, struct sof_ipc_stream_params *params,
                     bool force_update);
 
int audio_buffer_sink_on_audio_format_set(struct sof_sink *sink);
 
int audio_buffer_sink_set_alignment_constants(struct sof_sink *sink,
                          const uint32_t byte_align,
                          const uint32_t frame_align_req);
 
uint32_t audio_buffer_sink_get_lft(struct sof_sink *sink);
 
#endif /* __SOF_AUDIO_BUFFER__ */