@samitouri / QOSamiQemu / commits / 61e95a0c60

audio: make all the backend-specific APIs take the be

This will allow to dispatch to different implementations next. Reviewed-by: Mark Cave-Ayland <mark.caveayland@nutanix.com> Reviewed-by: Akihiko Odaki <odaki@rsg.ci.i.u-tokyo.ac.jp> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Marc-André Lureau committed Nov 4, 2025 at 19:38 UTC 61e95a0c608ca169b1d0ab41f0d4da6011c2e680

22 files changed +192 -173

audio/audio.c

+9 -9

@@ -847,7 +847,7 @@ static void audio_timer (void *opaque)

847 /*

848 * Public API

849 */

850 -size_t AUD_write(SWVoiceOut *sw, void *buf, size_t size)

850 +size_t AUD_write(AudioBackend *be, SWVoiceOut *sw, void *buf, size_t size)

851 {

852 HWVoiceOut *hw;

853

@@ -869,7 +869,7 @@ size_t AUD_write(SWVoiceOut *sw, void *buf, size_t size)

869 }

870 }

871

872 -size_t AUD_read(SWVoiceIn *sw, void *buf, size_t size)

872 +size_t AUD_read(AudioBackend *be, SWVoiceIn *sw, void *buf, size_t size)

873 {

874 HWVoiceIn *hw;

875

@@ -891,7 +891,7 @@ size_t AUD_read(SWVoiceIn *sw, void *buf, size_t size)

891 }

892 }

893

894 -int AUD_get_buffer_size_out(SWVoiceOut *sw)

894 +int AUD_get_buffer_size_out(AudioBackend *be, SWVoiceOut *sw)

895 {

896 if (!sw) {

897 return 0;

@@ -904,7 +904,7 @@ int AUD_get_buffer_size_out(SWVoiceOut *sw)

904 return sw->hw->samples * sw->hw->info.bytes_per_frame;

905 }

906

907 -void AUD_set_active_out(SWVoiceOut *sw, bool on)

907 +void AUD_set_active_out(AudioBackend *be, SWVoiceOut *sw, bool on)

908 {

909 HWVoiceOut *hw;

910

@@ -952,7 +952,7 @@ void AUD_set_active_out(SWVoiceOut *sw, bool on)

952 }

953 }

954

955 -void AUD_set_active_in(SWVoiceIn *sw, bool on)

955 +void AUD_set_active_in(AudioBackend *be, SWVoiceIn *sw, bool on)

956 {

957 HWVoiceIn *hw;

958

@@ -997,7 +997,7 @@ void AUD_set_active_in(SWVoiceIn *sw, bool on)

997 }

998 }

999

1000 -static size_t audio_get_avail (SWVoiceIn *sw)

1000 +static size_t audio_get_avail(SWVoiceIn *sw)

1001 {

1002 size_t live;

1003

@@ -1938,7 +1938,7 @@ CaptureVoiceOut *AUD_add_capture(

1938 return cap;

1939 }

1940

1941 -void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque)

1941 +void AUD_del_capture(AudioBackend *be, CaptureVoiceOut *cap, void *cb_opaque)

1942 {

1943 struct capture_callback *cb;

1944

@@ -1977,7 +1977,7 @@ void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque)

1977 }

1978 }

1979

1980 -void AUD_set_volume_out(SWVoiceOut *sw, Volume *vol)

1980 +void AUD_set_volume_out(AudioBackend *be, SWVoiceOut *sw, Volume *vol)

1981 {

1982 if (sw) {

1983 HWVoiceOut *hw = sw->hw;

@@ -1993,7 +1993,7 @@ void AUD_set_volume_out(SWVoiceOut *sw, Volume *vol)

1993 }

1994 }

1995

1996 -void AUD_set_volume_in(SWVoiceIn *sw, Volume *vol)

1996 +void AUD_set_volume_in(AudioBackend *be, SWVoiceIn *sw, Volume *vol)

1997 {

1998 if (sw) {

1999 HWVoiceIn *hw = sw->hw;

audio/audio_template.h

+1 -1

@@ -569,7 +569,7 @@ SW *glue (AUD_open_, TYPE) (

569 return NULL;

570 }

571

572 -bool glue(AUD_is_active_, TYPE)(SW *sw)

572 +bool glue(AUD_is_active_, TYPE)(AudioBackend *be, SW *sw)

573 {

574 return sw ? sw->active : 0;

575 }

audio/wavcapture.c

+5 -2

@@ -1,4 +1,5 @@

1 #include "qemu/osdep.h"

2 +#include "qemu/audio.h"

3 #include "qemu/qemu-print.h"

4 #include "qemu/error-report.h"

5 #include "audio_int.h"

@@ -10,6 +11,7 @@ typedef struct {

11 int freq;

12 int bits;

13 int nchannels;

14 + AudioBackend *audio_be;

15 CaptureVoiceOut *cap;

16 } WAVState;

@@ -84,7 +86,7 @@ static void wav_capture_destroy (void *opaque)

86 {

87 WAVState *wav = opaque;

87 - AUD_del_capture (wav->cap, wav);

89 + AUD_del_capture(wav->audio_be, wav->cap, wav);

90 g_free (wav);

91 }

@@ -159,6 +161,7 @@ int wav_start_capture(AudioBackend *state, CaptureState *s, const char *path,

161 return -1;

162 }

163

164 + wav->audio_be = state;

165 wav->path = g_strdup (path);

166 wav->bits = bits;

167 wav->nchannels = nchannels;

@@ -169,7 +172,7 @@ int wav_start_capture(AudioBackend *state, CaptureState *s, const char *path,

172 goto error_free;

173 }

174

172 - cap = AUD_add_capture(state, &as, &ops, wav);

175 + cap = AUD_add_capture(wav->audio_be, &as, &ops, wav);

176 if (!cap) {

177 error_report("Failed to add audio capture");

178 goto error_free;

hw/audio/ac97.c

+12 -12

@@ -246,15 +246,15 @@ static void voice_set_active(AC97LinkState *s, int bm_index, int on)

246 {

247 switch (bm_index) {

248 case PI_INDEX:

249 - AUD_set_active_in(s->voice_pi, on);

249 + AUD_set_active_in(s->audio_be, s->voice_pi, on);

250 break;

251

252 case PO_INDEX:

253 - AUD_set_active_out(s->voice_po, on);

253 + AUD_set_active_out(s->audio_be, s->voice_po, on);

254 break;

255

256 case MC_INDEX:

257 - AUD_set_active_in(s->voice_mc, on);

257 + AUD_set_active_in(s->audio_be, s->voice_mc, on);

258 break;

259

260 default:

@@ -378,15 +378,15 @@ static void reset_voices(AC97LinkState *s, uint8_t active[LAST_INDEX])

378

379 freq = mixer_load(s, AC97_PCM_LR_ADC_Rate);

380 open_voice(s, PI_INDEX, freq);

381 - AUD_set_active_in(s->voice_pi, active[PI_INDEX]);

381 + AUD_set_active_in(s->audio_be, s->voice_pi, active[PI_INDEX]);

382

383 freq = mixer_load(s, AC97_PCM_Front_DAC_Rate);

384 open_voice(s, PO_INDEX, freq);

385 - AUD_set_active_out(s->voice_po, active[PO_INDEX]);

385 + AUD_set_active_out(s->audio_be, s->voice_po, active[PO_INDEX]);

386

387 freq = mixer_load(s, AC97_MIC_ADC_Rate);

388 open_voice(s, MC_INDEX, freq);

389 - AUD_set_active_in(s->voice_mc, active[MC_INDEX]);

389 + AUD_set_active_in(s->audio_be, s->voice_mc, active[MC_INDEX]);

390 }

391

392 static void get_volume(uint16_t vol, uint16_t mask, int inverse,

@@ -416,7 +416,7 @@ static void update_combined_volume_out(AC97LinkState *s)

416 lvol = (lvol * plvol) / 255;

417 rvol = (rvol * prvol) / 255;

418

419 - AUD_set_volume_out_lr(s->voice_po, mute, lvol, rvol);

419 + AUD_set_volume_out_lr(s->audio_be, s->voice_po, mute, lvol, rvol);

420 }

421

422 static void update_volume_in(AC97LinkState *s)

@@ -427,7 +427,7 @@ static void update_volume_in(AC97LinkState *s)

427 get_volume(mixer_load(s, AC97_Record_Gain_Mute), 0x0f, 0,

428 &mute, &lvol, &rvol);

429

430 - AUD_set_volume_in_lr(s->voice_pi, mute, lvol, rvol);

430 + AUD_set_volume_in_lr(s->audio_be, s->voice_pi, mute, lvol, rvol);

431 }

432

433 static void set_volume(AC97LinkState *s, int index, uint32_t val)

@@ -904,7 +904,7 @@ static int write_audio(AC97LinkState *s, AC97BusMasterRegs *r,

904 int copied;

905 to_copy = MIN(temp, sizeof(tmpbuf));

906 pci_dma_read(&s->dev, addr, tmpbuf, to_copy);

907 - copied = AUD_write(s->voice_po, tmpbuf, to_copy);

907 + copied = AUD_write(s->audio_be, s->voice_po, tmpbuf, to_copy);

908 dolog("write_audio max=%x to_copy=%x copied=%x",

909 max, to_copy, copied);

910 if (!copied) {

@@ -948,7 +948,7 @@ static void write_bup(AC97LinkState *s, int elapsed)

948 while (elapsed) {

949 int temp = MIN(elapsed, sizeof(s->silence));

950 while (temp) {

951 - int copied = AUD_write(s->voice_po, s->silence, temp);

951 + int copied = AUD_write(s->audio_be, s->voice_po, s->silence, temp);

952 if (!copied) {

953 return;

954 }

@@ -978,7 +978,7 @@ static int read_audio(AC97LinkState *s, AC97BusMasterRegs *r,

978 while (temp) {

979 int acquired;

980 to_copy = MIN(temp, sizeof(tmpbuf));

981 - acquired = AUD_read(voice, tmpbuf, to_copy);

981 + acquired = AUD_read(s->audio_be, voice, tmpbuf, to_copy);

982 if (!acquired) {

983 *stop = 1;

984 break;

@@ -1275,7 +1275,7 @@ static void ac97_realize(PCIDevice *dev, Error **errp)

1275 AC97LinkState *s = AC97(dev);

1276 uint8_t *c = s->dev.config;

1277

1278 - if (!AUD_backend_check (&s->audio_be, errp)) {

1278 + if (!AUD_backend_check(&s->audio_be, errp)) {

1279 return;

1280 }

1281

hw/audio/adlib.c

+5 -4

@@ -95,7 +95,7 @@ static void adlib_write(void *opaque, uint32_t nport, uint32_t val)

95 int a = nport & 3;

97 s->active = 1;

98 - AUD_set_active_out (s->voice, 1);

98 + AUD_set_active_out(s->audio_be, s->voice, 1);

100 adlib_kill_timers (s);

101

@@ -143,7 +143,8 @@ static int write_audio (AdlibState *s, int samples)

143 int nbytes, wbytes, wsampl;

144

145 nbytes = samples << SHIFT;

146 - wbytes = AUD_write (

146 + wbytes = AUD_write(

147 + s->audio_be,

148 s->voice,

149 s->mixbuf + (pos << (SHIFT - 1)),

150 nbytes

@@ -255,7 +256,7 @@ static void adlib_realizefn (DeviceState *dev, Error **errp)

256 as.fmt = AUDIO_FORMAT_S16;

257 as.endianness = HOST_BIG_ENDIAN;

258

258 - s->voice = AUD_open_out (

259 + s->voice = AUD_open_out(

260 s->audio_be,

261 s->voice,

262 "adlib",

@@ -269,7 +270,7 @@ static void adlib_realizefn (DeviceState *dev, Error **errp)

270 return;

271 }

272

272 - s->samples = AUD_get_buffer_size_out (s->voice) >> SHIFT;

273 + s->samples = AUD_get_buffer_size_out(s->audio_be, s->voice) >> SHIFT;

274 s->mixbuf = g_malloc0 (s->samples << SHIFT);

275

276 adlib_portio_list[0].offset = s->port;

hw/audio/asc.c

+8 -8

@@ -355,12 +355,12 @@ static void asc_out_cb(void *opaque, int free_b)

355 * loop because the FIFO has run out of data, and the driver

356 * reuses the stale content in its circular audio buffer.

357 */

358 - AUD_write(s->voice, s->silentbuf, samples << s->shift);

358 + AUD_write(s->audio_be, s->voice, s->silentbuf, samples << s->shift);

359 }

360 return;

361 }

362

363 - AUD_write(s->voice, s->mixbuf, generated << s->shift);

363 + AUD_write(s->audio_be, s->voice, s->mixbuf, generated << s->shift);

364 }

365

366 static uint64_t asc_fifo_read(void *opaque, hwaddr addr,

@@ -470,9 +470,9 @@ static void asc_write(void *opaque, hwaddr addr, uint64_t value,

470 asc_fifo_reset(&s->fifos[1]);

471 asc_lower_irq(s);

472 if (value != 0) {

473 - AUD_set_active_out(s->voice, 1);

473 + AUD_set_active_out(s->audio_be, s->voice, 1);

474 } else {

475 - AUD_set_active_out(s->voice, 0);

475 + AUD_set_active_out(s->audio_be, s->voice, 0);

476 }

477 }

478 break;

@@ -489,7 +489,7 @@ static void asc_write(void *opaque, hwaddr addr, uint64_t value,

489 {

490 int vol = (value & 0xe0);

491

492 - AUD_set_volume_out_lr(s->voice, 0, vol, vol);

492 + AUD_set_volume_out_lr(s->audio_be, s->voice, 0, vol, vol);

493 break;

494 }

495 }

@@ -545,7 +545,7 @@ static int asc_post_load(void *opaque, int version)

545 ASCState *s = ASC(opaque);

546

547 if (s->regs[ASC_MODE] != 0) {

548 - AUD_set_active_out(s->voice, 1);

548 + AUD_set_active_out(s->audio_be, s->voice, 1);

549 }

550

551 return 0;

@@ -614,7 +614,7 @@ static void asc_reset_hold(Object *obj, ResetType type)

614 {

615 ASCState *s = ASC(obj);

616

617 - AUD_set_active_out(s->voice, 0);

617 + AUD_set_active_out(s->audio_be, s->voice, 0);

618

619 memset(s->regs, 0, sizeof(s->regs));

620 asc_fifo_reset(&s->fifos[0]);

@@ -658,7 +658,7 @@ static void asc_realize(DeviceState *dev, Error **errp)

658 }

659

660 s->shift = 1;

661 - s->samples = AUD_get_buffer_size_out(s->voice) >> s->shift;

661 + s->samples = AUD_get_buffer_size_out(s->audio_be, s->voice) >> s->shift;

662 s->mixbuf = g_malloc0(s->samples << s->shift);

663

664 s->silentbuf = g_malloc(s->samples << s->shift);

hw/audio/cs4231a.c

+8 -8

@@ -327,7 +327,7 @@ static void cs_reset_voices (CSState *s, uint32_t val)

327 goto error;

328 }

329

330 - s->voice = AUD_open_out (

330 + s->voice = AUD_open_out(

331 s->audio_be,

332 s->voice,

333 "cs4231a",

@@ -339,7 +339,7 @@ static void cs_reset_voices (CSState *s, uint32_t val)

339 if (s->dregs[Interface_Configuration] & PEN) {

340 if (!s->dma_running) {

341 k->hold_DREQ(s->isa_dma, s->dma);

342 - AUD_set_active_out (s->voice, 1);

342 + AUD_set_active_out(s->audio_be, s->voice, 1);

343 s->transferred = 0;

344 }

345 s->dma_running = 1;

@@ -347,7 +347,7 @@ static void cs_reset_voices (CSState *s, uint32_t val)

347 else {

348 if (s->dma_running) {

349 k->release_DREQ(s->isa_dma, s->dma);

350 - AUD_set_active_out (s->voice, 0);

350 + AUD_set_active_out(s->audio_be, s->voice, 0);

351 }

352 s->dma_running = 0;

353 }

@@ -356,7 +356,7 @@ static void cs_reset_voices (CSState *s, uint32_t val)

356 error:

357 if (s->dma_running) {

358 k->release_DREQ(s->isa_dma, s->dma);

359 - AUD_set_active_out (s->voice, 0);

359 + AUD_set_active_out(s->audio_be, s->voice, 0);

360 }

361 }

362

@@ -465,7 +465,7 @@ static void cs_write (void *opaque, hwaddr addr,

465 if (s->dma_running) {

466 IsaDmaClass *k = ISADMA_GET_CLASS(s->isa_dma);

467 k->release_DREQ(s->isa_dma, s->dma);

468 - AUD_set_active_out (s->voice, 0);

468 + AUD_set_active_out(s->audio_be, s->voice, 0);

469 s->dma_running = 0;

470 }

471 }

@@ -551,11 +551,11 @@ static int cs_write_audio (CSState *s, int nchan, int dma_pos,

551

552 for (i = 0; i < copied; ++i)

553 linbuf[i] = s->tab[tmpbuf[i]];

554 - copied = AUD_write (s->voice, linbuf, copied << 1);

554 + copied = AUD_write(s->audio_be, s->voice, linbuf, copied << 1);

555 copied >>= 1;

556 }

557 else {

558 - copied = AUD_write (s->voice, tmpbuf, copied);

558 + copied = AUD_write(s->audio_be, s->voice, tmpbuf, copied);

559 }

560

561 temp -= copied;

@@ -614,7 +614,7 @@ static int cs4231a_pre_load (void *opaque)

614 if (s->dma_running) {

615 IsaDmaClass *k = ISADMA_GET_CLASS(s->isa_dma);

616 k->release_DREQ(s->isa_dma, s->dma);

617 - AUD_set_active_out (s->voice, 0);

617 + AUD_set_active_out(s->audio_be, s->voice, 0);

618 }

619 s->dma_running = 0;

620 return 0;

hw/audio/es1370.c

+6 -6

@@ -411,7 +411,7 @@ static void es1370_update_voices (ES1370State *s, uint32_t ctl, uint32_t sctl)

411

412 if (i == ADC_CHANNEL) {

413 s->adc_voice =

414 - AUD_open_in (

414 + AUD_open_in(

415 s->audio_be,

416 s->adc_voice,

417 "es1370.adc",

@@ -421,7 +421,7 @@ static void es1370_update_voices (ES1370State *s, uint32_t ctl, uint32_t sctl)

421 );

422 } else {

423 s->dac_voice[i] =

424 - AUD_open_out (

424 + AUD_open_out(

425 s->audio_be,

426 s->dac_voice[i],

427 i ? "es1370.dac2" : "es1370.dac1",

@@ -438,9 +438,9 @@ static void es1370_update_voices (ES1370State *s, uint32_t ctl, uint32_t sctl)

438 int on = (ctl & b->ctl_en) && !(sctl & b->sctl_pause);

439

440 if (i == ADC_CHANNEL) {

441 - AUD_set_active_in (s->adc_voice, on);

441 + AUD_set_active_in(s->audio_be, s->adc_voice, on);

442 } else {

443 - AUD_set_active_out (s->dac_voice[i], on);

443 + AUD_set_active_out(s->audio_be, s->dac_voice[i], on);

444 }

445 }

446 }

@@ -627,7 +627,7 @@ static void es1370_transfer_audio (ES1370State *s, struct chan *d, int loop_sel,

627 int acquired, to_copy;

628

629 to_copy = MIN(to_transfer, sizeof(tmpbuf));

630 - acquired = AUD_read (s->adc_voice, tmpbuf, to_copy);

630 + acquired = AUD_read(s->audio_be, s->adc_voice, tmpbuf, to_copy);

631 if (!acquired) {

632 break;

633 }

@@ -646,7 +646,7 @@ static void es1370_transfer_audio (ES1370State *s, struct chan *d, int loop_sel,

646

647 to_copy = MIN(to_transfer, sizeof(tmpbuf));

648 pci_dma_read (&s->dev, addr, tmpbuf, to_copy);

649 - copied = AUD_write (voice, tmpbuf, to_copy);

649 + copied = AUD_write(s->audio_be, voice, tmpbuf, to_copy);

650 if (!copied) {

651 break;

652 }

hw/audio/gus.c

+5 -4

@@ -87,7 +87,8 @@ static int write_audio (GUSState *s, int samples)

87 int nbytes, wbytes, wsampl;

89 nbytes = samples << s->shift;

90 - wbytes = AUD_write (

90 + wbytes = AUD_write(

91 + s->audio_be,

92 s->voice,

93 s->mixbuf + (pos << (s->shift - 1)),

94 nbytes

@@ -257,7 +258,7 @@ static void gus_realizefn (DeviceState *dev, Error **errp)

258 as.fmt = AUDIO_FORMAT_S16;

259 as.endianness = HOST_BIG_ENDIAN;

260

260 - s->voice = AUD_open_out (

261 + s->voice = AUD_open_out(

262 s->audio_be,

263 NULL,

264 "gus",

@@ -272,7 +273,7 @@ static void gus_realizefn (DeviceState *dev, Error **errp)

273 }

274

275 s->shift = 2;

275 - s->samples = AUD_get_buffer_size_out (s->voice) >> s->shift;

276 + s->samples = AUD_get_buffer_size_out(s->audio_be, s->voice) >> s->shift;

277 s->mixbuf = g_malloc0 (s->samples << s->shift);

278

279 isa_register_portio_list(d, &s->portio_list1, s->port,

@@ -287,7 +288,7 @@ static void gus_realizefn (DeviceState *dev, Error **errp)

288 s->emu.opaque = s;

289 s->pic = isa_bus_get_irq(bus, s->emu.gusirq);

290

290 - AUD_set_active_out (s->voice, 1);

291 + AUD_set_active_out(s->audio_be, s->voice, 1);

292 }

293

294 static const Property gus_properties[] = {

hw/audio/hda-codec.c

+12 -8

@@ -275,7 +275,8 @@ static void hda_audio_input_cb(void *opaque, int avail)

275 while (to_transfer) {

276 uint32_t start = (uint32_t) (wpos & B_MASK);

277 uint32_t chunk = (uint32_t) MIN(B_SIZE - start, to_transfer);

278 - uint32_t read = AUD_read(st->voice.in, st->buf + start, chunk);

278 + uint32_t read = AUD_read(st->state->audio_be, st->voice.in,

279 + st->buf + start, chunk);

280 wpos += read;

281 to_transfer -= read;

282 st->wpos += read;

@@ -354,7 +355,8 @@ static void hda_audio_output_cb(void *opaque, int avail)

355 while (to_transfer) {

356 uint32_t start = (uint32_t) (rpos & B_MASK);

357 uint32_t chunk = (uint32_t) MIN(B_SIZE - start, to_transfer);

357 - uint32_t written = AUD_write(st->voice.out, st->buf + start, chunk);

358 + uint32_t written = AUD_write(st->state->audio_be, st->voice.out,

359 + st->buf + start, chunk);

360 rpos += written;

361 to_transfer -= written;

362 st->rpos += written;

@@ -375,7 +377,8 @@ static void hda_audio_compat_input_cb(void *opaque, int avail)

377

378 while (avail - recv >= sizeof(st->compat_buf)) {

379 if (st->compat_bpos != sizeof(st->compat_buf)) {

378 - len = AUD_read(st->voice.in, st->compat_buf + st->compat_bpos,

380 + len = AUD_read(st->state->audio_be, st->voice.in,

381 + st->compat_buf + st->compat_bpos,

382 sizeof(st->compat_buf) - st->compat_bpos);

383 st->compat_bpos += len;

384 recv += len;

@@ -408,7 +411,8 @@ static void hda_audio_compat_output_cb(void *opaque, int avail)

411 }

412 st->compat_bpos = 0;

413 }

411 - len = AUD_write(st->voice.out, st->compat_buf + st->compat_bpos,

414 + len = AUD_write(st->state->audio_be, st->voice.out,

415 + st->compat_buf + st->compat_bpos,

416 sizeof(st->compat_buf) - st->compat_bpos);

417 st->compat_bpos += len;

418 sent += len;

@@ -440,9 +444,9 @@ static void hda_audio_set_running(HDAAudioStream *st, bool running)

444 }

445 }

446 if (st->output) {

443 - AUD_set_active_out(st->voice.out, st->running);

447 + AUD_set_active_out(st->state->audio_be, st->voice.out, st->running);

448 } else {

445 - AUD_set_active_in(st->voice.in, st->running);

449 + AUD_set_active_in(st->state->audio_be, st->voice.in, st->running);

450 }

451 }

452

@@ -466,9 +470,9 @@ static void hda_audio_set_amp(HDAAudioStream *st)

470 return;

471 }

472 if (st->output) {

469 - AUD_set_volume_out_lr(st->voice.out, muted, left, right);

473 + AUD_set_volume_out_lr(st->state->audio_be, st->voice.out, muted, left, right);

474 } else {

471 - AUD_set_volume_in_lr(st->voice.in, muted, left, right);

475 + AUD_set_volume_in_lr(st->state->audio_be, st->voice.in, muted, left, right);

476 }

477 }

478

hw/audio/lm4549.c

+6 -6

@@ -101,11 +101,11 @@ static void lm4549_audio_transfer(lm4549_state *s)

101 uint32_t i;

102

103 /* Activate the voice */

104 - AUD_set_active_out(s->voice, 1);

104 + AUD_set_active_out(s->audio_be, s->voice, 1);

105 s->voice_is_active = 1;

106

107 /* Try to write the buffer content */

108 - written_bytes = AUD_write(s->voice, s->buffer,

108 + written_bytes = AUD_write(s->audio_be, s->voice, s->buffer,

109 s->buffer_level * sizeof(uint16_t));

110 written_samples = written_bytes >> 1;

111

@@ -129,14 +129,14 @@ static void lm4549_audio_out_callback(void *opaque, int free)

129 static uint32_t prev_buffer_level;

130

131 #ifdef LM4549_DEBUG

132 - int size = AUD_get_buffer_size_out(s->voice);

132 + int size = AUD_get_buffer_size_out(s->audio_be, s->voice);

133 DPRINTF("audio_out_callback size = %i free = %i\n", size, free);

134 #endif

135

136 /* Detect that no data are consumed

137 => disable the voice */

138 if (s->buffer_level == prev_buffer_level) {

139 - AUD_set_active_out(s->voice, 0);

139 + AUD_set_active_out(s->audio_be, s->voice, 0);

140 s->voice_is_active = 0;

141 }

142 prev_buffer_level = s->buffer_level;

@@ -285,7 +285,7 @@ static int lm4549_post_load(void *opaque, int version_id)

285

286 /* Request data */

287 if (s->voice_is_active == 1) {

288 - lm4549_audio_out_callback(s, AUD_get_buffer_size_out(s->voice));

288 + lm4549_audio_out_callback(s, AUD_get_buffer_size_out(s->audio_be, s->voice));

289 }

290

291 return 0;

@@ -323,7 +323,7 @@ void lm4549_init(lm4549_state *s, lm4549_callback data_req_cb, void* opaque,

323 &as

324 );

325

326 - AUD_set_volume_out_lr(s->voice, 0, 255, 255);

326 + AUD_set_volume_out_lr(s->audio_be, s->voice, 0, 255, 255);

327

328 s->voice_is_active = 0;

329

hw/audio/pcspk.c

+2 -2

@@ -105,7 +105,7 @@ static void pcspk_callback(void *opaque, int free)

105

106 while (free > 0) {

107 n = MIN(s->samples - s->play_pos, (unsigned int)free);

108 - n = AUD_write(s->voice, &s->sample_buf[s->play_pos], n);

108 + n = AUD_write(s->audio_be, s->voice, &s->sample_buf[s->play_pos], n);

109 if (!n)

110 break;

111 s->play_pos = (s->play_pos + n) % s->samples;

@@ -163,7 +163,7 @@ static void pcspk_io_write(void *opaque, hwaddr addr, uint64_t val,

163 if (s->voice) {

164 if (gate) /* restart */

165 s->play_pos = 0;

166 - AUD_set_active_out(s->voice, gate & s->data_on);

166 + AUD_set_active_out(s->audio_be, s->voice, gate & s->data_on);

167 }

168 }

169

hw/audio/sb16.c

+7 -7

@@ -185,11 +185,11 @@ static void control (SB16State *s, int hold)

185

186 if (hold) {

187 k->hold_DREQ(isa_dma, dma);

188 - AUD_set_active_out (s->voice, 1);

188 + AUD_set_active_out(s->audio_be, s->voice, 1);

189 }

190 else {

191 k->release_DREQ(isa_dma, dma);

192 - AUD_set_active_out (s->voice, 0);

192 + AUD_set_active_out(s->audio_be, s->voice, 0);

193 }

194 }

195

@@ -215,7 +215,7 @@ static void continue_dma8 (SB16State *s)

215 as.fmt = s->fmt;

216 as.endianness = 0;

217

218 - s->voice = AUD_open_out (

218 + s->voice = AUD_open_out(

219 s->audio_be,

220 s->voice,

221 "sb16",

@@ -378,7 +378,7 @@ static void dma_cmd (SB16State *s, uint8_t cmd, uint8_t d0, int dma_len)

378 as.fmt = s->fmt;

379 as.endianness = 0;

380

381 - s->voice = AUD_open_out (

381 + s->voice = AUD_open_out(

382 s->audio_be,

383 s->voice,

384 "sb16",

@@ -879,7 +879,7 @@ static void legacy_reset (SB16State *s)

879 as.fmt = AUDIO_FORMAT_U8;

880 as.endianness = 0;

881

882 - s->voice = AUD_open_out (

882 + s->voice = AUD_open_out(

883 s->audio_be,

884 s->voice,

885 "sb16",

@@ -1196,7 +1196,7 @@ static int write_audio (SB16State *s, int nchan, int dma_pos,

1196 }

1197

1198 copied = k->read_memory(isa_dma, nchan, tmpbuf, dma_pos, to_copy);

1199 - copied = AUD_write (s->voice, tmpbuf, copied);

1199 + copied = AUD_write(s->audio_be, s->voice, tmpbuf, copied);

1200

1201 temp -= copied;

1202 dma_pos = (dma_pos + copied) % dma_len;

@@ -1302,7 +1302,7 @@ static int sb16_post_load (void *opaque, int version_id)

1302 as.fmt = s->fmt;

1303 as.endianness = 0;

1304

1305 - s->voice = AUD_open_out (

1305 + s->voice = AUD_open_out(

1306 s->audio_be,

1307 s->voice,

1308 "sb16",

hw/audio/via-ac97.c

+7 -7

@@ -53,7 +53,7 @@ static void codec_volume_set_out(ViaAC97State *s)

53 rvol /= 255;

54 mute = CODEC_REG(s, AC97_Master_Volume_Mute) >> MUTE_SHIFT;

55 mute |= CODEC_REG(s, AC97_PCM_Out_Volume_Mute) >> MUTE_SHIFT;

56 - AUD_set_volume_out_lr(s->vo, mute, lvol, rvol);

56 + AUD_set_volume_out_lr(s->audio_be, s->vo, mute, lvol, rvol);

57 }

59 static void codec_reset(ViaAC97State *s)

@@ -189,7 +189,7 @@ static void out_cb(void *opaque, int avail)

189 while (temp) {

190 to_copy = MIN(temp, sizeof(tmpbuf));

191 pci_dma_read(&s->dev, c->addr, tmpbuf, to_copy);

192 - copied = AUD_write(s->vo, tmpbuf, to_copy);

192 + copied = AUD_write(s->audio_be, s->vo, tmpbuf, to_copy);

193 if (!copied) {

194 stop = true;

195 break;

@@ -208,7 +208,7 @@ static void out_cb(void *opaque, int avail)

208 c->stat |= STAT_PAUSED;

209 } else {

210 c->stat &= ~STAT_ACTIVE;

211 - AUD_set_active_out(s->vo, 0);

211 + AUD_set_active_out(s->audio_be, s->vo, 0);

212 }

213 if (c->type & STAT_EOL) {

214 via_isa_set_irq(&s->dev, 0, 1);

@@ -317,20 +317,20 @@ static void sgd_write(void *opaque, hwaddr addr, uint64_t val, unsigned size)

317 break;

318 case 1:

319 if (val & CNTL_START) {

320 - AUD_set_active_out(s->vo, 1);

320 + AUD_set_active_out(s->audio_be, s->vo, 1);

321 s->aur.stat = STAT_ACTIVE;

322 }

323 if (val & CNTL_TERM) {

324 - AUD_set_active_out(s->vo, 0);

324 + AUD_set_active_out(s->audio_be, s->vo, 0);

325 s->aur.stat &= ~(STAT_ACTIVE | STAT_PAUSED);

326 s->aur.clen = 0;

327 }

328 if (val & CNTL_PAUSE) {

329 - AUD_set_active_out(s->vo, 0);

329 + AUD_set_active_out(s->audio_be, s->vo, 0);

330 s->aur.stat &= ~STAT_ACTIVE;

331 s->aur.stat |= STAT_PAUSED;

332 } else if (!(val & CNTL_PAUSE) && (s->aur.stat & STAT_PAUSED)) {

333 - AUD_set_active_out(s->vo, 1);

333 + AUD_set_active_out(s->audio_be, s->vo, 1);

334 s->aur.stat |= STAT_ACTIVE;

335 s->aur.stat &= ~STAT_PAUSED;

336 }

hw/audio/virtio-snd.c

+8 -6

@@ -475,7 +475,7 @@ static uint32_t virtio_snd_pcm_prepare(VirtIOSound *s, uint32_t stream_id)

475 stream,

476 virtio_snd_pcm_out_cb,

477 &as);

478 - AUD_set_volume_out_lr(stream->voice.out, 0, 255, 255);

478 + AUD_set_volume_out_lr(s->audio_be, stream->voice.out, 0, 255, 255);

479 } else {

480 stream->voice.in = AUD_open_in(s->audio_be,

481 stream->voice.in,

@@ -483,7 +483,7 @@ static uint32_t virtio_snd_pcm_prepare(VirtIOSound *s, uint32_t stream_id)

483 stream,

484 virtio_snd_pcm_in_cb,

485 &as);

486 - AUD_set_volume_in_lr(stream->voice.in, 0, 255, 255);

486 + AUD_set_volume_in_lr(s->audio_be, stream->voice.in, 0, 255, 255);

487 }

488

489 return cpu_to_le32(VIRTIO_SND_S_OK);

@@ -573,9 +573,9 @@ static void virtio_snd_handle_pcm_start_stop(VirtIOSound *s,

573 stream->active = start;

574 }

575 if (stream->info.direction == VIRTIO_SND_D_OUTPUT) {

576 - AUD_set_active_out(stream->voice.out, start);

576 + AUD_set_active_out(s->audio_be, stream->voice.out, start);

577 } else {

578 - AUD_set_active_in(stream->voice.in, start);

578 + AUD_set_active_in(s->audio_be, stream->voice.in, start);

579 }

580 } else {

581 error_report("Invalid stream id: %"PRIu32, stream_id);

@@ -1177,7 +1177,8 @@ static void virtio_snd_pcm_out_cb(void *data, int available)

1177 buffer->populated = true;

1178 }

1179 for (;;) {

1180 - size = AUD_write(stream->voice.out,

1180 + size = AUD_write(stream->s->audio_be,

1181 + stream->voice.out,

1182 buffer->data + buffer->offset,

1183 MIN(buffer->size, available));

1184 assert(size <= MIN(buffer->size, available));

@@ -1279,7 +1280,8 @@ static void virtio_snd_pcm_in_cb(void *data, int available)

1280 to_read = stream->params.period_bytes - buffer->size;

1281 to_read = MIN(to_read, available);

1282 to_read = MIN(to_read, max_size - buffer->size);

1282 - size = AUD_read(stream->voice.in,

1283 + size = AUD_read(stream->s->audio_be,

1284 + stream->voice.in,

1285 buffer->data + buffer->size,

1286 to_read);

1287 if (!size) {

hw/audio/wm8750.c

+12 -12

@@ -72,7 +72,7 @@ static inline void wm8750_in_load(WM8750State *s)

72 if (s->idx_in + s->req_in <= sizeof(s->data_in))

73 return;

74 s->idx_in = MAX(0, (int) sizeof(s->data_in) - s->req_in);

75 - AUD_read(*s->in[0], s->data_in + s->idx_in,

75 + AUD_read(s->audio_be, *s->in[0], s->data_in + s->idx_in,

76 sizeof(s->data_in) - s->idx_in);

77 }

@@ -80,7 +80,7 @@ static inline void wm8750_out_flush(WM8750State *s)

80 {

81 int sent = 0;

82 while (sent < s->idx_out)

83 - sent += AUD_write(*s->out[0], s->data_out + sent, s->idx_out - sent)

83 + sent += AUD_write(s->audio_be, *s->out[0], s->data_out + sent, s->idx_out - sent)

84 ?: s->idx_out;

85 s->idx_out = 0;

86 }

@@ -145,30 +145,30 @@ static void wm8750_vol_update(WM8750State *s)

145 {

146 /* FIXME: multiply all volumes by s->invol[2], s->invol[3] */

147

148 - AUD_set_volume_in_lr(s->adc_voice[0], s->mute,

148 + AUD_set_volume_in_lr(s->audio_be, s->adc_voice[0], s->mute,

149 s->inmute[0] ? 0 : WM8750_INVOL_TRANSFORM(s->invol[0]),

150 s->inmute[1] ? 0 : WM8750_INVOL_TRANSFORM(s->invol[1]));

151 - AUD_set_volume_in_lr(s->adc_voice[1], s->mute,

151 + AUD_set_volume_in_lr(s->audio_be, s->adc_voice[1], s->mute,

152 s->inmute[0] ? 0 : WM8750_INVOL_TRANSFORM(s->invol[0]),

153 s->inmute[1] ? 0 : WM8750_INVOL_TRANSFORM(s->invol[1]));

154 - AUD_set_volume_in_lr(s->adc_voice[2], s->mute,

154 + AUD_set_volume_in_lr(s->audio_be, s->adc_voice[2], s->mute,

155 s->inmute[0] ? 0 : WM8750_INVOL_TRANSFORM(s->invol[0]),

156 s->inmute[1] ? 0 : WM8750_INVOL_TRANSFORM(s->invol[1]));

157

158 /* FIXME: multiply all volumes by s->outvol[0], s->outvol[1] */

159

160 /* Speaker: LOUT2VOL ROUT2VOL */

161 - AUD_set_volume_out_lr(s->dac_voice[0], s->mute,

161 + AUD_set_volume_out_lr(s->audio_be, s->dac_voice[0], s->mute,

162 s->outmute[0] ? 0 : WM8750_OUTVOL_TRANSFORM(s->outvol[4]),

163 s->outmute[1] ? 0 : WM8750_OUTVOL_TRANSFORM(s->outvol[5]));

164

165 /* Headphone: LOUT1VOL ROUT1VOL */

166 - AUD_set_volume_out_lr(s->dac_voice[1], s->mute,

166 + AUD_set_volume_out_lr(s->audio_be, s->dac_voice[1], s->mute,

167 s->outmute[0] ? 0 : WM8750_OUTVOL_TRANSFORM(s->outvol[2]),

168 s->outmute[1] ? 0 : WM8750_OUTVOL_TRANSFORM(s->outvol[3]));

169

170 /* MONOOUT: MONOVOL MONOVOL */

171 - AUD_set_volume_out_lr(s->dac_voice[2], s->mute,

171 + AUD_set_volume_out_lr(s->audio_be, s->dac_voice[2], s->mute,

172 s->outmute[0] ? 0 : WM8750_OUTVOL_TRANSFORM(s->outvol[6]),

173 s->outmute[1] ? 0 : WM8750_OUTVOL_TRANSFORM(s->outvol[6]));

174 }

@@ -182,9 +182,9 @@ static void wm8750_set_format(WM8750State *s)

182 wm8750_out_flush(s);

183

184 if (s->in[0] && *s->in[0])

185 - AUD_set_active_in(*s->in[0], 0);

185 + AUD_set_active_in(s->audio_be, *s->in[0], 0);

186 if (s->out[0] && *s->out[0])

187 - AUD_set_active_out(*s->out[0], 0);

187 + AUD_set_active_out(s->audio_be, *s->out[0], 0);

188

189 for (i = 0; i < IN_PORT_N; i ++)

190 if (s->adc_voice[i]) {

@@ -235,9 +235,9 @@ static void wm8750_set_format(WM8750State *s)

235 * for mixing or combining paths to different ports, so we

236 * connect both channels to where the left channel is routed. */

237 if (s->in[0] && *s->in[0])

238 - AUD_set_active_in(*s->in[0], 1);

238 + AUD_set_active_in(s->audio_be, *s->in[0], 1);

239 if (s->out[0] && *s->out[0])

240 - AUD_set_active_out(*s->out[0], 1);

240 + AUD_set_active_out(s->audio_be, *s->out[0], 1);

241 }

242

243 static void wm8750_clk_update(WM8750State *s, int ext)

hw/display/xlnx_dp.c

+5 -5

@@ -331,7 +331,7 @@ static inline void xlnx_dp_audio_activate(XlnxDPState *s)

331 {

332 bool activated = ((s->core_registers[DP_TX_AUDIO_CONTROL]

333 & DP_TX_AUD_CTRL) != 0);

334 - AUD_set_active_out(s->amixer_output_stream, activated);

334 + AUD_set_active_out(s->audio_be, s->amixer_output_stream, activated);

335 xlnx_dpdma_set_host_data_location(s->dpdma, DP_AUDIO_DMA_CHANNEL(0),

336 &s->audio_buffer_0);

337 xlnx_dpdma_set_host_data_location(s->dpdma, DP_AUDIO_DMA_CHANNEL(1),

@@ -401,7 +401,7 @@ static void xlnx_dp_audio_callback(void *opaque, int avail)

401 /* Send the buffer through the audio. */

402 if (s->byte_left <= MAX_QEMU_BUFFER_SIZE) {

403 if (s->byte_left != 0) {

404 - written = AUD_write(s->amixer_output_stream,

404 + written = AUD_write(s->audio_be, s->amixer_output_stream,

405 &s->out_buffer[s->data_ptr], s->byte_left);

406 } else {

407 int len_to_copy;

@@ -413,12 +413,12 @@ static void xlnx_dp_audio_callback(void *opaque, int avail)

413 while (avail) {

414 len_to_copy = MIN(AUD_CHBUF_MAX_DEPTH, avail);

415 memset(s->out_buffer, 0, len_to_copy);

416 - avail -= AUD_write(s->amixer_output_stream, s->out_buffer,

416 + avail -= AUD_write(s->audio_be, s->amixer_output_stream, s->out_buffer,

417 len_to_copy);

418 }

419 }

420 } else {

421 - written = AUD_write(s->amixer_output_stream,

421 + written = AUD_write(s->audio_be, s->amixer_output_stream,

422 &s->out_buffer[s->data_ptr], MAX_QEMU_BUFFER_SIZE);

423 }

424 s->byte_left -= written;

@@ -1401,7 +1401,7 @@ static void xlnx_dp_realize(DeviceState *dev, Error **errp)

1401 s,

1402 xlnx_dp_audio_callback,

1403 &as);

1404 - AUD_set_volume_out_lr(s->amixer_output_stream, 0, 255, 255);

1404 + AUD_set_volume_out_lr(s->audio_be, s->amixer_output_stream, 0, 255, 255);

1405 xlnx_dp_audio_activate(s);

1406 s->vblank = ptimer_init(vblank_hit, s, DP_VBLANK_PTIMER_POLICY);

1407 ptimer_transaction_begin(s->vblank);

hw/usb/dev-audio.c

+6 -6

@@ -669,7 +669,7 @@ static void output_callback(void *opaque, int avail)

669 return;

670 }

671

672 - written = AUD_write(s->out.voice, data, len);

672 + written = AUD_write(s->audio_be, s->out.voice, data, len);

673 avail -= written;

674 s->out.buf.cons += written;

675

@@ -683,7 +683,7 @@ static int usb_audio_set_output_altset(USBAudioState *s, int altset)

683 {

684 switch (altset) {

685 case ALTSET_OFF:

686 - AUD_set_active_out(s->out.voice, false);

686 + AUD_set_active_out(s->audio_be, s->out.voice, false);

687 break;

688 case ALTSET_STEREO:

689 case ALTSET_51:

@@ -692,7 +692,7 @@ static int usb_audio_set_output_altset(USBAudioState *s, int altset)

692 usb_audio_reinit(USB_DEVICE(s), altset_channels[altset]);

693 }

694 streambuf_init(&s->out.buf, s->buffer, s->out.channels);

695 - AUD_set_active_out(s->out.voice, true);

695 + AUD_set_active_out(s->audio_be, s->out.voice, true);

696 break;

697 default:

698 return -1;

@@ -805,7 +805,7 @@ static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,

805 }

806 fprintf(stderr, "\n");

807 }

808 - AUD_set_volume_out(s->out.voice, &s->out.vol);

808 + AUD_set_volume_out(s->audio_be, s->out.voice, &s->out.vol);

809 }

810

811 return ret;

@@ -980,8 +980,8 @@ static void usb_audio_reinit(USBDevice *dev, unsigned channels)

980

981 s->out.voice = AUD_open_out(s->audio_be, s->out.voice, TYPE_USB_AUDIO,

982 s, output_callback, &s->out.as);

983 - AUD_set_volume_out(s->out.voice, &s->out.vol);

984 - AUD_set_active_out(s->out.voice, 0);

983 + AUD_set_volume_out(s->audio_be, s->out.voice, &s->out.vol);

984 + AUD_set_active_out(s->audio_be, s->out.voice, 0);

985 }

986

987 static const VMStateDescription vmstate_usb_audio = {

include/qemu/audio-capture.h

+6 -3

@@ -36,8 +36,11 @@ CaptureVoiceOut *AUD_add_capture(

36 AudioBackend *be,

37 struct audsettings *as,

38 struct audio_capture_ops *ops,

39 - void *opaque

40 - );

41 -void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque);

39 + void *opaque);

40 +

41 +void AUD_del_capture(

42 + AudioBackend *be,

43 + CaptureVoiceOut *cap,

44 + void *cb_opaque);

46 #endif /* QEMU_AUDIO_CAPTURE_H */

include/qemu/audio.h

+19 -15

@@ -63,7 +63,7 @@ typedef struct AudioBackendClass {

64 bool AUD_backend_check(AudioBackend **be, Error **errp);

66 -SWVoiceOut *AUD_open_out (

66 +SWVoiceOut *AUD_open_out(

67 AudioBackend *be,

68 SWVoiceOut *sw,

69 const char *name,

@@ -72,11 +72,11 @@ SWVoiceOut *AUD_open_out (

72 const struct audsettings *settings

73 );

75 -void AUD_close_out (AudioBackend *be, SWVoiceOut *sw);

76 -size_t AUD_write (SWVoiceOut *sw, void *pcm_buf, size_t size);

77 -int AUD_get_buffer_size_out (SWVoiceOut *sw);

78 -void AUD_set_active_out(SWVoiceOut *sw, bool on);

79 -bool AUD_is_active_out(SWVoiceOut *sw);

75 +void AUD_close_out(AudioBackend *be, SWVoiceOut *sw);

76 +size_t AUD_write(AudioBackend *be, SWVoiceOut *sw, void *pcm_buf, size_t size);

77 +int AUD_get_buffer_size_out(AudioBackend *be, SWVoiceOut *sw);

78 +void AUD_set_active_out(AudioBackend *be, SWVoiceOut *sw, bool on);

79 +bool AUD_is_active_out(AudioBackend *be, SWVoiceOut *sw);

81 #define AUDIO_MAX_CHANNELS 16

82 typedef struct Volume {

@@ -85,19 +85,23 @@ typedef struct Volume {

85 uint8_t vol[AUDIO_MAX_CHANNELS];

86 } Volume;

88 -void AUD_set_volume_out(SWVoiceOut *sw, Volume *vol);

89 -void AUD_set_volume_in(SWVoiceIn *sw, Volume *vol);

88 +void AUD_set_volume_out(AudioBackend *be, SWVoiceOut *sw, Volume *vol);

89 +void AUD_set_volume_in(AudioBackend *be, SWVoiceIn *sw, Volume *vol);

91 static inline void

92 -AUD_set_volume_out_lr(SWVoiceOut *sw, bool mut, uint8_t lvol, uint8_t rvol) {

93 - AUD_set_volume_out(sw, &(Volume) {

92 +AUD_set_volume_out_lr(AudioBackend *be, SWVoiceOut *sw,

93 + bool mut, uint8_t lvol, uint8_t rvol)

94 +{

95 + AUD_set_volume_out(be, sw, &(Volume) {

96 .mute = mut, .channels = 2, .vol = { lvol, rvol }

97 });

98 }

100 static inline void

99 -AUD_set_volume_in_lr(SWVoiceIn *sw, bool mut, uint8_t lvol, uint8_t rvol) {

100 - AUD_set_volume_in(sw, &(Volume) {

101 +AUD_set_volume_in_lr(AudioBackend *be, SWVoiceIn *sw,

102 + bool mut, uint8_t lvol, uint8_t rvol)

103 +{

104 + AUD_set_volume_in(be, sw, &(Volume) {

105 .mute = mut, .channels = 2, .vol = { lvol, rvol }

106 });

107 }

@@ -112,9 +116,9 @@ SWVoiceIn *AUD_open_in(

116 );

117

118 void AUD_close_in(AudioBackend *be, SWVoiceIn *sw);

115 -size_t AUD_read (SWVoiceIn *sw, void *pcm_buf, size_t size);

116 -void AUD_set_active_in(SWVoiceIn *sw, bool on);

117 -bool AUD_is_active_in(SWVoiceIn *sw);

119 +size_t AUD_read(AudioBackend *be, SWVoiceIn *sw, void *pcm_buf, size_t size);

120 +void AUD_set_active_in(AudioBackend *be, SWVoiceIn *sw, bool on);

121 +bool AUD_is_active_in(AudioBackend *be, SWVoiceIn *sw);

122

123 void audio_cleanup(void);

124

tests/audio/test-audio.c

+42 -41

@@ -142,7 +142,7 @@ static void test_sine_callback(void *opaque, int avail)

142

143 generate_sine_samples(buffer, frames_to_write, s->frames_written);

144

145 - bytes_written = AUD_write(s->voice, buffer,

145 + bytes_written = AUD_write(s->be, s->voice, buffer,

146 frames_to_write * sizeof(int16_t) * CHANNELS);

147 s->frames_written += bytes_written / (sizeof(int16_t) * CHANNELS);

148 }

@@ -163,7 +163,7 @@ static void test_audio_out_sine_wave(void)

163 &state, test_sine_callback);

164

165 g_test_message("Playing 440Hz sine wave for %d seconds...", DURATION_SECS);

166 - AUD_set_active_out(state.voice, true);

166 + AUD_set_active_out(state.be, state.voice, true);

167

168 /*

169 * Run the audio subsystem until all frames are written or timeout.

@@ -188,7 +188,7 @@ static void test_audio_out_sine_wave(void)

188

189 g_assert_cmpint(state.frames_written, ==, state.total_frames);

190

191 - AUD_set_active_out(state.voice, false);

191 + AUD_set_active_out(state.be, state.voice, false);

192 AUD_close_out(state.be, state.voice);

193 }

194

@@ -224,13 +224,13 @@ static void test_audio_out_active_state(void)

224 be = get_test_audio_backend();

225 voice = open_test_voice_out(be, "test-active", NULL, dummy_audio_callback);

226

227 - g_assert_false(AUD_is_active_out(voice));

227 + g_assert_false(AUD_is_active_out(be, voice));

228

229 - AUD_set_active_out(voice, true);

230 - g_assert_true(AUD_is_active_out(voice));

229 + AUD_set_active_out(be, voice, true);

230 + g_assert_true(AUD_is_active_out(be, voice));

231

232 - AUD_set_active_out(voice, false);

233 - g_assert_false(AUD_is_active_out(voice));

232 + AUD_set_active_out(be, voice, false);

233 + g_assert_false(AUD_is_active_out(be, voice));

234

235 AUD_close_out(be, voice);

236 }

@@ -244,13 +244,13 @@ static void test_audio_out_buffer_size(void)

244 be = get_test_audio_backend();

245 voice = open_test_voice_out(be, "test-buffer", NULL, dummy_audio_callback);

246

247 - buffer_size = AUD_get_buffer_size_out(voice);

247 + buffer_size = AUD_get_buffer_size_out(be, voice);

248 g_test_message("Buffer size: %d bytes", buffer_size);

249 g_assert_cmpint(buffer_size, >, 0);

250

251 AUD_close_out(be, voice);

252

253 - g_assert_cmpint(AUD_get_buffer_size_out(NULL), ==, 0);

253 + g_assert_cmpint(AUD_get_buffer_size_out(NULL, NULL), ==, 0);

254 }

255

256 static void test_audio_out_volume(void)

@@ -263,13 +263,13 @@ static void test_audio_out_volume(void)

263 voice = open_test_voice_out(be, "test-volume", NULL, dummy_audio_callback);

264

265 vol = (Volume){ .mute = false, .channels = 2, .vol = {255, 255} };

266 - AUD_set_volume_out(voice, &vol);

266 + AUD_set_volume_out(be, voice, &vol);

267

268 vol = (Volume){ .mute = true, .channels = 2, .vol = {255, 255} };

269 - AUD_set_volume_out(voice, &vol);

269 + AUD_set_volume_out(be, voice, &vol);

270

271 vol = (Volume){ .mute = false, .channels = 2, .vol = {128, 128} };

272 - AUD_set_volume_out(voice, &vol);

272 + AUD_set_volume_out(be, voice, &vol);

273

274 AUD_close_out(be, voice);

275 }

@@ -286,13 +286,13 @@ static void test_audio_in_active_state(void)

286 return;

287 }

288

289 - g_assert_false(AUD_is_active_in(voice));

289 + g_assert_false(AUD_is_active_in(be, voice));

290

291 - AUD_set_active_in(voice, true);

292 - g_assert_true(AUD_is_active_in(voice));

291 + AUD_set_active_in(be, voice, true);

292 + g_assert_true(AUD_is_active_in(be, voice));

293

294 - AUD_set_active_in(voice, false);

295 - g_assert_false(AUD_is_active_in(voice));

294 + AUD_set_active_in(be, voice, false);

295 + g_assert_false(AUD_is_active_in(be, voice));

296

297 AUD_close_in(be, voice);

298 }

@@ -311,10 +311,10 @@ static void test_audio_in_volume(void)

311 }

312

313 vol = (Volume){ .mute = false, .channels = 2, .vol = {255, 255} };

314 - AUD_set_volume_in(voice, &vol);

314 + AUD_set_volume_in(be, voice, &vol);

315

316 vol = (Volume){ .mute = true, .channels = 2, .vol = {255, 255} };

317 - AUD_set_volume_in(voice, &vol);

317 + AUD_set_volume_in(be, voice, &vol);

318

319 AUD_close_in(be, voice);

320 }

@@ -427,7 +427,7 @@ static void test_audio_capture(void)

427 &sine_state, test_sine_callback);

428 sine_state.voice = voice;

429

430 - AUD_set_active_out(voice, true);

430 + AUD_set_active_out(be, voice, true);

431

432 start_time = g_get_monotonic_time();

433 while (sine_state.frames_written < sine_state.total_frames ||

@@ -472,10 +472,10 @@ static void test_audio_capture(void)

472 g_assert_cmpfloat(match_ratio, >=, 0.9);

473 }

474

475 - AUD_set_active_out(voice, false);

475 + AUD_set_active_out(be, voice, false);

476 AUD_close_out(be, voice);

477

478 - AUD_del_capture(cap, &state);

478 + AUD_del_capture(be, cap, &state);

479 g_assert_true(state.destroy_called);

480

481 g_free(state.captured_samples);

@@ -483,26 +483,27 @@ static void test_audio_capture(void)

483

484 static void test_audio_null_handling(void)

485 {

486 + AudioBackend *be = get_test_audio_backend();

487 uint8_t buffer[64];

488

489 /* AUD_is_active_out/in(NULL) should return false */

489 - g_assert_false(AUD_is_active_out(NULL));

490 - g_assert_false(AUD_is_active_in(NULL));

490 + g_assert_false(AUD_is_active_out(be, NULL));

491 + g_assert_false(AUD_is_active_in(be, NULL));

492

493 /* AUD_get_buffer_size_out(NULL) should return 0 */

493 - g_assert_cmpint(AUD_get_buffer_size_out(NULL), ==, 0);

494 + g_assert_cmpint(AUD_get_buffer_size_out(be, NULL), ==, 0);

495

496 /* AUD_write/read(NULL, ...) should return size (no-op) */

496 - g_assert_cmpuint(AUD_write(NULL, buffer, sizeof(buffer)), ==,

497 + g_assert_cmpuint(AUD_write(be, NULL, buffer, sizeof(buffer)), ==,

498 sizeof(buffer));

498 - g_assert_cmpuint(AUD_read(NULL, buffer, sizeof(buffer)), ==,

499 + g_assert_cmpuint(AUD_read(be, NULL, buffer, sizeof(buffer)), ==,

500 sizeof(buffer));

501

502 /* These should not crash */

502 - AUD_set_active_out(NULL, true);

503 - AUD_set_active_out(NULL, false);

504 - AUD_set_active_in(NULL, true);

505 - AUD_set_active_in(NULL, false);

503 + AUD_set_active_out(be, NULL, true);

504 + AUD_set_active_out(be, NULL, false);

505 + AUD_set_active_in(be, NULL, true);

506 + AUD_set_active_in(be, NULL, false);

507 }

508

509 static void test_audio_multiple_voices(void)

@@ -516,19 +517,19 @@ static void test_audio_multiple_voices(void)

517 out2 = open_test_voice_out(be, "test-multi-out2", NULL, dummy_audio_callback);

518 in1 = open_test_voice_in(be, "test-multi-in1", NULL, dummy_audio_callback);

519

519 - AUD_set_active_out(out1, true);

520 - AUD_set_active_out(out2, true);

521 - AUD_set_active_in(in1, true);

520 + AUD_set_active_out(be, out1, true);

521 + AUD_set_active_out(be, out2, true);

522 + AUD_set_active_in(be, in1, true);

523

523 - g_assert_true(AUD_is_active_out(out1));

524 - g_assert_true(AUD_is_active_out(out2));

524 + g_assert_true(AUD_is_active_out(be, out1));

525 + g_assert_true(AUD_is_active_out(be, out2));

526 if (in1) {

526 - g_assert_true(AUD_is_active_in(in1));

527 + g_assert_true(AUD_is_active_in(be, in1));

528 }

529

529 - AUD_set_active_out(out1, false);

530 - AUD_set_active_out(out2, false);

531 - AUD_set_active_in(in1, false);

530 + AUD_set_active_out(be, out1, false);

531 + AUD_set_active_out(be, out2, false);

532 + AUD_set_active_in(be, in1, false);

533

534 AUD_close_in(be, in1);

535 AUD_close_out(be, out2);

ui/vnc.c

+1 -1

@@ -1289,7 +1289,7 @@ static void audio_add(VncState *vs)

1289 static void audio_del(VncState *vs)

1290 {

1291 if (vs->audio_cap) {

1292 - AUD_del_capture(vs->audio_cap, vs);

1292 + AUD_del_capture(vs->vd->audio_be, vs->audio_cap, vs);

1293 vs->audio_cap = NULL;

1294 }

1295 }