Commit 571a8c52 authored by Kővágó, Zoltán's avatar Kővágó, Zoltán Committed by Gerd Hoffmann
Browse files

audio: split ctl_* functions into enable_* and volume_* 



This way we no longer need vararg functions, improving compile time
error detection.  Also now it's possible to check actually what commands
are supported, without needing to manually update ctl_caps.

Signed-off-by: default avatarKővágó, Zoltán <DirtY.iCE.hu@gmail.com>
Message-id: 2b08b3773569c5be055d0a0fb2f29ff64e79f0f4.1568927990.git.DirtY.iCE.hu@gmail.com
Signed-off-by: default avatarGerd Hoffmann <kraxel@redhat.com>
parent 857271a2

audio/alsaaudio.c

+25 −37
Original line number Diff line number Diff line
@@ -731,14 +731,12 @@ static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int ctl) 
    return 0;

}



static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)

static void alsa_enable_out(HWVoiceOut *hw, bool enable)

{

    ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;

    AudiodevAlsaPerDirectionOptions *apdo = alsa->dev->u.alsa.out;



    switch (cmd) {

    case VOICE_ENABLE:

        {

    if (enable) {

        bool poll_mode = apdo->try_poll;



        ldebug("enabling voice\n");
@@ -746,19 +744,15 @@ static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...) 
            poll_mode = 0;

        }

        hw->poll_mode = poll_mode;

            return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PREPARE);

        }



    case VOICE_DISABLE:

        alsa_voice_ctl(alsa->handle, "playback", VOICE_CTL_PREPARE);

    } else {

        ldebug("disabling voice\n");

        if (hw->poll_mode) {

            hw->poll_mode = 0;

            alsa_fini_poll(&alsa->pollhlp);

        }

        return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PAUSE);

        alsa_voice_ctl(alsa->handle, "playback", VOICE_CTL_PAUSE);

    }



    return -1;

}



static int alsa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
@@ -841,14 +835,12 @@ static size_t alsa_read(HWVoiceIn *hw, void *buf, size_t len) 
    return pos;

}



static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)

static void alsa_enable_in(HWVoiceIn *hw, bool enable)

{

    ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;

    AudiodevAlsaPerDirectionOptions *apdo = alsa->dev->u.alsa.in;



    switch (cmd) {

    case VOICE_ENABLE:

        {

    if (enable) {

        bool poll_mode = apdo->try_poll;



        ldebug("enabling voice\n");
@@ -857,19 +849,15 @@ static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...) 
        }

        hw->poll_mode = poll_mode;



            return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_START);

        }



    case VOICE_DISABLE:

        alsa_voice_ctl(alsa->handle, "capture", VOICE_CTL_START);

    } else {

        ldebug ("disabling voice\n");

        if (hw->poll_mode) {

            hw->poll_mode = 0;

            alsa_fini_poll(&alsa->pollhlp);

        }

        return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_PAUSE);

        alsa_voice_ctl(alsa->handle, "capture", VOICE_CTL_PAUSE);

    }



    return -1;

}



static void alsa_init_per_direction(AudiodevAlsaPerDirectionOptions *apdo)
@@ -924,12 +912,12 @@ static struct audio_pcm_ops alsa_pcm_ops = { 
    .init_out = alsa_init_out,

    .fini_out = alsa_fini_out,

    .write    = alsa_write,

    .ctl_out  = alsa_ctl_out,

    .enable_out = alsa_enable_out,



    .init_in  = alsa_init_in,

    .fini_in  = alsa_fini_in,

    .read     = alsa_read,

    .ctl_in   = alsa_ctl_in,

    .enable_in = alsa_enable_in,

};



static struct audio_driver alsa_audio_driver = {

audio/audio.c

+28 −17
Original line number Diff line number Diff line
@@ -636,7 +636,7 @@ static size_t audio_pcm_sw_read(SWVoiceIn *sw, void *buf, size_t size) 
        total += isamp;

    }



    if (!(hw->ctl_caps & VOICE_VOLUME_CAP)) {

    if (!hw->pcm_ops->volume_in) {

        mixeng_volume (sw->buf, ret, &sw->vol);

    }
@@ -723,7 +723,7 @@ static size_t audio_pcm_sw_write(SWVoiceOut *sw, void *buf, size_t size) 
    if (swlim) {

        sw->conv (sw->buf, buf, swlim);



        if (!(sw->hw->ctl_caps & VOICE_VOLUME_CAP)) {

        if (!sw->hw->pcm_ops->volume_out) {

            mixeng_volume (sw->buf, swlim, &sw->vol);

        }

    }
@@ -890,7 +890,9 @@ void AUD_set_active_out (SWVoiceOut *sw, int on) 
            if (!hw->enabled) {

                hw->enabled = 1;

                if (s->vm_running) {

                    hw->pcm_ops->ctl_out(hw, VOICE_ENABLE);

                    if (hw->pcm_ops->enable_out) {

                        hw->pcm_ops->enable_out(hw, true);

                    }

                    audio_reset_timer (s);

                }

            }
@@ -935,7 +937,9 @@ void AUD_set_active_in (SWVoiceIn *sw, int on) 
            if (!hw->enabled) {

                hw->enabled = 1;

                if (s->vm_running) {

                    hw->pcm_ops->ctl_in(hw, VOICE_ENABLE);

                    if (hw->pcm_ops->enable_in) {

                        hw->pcm_ops->enable_in(hw, true);

                    }

                    audio_reset_timer (s);

                }

            }
@@ -952,7 +956,9 @@ void AUD_set_active_in (SWVoiceIn *sw, int on) 


                if (nb_active == 1) {

                    hw->enabled = 0;

                    hw->pcm_ops->ctl_in (hw, VOICE_DISABLE);

                    if (hw->pcm_ops->enable_in) {

                        hw->pcm_ops->enable_in(hw, false);

                    }

                }

            }

        }
@@ -1105,7 +1111,9 @@ static void audio_run_out (AudioState *s) 
#endif

            hw->enabled = 0;

            hw->pending_disable = 0;

            hw->pcm_ops->ctl_out (hw, VOICE_DISABLE);

            if (hw->pcm_ops->enable_out) {

                hw->pcm_ops->enable_out(hw, false);

            }

            for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {

                sc->sw.active = 0;

                audio_recalc_and_notify_capture (sc->cap);
@@ -1470,15 +1478,18 @@ static void audio_vm_change_state_handler (void *opaque, int running, 
    AudioState *s = opaque;

    HWVoiceOut *hwo = NULL;

    HWVoiceIn *hwi = NULL;

    int op = running ? VOICE_ENABLE : VOICE_DISABLE;



    s->vm_running = running;

    while ((hwo = audio_pcm_hw_find_any_enabled_out(s, hwo))) {

        hwo->pcm_ops->ctl_out(hwo, op);

        if (hwo->pcm_ops->enable_out) {

            hwo->pcm_ops->enable_out(hwo, running);

        }

    }



    while ((hwi = audio_pcm_hw_find_any_enabled_in(s, hwi))) {

        hwi->pcm_ops->ctl_in(hwi, op);

        if (hwi->pcm_ops->enable_in) {

            hwi->pcm_ops->enable_in(hwi, running);

        }

    }

    audio_reset_timer (s);

}
@@ -1498,8 +1509,8 @@ static void free_audio_state(AudioState *s) 
    QLIST_FOREACH_SAFE(hwo, &s->hw_head_out, entries, hwon) {

        SWVoiceCap *sc;



        if (hwo->enabled) {

            hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE);

        if (hwo->enabled && hwo->pcm_ops->enable_out) {

            hwo->pcm_ops->enable_out(hwo, false);

        }

        hwo->pcm_ops->fini_out (hwo);
@@ -1515,8 +1526,8 @@ static void free_audio_state(AudioState *s) 
    }



    QLIST_FOREACH_SAFE(hwi, &s->hw_head_in, entries, hwin) {

        if (hwi->enabled) {

            hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE);

        if (hwi->enabled && hwi->pcm_ops->enable_in) {

            hwi->pcm_ops->enable_in(hwi, false);

        }

        hwi->pcm_ops->fini_in (hwi);

        QLIST_REMOVE(hwi, entries);
@@ -1838,8 +1849,8 @@ void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol) 
        sw->vol.l = nominal_volume.l * lvol / 255;

        sw->vol.r = nominal_volume.r * rvol / 255;



        if (hw->pcm_ops->ctl_out) {

            hw->pcm_ops->ctl_out (hw, VOICE_VOLUME, sw);

        if (hw->pcm_ops->volume_out) {

            hw->pcm_ops->volume_out(hw, &sw->vol);

        }

    }

}
@@ -1853,8 +1864,8 @@ void AUD_set_volume_in (SWVoiceIn *sw, int mute, uint8_t lvol, uint8_t rvol) 
        sw->vol.l = nominal_volume.l * lvol / 255;

        sw->vol.r = nominal_volume.r * rvol / 255;



        if (hw->pcm_ops->ctl_in) {

            hw->pcm_ops->ctl_in (hw, VOICE_VOLUME, sw);

        if (hw->pcm_ops->volume_in) {

            hw->pcm_ops->volume_in(hw, &sw->vol);

        }

    }

}

audio/audio_int.h

+4 −11
Original line number Diff line number Diff line
@@ -74,7 +74,6 @@ typedef struct HWVoiceOut { 
    size_t samples;

    QLIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head;

    QLIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head;

    int ctl_caps;

    struct audio_pcm_ops *pcm_ops;

    QLIST_ENTRY (HWVoiceOut) entries;

} HWVoiceOut;
@@ -96,7 +95,6 @@ typedef struct HWVoiceIn { 


    size_t samples;

    QLIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head;

    int ctl_caps;

    struct audio_pcm_ops *pcm_ops;

    QLIST_ENTRY (HWVoiceIn) entries;

} HWVoiceIn;
@@ -148,7 +146,6 @@ struct audio_driver { 
    int max_voices_in;

    int voice_size_out;

    int voice_size_in;

    int ctl_caps;

    QLIST_ENTRY(audio_driver) next;

};
@@ -168,14 +165,16 @@ struct audio_pcm_ops { 
     * size may be smaller

     */

    size_t (*put_buffer_out)(HWVoiceOut *hw, void *buf, size_t size);

    int    (*ctl_out) (HWVoiceOut *hw, int cmd, ...);

    void   (*enable_out)(HWVoiceOut *hw, bool enable);

    void   (*volume_out)(HWVoiceOut *hw, struct mixeng_volume *vol);



    int    (*init_in) (HWVoiceIn *hw, audsettings *as, void *drv_opaque);

    void   (*fini_in) (HWVoiceIn *hw);

    size_t (*read)    (HWVoiceIn *hw, void *buf, size_t size);

    void  *(*get_buffer_in)(HWVoiceIn *hw, size_t *size);

    void   (*put_buffer_in)(HWVoiceIn *hw, void *buf, size_t size);

    int    (*ctl_in)  (HWVoiceIn *hw, int cmd, ...);

    void   (*enable_in)(HWVoiceIn *hw, bool enable);

    void   (*volume_in)(HWVoiceIn *hw, struct mixeng_volume *vol);

};



void *audio_generic_get_buffer_in(HWVoiceIn *hw, size_t *size);
@@ -251,12 +250,6 @@ void audio_rate_start(RateCtl *rate); 
size_t audio_rate_get_bytes(struct audio_pcm_info *info, RateCtl *rate,

                            size_t bytes_avail);



#define VOICE_ENABLE 1

#define VOICE_DISABLE 2

#define VOICE_VOLUME 3



#define VOICE_VOLUME_CAP (1 << VOICE_VOLUME)



static inline size_t audio_ring_dist(size_t dst, size_t src, size_t len)

{

    return (dst >= src) ? (dst - src) : (len - src + dst);

audio/audio_template.h

+0 −1
Original line number Diff line number Diff line
@@ -254,7 +254,6 @@ static HW *glue(audio_pcm_hw_add_new_, TYPE)(AudioState *s, 


    hw->s = s;

    hw->pcm_ops = drv->pcm_ops;

    hw->ctl_caps = drv->ctl_caps;



    QLIST_INIT (&hw->sw_head);

#ifdef DAC

audio/coreaudio.c

+4 −9
Original line number Diff line number Diff line
@@ -648,13 +648,12 @@ static void coreaudio_fini_out (HWVoiceOut *hw) 
    }

}



static int coreaudio_ctl_out (HWVoiceOut *hw, int cmd, ...)

static void coreaudio_enable_out(HWVoiceOut *hw, bool enable)

{

    OSStatus status;

    coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;



    switch (cmd) {

    case VOICE_ENABLE:

    if (enable) {

        /* start playback */

        if (!isPlaying(core->outputDeviceID)) {

            status = AudioDeviceStart(core->outputDeviceID, core->ioprocid);
@@ -662,9 +661,7 @@ static int coreaudio_ctl_out (HWVoiceOut *hw, int cmd, ...) 
                coreaudio_logerr (status, "Could not resume playback\n");

            }

        }

        break;



    case VOICE_DISABLE:

    } else {

        /* stop playback */

        if (!audio_is_cleaning_up()) {

            if (isPlaying(core->outputDeviceID)) {
@@ -675,9 +672,7 @@ static int coreaudio_ctl_out (HWVoiceOut *hw, int cmd, ...) 
                }

            }

        }

        break;

    }

    return 0;

}



static void *coreaudio_audio_init(Audiodev *dev)
@@ -695,7 +690,7 @@ static struct audio_pcm_ops coreaudio_pcm_ops = { 
    .write    = coreaudio_write,

    .get_buffer_out = coreaudio_get_buffer_out,

    .put_buffer_out = coreaudio_put_buffer_out_nowrite,

    .ctl_out  = coreaudio_ctl_out

    .enable_out = coreaudio_enable_out

};



static struct audio_driver coreaudio_audio_driver = {