HWVoiceOut hw;
void *pcm_buf;
snd_pcm_t *handle;
- int can_pause;
- int was_enabled;
} ALSAVoiceOut;
typedef struct ALSAVoiceIn {
HWVoiceIn hw;
snd_pcm_t *handle;
void *pcm_buf;
- int can_pause;
} ALSAVoiceIn;
static struct {
int buffer_size_out_overriden;
int period_size_out_overriden;
+ int verbose;
} conf = {
#ifdef HIGH_LATENCY
.size_in_usec_in = 1,
#else
#define DEFAULT_BUFFER_SIZE 1024
#define DEFAULT_PERIOD_SIZE 256
- .buffer_size_in = DEFAULT_BUFFER_SIZE,
- .period_size_in = DEFAULT_PERIOD_SIZE,
+ .buffer_size_in = DEFAULT_BUFFER_SIZE * 4,
+ .period_size_in = DEFAULT_PERIOD_SIZE * 4,
.buffer_size_out = DEFAULT_BUFFER_SIZE,
.period_size_out = DEFAULT_PERIOD_SIZE,
.buffer_size_in_overriden = 0,
.period_size_in_overriden = 0,
.period_size_out_overriden = 0,
#endif
- .threshold = 0
+ .threshold = 0,
+ .verbose = 0
};
struct alsa_params_req {
int freq;
audfmt_e fmt;
int nchannels;
- int can_pause;
snd_pcm_uframes_t samples;
};
goto err;
}
- obt->can_pause = snd_pcm_hw_params_can_pause (hw_params);
- if (obt->can_pause < 0) {
- alsa_logerr (err, "Could not get pause capability for %s\n", typ);
- obt->can_pause = 0;
- }
-
if (!in && conf.threshold) {
snd_pcm_uframes_t threshold;
int bytes_per_sec;
return 0;
}
+static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
+{
+ snd_pcm_sframes_t avail;
+
+ avail = snd_pcm_avail_update (handle);
+ if (avail < 0) {
+ if (avail == -EPIPE) {
+ if (!alsa_recover (handle)) {
+ avail = snd_pcm_avail_update (handle);
+ }
+ }
+
+ if (avail < 0) {
+ alsa_logerr (avail,
+ "Could not obtain number of available frames\n");
+ return -1;
+ }
+ }
+
+ return avail;
+}
+
static int alsa_run_out (HWVoiceOut *hw)
{
ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
return 0;
}
- avail = snd_pcm_avail_update (alsa->handle);
+ avail = alsa_get_avail (alsa->handle);
if (avail < 0) {
- if (avail == -EPIPE) {
- if (!alsa_recover (alsa->handle)) {
- avail = snd_pcm_avail_update (alsa->handle);
- if (avail >= 0) {
- goto ok;
- }
- }
- }
-
- alsa_logerr (avail, "Could not get amount free space\n");
+ dolog ("Could not get number of available playback frames\n");
return 0;
}
- ok:
decr = audio_MIN (live, avail);
samples = decr;
rpos = hw->rpos;
while (samples) {
int left_till_end_samples = hw->samples - rpos;
- int convert_samples = audio_MIN (samples, left_till_end_samples);
+ int len = audio_MIN (samples, left_till_end_samples);
snd_pcm_sframes_t written;
src = hw->mix_buf + rpos;
dst = advance (alsa->pcm_buf, rpos << hw->info.shift);
- hw->clip (dst, src, convert_samples);
+ hw->clip (dst, src, len);
- while (convert_samples) {
- written = snd_pcm_writei (alsa->handle, dst, convert_samples);
+ while (len) {
+ written = snd_pcm_writei (alsa->handle, dst, len);
- if (written < 0) {
+ if (written <= 0) {
switch (written) {
- case -EPIPE:
- if (!alsa_recover (alsa->handle)) {
- continue;
+ case 0:
+ if (conf.verbose) {
+ dolog ("Failed to write %d frames (wrote zero)\n", len);
}
- dolog ("Failed to write %d frames to %p, "
- "handle %p not prepared\n",
- convert_samples,
- dst,
- alsa->handle);
goto exit;
- case -EAGAIN:
+ case -EPIPE:
+ if (alsa_recover (alsa->handle)) {
+ alsa_logerr (written, "Failed to write %d frames\n",
+ len);
+ goto exit;
+ }
+ if (conf.verbose) {
+ dolog ("Recovering from playback xrun\n");
+ }
continue;
+ case -EAGAIN:
+ goto exit;
+
default:
alsa_logerr (written, "Failed to write %d frames to %p\n",
- convert_samples, dst);
+ len, dst);
goto exit;
}
}
mixeng_clear (src, written);
rpos = (rpos + written) % hw->samples;
samples -= written;
- convert_samples -= written;
+ len -= written;
dst = advance (dst, written << hw->info.shift);
src += written;
}
&obt_as,
audio_need_to_swap_endian (endianness)
);
- alsa->can_pause = obt.can_pause;
hw->samples = obt.samples;
alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
}
alsa->handle = handle;
- alsa->was_enabled = 0;
return 0;
}
-static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
+static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause)
{
int err;
+
+ if (pause) {
+ err = snd_pcm_drop (handle);
+ if (err < 0) {
+ alsa_logerr (err, "Could not stop %s", typ);
+ return -1;
+ }
+ }
+ else {
+ err = snd_pcm_prepare (handle);
+ if (err < 0) {
+ alsa_logerr (err, "Could not prepare handle for %s", typ);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
+{
ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
switch (cmd) {
case VOICE_ENABLE:
ldebug ("enabling voice\n");
- audio_pcm_info_clear_buf (&hw->info, alsa->pcm_buf, hw->samples);
- if (alsa->can_pause) {
- /* Why this was_enabled madness is needed at all?? */
- if (alsa->was_enabled) {
- err = snd_pcm_pause (alsa->handle, 0);
- if (err < 0) {
- alsa_logerr (err, "Failed to resume playing\n");
- /* not fatal really */
- }
- }
- else {
- alsa->was_enabled = 1;
- }
- }
- break;
+ return alsa_voice_ctl (alsa->handle, "playback", 0);
case VOICE_DISABLE:
ldebug ("disabling voice\n");
- if (alsa->can_pause) {
- err = snd_pcm_pause (alsa->handle, 1);
- if (err < 0) {
- alsa_logerr (err, "Failed to stop playing\n");
- /* not fatal really */
- }
- }
- break;
+ return alsa_voice_ctl (alsa->handle, "playback", 1);
}
- return 0;
+
+ return -1;
}
static int alsa_init_in (HWVoiceIn *hw, audsettings_t *as)
&obt_as,
audio_need_to_swap_endian (endianness)
);
- alsa->can_pause = obt.can_pause;
hw->samples = obt.samples;
alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
int i;
int live = audio_pcm_hw_get_live_in (hw);
int dead = hw->samples - live;
+ int decr;
struct {
int add;
int len;
{ hw->wpos, 0 },
{ 0, 0 }
};
-
+ snd_pcm_sframes_t avail;
snd_pcm_uframes_t read_samples = 0;
if (!dead) {
return 0;
}
- if (hw->wpos + dead > hw->samples) {
+ avail = alsa_get_avail (alsa->handle);
+ if (avail < 0) {
+ dolog ("Could not get number of captured frames\n");
+ return 0;
+ }
+
+ if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
+ avail = hw->samples;
+ }
+
+ decr = audio_MIN (dead, avail);
+ if (!decr) {
+ return 0;
+ }
+
+ if (hw->wpos + decr > hw->samples) {
bufs[0].len = (hw->samples - hw->wpos);
- bufs[1].len = (dead - (hw->samples - hw->wpos));
+ bufs[1].len = (decr - (hw->samples - hw->wpos));
}
else {
- bufs[0].len = dead;
+ bufs[0].len = decr;
}
-
for (i = 0; i < 2; ++i) {
void *src;
st_sample_t *dst;
while (len) {
nread = snd_pcm_readi (alsa->handle, src, len);
- if (nread < 0) {
+ if (nread <= 0) {
switch (nread) {
- case -EPIPE:
- if (!alsa_recover (alsa->handle)) {
- continue;
+ case 0:
+ if (conf.verbose) {
+ dolog ("Failed to read %ld frames (read zero)\n", len);
}
- dolog (
- "Failed to read %ld frames from %p, "
- "handle %p not prepared\n",
- len,
- src,
- alsa->handle
- );
goto exit;
- case -EAGAIN:
+ case -EPIPE:
+ if (alsa_recover (alsa->handle)) {
+ alsa_logerr (nread, "Failed to read %ld frames\n", len);
+ goto exit;
+ }
+ if (conf.verbose) {
+ dolog ("Recovering from capture xrun\n");
+ }
continue;
+ case -EAGAIN:
+ goto exit;
+
default:
alsa_logerr (
nread,
static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
{
- (void) hw;
- (void) cmd;
- return 0;
+ ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
+
+ switch (cmd) {
+ case VOICE_ENABLE:
+ ldebug ("enabling voice\n");
+ return alsa_voice_ctl (alsa->handle, "capture", 0);
+
+ case VOICE_DISABLE:
+ ldebug ("disabling voice\n");
+ return alsa_voice_ctl (alsa->handle, "capture", 1);
+ }
+
+ return -1;
}
static void *alsa_audio_init (void)
{"ADC_DEV", AUD_OPT_STR, &conf.pcm_name_in,
"ADC device name", NULL, 0},
+
+ {"VERBOSE", AUD_OPT_BOOL, &conf.verbose,
+ "Behave in a more verbose way", NULL, 0},
+
{NULL, 0, NULL, NULL, NULL, 0}
};
{ 0 }, /* period */
0, /* plive */
- 0
+ 0 /* log_to_monitor */
};
static AudioState glob_audio_state;
/*
* Hard voice (capture)
*/
-static void audio_pcm_hw_free_resources_in (HWVoiceIn *hw)
-{
- if (hw->conv_buf) {
- qemu_free (hw->conv_buf);
- }
- hw->conv_buf = NULL;
-}
-
-static int audio_pcm_hw_alloc_resources_in (HWVoiceIn *hw)
-{
- hw->conv_buf = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (st_sample_t));
- if (!hw->conv_buf) {
- dolog ("Could not allocate ADC conversion buffer (%d samples)\n",
- hw->samples);
- return -1;
- }
- return 0;
-}
-
static int audio_pcm_hw_find_min_in (HWVoiceIn *hw)
{
SWVoiceIn *sw;
/*
* Soft voice (capture)
*/
-static void audio_pcm_sw_free_resources_in (SWVoiceIn *sw)
-{
- if (sw->conv_buf) {
- qemu_free (sw->conv_buf);
- }
-
- if (sw->rate) {
- st_rate_stop (sw->rate);
- }
-
- sw->conv_buf = NULL;
- sw->rate = NULL;
-}
-
-static int audio_pcm_sw_alloc_resources_in (SWVoiceIn *sw)
-{
- int samples = ((int64_t) sw->hw->samples << 32) / sw->ratio;
- sw->conv_buf = audio_calloc (AUDIO_FUNC, samples, sizeof (st_sample_t));
- if (!sw->conv_buf) {
- dolog ("Could not allocate buffer for `%s' (%d samples)\n",
- SW_NAME (sw), samples);
- return -1;
- }
-
- sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq);
- if (!sw->rate) {
- qemu_free (sw->conv_buf);
- sw->conv_buf = NULL;
- return -1;
- }
- return 0;
-}
-
-static int audio_pcm_sw_init_in (
- SWVoiceIn *sw,
- HWVoiceIn *hw,
- const char *name,
- audsettings_t *as
- )
-{
- /* None of the cards emulated by QEMU are big-endian
- hence following shortcut */
- audio_pcm_init_info (&sw->info, as, audio_need_to_swap_endian (0));
- sw->hw = hw;
- sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq;
-
- sw->clip =
- mixeng_clip
- [sw->info.nchannels == 2]
- [sw->info.sign]
- [sw->info.swap_endian]
- [sw->info.bits == 16];
-
- sw->name = qemu_strdup (name);
- audio_pcm_sw_free_resources_in (sw);
- return audio_pcm_sw_alloc_resources_in (sw);
-}
-
static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw)
{
HWVoiceIn *hw = sw->hw;
{
HWVoiceIn *hw = sw->hw;
int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;
- st_sample_t *src, *dst = sw->conv_buf;
+ st_sample_t *src, *dst = sw->buf;
rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples;
total += isamp;
}
- sw->clip (buf, sw->conv_buf, ret);
+ sw->clip (buf, sw->buf, ret);
sw->total_hw_samples_acquired += total;
return ret << sw->info.shift;
}
/*
* Hard voice (playback)
*/
-static void audio_pcm_hw_free_resources_out (HWVoiceOut *hw)
-{
- if (hw->mix_buf) {
- qemu_free (hw->mix_buf);
- }
-
- hw->mix_buf = NULL;
-}
-
-static int audio_pcm_hw_alloc_resources_out (HWVoiceOut *hw)
-{
- hw->mix_buf = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (st_sample_t));
- if (!hw->mix_buf) {
- dolog ("Could not allocate DAC mixing buffer (%d samples)\n",
- hw->samples);
- return -1;
- }
-
- return 0;
-}
-
static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)
{
SWVoiceOut *sw;
/*
* Soft voice (playback)
*/
-static void audio_pcm_sw_free_resources_out (SWVoiceOut *sw)
-{
- if (sw->buf) {
- qemu_free (sw->buf);
- }
-
- if (sw->rate) {
- st_rate_stop (sw->rate);
- }
-
- sw->buf = NULL;
- sw->rate = NULL;
-}
-
-static int audio_pcm_sw_alloc_resources_out (SWVoiceOut *sw)
-{
- sw->buf = audio_calloc (AUDIO_FUNC, sw->hw->samples, sizeof (st_sample_t));
- if (!sw->buf) {
- dolog ("Could not allocate buffer for `%s' (%d samples)\n",
- SW_NAME (sw), sw->hw->samples);
- return -1;
- }
-
- sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq);
- if (!sw->rate) {
- qemu_free (sw->buf);
- sw->buf = NULL;
- return -1;
- }
- return 0;
-}
-
-static int audio_pcm_sw_init_out (
- SWVoiceOut *sw,
- HWVoiceOut *hw,
- const char *name,
- audsettings_t *as
- )
-{
- /* None of the cards emulated by QEMU are big-endian
- hence following shortcut */
- audio_pcm_init_info (&sw->info, as, audio_need_to_swap_endian (0));
- sw->hw = hw;
- sw->empty = 1;
- sw->active = 0;
- sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq;
- sw->total_hw_samples_mixed = 0;
-
- sw->conv =
- mixeng_conv
- [sw->info.nchannels == 2]
- [sw->info.sign]
- [sw->info.swap_endian]
- [sw->info.bits == 16];
- sw->name = qemu_strdup (name);
-
- audio_pcm_sw_free_resources_out (sw);
- return audio_pcm_sw_alloc_resources_out (sw);
-}
-
int audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int size)
{
int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;
}
}
+static void audio_timer (void *opaque)
+{
+ AudioState *s = opaque;
+
+ audio_run_out (s);
+ audio_run_in (s);
+
+ qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + conf.period.ticks);
+}
+
static struct audio_option audio_options[] = {
/* DAC */
{"DAC_FIXED_SETTINGS", AUD_OPT_BOOL, &conf.fixed_out.enabled,
{"PLIVE", AUD_OPT_BOOL, &conf.plive,
"(undocumented)", NULL, 0},
-
{"LOG_TO_MONITOR", AUD_OPT_BOOL, &conf.log_to_monitor,
"print logging messages to montior instead of stderr", NULL, 0},
{NULL, 0, NULL, NULL, NULL, 0}
};
+static void audio_pp_nb_voices (const char *typ, int nb)
+{
+ switch (nb) {
+ case 0:
+ printf ("Does not support %s\n", typ);
+ break;
+ case 1:
+ printf ("One %s voice\n", typ);
+ break;
+ case INT_MAX:
+ printf ("Theoretically supports many %s voices\n", typ);
+ break;
+ default:
+ printf ("Theoretically supports upto %d %s voices\n", nb, typ);
+ break;
+ }
+
+}
+
void AUD_help (void)
{
size_t i;
printf ("Name: %s\n", d->name);
printf ("Description: %s\n", d->descr);
- switch (d->max_voices_out) {
- case 0:
- printf ("Does not support DAC\n");
- break;
- case 1:
- printf ("One DAC voice\n");
- break;
- case INT_MAX:
- printf ("Theoretically supports many DAC voices\n");
- break;
- default:
- printf ("Theoretically supports upto %d DAC voices\n",
- d->max_voices_out);
- break;
- }
-
- switch (d->max_voices_in) {
- case 0:
- printf ("Does not support ADC\n");
- break;
- case 1:
- printf ("One ADC voice\n");
- break;
- case INT_MAX:
- printf ("Theoretically supports many ADC voices\n");
- break;
- default:
- printf ("Theoretically supports upto %d ADC voices\n",
- d->max_voices_in);
- break;
- }
+ audio_pp_nb_voices ("playback", d->max_voices_out);
+ audio_pp_nb_voices ("capture", d->max_voices_in);
if (d->options) {
printf ("Options:\n");
"Example:\n"
#ifdef _WIN32
" set QEMU_AUDIO_DRV=wav\n"
- " set QEMU_WAV_PATH=c:/tune.wav\n"
+ " set QEMU_WAV_PATH=c:\\tune.wav\n"
#else
" export QEMU_AUDIO_DRV=wav\n"
" export QEMU_WAV_PATH=$HOME/tune.wav\n"
);
}
-void audio_timer (void *opaque)
-{
- AudioState *s = opaque;
-
- audio_run_out (s);
- audio_run_in (s);
-
- qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + conf.period.ticks);
-}
-
static int audio_driver_init (AudioState *s, struct audio_driver *drv)
{
if (drv->options) {
s->drv_opaque = drv->init ();
if (s->drv_opaque) {
- if (s->nb_hw_voices_out > drv->max_voices_out) {
- if (!drv->max_voices_out) {
- dolog ("`%s' does not support DAC\n", drv->name);
- }
- else {
- dolog (
- "`%s' does not support %d multiple DAC voicess\n"
- "Resetting to %d\n",
- drv->name,
- s->nb_hw_voices_out,
- drv->max_voices_out
- );
- }
- s->nb_hw_voices_out = drv->max_voices_out;
- }
-
-
- if (!drv->voice_size_in && drv->max_voices_in) {
- ldebug ("warning: No ADC voice size defined for `%s'\n",
- drv->name);
- drv->max_voices_in = 0;
- }
-
- if (!drv->voice_size_out && drv->max_voices_out) {
- ldebug ("warning: No DAC voice size defined for `%s'\n",
- drv->name);
- }
-
- if (drv->voice_size_in && !drv->max_voices_in) {
- ldebug ("warning: `%s' ADC voice size %d, zero voices \n",
- drv->name, drv->voice_size_out);
- }
-
- if (drv->voice_size_out && !drv->max_voices_out) {
- ldebug ("warning: `%s' DAC voice size %d, zero voices \n",
- drv->name, drv->voice_size_in);
- }
-
- if (s->nb_hw_voices_in > drv->max_voices_in) {
- if (!drv->max_voices_in) {
- ldebug ("`%s' does not support ADC\n", drv->name);
- }
- else {
- dolog (
- "`%s' does not support %d multiple ADC voices\n"
- "Resetting to %d\n",
- drv->name,
- s->nb_hw_voices_in,
- drv->max_voices_in
- );
- }
- s->nb_hw_voices_in = drv->max_voices_in;
- }
-
- LIST_INIT (&s->hw_head_out);
- LIST_INIT (&s->hw_head_in);
+ audio_init_nb_voices_out (s, drv);
+ audio_init_nb_voices_in (s, drv);
s->drv = drv;
return 0;
}
HWVoiceOut *hwo = NULL;
HWVoiceIn *hwi = NULL;
- while ((hwo = audio_pcm_hw_find_any_out (s, hwo))) {
- if (!hwo->pcm_ops) {
- continue;
- }
-
- if (hwo->enabled) {
- hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE);
- }
+ while ((hwo = audio_pcm_hw_find_any_enabled_out (s, hwo))) {
+ hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE);
hwo->pcm_ops->fini_out (hwo);
}
- while ((hwi = audio_pcm_hw_find_any_in (s, hwi))) {
- if (!hwi->pcm_ops) {
- continue;
- }
-
- if (hwi->enabled) {
- hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE);
- }
+ while ((hwi = audio_pcm_hw_find_any_enabled_in (s, hwi))) {
+ hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE);
hwi->pcm_ops->fini_in (hwi);
}
const char *drvname;
AudioState *s = &glob_audio_state;
+ LIST_INIT (&s->hw_head_out);
+ LIST_INIT (&s->hw_head_in);
+ atexit (audio_atexit);
+
+ s->ts = qemu_new_timer (vm_clock, audio_timer, s);
+ if (!s->ts) {
+ dolog ("Could not create audio timer\n");
+ return NULL;
+ }
+
audio_process_options ("AUDIO", audio_options);
s->nb_hw_voices_out = conf.fixed_out.nb_voices;
s->nb_hw_voices_in = conf.fixed_in.nb_voices;
if (s->nb_hw_voices_out <= 0) {
- dolog ("Bogus number of DAC voices %d\n",
+ dolog ("Bogus number of playback voices %d, setting to 1\n",
s->nb_hw_voices_out);
s->nb_hw_voices_out = 1;
}
if (s->nb_hw_voices_in <= 0) {
- dolog ("Bogus number of ADC voices %d\n",
+ dolog ("Bogus number of capture voices %d, setting to 0\n",
s->nb_hw_voices_in);
- s->nb_hw_voices_in = 1;
+ s->nb_hw_voices_in = 0;
}
{
drvname = audio_get_conf_str ("QEMU_AUDIO_DRV", NULL, &def);
}
- s->ts = qemu_new_timer (vm_clock, audio_timer, s);
- if (!s->ts) {
- dolog ("Could not create audio timer\n");
- return NULL;
- }
-
if (drvname) {
int found = 0;
}
if (done) {
+ VMChangeStateEntry *e;
+
if (conf.period.hz <= 0) {
if (conf.period.hz < 0) {
dolog ("warning: Timer period is negative - %d "
conf.period.ticks = ticks_per_sec / conf.period.hz;
}
- qemu_add_vm_change_state_handler (audio_vm_change_state_handler, s);
+ e = qemu_add_vm_change_state_handler (audio_vm_change_state_handler, s);
+ if (!e) {
+ dolog ("warning: Could not register change state handler\n"
+ "(Audio can continue looping even after stopping the VM)\n");
+ }
}
else {
qemu_del_timer (s->ts);
LIST_INIT (&s->card_head);
register_savevm ("audio", 0, 1, audio_save, audio_load, s);
- atexit (audio_atexit);
qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + conf.period.ticks);
return s;
}
const char *name,
void *callback_opaque,
audio_callback_fn_t callback_fn,
- audsettings_t *settings
+ audsettings_t *settings,
+ int sw_endian
);
void AUD_close_out (QEMUSoundCard *card, SWVoiceOut *sw);
const char *name,
void *callback_opaque,
audio_callback_fn_t callback_fn,
- audsettings_t *settings
+ audsettings_t *settings,
+ int sw_endian
);
void AUD_close_in (QEMUSoundCard *card, SWVoiceIn *sw);
int64_t ratio;
void *rate;
int total_hw_samples_acquired;
- st_sample_t *conv_buf;
+ st_sample_t *buf;
f_sample *clip;
HWVoiceIn *hw;
char *name;
*/
#ifdef DAC
+#define NAME "playback"
+#define HWBUF hw->mix_buf
#define TYPE out
-#define HW glue (HWVoice, Out)
-#define SW glue (SWVoice, Out)
+#define HW HWVoiceOut
+#define SW SWVoiceOut
#else
+#define NAME "capture"
#define TYPE in
-#define HW glue (HWVoice, In)
-#define SW glue (SWVoice, In)
+#define HW HWVoiceIn
+#define SW SWVoiceIn
+#define HWBUF hw->conv_buf
#endif
-static int glue (audio_pcm_hw_init_, TYPE) (
- HW *hw,
- audsettings_t *as
+static void glue (audio_init_nb_voices_, TYPE) (
+ AudioState *s,
+ struct audio_driver *drv
)
{
- glue (audio_pcm_hw_free_resources_, TYPE) (hw);
+ int max_voices = glue (drv->max_voices_, TYPE);
+ int voice_size = glue (drv->voice_size_, TYPE);
- if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
- return -1;
+ if (glue (s->nb_hw_voices_, TYPE) > max_voices) {
+ if (!max_voices) {
+#ifdef DAC
+ dolog ("Driver `%s' does not support " NAME "\n", drv->name);
+#endif
+ }
+ else {
+ dolog ("Driver `%s' does not support %d " NAME " voices, max %d\n",
+ drv->name,
+ glue (s->nb_hw_voices_, TYPE),
+ max_voices);
+ }
+ glue (s->nb_hw_voices_, TYPE) = max_voices;
}
- if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) {
- dolog ("hw->samples=%d\n", hw->samples);
+ if (audio_bug (AUDIO_FUNC, !voice_size && max_voices)) {
+ dolog ("drv=`%s' voice_size=0 max_voices=%d\n",
+ drv->name, max_voices);
+ glue (s->nb_hw_voices_, TYPE) = 0;
+ }
+
+ if (audio_bug (AUDIO_FUNC, voice_size && !max_voices)) {
+ dolog ("drv=`%s' voice_size=%d max_voices=0\n",
+ drv->name, voice_size);
+ }
+}
+
+static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw)
+{
+ if (HWBUF) {
+ qemu_free (HWBUF);
+ }
+
+ HWBUF = NULL;
+}
+
+static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw)
+{
+ HWBUF = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (st_sample_t));
+ if (!HWBUF) {
+ dolog ("Could not allocate " NAME " buffer (%d samples)\n",
+ hw->samples);
return -1;
}
- LIST_INIT (&hw->sw_head);
+ return 0;
+}
+
+static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw)
+{
+ if (sw->buf) {
+ qemu_free (sw->buf);
+ }
+
+ if (sw->rate) {
+ st_rate_stop (sw->rate);
+ }
+
+ sw->buf = NULL;
+ sw->rate = NULL;
+}
+
+static int glue (audio_pcm_sw_alloc_resources_, TYPE) (SW *sw)
+{
+ int samples;
+
#ifdef DAC
- hw->clip =
- mixeng_clip
+ samples = sw->hw->samples;
#else
- hw->conv =
- mixeng_conv
+ samples = ((int64_t) sw->hw->samples << 32) / sw->ratio;
#endif
- [hw->info.nchannels == 2]
- [hw->info.sign]
- [hw->info.swap_endian]
- [hw->info.bits == 16];
- if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
- glue (hw->pcm_ops->fini_, TYPE) (hw);
+ sw->buf = audio_calloc (AUDIO_FUNC, samples, sizeof (st_sample_t));
+ if (!sw->buf) {
+ dolog ("Could not allocate buffer for `%s' (%d samples)\n",
+ SW_NAME (sw), samples);
return -1;
}
+#ifdef DAC
+ sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq);
+#else
+ sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq);
+#endif
+ if (!sw->rate) {
+ qemu_free (sw->buf);
+ sw->buf = NULL;
+ return -1;
+ }
return 0;
}
+static int glue (audio_pcm_sw_init_, TYPE) (
+ SW *sw,
+ HW *hw,
+ const char *name,
+ audsettings_t *as,
+ int endian
+ )
+{
+ int err;
+
+ audio_pcm_init_info (&sw->info, as, audio_need_to_swap_endian (endian));
+ sw->hw = hw;
+ sw->active = 0;
+#ifdef DAC
+ sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq;
+ sw->total_hw_samples_mixed = 0;
+ sw->empty = 1;
+#else
+ sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq;
+#endif
+
+#ifdef DAC
+ sw->conv = mixeng_conv
+#else
+ sw->clip = mixeng_clip
+#endif
+ [sw->info.nchannels == 2]
+ [sw->info.sign]
+ [sw->info.swap_endian]
+ [sw->info.bits == 16];
+
+ sw->name = qemu_strdup (name);
+ err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw);
+ if (err) {
+ qemu_free (sw->name);
+ sw->name = NULL;
+ }
+ return err;
+}
+
static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw)
{
glue (audio_pcm_sw_free_resources_, TYPE) (sw);
return NULL;
}
-static HW *glue (audio_pcm_hw_find_any_passive_, TYPE) (AudioState *s)
-{
- if (glue (s->nb_hw_voices_, TYPE)) {
- struct audio_driver *drv = s->drv;
-
- if (audio_bug (AUDIO_FUNC, !drv)) {
- dolog ("No host audio driver\n");
- return NULL;
- }
-
- HW *hw = audio_calloc (AUDIO_FUNC, 1, glue (drv->voice_size_, TYPE));
- if (!hw) {
- dolog ("Can not allocate voice `%s' size %d\n",
- drv->name, glue (drv->voice_size_, TYPE));
- return NULL;
- }
-
- LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
- glue (s->nb_hw_voices_, TYPE) -= 1;
- return hw;
- }
-
- return NULL;
-}
-
static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
AudioState *s,
HW *hw,
static HW *glue (audio_pcm_hw_add_new_, TYPE) (AudioState *s, audsettings_t *as)
{
HW *hw;
+ struct audio_driver *drv = s->drv;
- hw = glue (audio_pcm_hw_find_any_passive_, TYPE) (s);
- if (hw) {
- hw->pcm_ops = s->drv->pcm_ops;
- if (!hw->pcm_ops) {
- return NULL;
- }
+ if (!glue (s->nb_hw_voices_, TYPE)) {
+ return NULL;
+ }
- if (glue (audio_pcm_hw_init_, TYPE) (hw, as)) {
- glue (audio_pcm_hw_gc_, TYPE) (s, &hw);
- return NULL;
- }
- else {
- return hw;
- }
+ if (audio_bug (AUDIO_FUNC, !drv)) {
+ dolog ("No host audio driver\n");
+ return NULL;
}
+ if (audio_bug (AUDIO_FUNC, !drv->pcm_ops)) {
+ dolog ("Host audio driver without pcm_ops\n");
+ return NULL;
+ }
+
+ hw = audio_calloc (AUDIO_FUNC, 1, glue (drv->voice_size_, TYPE));
+ if (!hw) {
+ dolog ("Can not allocate voice `%s' size %d\n",
+ drv->name, glue (drv->voice_size_, TYPE));
+ return NULL;
+ }
+
+ hw->pcm_ops = drv->pcm_ops;
+ LIST_INIT (&hw->sw_head);
+
+ if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
+ goto err0;
+ }
+
+ if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) {
+ dolog ("hw->samples=%d\n", hw->samples);
+ goto err1;
+ }
+
+#ifdef DAC
+ hw->clip = mixeng_clip
+#else
+ hw->conv = mixeng_conv
+#endif
+ [hw->info.nchannels == 2]
+ [hw->info.sign]
+ [hw->info.swap_endian]
+ [hw->info.bits == 16];
+
+ if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
+ goto err1;
+ }
+
+ LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
+ glue (s->nb_hw_voices_, TYPE) -= 1;
+ return hw;
+
+ err1:
+ glue (hw->pcm_ops->fini_, TYPE) (hw);
+ err0:
+ qemu_free (hw);
return NULL;
}
static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
AudioState *s,
const char *sw_name,
- audsettings_t *as
+ audsettings_t *as,
+ int sw_endian
)
{
SW *sw;
glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw);
- if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) {
+ if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as, sw_endian)) {
goto err3;
}
glue (audio_pcm_hw_gc_, TYPE) (s, &sw->hw);
qemu_free (sw);
}
+
void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw)
{
if (sw) {
const char *name,
void *callback_opaque ,
audio_callback_fn_t callback_fn,
- audsettings_t *as
+ audsettings_t *as,
+ int sw_endian
)
{
AudioState *s;
goto fail;
}
- if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) {
+ glue (audio_pcm_sw_fini_, TYPE) (sw);
+ if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as, sw_endian)) {
goto fail;
}
}
else {
- sw = glue (audio_pcm_create_voice_pair_, TYPE) (s, name, as);
+ sw = glue (audio_pcm_create_voice_pair_, TYPE) (s, name, as, sw_endian);
if (!sw) {
dolog ("Failed to create voice `%s'\n", name);
- goto fail;
+ return NULL;
}
}
#undef TYPE
#undef HW
#undef SW
+#undef HWBUF
+#undef NAME
{
va_list ap;
+ va_start (ap, fmt);
AUD_vlog (AUDIO_CAP, fmt, ap);
+ va_end (ap);
- va_start (ap, fmt);
AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
- va_end (ap);
}
static void GCC_FMT_ATTR (3, 4) oss_logerr2 (
audfmt_e effective_fmt;
audsettings_t obt_as;
+ oss->fd = -1;
+
req.fmt = aud_to_ossfmt (as->fmt);
req.freq = as->freq;
req.nchannels = as->nchannels;
audfmt_e effective_fmt;
audsettings_t obt_as;
+ oss->fd = -1;
+
req.fmt = aud_to_ossfmt (as->fmt);
req.freq = as->freq;
req.nchannels = as->nchannels;
OSDN Git Service
