qf/nuq
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/nuq synced 2024-11-25 05:21:41 +00:00
Code Issues Projects Releases Packages Wiki Activity

snd_alsa_0_6.c:

Browse source 
works with latest ALSA (note, ymmv)
sw_model_alias.c:
	fix the frozen torches bug
This commit is contained in:
Bill Currie 2000-12-17 04:32:41 +00:00
parent 954447c1a6
commit 4e5fe35cd3
2 changed files with 220 additions and 210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

422
source/snd_alsa_0_6.c
View file

@ -35,240 +35,241 @@
#include <sys/asoundlib.h> #include <sys/asoundlib.h>
#include "console.h"
#include "qargs.h"
#include "qtypes.h" #include "qtypes.h"
#include "sound.h" #include "sound.h"
#include "qargs.h" #include "va.h"
#include "console.h"
static int snd_inited; static int snd_inited;
static snd_pcm_t *pcm_handle; static snd_pcm_t *pcm_handle;
static snd_pcm_params_info_t cpinfo; static snd_pcm_hw_info_t hwinfo;
static snd_pcm_params_t params; static snd_pcm_hw_params_t hwparams;
static snd_pcm_setup_t setup; static snd_pcm_sw_params_t swparams;
static snd_pcm_channel_area_t mmap_stopped_areas[2]; static const snd_pcm_channel_area_t *mmap_running_areas;
static snd_pcm_channel_area_t mmap_running_areas[2]; static int card = -1, dev = -1;
static int card=-1,dev=-1,subdev=-1;;
int check_card(int card) int
check_card (int card)
{ {
snd_ctl_t *handle; snd_ctl_t *handle;
snd_ctl_hw_info_t info; int rc;
int rc;
if ((rc = snd_ctl_hw_open(&handle, 0, card)) < 0) { if ((rc = snd_ctl_open (&handle, va ("hw:%d", card))) < 0) {
Con_Printf("Error: control open (%i): %s\n", card, snd_strerror(rc)); Con_Printf ("Error: control open (%i): %s\n", card, snd_strerror (rc));
return rc; return rc;
} }
if ((rc = snd_ctl_hw_info(handle, &info)) < 0) { if (dev == -1) {
Con_Printf("Error: control hardware info (%i): %s\n", card, while (1) {
snd_strerror(rc)); if ((rc = snd_ctl_pcm_next_device (handle, &dev)) < 0) {
snd_ctl_close(handle); Con_Printf ("Error: next device: %s\n", snd_strerror (rc));
return rc; return rc;
} }
snd_ctl_close(handle); if (dev < 0)
if (dev==-1) { break;
for (dev = 0; dev < info.pcmdevs; dev++) { if ((rc = snd_pcm_open (&pcm_handle, va ("hw:%d,%d", card, dev),
if ((rc=snd_pcm_hw_open_subdevice(&pcm_handle,card,dev,subdev, SND_PCM_STREAM_PLAYBACK,
SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) == 0) {
SND_PCM_NONBLOCK))==0) { goto exit;
return 0;
} }
} }
} else { } else {
if (dev>=0 && dev <info.pcmdevs) { if ((rc = snd_pcm_open (&pcm_handle, va ("hw:%d,%d", card, dev),
if ((rc=snd_pcm_hw_open_subdevice(&pcm_handle,card,dev,subdev, SND_PCM_STREAM_PLAYBACK,
SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) == 0) {
SND_PCM_NONBLOCK))==0) { goto exit;
return 0;
}
} }
Con_Printf ("Error: snd_pcm_open %d: %s\n", dev, snd_strerror (rc));
goto exit;
} }
return 1; rc = 1;
exit:
snd_ctl_close(handle);
return rc;
} }
qboolean SNDDMA_Init(void) qboolean
SNDDMA_Init (void)
{ {
int rc=0,i; int rc = 0, i;
char *err_msg=""; char *err_msg = "";
int rate=-1,format=-1,bps,stereo=-1,frag_size,frame_size; int rate = -1, format = -1, stereo = -1, frag_size;
unsigned int mask;
mask = snd_cards_mask(); if ((i = COM_CheckParm ("-sndcard")) != 0) {
if (!mask) { card = atoi (com_argv[i + 1]);
Con_Printf("No sound cards detected\n");
return 0;
} }
if ((i=COM_CheckParm("-sndcard"))!=0) { if ((i = COM_CheckParm ("-snddev")) != 0) {
card=atoi(com_argv[i+1]); dev = atoi (com_argv[i + 1]);
} }
if ((i=COM_CheckParm("-snddev"))!=0) { if ((i = COM_CheckParm ("-sndbits")) != 0) {
dev=atoi(com_argv[i+1]); i = atoi (com_argv[i + 1]);
} if (i == 16) {
if ((i=COM_CheckParm("-sndbits")) != 0) { format = SND_PCM_FMTBIT_S16_LE;
i = atoi(com_argv[i+1]); } else if (i == 8) {
if (i==16) { format = SND_PCM_FMTBIT_U8;
format = SND_PCM_SFMT_S16_LE;
} else if (i==8) {
format = SND_PCM_SFMT_U8;
} else { } else {
Con_Printf("Error: invalid sample bits: %d\n", i); Con_Printf ("Error: invalid sample bits: %d\n", i);
return 0; return 0;
} }
} }
if ((i=COM_CheckParm("-sndspeed")) != 0) { if ((i = COM_CheckParm ("-sndspeed")) != 0) {
rate = atoi(com_argv[i+1]); rate = atoi (com_argv[i + 1]);
if (rate!=44100 && rate!=22050 && rate!=11025) { if (rate != 44100 && rate != 22050 && rate != 11025) {
Con_Printf("Error: invalid sample rate: %d\n", rate); Con_Printf ("Error: invalid sample rate: %d\n", rate);
return 0; return 0;
} }
} }
if ((i=COM_CheckParm("-sndmono")) != 0) { if ((i = COM_CheckParm ("-sndmono")) != 0) {
stereo=0; stereo = 0;
} }
if (card==-1) { if (card == -1) {
for (card=0; card<SND_CARDS; card++) { if (snd_card_next(&card) < 0 || card < 0) {
if (!(mask & (1<<card))) Con_Printf ("No sound cards detected\n");
continue; return 0;
rc=check_card(card); }
if (rc<0) while (card >= 0) {
rc = check_card (card);
if (rc < 0)
return 0; return 0;
if (!rc) if (!rc)
goto dev_openned; goto dev_openned;
} }
} else { } else {
if (dev==-1) { if (dev == -1) {
rc=check_card(card); rc = check_card (card);
if (rc<0) if (rc < 0)
return 0; return 0;
if (!rc) if (!rc)
goto dev_openned; goto dev_openned;
} else { } else {
if ((rc=snd_pcm_hw_open_subdevice(&pcm_handle,card,dev,subdev, if ((rc = snd_pcm_open (&pcm_handle, va ("hw:%d,%d", card, dev),
SND_PCM_STREAM_PLAYBACK, SND_PCM_STREAM_PLAYBACK,
SND_PCM_NONBLOCK))<0) { SND_PCM_NONBLOCK)) == 0) {
Con_Printf("Error: audio open error: %s\n", snd_strerror(rc)); Con_Printf ("Error: audio open error: %s\n", snd_strerror (rc));
return 0; return 0;
} }
goto dev_openned; goto dev_openned;
} }
} }
Con_Printf("Error: audio open error: %s\n", snd_strerror(rc)); Con_Printf ("Error: audio open error: %s\n", snd_strerror (rc));
return 0; return 0;
dev_openned: dev_openned:
Con_Printf("Using card %d, device %d.\n", card, dev); Con_Printf ("Using card %d, device %d.\n", card, dev);
memset(&cpinfo, 0, sizeof(cpinfo)); memset (&hwinfo, 0, sizeof (hwinfo));
snd_pcm_params_info(pcm_handle, &cpinfo); snd_pcm_hw_info_any (&hwinfo);
Con_Printf("%08x %08x %08x\n",cpinfo.flags,cpinfo.formats,cpinfo.rates); hwinfo.access_mask = SND_PCM_ACCBIT_MMAP_INTERLEAVED;
if ((rate==-1 || rate==44100) && cpinfo.rates & SND_PCM_RATE_44100) { err_msg = "snd_pcm_hw_info";
rate=44100; if ((rc = snd_pcm_hw_info (pcm_handle, &hwinfo)) < 0)
frag_size=256; /* assuming stereo 8 bit */ goto error;
} else if ((rate==-1 || rate==22050) && cpinfo.rates & SND_PCM_RATE_22050) { Con_Printf ("%08x %08x\n", hwinfo.access_mask, hwinfo.format_mask);
rate=22050; rate = 44100;
frag_size=128; /* assuming stereo 8 bit */ frag_size = 4;
} else if ((rate==-1 || rate==11025) && cpinfo.rates & SND_PCM_RATE_11025) { #if 0 // XXX
rate=11025; if ((rate == -1 || rate == 44100) && hwinfo.rates & SND_PCM_RATE_44100) {
frag_size=64; /* assuming stereo 8 bit */ rate = 44100;
frag_size = 256; /* assuming stereo 8 bit */
} else if ((rate == -1 || rate == 22050)
&& hwinfo.rates & SND_PCM_RATE_22050) {
rate = 22050;
frag_size = 128; /* assuming stereo 8 bit */
} else if ((rate == -1 || rate == 11025)
&& hwinfo.rates & SND_PCM_RATE_11025) {
rate = 11025;
frag_size = 64; /* assuming stereo 8 bit */
} else { } else {
Con_Printf("ALSA: desired rates not supported\n"); Con_Printf ("ALSA: desired rates not supported\n");
goto error_2; goto error_2;
} }
if ((format==-1 || format==SND_PCM_SFMT_S16_LE) && cpinfo.formats & SND_PCM_FMT_S16_LE) { #endif
format=SND_PCM_SFMT_S16_LE; if ((format == -1 || format == SND_PCM_FMTBIT_S16_LE)
bps=16; && hwinfo.format_mask & SND_PCM_FORMAT_S16_LE) {
frame_size=2; format = SND_PCM_FORMAT_S16_LE;
} else if ((format==-1 || format==SND_PCM_SFMT_U8) && cpinfo.formats & SND_PCM_FMT_U8) { } else if ((format == -1 || format == SND_PCM_FORMAT_U8)
format=SND_PCM_SFMT_U8; && hwinfo.format_mask & SND_PCM_FORMAT_U8) {
bps=8; format = SND_PCM_FORMAT_U8;
frame_size=1;
} else { } else {
Con_Printf("ALSA: desired formats not supported\n"); Con_Printf ("ALSA: desired formats not supported\n");
goto error_2; goto error_2;
} }
//XXX can't support non-interleaved stereo // XXX can't support non-interleaved stereo
if (stereo && (cpinfo.flags & SND_PCM_INFO_INTERLEAVED) && cpinfo.max_channels>=2) { if (stereo && (hwinfo.access_mask & SND_PCM_ACCBIT_MMAP_INTERLEAVED)
stereo=1; && hwinfo.channels_max >= 2) {
frame_size*=2; stereo = 1;
} else { } else {
stereo=0; stereo = 0;
} }
memset(&params, 0, sizeof(params)); memset (&hwparams, 0, sizeof (hwparams));
//XXX can't support non-interleaved stereo // XXX can't support non-interleaved stereo
params.xfer_mode = stereo ? SND_PCM_XFER_INTERLEAVED hwparams.access = stereo ? SND_PCM_ACCESS_MMAP_INTERLEAVED
: SND_PCM_XFER_NONINTERLEAVED; : SND_PCM_ACCESS_MMAP_NONINTERLEAVED;
params.mmap_shape = stereo ? SND_PCM_XFER_INTERLEAVED hwparams.format = format;
: SND_PCM_XFER_NONINTERLEAVED; hwparams.rate = rate;
params.format.sfmt=format; hwparams.channels = stereo + 1;
params.format.rate=rate;
params.format.channels=stereo+1;
params.start_mode = SND_PCM_START_EXPLICIT;
params.xrun_mode = SND_PCM_XRUN_NONE;
params.buffer_size = (2<<16) / frame_size; hwparams.fragment_size = 32;
params.frag_size=frag_size; hwparams.fragments = 512;
params.avail_min = frag_size;
params.boundary = params.buffer_size; err_msg = "snd_pcm_hw_params";
if ((rc = snd_pcm_hw_params (pcm_handle, &hwparams)) < 0) {
while (1) { Con_Printf("failed: %08x\n", hwparams.fail_mask);
err_msg="audio params"; goto error;
if ((rc=snd_pcm_params(pcm_handle, &params))<0)
goto error;
memset(&setup, 0, sizeof(setup));
err_msg="audio setup";
if ((rc=snd_pcm_setup(pcm_handle, &setup))<0)
goto error;
if (setup.buffer_size == params.buffer_size)
break;
params.boundary = params.buffer_size = setup.buffer_size;
} }
err_msg="audio mmap"; memset (&swparams, 0, sizeof (swparams));
if ((rc=snd_pcm_mmap(pcm_handle))<0) swparams.start_mode = SND_PCM_START_EXPLICIT;
swparams.xrun_mode = SND_PCM_XRUN_FRAGMENT;
swparams.xfer_min = 1;
swparams.xfer_align = 1;
err_msg = "snd_pcm_sw_params";
if ((rc = snd_pcm_sw_params (pcm_handle, &swparams)) < 0) {
Con_Printf("failed: %08x\n", swparams.fail_mask);
goto error; goto error;
if ((rc=snd_pcm_mmap_get_areas(pcm_handle, mmap_stopped_areas, mmap_running_areas))) }
goto error;
err_msg="audio prepare"; err_msg = "audio prepare";
if ((rc=snd_pcm_prepare(pcm_handle))<0) if ((rc = snd_pcm_prepare (pcm_handle)) < 0)
goto error; goto error;
shm=&sn; mmap_running_areas = snd_pcm_mmap_areas (pcm_handle);
memset((dma_t*)shm,0,sizeof(*shm));
shm->splitbuffer = 0;
shm->channels=setup.format.channels;
shm->submission_chunk=frag_size; // don't mix less than this #
shm->samplepos=0; // in mono samples
shm->samplebits=setup.format.sfmt==SND_PCM_SFMT_S16_LE?16:8;
shm->samples=setup.buffer_size*shm->channels; // mono samples in buffer
shm->speed=setup.format.rate;
shm->buffer=(unsigned char*)mmap_running_areas->addr;
Con_Printf("%5d stereo\n", shm->channels - 1);
Con_Printf("%5d samples\n", shm->samples);
Con_Printf("%5d samplepos\n", shm->samplepos);
Con_Printf("%5d samplebits\n", shm->samplebits);
Con_Printf("%5d submission_chunk\n", shm->submission_chunk);
Con_Printf("%5d speed\n", shm->speed);
Con_Printf("0x%x dma buffer\n", (int)shm->buffer);
Con_Printf("%5d total_channels\n", total_channels);
snd_inited=1; shm = &sn;
memset ((dma_t *) shm, 0, sizeof (*shm));
shm->splitbuffer = 0;
shm->channels = hwparams.channels;
shm->submission_chunk = frag_size; // don't mix less than this #
shm->samplepos = 0; // in mono samples
shm->samplebits = hwparams.format == SND_PCM_FORMAT_S16_LE ? 16 : 8;
shm->samples = hwparams.fragment_size * hwparams.fragments
* shm->channels; // mono samples in buffer
shm->speed = hwparams.rate;
shm->buffer = (unsigned char *) mmap_running_areas->addr;
Con_Printf ("%5d stereo\n", shm->channels - 1);
Con_Printf ("%5d samples\n", shm->samples);
Con_Printf ("%5d samplepos\n", shm->samplepos);
Con_Printf ("%5d samplebits\n", shm->samplebits);
Con_Printf ("%5d submission_chunk\n", shm->submission_chunk);
Con_Printf ("%5d speed\n", shm->speed);
Con_Printf ("0x%x dma buffer\n", (int) shm->buffer);
Con_Printf ("%5d total_channels\n", total_channels);
snd_inited = 1;
return 1; return 1;
error: error:
Con_Printf("Error: %s: %s\n", err_msg, snd_strerror(rc)); Con_Printf ("Error: %s: %s\n", err_msg, snd_strerror (rc));
error_2: error_2:
snd_pcm_close(pcm_handle); snd_pcm_close (pcm_handle);
return 0; return 0;
} }
static inline int static inline int
get_hw_ptr() get_hw_ptr ()
{ {
size_t app_ptr; size_t app_ptr;
ssize_t delay; ssize_t delay;
int hw_ptr; int hw_ptr;
if (snd_pcm_state (pcm_handle) != SND_PCM_STATE_RUNNING) if (snd_pcm_state (pcm_handle) != SND_PCM_STATE_RUNNING)
return 0; return 0;
@ -278,23 +279,25 @@ get_hw_ptr()
return hw_ptr; return hw_ptr;
} }
int SNDDMA_GetDMAPos(void) int
SNDDMA_GetDMAPos (void)
{ {
int hw_ptr; int hw_ptr;
if (!snd_inited) return 0; if (!snd_inited)
return 0;
hw_ptr = get_hw_ptr(); hw_ptr = get_hw_ptr ();
hw_ptr *= shm->channels; hw_ptr *= shm->channels;
shm->samplepos = hw_ptr; shm->samplepos = hw_ptr;
return shm->samplepos; return shm->samplepos;
} }
void SNDDMA_Shutdown(void) void
SNDDMA_Shutdown (void)
{ {
if (snd_inited) if (snd_inited) {
{ snd_pcm_close (pcm_handle);
snd_pcm_close(pcm_handle);
snd_inited = 0; snd_inited = 0;
} }
} }
@ -306,44 +309,49 @@ SNDDMA_Submit
Send sound to device if buffer isn't really the dma buffer Send sound to device if buffer isn't really the dma buffer
=============== ===============
*/ */
void SNDDMA_Submit(void) void
SNDDMA_Submit (void)
{ {
int count = paintedtime - soundtime; int count = paintedtime - soundtime;
int avail; int avail;
int missed; int missed;
int state; int state;
int hw_ptr; int hw_ptr;
int offset; int offset;
state = snd_pcm_state (pcm_handle); state = snd_pcm_state (pcm_handle);
switch (state) { switch (state) {
case SND_PCM_STATE_PREPARED: case SND_PCM_STATE_XRUN:
snd_pcm_mmap_forward (pcm_handle, count); //snd_pcm_reset (pcm_handle);
snd_pcm_start (pcm_handle); snd_pcm_prepare (pcm_handle);
break; //break;
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_PREPARED:
hw_ptr = get_hw_ptr();
missed = hw_ptr - shm->samplepos / shm->channels;
count -= missed;
offset = snd_pcm_mmap_offset (pcm_handle);
if (offset > hw_ptr)
count -= (offset - hw_ptr);
else
count -= (setup.buffer_size - hw_ptr + offset);
if (count < 0) {
snd_pcm_rewind (pcm_handle, -count);
} else if (count > 0) {
avail = snd_pcm_avail_update(pcm_handle);
if (avail > 0 && count > avail) {
snd_pcm_mmap_forward (pcm_handle, avail);
count -= avail;
}
snd_pcm_mmap_forward (pcm_handle, count); snd_pcm_mmap_forward (pcm_handle, count);
} snd_pcm_start (pcm_handle);
break; //break;
default: case SND_PCM_STATE_RUNNING:
break; hw_ptr = get_hw_ptr ();
missed = hw_ptr - shm->samplepos / shm->channels;
count -= missed;
offset = snd_pcm_mmap_offset (pcm_handle);
if (offset > hw_ptr)
count -= (offset - hw_ptr);
else
count -= (hwparams.fragments - hw_ptr + offset);
if (count < 0) {
snd_pcm_rewind (pcm_handle, -count);
} else if (count > 0) {
avail = snd_pcm_avail_update (pcm_handle);
if (avail > 0 && count > avail) {
snd_pcm_mmap_forward (pcm_handle, avail);
count -= avail;
}
snd_pcm_mmap_forward (pcm_handle, count);
}
break;
default:
printf("snd_alsa: nexpected state: %d\n", state);
break;
} }
} }

8
source/sw_model_alias.c
View file

@ -277,9 +277,11 @@ void * Mod_LoadAliasGroup (void * pin, maliasframedesc_t *frame)
ptemp = (void *)pin_intervals; ptemp = (void *)pin_intervals;
for (i=0 ; i<numframes ; i++) for (i=0 ; i<numframes ; i++) {
{ maliasframedesc_t temp_frame;
ptemp = Mod_LoadAliasFrame (ptemp, (maliasframedesc_t*)&paliasgroup->frames[i]); ptemp = Mod_LoadAliasFrame (ptemp, &temp_frame);
memcpy (&paliasgroup->frames[i], &temp_frame,
sizeof(paliasgroup->frames[i]));
} }
return ptemp; return ptemp;