include/xas/audio.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

#ifndef _XAS_AUDIO_H
#define _XAS_AUDIO_H

#include <stdint.h>
#include <sys/types.h>

#define XAS_AUDIO_PCM_8_BIT  1
#define XAS_AUDIO_PCM_16_BIT 2

#define XAS_AUDIO_MONO   1
#define XAS_AUDIO_STEREO 2

#define XAS_AUDIO_STEREO_LEFT  0
#define XAS_AUDIO_STEREO_RIGHT 1

enum xas_audio_stream_type {
    XAS_AUDIO_STREAM_SINK,
    XAS_AUDIO_STREAM_SOURCE
};

typedef struct _xas_audio_stream xas_audio_stream;

typedef ssize_t (*xas_audio_drain)(void *ctx, void *samples, size_t count);

typedef ssize_t (*xas_audio_fill)(void *ctx, void *samples, size_t count);

typedef void (*xas_audio_cleanup)(void *ctx);

typedef struct _xas_audio_format {
    size_t channels,
           sample_size,
           sample_rate;
} xas_audio_format;

struct _xas_audio_stream {
    enum xas_audio_stream_type type;

    xas_audio_format format;

    size_t buffer_size,
           buffer_count;

    union {
        void *callback;
        xas_audio_drain drain;
        xas_audio_fill  fill;
    };

    xas_audio_cleanup cleanup;

    void *ctx;
};

int xas_audio_format_eq(xas_audio_format a, xas_audio_format b);

xas_audio_format xas_audio_format_mono(xas_audio_format format);

void xas_audio_zero(xas_audio_format format,
                      void *dest,
                      size_t index,
                      size_t count);

void xas_audio_copy(xas_audio_format format,
                      void *dest,
                      void *src,
                      size_t index_dest,
                      size_t index_src,
                      size_t count);

void xas_audio_apply_gain(xas_audio_format format,
                            void *dest,
                            float gain,
                            size_t index,
                            size_t count);

xas_audio_stream *xas_audio_stream_new_sink(xas_audio_drain drain,
                                                xas_audio_cleanup cleanup,
                                                xas_audio_format format,
                                                size_t buffer_size,
                                                void *ctx);

xas_audio_stream *xas_audio_stream_new_source(xas_audio_fill fill,
                                                  xas_audio_cleanup cleanup,
                                                  xas_audio_format format,
                                                  size_t buffer_size,
                                                  void *ctx);

void xas_audio_stream_destroy(xas_audio_stream *stream);

void *xas_audio_stream_buffer(xas_audio_stream *stream);

ssize_t xas_audio_stream_write(xas_audio_stream *sink,
                                 void *samples,
                                 size_t count);

int xas_audio_stream_flush(xas_audio_stream *stream);

ssize_t xas_audio_stream_read(xas_audio_stream *source,
                                void **samples,
                                size_t count);

#endif /* _XAS_AUDIO_H */