summaryrefslogtreecommitdiffstats
path: root/audio/out/internal.h
blob: 7951b3861ed446b3f48c38737ca26e428ebbb2cc (plain)
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
/*
 * This file is part of mpv.
 *
 * mpv is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * mpv is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with mpv.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef MP_AO_INTERNAL_H_
#define MP_AO_INTERNAL_H_

#include <stdatomic.h>
#include <stdbool.h>

#include "audio/out/ao.h"

/* global data used by ao.c and ao drivers */
struct ao {
    int samplerate;
    struct mp_chmap channels;
    int format;                 // one of AF_FORMAT_...
    int bps;                    // bytes per second (per plane)
    int sstride;                // size of a sample on each plane
                                // (format_size*num_channels/num_planes)
    int num_planes;
    bool probing;               // if true, don't fail loudly on init
    bool untimed;               // don't assume realtime playback
    int device_buffer;          // device buffer in samples (guessed by
                                // common init code if not set by driver)
    const struct ao_driver *driver;
    bool driver_initialized;
    void *priv;
    struct mpv_global *global;
    struct encode_lavc_context *encode_lavc_ctx;
    void (*wakeup_cb)(void *ctx);
    void *wakeup_ctx;
    struct mp_log *log; // Using e.g. "[ao/coreaudio]" as prefix
    int init_flags; // AO_INIT_* flags
    bool stream_silence;        // if audio inactive, just play silence

    // The device as selected by the user, usually using ao_device_desc.name
    // from an entry from the list returned by driver->list_devices. If the
    // default device should be used, this is set to NULL.
    char *device;

    // Application name to report to the audio API.
    char *client_name;

    // Used during init: if init fails, redirect to this ao
    char *redirect;

    // Internal events (use ao_request_reload(), ao_hotplug_event())
    atomic_uint events_;

    // Float gain multiplicator
    _Atomic float gain;

    int buffer;
    double def_buffer;
    struct buffer_state *buffer_state;
};

void init_buffer_pre(struct ao *ao);
bool init_buffer_post(struct ao *ao);

struct mp_pcm_state {
    // Note: free_samples+queued_samples <= ao->device_buffer; the sum may be
    //       less if the audio API can report partial periods played, while
    //       free_samples should be period-size aligned. If free_samples is not
    //       period-size aligned, the AO thread might get into a situation where
    //       it writes a very small number of samples in each iteration, leading
    //       to extremely inefficient behavior.
    //       Keep in mind that write() may write less than free_samples (or your
    //       period size alignment) anyway.
    int free_samples;       // number of free space in ring buffer
    int queued_samples;     // number of samples to play in ring buffer
    double delay;           // total latency in seconds (includes queued_samples)
    bool playing;           // set if underlying API is actually playing audio;
                            // the AO must unset it on underrun (accidental
                            // underrun and EOF are indistinguishable; the upper
                            // layers decide what it was)
                            // real pausing may assume playing=true
};

/* Note:
 *
 * In general, there are two types of audio drivers:
 *  a) push based (the user queues data that should be played)
 *  b) pull callback based (the audio API calls a callback to get audio)
 *
 * The ao.c code can handle both. It basically implements two audio paths
 * and provides a uniform API for them. If ao_driver->write is NULL, it assumes
 * that the driver uses a callback based audio API, otherwise push based.
 *
 * Requirements:
 *  a+b) Mandatory for both types:
 *          init
 *          uninit
 *          start
 *     Optional for both types:
 *          control
 *  a) ->write is called to queue audio. push.c creates a thread to regularly
 *     refill audio device buffers with ->write, but all driver functions are
 *     always called under an exclusive lock.
 *     Mandatory:
 *          reset
 *          write
 *          get_state
 *     Optional:
 *          set_pause
 *  b) ->write must be NULL. ->start must be provided, and should make the
 *     audio API start calling the audio callback. Your audio callback should
 *     in turn call ao_read_data() to get audio data. Most functions are
 *     optional and will be emulated if missing (e.g. pausing is emulated as
 *     silence).
 *     Also, the following optional callbacks can be provided:
 *          reset       (stops the audio callback, start() restarts it)
 */
struct ao_driver {
    // If true, use with encoding only.
    bool encode;
    // Name used for --ao.
    const char *name;
    // Description shown with --ao=help.
    const char *description;
    // This requires waiting for a AO_EVENT_INITIAL_UNBLOCK event before the
    // first write() call is done. Encode mode uses this, and push mode
    // respects it automatically (don't use with pull mode).
    bool initially_blocked;
    // If true, write units of entire frames. The write() call is modified to
    // use data==mp_aframe. Useful for encoding AO only.
    bool write_frames;
    // Init the device using ao->format/ao->channels/ao->samplerate. If the
    // device doesn't accept these parameters, you can attempt to negotiate
    // fallback parameters, and set the ao format fields accordingly.
    int (*init)(struct ao *ao);
    // Optional. See ao_control() etc. in ao.c
    int (*control)(struct ao *ao, enum aocontrol cmd, void *arg);
    void (*uninit)(struct ao *ao);
    // Stop all audio playback, clear buffers, back to state after init().
    // Optional for pull AOs.
    void (*reset)(struct ao *ao);
    // push based: set pause state. Only called after start() and before reset().
    //             returns success (this is intended for paused=true; if it
    //             returns false, playback continues, and the core emulates via
    //             reset(); unpausing always works)
    //             The pausing state is also cleared by reset().
    bool (*set_pause)(struct ao *ao, bool paused);
    // pull based: start the audio callback
    // push based: start playing queued data
    //             AO should call ao_wakeup_playthread() if a period boundary
    //             is crossed, or playback stops due to external reasons
    //             (including underruns or device removal)
    //             must set mp_pcm_state.playing; unset on error/underrun/end
    void (*start)(struct ao *ao);
    // push based: queue new data. This won't try to write more data than the
    // reported free space (samples <= mp_pcm_state.free_samples).
    // This must NOT start playback. start() does that, and write() may be
    // called multiple times before start() is called. It may also happen that
    // reset() is called to discard the buffer. start() without write() will
    // immediately reported an underrun.
    // Return false on failure.
    bool (*write)(struct ao *ao, void **data, int samples);
    // push based: return mandatory stream information
    void (*get_state)(struct ao *ao, struct mp_pcm_state *state);

    // Return the list of devices currently available in the system. Use
    // ao_device_list_add() to add entries. The selected device will be set as
    // ao->device (using ao_device_desc.name).
    // Warning: the ao struct passed is not initialized with ao_driver->init().
    //          Instead, hotplug_init/hotplug_uninit is called. If these
    //          callbacks are not set, no driver initialization call is done
    //          on the ao struct.
    void (*list_devs)(struct ao *ao, struct ao_device_list *list);

    // If set, these are called before/after ao_driver->list_devs is called.
    // It is also assumed that the driver can do hotplugging - which means
    // it is expected to call ao_hotplug_event(ao) whenever the system's
    // audio device list changes. The player will then call list_devs() again.
    int (*hotplug_init)(struct ao *ao);
    void (*hotplug_uninit)(struct ao *ao);

    // For option parsing (see vo.h)
    int priv_size;
    const void *priv_defaults;
    const struct m_option *options;
    const char *options_prefix;
    const struct m_sub_options *global_opts;
};

// These functions can be called by AOs.

int ao_read_data(struct ao *ao, void **data, int samples, int64_t out_time_ns);
MP_WARN_UNUSED_RESULT
int ao_read_data_nonblocking(struct ao *ao, void **data, int samples, int64_t out_time_ns);

bool ao_chmap_sel_adjust(struct ao *ao, const struct mp_chmap_sel *s,
                         struct mp_chmap *map);
bool ao_chmap_sel_adjust2(struct ao *ao, const struct mp_chmap_sel *s,
                          struct mp_chmap *map, bool safe_multichannel);
bool ao_chmap_sel_get_def(struct ao *ao, const struct mp_chmap_sel *s,
                          struct mp_chmap *map, int num);

// Add a deep copy of e to the list.
// Call from ao_driver->list_devs callback only.
void ao_device_list_add(struct ao_device_list *list, struct ao *ao,
                        struct ao_device_desc *e);

void ao_post_process_data(struct ao *ao, void **data, int num_samples);

struct ao_convert_fmt {
    int src_fmt;        // source AF_FORMAT_*
    int channels;       // number of channels
    int dst_bits;       // total target data sample size
    int pad_msb;        // padding in the MSB (i.e. required shifting)
    int pad_lsb;        // padding in LSB (required 0 bits) (ignored)
};

bool ao_can_convert_inplace(struct ao_convert_fmt *fmt);
bool ao_need_conversion(struct ao_convert_fmt *fmt);
void ao_convert_inplace(struct ao_convert_fmt *fmt, void **data, int num_samples);

void ao_wakeup_playthread(struct ao *ao);

int ao_read_data_converted(struct ao *ao, struct ao_convert_fmt *fmt,
                           void **data, int samples, int64_t out_time_ns);

#endif