mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-02 15:25:32 +00:00
772 lines
26 KiB
C
772 lines
26 KiB
C
/*
|
|
* Wine Driver for ALSA
|
|
*
|
|
* Copyright 2002 Eric Pouech
|
|
* Copyright 2007 Maarten Lankhorst
|
|
*
|
|
* This file has a few shared generic subroutines shared among the alsa
|
|
* implementation.
|
|
*
|
|
* This library 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.
|
|
*
|
|
* This library 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 this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "mmddk.h"
|
|
|
|
#include "ks.h"
|
|
#include "guiddef.h"
|
|
#include "ksmedia.h"
|
|
|
|
#include "alsa.h"
|
|
|
|
#ifdef HAVE_ALSA
|
|
|
|
#include "wine/library.h"
|
|
#include "wine/unicode.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(alsa);
|
|
/* unless someone makes a wineserver kernel module, Unix pipes are faster than win32 events */
|
|
#define USE_PIPE_SYNC
|
|
|
|
#ifdef USE_PIPE_SYNC
|
|
#define INIT_OMR(omr) do { if (pipe(omr->msg_pipe) < 0) { omr->msg_pipe[0] = omr->msg_pipe[1] = -1; } } while (0)
|
|
#define CLOSE_OMR(omr) do { close(omr->msg_pipe[0]); close(omr->msg_pipe[1]); } while (0)
|
|
#define SIGNAL_OMR(omr) do { int x = 0; write((omr)->msg_pipe[1], &x, sizeof(x)); } while (0)
|
|
#define CLEAR_OMR(omr) do { int x = 0; read((omr)->msg_pipe[0], &x, sizeof(x)); } while (0)
|
|
#define RESET_OMR(omr) do { } while (0)
|
|
#define WAIT_OMR(omr, sleep) \
|
|
do { struct pollfd pfd; pfd.fd = (omr)->msg_pipe[0]; \
|
|
pfd.events = POLLIN; poll(&pfd, 1, sleep); } while (0)
|
|
#else
|
|
#define INIT_OMR(omr) do { omr->msg_event = CreateEventW(NULL, FALSE, FALSE, NULL); } while (0)
|
|
#define CLOSE_OMR(omr) do { CloseHandle(omr->msg_event); } while (0)
|
|
#define SIGNAL_OMR(omr) do { SetEvent((omr)->msg_event); } while (0)
|
|
#define CLEAR_OMR(omr) do { } while (0)
|
|
#define RESET_OMR(omr) do { ResetEvent((omr)->msg_event); } while (0)
|
|
#define WAIT_OMR(omr, sleep) \
|
|
do { WaitForSingleObject((omr)->msg_event, sleep); } while (0)
|
|
#endif
|
|
|
|
#define ALSA_RING_BUFFER_INCREMENT 64
|
|
|
|
/******************************************************************
|
|
* ALSA_InitRingMessage
|
|
*
|
|
* Initialize the ring of messages for passing between driver's caller and playback/record
|
|
* thread
|
|
*/
|
|
int ALSA_InitRingMessage(ALSA_MSG_RING* omr)
|
|
{
|
|
omr->msg_toget = 0;
|
|
omr->msg_tosave = 0;
|
|
INIT_OMR(omr);
|
|
omr->ring_buffer_size = ALSA_RING_BUFFER_INCREMENT;
|
|
omr->messages = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,omr->ring_buffer_size * sizeof(ALSA_MSG));
|
|
|
|
InitializeCriticalSection(&omr->msg_crst);
|
|
omr->msg_crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ALSA_MSG_RING.msg_crst");
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************
|
|
* ALSA_DestroyRingMessage
|
|
*
|
|
*/
|
|
int ALSA_DestroyRingMessage(ALSA_MSG_RING* omr)
|
|
{
|
|
CLOSE_OMR(omr);
|
|
HeapFree(GetProcessHeap(),0,omr->messages);
|
|
omr->ring_buffer_size = 0;
|
|
omr->msg_crst.DebugInfo->Spare[0] = 0;
|
|
DeleteCriticalSection(&omr->msg_crst);
|
|
return 0;
|
|
}
|
|
/******************************************************************
|
|
* ALSA_ResetRingMessage
|
|
*
|
|
*/
|
|
void ALSA_ResetRingMessage(ALSA_MSG_RING* omr)
|
|
{
|
|
RESET_OMR(omr);
|
|
}
|
|
|
|
/******************************************************************
|
|
* ALSA_WaitRingMessage
|
|
*
|
|
*/
|
|
void ALSA_WaitRingMessage(ALSA_MSG_RING* omr, DWORD sleep)
|
|
{
|
|
WAIT_OMR(omr, sleep);
|
|
}
|
|
|
|
/******************************************************************
|
|
* ALSA_AddRingMessage
|
|
*
|
|
* Inserts a new message into the ring (should be called from DriverProc derivated routines)
|
|
*/
|
|
int ALSA_AddRingMessage(ALSA_MSG_RING* omr, enum win_wm_message msg, DWORD param, BOOL wait)
|
|
{
|
|
HANDLE hEvent = INVALID_HANDLE_VALUE;
|
|
|
|
EnterCriticalSection(&omr->msg_crst);
|
|
if ((omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size)))
|
|
{
|
|
int old_ring_buffer_size = omr->ring_buffer_size;
|
|
omr->ring_buffer_size += ALSA_RING_BUFFER_INCREMENT;
|
|
omr->messages = HeapReAlloc(GetProcessHeap(),0,omr->messages, omr->ring_buffer_size * sizeof(ALSA_MSG));
|
|
/* Now we need to rearrange the ring buffer so that the new
|
|
buffers just allocated are in between omr->msg_tosave and
|
|
omr->msg_toget.
|
|
*/
|
|
if (omr->msg_tosave < omr->msg_toget)
|
|
{
|
|
memmove(&(omr->messages[omr->msg_toget + ALSA_RING_BUFFER_INCREMENT]),
|
|
&(omr->messages[omr->msg_toget]),
|
|
sizeof(ALSA_MSG)*(old_ring_buffer_size - omr->msg_toget)
|
|
);
|
|
omr->msg_toget += ALSA_RING_BUFFER_INCREMENT;
|
|
}
|
|
}
|
|
if (wait)
|
|
{
|
|
hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
|
|
if (hEvent == INVALID_HANDLE_VALUE)
|
|
{
|
|
ERR("can't create event !?\n");
|
|
LeaveCriticalSection(&omr->msg_crst);
|
|
return 0;
|
|
}
|
|
if (omr->msg_toget != omr->msg_tosave && omr->messages[omr->msg_toget].msg != WINE_WM_HEADER)
|
|
FIXME("two fast messages in the queue!!!! toget = %d(%s), tosave=%d(%s)\n",
|
|
omr->msg_toget,ALSA_getCmdString(omr->messages[omr->msg_toget].msg),
|
|
omr->msg_tosave,ALSA_getCmdString(omr->messages[omr->msg_tosave].msg));
|
|
|
|
/* fast messages have to be added at the start of the queue */
|
|
omr->msg_toget = (omr->msg_toget + omr->ring_buffer_size - 1) % omr->ring_buffer_size;
|
|
|
|
omr->messages[omr->msg_toget].msg = msg;
|
|
omr->messages[omr->msg_toget].param = param;
|
|
omr->messages[omr->msg_toget].hEvent = hEvent;
|
|
}
|
|
else
|
|
{
|
|
omr->messages[omr->msg_tosave].msg = msg;
|
|
omr->messages[omr->msg_tosave].param = param;
|
|
omr->messages[omr->msg_tosave].hEvent = INVALID_HANDLE_VALUE;
|
|
omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
|
|
}
|
|
LeaveCriticalSection(&omr->msg_crst);
|
|
/* signal a new message */
|
|
SIGNAL_OMR(omr);
|
|
if (wait)
|
|
{
|
|
/* wait for playback/record thread to have processed the message */
|
|
WaitForSingleObject(hEvent, INFINITE);
|
|
CloseHandle(hEvent);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/******************************************************************
|
|
* ALSA_RetrieveRingMessage
|
|
*
|
|
* Get a message from the ring. Should be called by the playback/record thread.
|
|
*/
|
|
int ALSA_RetrieveRingMessage(ALSA_MSG_RING* omr,
|
|
enum win_wm_message *msg, DWORD *param, HANDLE *hEvent)
|
|
{
|
|
EnterCriticalSection(&omr->msg_crst);
|
|
|
|
if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
|
|
{
|
|
LeaveCriticalSection(&omr->msg_crst);
|
|
return 0;
|
|
}
|
|
|
|
*msg = omr->messages[omr->msg_toget].msg;
|
|
omr->messages[omr->msg_toget].msg = 0;
|
|
*param = omr->messages[omr->msg_toget].param;
|
|
*hEvent = omr->messages[omr->msg_toget].hEvent;
|
|
omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
|
|
CLEAR_OMR(omr);
|
|
LeaveCriticalSection(&omr->msg_crst);
|
|
return 1;
|
|
}
|
|
|
|
/******************************************************************
|
|
* ALSA_PeekRingMessage
|
|
*
|
|
* Peek at a message from the ring but do not remove it.
|
|
* Should be called by the playback/record thread.
|
|
*/
|
|
int ALSA_PeekRingMessage(ALSA_MSG_RING* omr,
|
|
enum win_wm_message *msg,
|
|
DWORD *param, HANDLE *hEvent)
|
|
{
|
|
EnterCriticalSection(&omr->msg_crst);
|
|
|
|
if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
|
|
{
|
|
LeaveCriticalSection(&omr->msg_crst);
|
|
return 0;
|
|
}
|
|
|
|
*msg = omr->messages[omr->msg_toget].msg;
|
|
*param = omr->messages[omr->msg_toget].param;
|
|
*hEvent = omr->messages[omr->msg_toget].hEvent;
|
|
LeaveCriticalSection(&omr->msg_crst);
|
|
return 1;
|
|
}
|
|
|
|
/*======================================================================*
|
|
* Utility functions *
|
|
*======================================================================*/
|
|
|
|
/* These strings used only for tracing */
|
|
const char * ALSA_getCmdString(enum win_wm_message msg)
|
|
{
|
|
static char unknown[32];
|
|
#define MSG_TO_STR(x) case x: return #x
|
|
switch(msg) {
|
|
MSG_TO_STR(WINE_WM_PAUSING);
|
|
MSG_TO_STR(WINE_WM_RESTARTING);
|
|
MSG_TO_STR(WINE_WM_RESETTING);
|
|
MSG_TO_STR(WINE_WM_HEADER);
|
|
MSG_TO_STR(WINE_WM_UPDATE);
|
|
MSG_TO_STR(WINE_WM_BREAKLOOP);
|
|
MSG_TO_STR(WINE_WM_CLOSING);
|
|
MSG_TO_STR(WINE_WM_STARTING);
|
|
MSG_TO_STR(WINE_WM_STOPPING);
|
|
}
|
|
#undef MSG_TO_STR
|
|
sprintf(unknown, "UNKNOWN(0x%08x)", msg);
|
|
return unknown;
|
|
}
|
|
|
|
const char * ALSA_getMessage(UINT msg)
|
|
{
|
|
static char unknown[32];
|
|
#define MSG_TO_STR(x) case x: return #x
|
|
switch(msg) {
|
|
MSG_TO_STR(DRVM_INIT);
|
|
MSG_TO_STR(DRVM_EXIT);
|
|
MSG_TO_STR(DRVM_ENABLE);
|
|
MSG_TO_STR(DRVM_DISABLE);
|
|
MSG_TO_STR(WIDM_OPEN);
|
|
MSG_TO_STR(WIDM_CLOSE);
|
|
MSG_TO_STR(WIDM_ADDBUFFER);
|
|
MSG_TO_STR(WIDM_PREPARE);
|
|
MSG_TO_STR(WIDM_UNPREPARE);
|
|
MSG_TO_STR(WIDM_GETDEVCAPS);
|
|
MSG_TO_STR(WIDM_GETNUMDEVS);
|
|
MSG_TO_STR(WIDM_GETPOS);
|
|
MSG_TO_STR(WIDM_RESET);
|
|
MSG_TO_STR(WIDM_START);
|
|
MSG_TO_STR(WIDM_STOP);
|
|
MSG_TO_STR(WODM_OPEN);
|
|
MSG_TO_STR(WODM_CLOSE);
|
|
MSG_TO_STR(WODM_WRITE);
|
|
MSG_TO_STR(WODM_PAUSE);
|
|
MSG_TO_STR(WODM_GETPOS);
|
|
MSG_TO_STR(WODM_BREAKLOOP);
|
|
MSG_TO_STR(WODM_PREPARE);
|
|
MSG_TO_STR(WODM_UNPREPARE);
|
|
MSG_TO_STR(WODM_GETDEVCAPS);
|
|
MSG_TO_STR(WODM_GETNUMDEVS);
|
|
MSG_TO_STR(WODM_GETPITCH);
|
|
MSG_TO_STR(WODM_SETPITCH);
|
|
MSG_TO_STR(WODM_GETPLAYBACKRATE);
|
|
MSG_TO_STR(WODM_SETPLAYBACKRATE);
|
|
MSG_TO_STR(WODM_GETVOLUME);
|
|
MSG_TO_STR(WODM_SETVOLUME);
|
|
MSG_TO_STR(WODM_RESTART);
|
|
MSG_TO_STR(WODM_RESET);
|
|
MSG_TO_STR(DRV_QUERYDEVICEINTERFACESIZE);
|
|
MSG_TO_STR(DRV_QUERYDEVICEINTERFACE);
|
|
MSG_TO_STR(DRV_QUERYDSOUNDIFACE);
|
|
MSG_TO_STR(DRV_QUERYDSOUNDDESC);
|
|
}
|
|
#undef MSG_TO_STR
|
|
sprintf(unknown, "UNKNOWN(0x%04x)", msg);
|
|
return unknown;
|
|
}
|
|
|
|
const char * ALSA_getFormat(WORD wFormatTag)
|
|
{
|
|
static char unknown[32];
|
|
#define FMT_TO_STR(x) case x: return #x
|
|
switch(wFormatTag) {
|
|
FMT_TO_STR(WAVE_FORMAT_PCM);
|
|
FMT_TO_STR(WAVE_FORMAT_EXTENSIBLE);
|
|
FMT_TO_STR(WAVE_FORMAT_MULAW);
|
|
FMT_TO_STR(WAVE_FORMAT_ALAW);
|
|
FMT_TO_STR(WAVE_FORMAT_ADPCM);
|
|
}
|
|
#undef FMT_TO_STR
|
|
sprintf(unknown, "UNKNOWN(0x%04x)", wFormatTag);
|
|
return unknown;
|
|
}
|
|
|
|
/* Allow 1% deviation for sample rates (some ES137x cards) */
|
|
BOOL ALSA_NearMatch(int rate1, int rate2)
|
|
{
|
|
return (((100 * (rate1 - rate2)) / rate1) == 0);
|
|
}
|
|
|
|
DWORD ALSA_bytes_to_mmtime(LPMMTIME lpTime, DWORD position, WAVEFORMATPCMEX* format)
|
|
{
|
|
TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%u nChannels=%u nAvgBytesPerSec=%u\n",
|
|
lpTime->wType, format->Format.wBitsPerSample, format->Format.nSamplesPerSec,
|
|
format->Format.nChannels, format->Format.nAvgBytesPerSec);
|
|
TRACE("Position in bytes=%u\n", position);
|
|
|
|
switch (lpTime->wType) {
|
|
case TIME_SAMPLES:
|
|
lpTime->u.sample = position / (format->Format.wBitsPerSample / 8 * format->Format.nChannels);
|
|
TRACE("TIME_SAMPLES=%u\n", lpTime->u.sample);
|
|
break;
|
|
case TIME_MS:
|
|
lpTime->u.ms = 1000.0 * position / (format->Format.wBitsPerSample / 8 * format->Format.nChannels * format->Format.nSamplesPerSec);
|
|
TRACE("TIME_MS=%u\n", lpTime->u.ms);
|
|
break;
|
|
case TIME_SMPTE:
|
|
lpTime->u.smpte.fps = 30;
|
|
position = position / (format->Format.wBitsPerSample / 8 * format->Format.nChannels);
|
|
position += (format->Format.nSamplesPerSec / lpTime->u.smpte.fps) - 1; /* round up */
|
|
lpTime->u.smpte.sec = position / format->Format.nSamplesPerSec;
|
|
position -= lpTime->u.smpte.sec * format->Format.nSamplesPerSec;
|
|
lpTime->u.smpte.min = lpTime->u.smpte.sec / 60;
|
|
lpTime->u.smpte.sec -= 60 * lpTime->u.smpte.min;
|
|
lpTime->u.smpte.hour = lpTime->u.smpte.min / 60;
|
|
lpTime->u.smpte.min -= 60 * lpTime->u.smpte.hour;
|
|
lpTime->u.smpte.fps = 30;
|
|
lpTime->u.smpte.frame = position * lpTime->u.smpte.fps / format->Format.nSamplesPerSec;
|
|
TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
|
|
lpTime->u.smpte.hour, lpTime->u.smpte.min,
|
|
lpTime->u.smpte.sec, lpTime->u.smpte.frame);
|
|
break;
|
|
default:
|
|
WARN("Format %d not supported, using TIME_BYTES !\n", lpTime->wType);
|
|
lpTime->wType = TIME_BYTES;
|
|
/* fall through */
|
|
case TIME_BYTES:
|
|
lpTime->u.cb = position;
|
|
TRACE("TIME_BYTES=%u\n", lpTime->u.cb);
|
|
break;
|
|
}
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
void ALSA_copyFormat(LPWAVEFORMATEX wf1, LPWAVEFORMATPCMEX wf2)
|
|
{
|
|
unsigned int iLength;
|
|
|
|
ZeroMemory(wf2, sizeof(wf2));
|
|
if (wf1->wFormatTag == WAVE_FORMAT_PCM)
|
|
iLength = sizeof(PCMWAVEFORMAT);
|
|
else if (wf1->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
|
|
iLength = sizeof(WAVEFORMATPCMEX);
|
|
else
|
|
iLength = sizeof(WAVEFORMATEX) + wf1->cbSize;
|
|
if (iLength > sizeof(WAVEFORMATPCMEX)) {
|
|
ERR("calculated %u bytes, capping to %u bytes\n", iLength, sizeof(WAVEFORMATPCMEX));
|
|
iLength = sizeof(WAVEFORMATPCMEX);
|
|
}
|
|
memcpy(wf2, wf1, iLength);
|
|
}
|
|
|
|
BOOL ALSA_supportedFormat(LPWAVEFORMATEX wf)
|
|
{
|
|
TRACE("(%p)\n",wf);
|
|
|
|
if (wf->nSamplesPerSec<DSBFREQUENCY_MIN||wf->nSamplesPerSec>DSBFREQUENCY_MAX)
|
|
return FALSE;
|
|
|
|
if (wf->wFormatTag == WAVE_FORMAT_PCM) {
|
|
if (wf->nChannels==1||wf->nChannels==2) {
|
|
if (wf->wBitsPerSample==8||wf->wBitsPerSample==16)
|
|
return TRUE;
|
|
}
|
|
} else if (wf->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
|
|
WAVEFORMATEXTENSIBLE * wfex = (WAVEFORMATEXTENSIBLE *)wf;
|
|
|
|
if (wf->cbSize == 22 &&
|
|
(IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM) ||
|
|
IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))) {
|
|
if (wf->nChannels>=1 && wf->nChannels<=6) {
|
|
if (wf->wBitsPerSample==wfex->Samples.wValidBitsPerSample) {
|
|
if (wf->wBitsPerSample==8||wf->wBitsPerSample==16||
|
|
wf->wBitsPerSample==24||wf->wBitsPerSample==32) {
|
|
return TRUE;
|
|
}
|
|
} else
|
|
WARN("wBitsPerSample != wValidBitsPerSample not supported yet\n");
|
|
}
|
|
} else
|
|
WARN("only KSDATAFORMAT_SUBTYPE_PCM and KSDATAFORMAT_SUBTYPE_IEEE_FLOAT "
|
|
"supported\n");
|
|
} else if (wf->wFormatTag == WAVE_FORMAT_MULAW || wf->wFormatTag == WAVE_FORMAT_ALAW) {
|
|
if (wf->wBitsPerSample==8)
|
|
return TRUE;
|
|
else
|
|
ERR("WAVE_FORMAT_MULAW and WAVE_FORMAT_ALAW wBitsPerSample must = 8\n");
|
|
|
|
} else if (wf->wFormatTag == WAVE_FORMAT_ADPCM) {
|
|
if (wf->wBitsPerSample==4)
|
|
return TRUE;
|
|
else
|
|
ERR("WAVE_FORMAT_ADPCM wBitsPerSample must = 4\n");
|
|
} else
|
|
WARN("only WAVE_FORMAT_PCM and WAVE_FORMAT_EXTENSIBLE supported\n");
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*======================================================================*
|
|
* Low level WAVE implementation *
|
|
*======================================================================*/
|
|
|
|
/**************************************************************************
|
|
* ALSA_CheckSetVolume [internal]
|
|
*
|
|
* Helper function for Alsa volume queries. This tries to simplify
|
|
* the process of managing the volume. All parameters are optional
|
|
* (pass NULL to ignore or not use).
|
|
* Return values are MMSYSERR_NOERROR on success, or !0 on failure;
|
|
* error codes are normalized into the possible documented return
|
|
* values from waveOutGetVolume.
|
|
*/
|
|
int ALSA_CheckSetVolume(snd_hctl_t *hctl, int *out_left, int *out_right,
|
|
int *out_min, int *out_max, int *out_step,
|
|
int *new_left, int *new_right)
|
|
{
|
|
int rc = MMSYSERR_NOERROR;
|
|
int value_count = 0;
|
|
snd_hctl_elem_t * elem = NULL;
|
|
snd_ctl_elem_info_t * eleminfop = NULL;
|
|
snd_ctl_elem_value_t * elemvaluep = NULL;
|
|
snd_ctl_elem_id_t * elemidp = NULL;
|
|
|
|
|
|
#define EXIT_ON_ERROR(f,txt,exitcode) do \
|
|
{ \
|
|
int err; \
|
|
if ( (err = (f) ) < 0) \
|
|
{ \
|
|
ERR(txt " failed: %s\n", snd_strerror(err)); \
|
|
rc = exitcode; \
|
|
goto out; \
|
|
} \
|
|
} while(0)
|
|
|
|
if (! hctl)
|
|
return MMSYSERR_NOTSUPPORTED;
|
|
|
|
/* Allocate areas to return information about the volume */
|
|
EXIT_ON_ERROR(snd_ctl_elem_id_malloc(&elemidp), "snd_ctl_elem_id_malloc", MMSYSERR_NOMEM);
|
|
EXIT_ON_ERROR(snd_ctl_elem_value_malloc (&elemvaluep), "snd_ctl_elem_value_malloc", MMSYSERR_NOMEM);
|
|
EXIT_ON_ERROR(snd_ctl_elem_info_malloc (&eleminfop), "snd_ctl_elem_info_malloc", MMSYSERR_NOMEM);
|
|
snd_ctl_elem_id_clear(elemidp);
|
|
snd_ctl_elem_value_clear(elemvaluep);
|
|
snd_ctl_elem_info_clear(eleminfop);
|
|
|
|
/* Setup and find an element id that exactly matches the characteristic we want
|
|
** FIXME: It is probably short sighted to hard code and fixate on PCM Playback Volume */
|
|
snd_ctl_elem_id_set_name(elemidp, "PCM Playback Volume");
|
|
snd_ctl_elem_id_set_interface(elemidp, SND_CTL_ELEM_IFACE_MIXER);
|
|
elem = snd_hctl_find_elem(hctl, elemidp);
|
|
if (elem)
|
|
{
|
|
/* Read and return volume information */
|
|
EXIT_ON_ERROR(snd_hctl_elem_info(elem, eleminfop), "snd_hctl_elem_info", MMSYSERR_NOTSUPPORTED);
|
|
value_count = snd_ctl_elem_info_get_count(eleminfop);
|
|
if (out_min || out_max || out_step)
|
|
{
|
|
if (!snd_ctl_elem_info_is_readable(eleminfop))
|
|
{
|
|
ERR("snd_ctl_elem_info_is_readable returned false; cannot return info\n");
|
|
rc = MMSYSERR_NOTSUPPORTED;
|
|
goto out;
|
|
}
|
|
|
|
if (out_min)
|
|
*out_min = snd_ctl_elem_info_get_min(eleminfop);
|
|
|
|
if (out_max)
|
|
*out_max = snd_ctl_elem_info_get_max(eleminfop);
|
|
|
|
if (out_step)
|
|
*out_step = snd_ctl_elem_info_get_step(eleminfop);
|
|
}
|
|
|
|
if (out_left || out_right)
|
|
{
|
|
EXIT_ON_ERROR(snd_hctl_elem_read(elem, elemvaluep), "snd_hctl_elem_read", MMSYSERR_NOTSUPPORTED);
|
|
|
|
if (out_left)
|
|
*out_left = snd_ctl_elem_value_get_integer(elemvaluep, 0);
|
|
|
|
if (out_right)
|
|
{
|
|
if (value_count == 1)
|
|
*out_right = snd_ctl_elem_value_get_integer(elemvaluep, 0);
|
|
else if (value_count == 2)
|
|
*out_right = snd_ctl_elem_value_get_integer(elemvaluep, 1);
|
|
else
|
|
{
|
|
ERR("Unexpected value count %d from snd_ctl_elem_info_get_count while getting volume info\n", value_count);
|
|
rc = -1;
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Set the volume */
|
|
if (new_left || new_right)
|
|
{
|
|
EXIT_ON_ERROR(snd_hctl_elem_read(elem, elemvaluep), "snd_hctl_elem_read", MMSYSERR_NOTSUPPORTED);
|
|
if (new_left)
|
|
snd_ctl_elem_value_set_integer(elemvaluep, 0, *new_left);
|
|
if (new_right)
|
|
{
|
|
if (value_count == 1)
|
|
snd_ctl_elem_value_set_integer(elemvaluep, 0, *new_right);
|
|
else if (value_count == 2)
|
|
snd_ctl_elem_value_set_integer(elemvaluep, 1, *new_right);
|
|
else
|
|
{
|
|
ERR("Unexpected value count %d from snd_ctl_elem_info_get_count while setting volume info\n", value_count);
|
|
rc = -1;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
EXIT_ON_ERROR(snd_hctl_elem_write(elem, elemvaluep), "snd_hctl_elem_write", MMSYSERR_NOTSUPPORTED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERR("Could not find 'PCM Playback Volume' element\n");
|
|
rc = MMSYSERR_NOTSUPPORTED;
|
|
}
|
|
|
|
|
|
#undef EXIT_ON_ERROR
|
|
|
|
out:
|
|
|
|
if (elemvaluep)
|
|
snd_ctl_elem_value_free(elemvaluep);
|
|
if (eleminfop)
|
|
snd_ctl_elem_info_free(eleminfop);
|
|
if (elemidp)
|
|
snd_ctl_elem_id_free(elemidp);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* ALSA_XRUNRecovery [internal]
|
|
*
|
|
* used to recovery from XRUN errors (buffer underflow/overflow)
|
|
*/
|
|
int ALSA_XRUNRecovery(WINE_WAVEDEV * wwo, int err)
|
|
{
|
|
if (err == -EPIPE) { /* under-run */
|
|
err = snd_pcm_prepare(wwo->pcm);
|
|
if (err < 0)
|
|
ERR( "underrun recovery failed. prepare failed: %s\n", snd_strerror(err));
|
|
return 0;
|
|
} else if (err == -ESTRPIPE) {
|
|
while ((err = snd_pcm_resume(wwo->pcm)) == -EAGAIN)
|
|
sleep(1); /* wait until the suspend flag is released */
|
|
if (err < 0) {
|
|
err = snd_pcm_prepare(wwo->pcm);
|
|
if (err < 0)
|
|
ERR("recovery from suspend failed, prepare failed: %s\n", snd_strerror(err));
|
|
}
|
|
return 0;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* ALSA_TraceParameters [internal]
|
|
*
|
|
* used to trace format changes, hw and sw parameters
|
|
*/
|
|
void ALSA_TraceParameters(snd_pcm_hw_params_t * hw_params, snd_pcm_sw_params_t * sw, int full)
|
|
{
|
|
int err;
|
|
snd_pcm_format_t format;
|
|
snd_pcm_access_t access;
|
|
err = snd_pcm_hw_params_get_access(hw_params, &access);
|
|
err = snd_pcm_hw_params_get_format(hw_params, &format);
|
|
|
|
#define X(x) ((x)? "true" : "false")
|
|
if (full)
|
|
TRACE("FLAGS: sampleres=%s overrng=%s pause=%s resume=%s syncstart=%s batch=%s block=%s double=%s "
|
|
"halfd=%s joint=%s\n",
|
|
X(snd_pcm_hw_params_can_mmap_sample_resolution(hw_params)),
|
|
X(snd_pcm_hw_params_can_overrange(hw_params)),
|
|
X(snd_pcm_hw_params_can_pause(hw_params)),
|
|
X(snd_pcm_hw_params_can_resume(hw_params)),
|
|
X(snd_pcm_hw_params_can_sync_start(hw_params)),
|
|
X(snd_pcm_hw_params_is_batch(hw_params)),
|
|
X(snd_pcm_hw_params_is_block_transfer(hw_params)),
|
|
X(snd_pcm_hw_params_is_double(hw_params)),
|
|
X(snd_pcm_hw_params_is_half_duplex(hw_params)),
|
|
X(snd_pcm_hw_params_is_joint_duplex(hw_params)));
|
|
#undef X
|
|
|
|
if (access >= 0)
|
|
TRACE("access=%s\n", snd_pcm_access_name(access));
|
|
else
|
|
{
|
|
snd_pcm_access_mask_t * acmask;
|
|
snd_pcm_access_mask_alloca(&acmask);
|
|
snd_pcm_hw_params_get_access_mask(hw_params, acmask);
|
|
for ( access = SND_PCM_ACCESS_MMAP_INTERLEAVED; access <= SND_PCM_ACCESS_LAST; access++)
|
|
if (snd_pcm_access_mask_test(acmask, access))
|
|
TRACE("access=%s\n", snd_pcm_access_name(access));
|
|
}
|
|
|
|
if (format >= 0)
|
|
{
|
|
TRACE("format=%s\n", snd_pcm_format_name(format));
|
|
|
|
}
|
|
else
|
|
{
|
|
snd_pcm_format_mask_t * fmask;
|
|
|
|
snd_pcm_format_mask_alloca(&fmask);
|
|
snd_pcm_hw_params_get_format_mask(hw_params, fmask);
|
|
for ( format = SND_PCM_FORMAT_S8; format <= SND_PCM_FORMAT_LAST ; format++)
|
|
if ( snd_pcm_format_mask_test(fmask, format) )
|
|
TRACE("format=%s\n", snd_pcm_format_name(format));
|
|
}
|
|
|
|
do {
|
|
int err=0;
|
|
unsigned int val=0;
|
|
err = snd_pcm_hw_params_get_channels(hw_params, &val);
|
|
if (err<0) {
|
|
unsigned int min = 0;
|
|
unsigned int max = 0;
|
|
err = snd_pcm_hw_params_get_channels_min(hw_params, &min),
|
|
err = snd_pcm_hw_params_get_channels_max(hw_params, &max);
|
|
TRACE("channels_min=%u, channels_min_max=%u\n", min, max);
|
|
} else {
|
|
TRACE("channels=%d\n", val);
|
|
}
|
|
} while(0);
|
|
do {
|
|
int err=0;
|
|
snd_pcm_uframes_t val=0;
|
|
err = snd_pcm_hw_params_get_buffer_size(hw_params, &val);
|
|
if (err<0) {
|
|
snd_pcm_uframes_t min = 0;
|
|
snd_pcm_uframes_t max = 0;
|
|
err = snd_pcm_hw_params_get_buffer_size_min(hw_params, &min),
|
|
err = snd_pcm_hw_params_get_buffer_size_max(hw_params, &max);
|
|
TRACE("buffer_size_min=%lu, buffer_size_min_max=%lu\n", min, max);
|
|
} else {
|
|
TRACE("buffer_size=%lu\n", val);
|
|
}
|
|
} while(0);
|
|
|
|
#define X(x) do { \
|
|
int err=0; \
|
|
int dir=0; \
|
|
unsigned int val=0; \
|
|
err = snd_pcm_hw_params_get_##x(hw_params,&val, &dir); \
|
|
if (err<0) { \
|
|
unsigned int min = 0; \
|
|
unsigned int max = 0; \
|
|
err = snd_pcm_hw_params_get_##x##_min(hw_params, &min, &dir); \
|
|
err = snd_pcm_hw_params_get_##x##_max(hw_params, &max, &dir); \
|
|
TRACE(#x "_min=%u " #x "_max=%u\n", min, max); \
|
|
} else \
|
|
TRACE(#x "=%d\n", val); \
|
|
} while(0)
|
|
|
|
X(rate);
|
|
X(buffer_time);
|
|
X(periods);
|
|
do {
|
|
int err=0;
|
|
int dir=0;
|
|
snd_pcm_uframes_t val=0;
|
|
err = snd_pcm_hw_params_get_period_size(hw_params, &val, &dir);
|
|
if (err<0) {
|
|
snd_pcm_uframes_t min = 0;
|
|
snd_pcm_uframes_t max = 0;
|
|
err = snd_pcm_hw_params_get_period_size_min(hw_params, &min, &dir),
|
|
err = snd_pcm_hw_params_get_period_size_max(hw_params, &max, &dir);
|
|
TRACE("period_size_min=%lu, period_size_min_max=%lu\n", min, max);
|
|
} else {
|
|
TRACE("period_size=%lu\n", val);
|
|
}
|
|
} while(0);
|
|
|
|
X(period_time);
|
|
X(tick_time);
|
|
#undef X
|
|
|
|
if (!sw)
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
/**************************************************************************
|
|
* DriverProc (WINEALSA.@)
|
|
*/
|
|
LRESULT CALLBACK ALSA_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
|
|
LPARAM dwParam1, LPARAM dwParam2)
|
|
{
|
|
/* EPP TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n", */
|
|
/* EPP dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
|
|
|
|
switch(wMsg) {
|
|
#ifdef HAVE_ALSA
|
|
case DRV_LOAD: ALSA_WaveInit();
|
|
ALSA_MidiInit();
|
|
return 1;
|
|
case DRV_FREE: return 1;
|
|
case DRV_OPEN: return 1;
|
|
case DRV_CLOSE: return 1;
|
|
case DRV_ENABLE: return 1;
|
|
case DRV_DISABLE: return 1;
|
|
case DRV_QUERYCONFIGURE: return 1;
|
|
case DRV_CONFIGURE: MessageBoxA(0, "ALSA MultiMedia Driver !", "ALSA Driver", MB_OK); return 1;
|
|
case DRV_INSTALL: return DRVCNF_RESTART;
|
|
case DRV_REMOVE: return DRVCNF_RESTART;
|
|
#endif
|
|
default:
|
|
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
|
|
}
|
|
}
|