audio_stream.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2020 - 2023 Intel Corporation. All rights reserved.
 *
 * Author: Karol Trzcinski <karolx.trzcinski@linux.intel.com>
 *     Adrian Warecki <adrian.warecki@intel.com>
 */
 
#ifndef __MODULE_AUDIO_AUDIO_STREAM_H__
#define __MODULE_AUDIO_AUDIO_STREAM_H__
 
#include <stdint.h>
#include <stdbool.h>
#include <rtos/panic.h>
#include "../ipc/stream.h"
 
enum sof_audio_buffer_state {
    AUDIOBUF_STATE_INITIAL,         /* Initial state, hw params not configured. */
    AUDIOBUF_STATE_READY,           /* Stream ready, hw params configured */
    AUDIOBUF_STATE_END_OF_STREAM,       /* Detected End Of Stream */
    AUDIOBUF_STATE_END_OF_STREAM_FLUSH, /* Detected End Of Stream, generating silence
                         * to flush buffers in dp modules.
                         */
};
 
struct sof_audio_stream_params {
    uint32_t id;
    uint32_t pipeline_id;
    enum sof_ipc_frame frame_fmt;   
    enum sof_ipc_frame valid_sample_fmt;
 
    uint32_t rate;      
    uint16_t channels;  
    uint16_t align_frame_cnt;
 
    uint16_t align_shift_idx;
 
    bool overrun_permitted; 
    bool underrun_permitted; 
    uint32_t buffer_fmt; 
    uint16_t chmap[SOF_IPC_MAX_CHANNELS];   
    enum sof_audio_buffer_state state;  
};
 
static inline size_t circ_buf_frames_without_wrap(const void *began, const void *end,
                          size_t sample_bytes, size_t channels)
{
    assert(sample_bytes > 0);
    assert(channels > 0);
    assert((const char *)end >= (const char *)began);
 
    return ((const char *)end - (const char *)began) / sample_bytes / channels;
}
 
struct cir_buf_source {
    const void *buf_start;  
    const void *buf_end;    
    const void *ptr;    
};
 
struct cir_buf_sink {
    void *buf_start;    
    void *buf_end;      
    void *ptr;      
};
 
static inline size_t cir_buf_samples_to_wrap_s16(const int16_t *ptr, const int16_t *buf_start,
                         size_t buf_samples)
{
    const int16_t *const buf_end = buf_start + buf_samples;
 
    assert(buf_end >= ptr);
 
    return buf_end - ptr;
}
 
static inline size_t cir_buf_samples_to_wrap_s32(const int32_t *ptr, const int32_t *buf_start,
                         size_t buf_samples)
{
    const int32_t *const buf_end = buf_start + buf_samples;
 
    assert(buf_end >= ptr);
 
    return buf_end - ptr;
}
 
static inline size_t cir_buf_samples_without_wrap_s16(const void *ptr, const void *buf_end)
{
    size_t to_end = (const int16_t *)buf_end - (const int16_t *)ptr;
 
    assert((uintptr_t)buf_end >= (uintptr_t)ptr);
    return to_end;
}
 
static inline size_t cir_buf_samples_without_wrap_s32(const void *ptr, const void *buf_end)
{
    size_t to_end = (const int32_t *)buf_end - (const int32_t *)ptr;
 
    assert((uintptr_t)buf_end >= (uintptr_t)ptr);
    return to_end;
}
 
static inline size_t cir_buf_bytes_without_wrap(const void *ptr, const void *buf_end)
{
    assert((uintptr_t)buf_end >= (uintptr_t)ptr);
    return (uintptr_t)buf_end - (uintptr_t)ptr;
}
 
static inline void *cir_buf_wrap(const void *ptr, const void *buf_addr, const void *buf_end)
{
    if (ptr >= buf_end)
        ptr = (const char *)buf_addr +
            ((const char *)ptr - (const char *)buf_end);
 
    assert((uintptr_t)ptr <= (uintptr_t)buf_end);
 
    return (void *)ptr;
}
 
static inline const void *source_cir_buf_wrap(const void *ptr, const void *buf_addr,
                          const void *buf_end)
{
    if (ptr >= buf_end)
        ptr = (const char *)buf_addr +
            ((const char *)ptr - (const char *)buf_end);
 
    assert((uintptr_t)ptr <= (uintptr_t)buf_end);
 
    return ptr;
}
 
static inline size_t cir_buf_bytes_without_wrap_rewind(const void *ptr, const void *buf_start)
{
    assert((uintptr_t)ptr >= (uintptr_t)buf_start);
 
    return (uintptr_t)ptr - (uintptr_t)buf_start;
}
 
static inline const void *source_cir_buf_rewind_wrap(const void *ptr, const void *buf_start,
                             const void *buf_end)
{
    if (ptr < buf_start)
        ptr = (const char *)buf_end - ((const char *)buf_start - (const char *)ptr);
 
    assert((uintptr_t)ptr >= (uintptr_t)buf_start);
 
    return ptr;
}
 
#endif /* __MODULE_AUDIO_AUDIO_STREAM_H__ */