struct aout_sys_t
{
audio_output_t *aout;
- aout_api_t *api; /**< Audio output back-end API */
+ aout_stream_t *stream; /**< Underlying audio output stream */
IMMDeviceEnumerator *it; /**< Device enumerator, NULL when exiting */
/*TODO: IMMNotificationClient*/
EnterMTA();
EnterCriticalSection(&sys->lock);
- hr = aout_api_TimeGet(sys->api, delay);
+ hr = aout_stream_TimeGet(sys->stream, delay);
LeaveCriticalSection(&sys->lock);
LeaveMTA();
EnterMTA();
EnterCriticalSection(&sys->lock);
- hr = aout_api_Play(sys->api, block);
+ hr = aout_stream_Play(sys->stream, block);
LeaveCriticalSection(&sys->lock);
LeaveMTA();
EnterMTA();
EnterCriticalSection(&sys->lock);
- hr = aout_api_Pause(sys->api, paused);
+ hr = aout_stream_Pause(sys->stream, paused);
LeaveCriticalSection(&sys->lock);
LeaveMTA();
if (wait)
{ /* Loosy drain emulation */
- if (FAILED(aout_api_TimeGet(sys->api, &delay)))
+ if (FAILED(aout_stream_TimeGet(sys->stream, &delay)))
delay = VLC_TS_INVALID;
}
else
- aout_api_Flush(sys->api);
+ aout_stream_Flush(sys->stream);
LeaveCriticalSection(&sys->lock);
LeaveMTA();
static int DeviceChanged(vlc_object_t *obj, const char *varname,
vlc_value_t prev, vlc_value_t cur, void *data)
{
- /* FIXME: This does not work. sys->dev, sys->manager and sys->api must be
+ /* FIXME: This does not work. sys->dev, ->manager and ->stream must be
* recreated. Those pointers are protected by the aout lock, which
* serializes accesses to the audio_output_t. Unfortunately,
* aout lock cannot be taken from a variable callback.
{
aout_sys_t *sys = aout->sys;
- assert (sys->api == NULL);
+ assert (sys->stream == NULL);
if (sys->dev == NULL)
return -1;
EnterMTA();
EnterCriticalSection(&sys->lock);
- sys->api = aout_api_Start(aout, fmt, sys->dev, &GUID_VLC_AUD_OUT);
+ sys->stream = aout_stream_Start(aout, fmt, sys->dev, &GUID_VLC_AUD_OUT);
LeaveCriticalSection(&sys->lock);
LeaveMTA();
- return (sys->api != NULL) ? 0 : -1;
+ return (sys->stream != NULL) ? 0 : -1;
}
static void Stop(audio_output_t *aout)
{
aout_sys_t *sys = aout->sys;
- assert (sys->api != NULL);
+ assert (sys->stream != NULL);
EnterMTA();
EnterCriticalSection(&sys->lock);
- aout_api_Stop(sys->api);
+ aout_stream_Stop(sys->stream);
LeaveCriticalSection(&sys->lock);
LeaveMTA();
- sys->api = NULL;
+ sys->stream = NULL;
}
static int Open(vlc_object_t *obj)
aout->sys = sys;
sys->aout = aout;
- sys->api = NULL;
+ sys->stream = NULL;
sys->it = NULL;
sys->session_events.lpVtbl = &vlc_AudioSessionEvents;
sys->refs = 1;
#ifndef VLC_AOUT_MMDEVICE_H
# define VLC_AOUT_MMDEVICE_H 1
-typedef struct aout_api aout_api_t;
+typedef struct aout_stream aout_stream_t;
/**
* Audio output simplified API for Windows
*/
-struct aout_api
+struct aout_stream
{
VLC_COMMON_MEMBERS
void *sys;
- HRESULT (*time_get)(aout_api_t *, mtime_t *);
- HRESULT (*play)(aout_api_t *, block_t *);
- HRESULT (*pause)(aout_api_t *, bool);
- HRESULT (*flush)(aout_api_t *);
+ HRESULT (*time_get)(aout_stream_t *, mtime_t *);
+ HRESULT (*play)(aout_stream_t *, block_t *);
+ HRESULT (*pause)(aout_stream_t *, bool);
+ HRESULT (*flush)(aout_stream_t *);
};
/**
* \param dev audio output device
* \param sid audio output session GUID [IN]
*/
-aout_api_t *aout_api_Start(vlc_object_t *parent, audio_sample_format_t *fmt,
- IMMDevice *dev, const GUID *sid);
-#define aout_api_Start(o,f,d,s) aout_api_Start(VLC_OBJECT(o),f,d,s)
+aout_stream_t *aout_stream_Start(vlc_object_t *parent,
+ audio_sample_format_t *fmt,
+ IMMDevice *dev, const GUID *sid);
+#define aout_stream_Start(o,f,d,s) aout_stream_Start(VLC_OBJECT(o),f,d,s)
/**
* Destroys an audio output stream.
*/
-void aout_api_Stop(aout_api_t *);
+void aout_stream_Stop(aout_stream_t *);
-static inline HRESULT aout_api_TimeGet(aout_api_t *api, mtime_t *delay)
+static inline HRESULT aout_stream_TimeGet(aout_stream_t *s, mtime_t *delay)
{
- return (api->time_get)(api, delay);
+ return (s->time_get)(s, delay);
}
-static inline HRESULT aout_api_Play(aout_api_t *api, block_t *block)
+static inline HRESULT aout_stream_Play(aout_stream_t *s, block_t *block)
{
- return (api->play)(api, block);
+ return (s->play)(s, block);
}
-static inline HRESULT aout_api_Pause(aout_api_t *api, bool paused)
+static inline HRESULT aout_stream_Pause(aout_stream_t *s, bool paused)
{
- return (api->pause)(api, paused);
+ return (s->pause)(s, paused);
}
-static inline HRESULT aout_api_Flush(aout_api_t *api)
+static inline HRESULT aout_stream_Flush(aout_stream_t *s)
{
- return (api->flush)(api);
+ return (s->flush)(s);
}
#endif
CoUninitialize();
}
-typedef struct aout_api_sys
+typedef struct aout_stream_sys
{
IAudioClient *client;
unsigned bytes_per_frame;
UINT32 written; /**< Frames written to the buffer */
UINT32 frames; /**< Total buffer size (frames) */
-} aout_api_sys_t;
+} aout_stream_sys_t;
/*** VLC audio output callbacks ***/
-static HRESULT TimeGet(aout_api_t *api, mtime_t *restrict delay)
+static HRESULT TimeGet(aout_stream_t *s, mtime_t *restrict delay)
{
- aout_api_sys_t *sys = api->sys;
+ aout_stream_sys_t *sys = s->sys;
void *pv;
UINT64 pos, qpcpos;
HRESULT hr;
hr = IAudioClock_GetPosition(clock, &pos, &qpcpos);
if (FAILED(hr))
- msg_Err(api, "cannot get position (error 0x%lx)", hr);
+ msg_Err(s, "cannot get position (error 0x%lx)", hr);
IAudioClock_Release(clock);
}
else
- msg_Err(api, "cannot get clock (error 0x%lx)", hr);
+ msg_Err(s, "cannot get clock (error 0x%lx)", hr);
if (SUCCEEDED(hr))
{
else
{
*delay = sys->written * CLOCK_FREQ / sys->rate;
- msg_Dbg(api, "extrapolating position: still propagating buffers");
+ msg_Dbg(s, "extrapolating position: still propagating buffers");
}
}
return hr;
}
-static HRESULT Play(aout_api_t *api, block_t *block)
+static HRESULT Play(aout_stream_t *s, block_t *block)
{
- aout_api_sys_t *sys = api->sys;
+ aout_stream_sys_t *sys = s->sys;
void *pv;
HRESULT hr;
hr = IAudioClient_GetService(sys->client, &IID_IAudioRenderClient, &pv);
if (FAILED(hr))
{
- msg_Err(api, "cannot get render client (error 0x%lx)", hr);
+ msg_Err(s, "cannot get render client (error 0x%lx)", hr);
goto out;
}
hr = IAudioClient_GetCurrentPadding(sys->client, &frames);
if (FAILED(hr))
{
- msg_Err(api, "cannot get current padding (error 0x%lx)", hr);
+ msg_Err(s, "cannot get current padding (error 0x%lx)", hr);
break;
}
hr = IAudioRenderClient_GetBuffer(render, frames, &dst);
if (FAILED(hr))
{
- msg_Err(api, "cannot get buffer (error 0x%lx)", hr);
+ msg_Err(s, "cannot get buffer (error 0x%lx)", hr);
break;
}
hr = IAudioRenderClient_ReleaseBuffer(render, frames, 0);
if (FAILED(hr))
{
- msg_Err(api, "cannot release buffer (error 0x%lx)", hr);
+ msg_Err(s, "cannot release buffer (error 0x%lx)", hr);
break;
}
IAudioClient_Start(sys->client);
return hr;
}
-static HRESULT Pause(aout_api_t *api, bool paused)
+static HRESULT Pause(aout_stream_t *s, bool paused)
{
- aout_api_sys_t *sys = api->sys;
+ aout_stream_sys_t *sys = s->sys;
HRESULT hr;
if (paused)
else
hr = IAudioClient_Start(sys->client);
if (FAILED(hr))
- msg_Warn(api, "cannot %s stream (error 0x%lx)",
+ msg_Warn(s, "cannot %s stream (error 0x%lx)",
paused ? "stop" : "start", hr);
return hr;
}
-static HRESULT Flush(aout_api_t *api)
+static HRESULT Flush(aout_stream_t *s)
{
- aout_api_sys_t *sys = api->sys;
+ aout_stream_sys_t *sys = s->sys;
HRESULT hr;
IAudioClient_Stop(sys->client);
hr = IAudioClient_Reset(sys->client);
if (FAILED(hr))
- msg_Warn(api, "cannot reset stream (error 0x%lx)", hr);
+ msg_Warn(s, "cannot reset stream (error 0x%lx)", hr);
else
sys->written = 0;
return hr;
return aout_CheckChannelReorder(chans_in, chans_out, mask, table);
}
-static HRESULT Start(aout_api_t *api, audio_sample_format_t *restrict fmt,
+static HRESULT Start(aout_stream_t *s, audio_sample_format_t *restrict fmt,
IMMDevice *dev, const GUID *sid)
{
- aout_api_sys_t *sys = malloc(sizeof (*sys));
+ aout_stream_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return E_OUTOFMEMORY;
sys->client = NULL;
Leave();
if (FAILED(hr))
{
- msg_Err(api, "cannot activate client (error 0x%lx)", hr);
+ msg_Err(s, "cannot activate client (error 0x%lx)", hr);
goto error;
}
sys->client = pv;
&wf.Format, &pwf);
if (FAILED(hr))
{
- msg_Err(api, "cannot negotiate audio format (error 0x%lx)", hr);
+ msg_Err(s, "cannot negotiate audio format (error 0x%lx)", hr);
goto error;
}
if (vlc_FromWave(pwf, fmt))
{
CoTaskMemFree(pwf);
- msg_Err(api, "unsupported audio format");
+ msg_Err(s, "unsupported audio format");
hr = E_INVALIDARG;
goto error;
}
- msg_Dbg(api, "modified format");
+ msg_Dbg(s, "modified format");
}
else
assert(pwf == NULL);
CoTaskMemFree(pwf);
if (FAILED(hr))
{
- msg_Err(api, "cannot initialize audio client (error 0x%lx)", hr);
+ msg_Err(s, "cannot initialize audio client (error 0x%lx)", hr);
goto error;
}
hr = IAudioClient_GetBufferSize(sys->client, &sys->frames);
if (FAILED(hr))
{
- msg_Err(api, "cannot get buffer size (error 0x%lx)", hr);
+ msg_Err(s, "cannot get buffer size (error 0x%lx)", hr);
goto error;
}
sys->rate = fmt->i_rate;
sys->bytes_per_frame = fmt->i_bytes_per_frame;
sys->written = 0;
- api->sys = sys;
- api->time_get = TimeGet;
- api->play = Play;
- api->pause = Pause;
- api->flush = Flush;
+ s->sys = sys;
+ s->time_get = TimeGet;
+ s->play = Play;
+ s->pause = Pause;
+ s->flush = Flush;
return S_OK;
error:
if (sys->client != NULL)
return hr;
}
-static void Stop(aout_api_t *api)
+static void Stop(aout_stream_t *s)
{
- aout_api_sys_t *sys = api->sys;
+ aout_stream_sys_t *sys = s->sys;
IAudioClient_Stop(sys->client); /* should not be needed */
IAudioClient_Release(sys->client);
}
-#undef aout_api_Start
-aout_api_t *aout_api_Start(vlc_object_t *parent, audio_sample_format_t *fmt,
- IMMDevice *dev, const GUID *sid)
+#undef aout_stream_Start
+aout_stream_t *aout_stream_Start(vlc_object_t *parent,
+ audio_sample_format_t *restrict fmt,
+ IMMDevice *dev, const GUID *sid)
{
- aout_api_t *api = vlc_object_create(parent, sizeof (*api));
- if (unlikely(api == NULL))
+ aout_stream_t *s = vlc_object_create(parent, sizeof (*s));
+ if (unlikely(s == NULL))
return NULL;
- HRESULT hr = Start(api, fmt, dev, sid);
+ HRESULT hr = Start(s, fmt, dev, sid);
if (FAILED(hr))
{
- vlc_object_release(api);
- api = NULL;
+ vlc_object_release(s);
+ s = NULL;
}
- return api;
+ return s;
}
-void aout_api_Stop(aout_api_t *api)
+void aout_stream_Stop(aout_stream_t *s)
{
- Stop(api);
- vlc_object_release(api);
+ Stop(s);
+ vlc_object_release(s);
}