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

audio: use size_t where makes sense 



Signed-off-by: default avatarKővágó, Zoltán <DirtY.iCE.hu@gmail.com>
Message-id: c5193e687fc6cc0f60cb3e90fe69ddf2027d0df1.1566168923.git.DirtY.iCE.hu@gmail.com
Signed-off-by: default avatarGerd Hoffmann <kraxel@redhat.com>
parent 1d793fec

audio/alsaaudio.c

+13 −13
Original line number Diff line number Diff line
@@ -681,10 +681,10 @@ static void alsa_write_pending (ALSAVoiceOut *alsa) 
    }

}



static int alsa_run_out (HWVoiceOut *hw, int live)

static size_t alsa_run_out(HWVoiceOut *hw, size_t live)

{

    ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;

    int decr;

    size_t decr;

    snd_pcm_sframes_t avail;



    avail = alsa_get_avail (alsa->handle);
@@ -739,7 +739,7 @@ static int alsa_init_out(HWVoiceOut *hw, struct audsettings *as, 


    alsa->pcm_buf = audio_calloc(__func__, obt.samples, 1 << hw->info.shift);

    if (!alsa->pcm_buf) {

        dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",

        dolog("Could not allocate DAC buffer (%zu samples, each %d bytes)\n",

              hw->samples, 1 << hw->info.shift);

        alsa_anal_close1 (&handle);

        return -1;
@@ -841,7 +841,7 @@ static int alsa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque) 


    alsa->pcm_buf = audio_calloc(__func__, hw->samples, 1 << hw->info.shift);

    if (!alsa->pcm_buf) {

        dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",

        dolog("Could not allocate ADC buffer (%zu samples, each %d bytes)\n",

              hw->samples, 1 << hw->info.shift);

        alsa_anal_close1 (&handle);

        return -1;
@@ -863,17 +863,17 @@ static void alsa_fini_in (HWVoiceIn *hw) 
    alsa->pcm_buf = NULL;

}



static int alsa_run_in (HWVoiceIn *hw)

static size_t alsa_run_in(HWVoiceIn *hw)

{

    ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;

    int hwshift = hw->info.shift;

    int i;

    int live = audio_pcm_hw_get_live_in (hw);

    int dead = hw->samples - live;

    int decr;

    size_t live = audio_pcm_hw_get_live_in (hw);

    size_t dead = hw->samples - live;

    size_t decr;

    struct {

        int add;

        int len;

        size_t add;

        size_t len;

    } bufs[2] = {

        { .add = hw->wpos, .len = 0 },

        { .add = 0,        .len = 0 }

audio/audio.c

+76 −80
Original line number Diff line number Diff line
@@ -528,10 +528,10 @@ static int audio_attach_capture (HWVoiceOut *hw) 
/*

 * Hard voice (capture)

 */

static int audio_pcm_hw_find_min_in (HWVoiceIn *hw)

static size_t audio_pcm_hw_find_min_in (HWVoiceIn *hw)

{

    SWVoiceIn *sw;

    int m = hw->total_samples_captured;

    size_t m = hw->total_samples_captured;



    for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {

        if (sw->active) {
@@ -541,28 +541,28 @@ static int audio_pcm_hw_find_min_in (HWVoiceIn *hw) 
    return m;

}



int audio_pcm_hw_get_live_in (HWVoiceIn *hw)

size_t audio_pcm_hw_get_live_in(HWVoiceIn *hw)

{

    int live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw);

    if (audio_bug(__func__, live < 0 || live > hw->samples)) {

        dolog ("live=%d hw->samples=%d\n", live, hw->samples);

    size_t live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw);

    if (audio_bug(__func__, live > hw->samples)) {

        dolog("live=%zu hw->samples=%zu\n", live, hw->samples);

        return 0;

    }

    return live;

}



int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf,

                           int live, int pending)

size_t audio_pcm_hw_clip_out(HWVoiceOut *hw, void *pcm_buf,

                             size_t live, size_t pending)

{

    int left = hw->samples - pending;

    int len = MIN (left, live);

    int clipped = 0;

    size_t left = hw->samples - pending;

    size_t len = MIN (left, live);

    size_t clipped = 0;



    while (len) {

        struct st_sample *src = hw->mix_buf + hw->rpos;

        uint8_t *dst = advance (pcm_buf, hw->rpos << hw->info.shift);

        int samples_till_end_of_buf = hw->samples - hw->rpos;

        int samples_to_clip = MIN (len, samples_till_end_of_buf);

        size_t samples_till_end_of_buf = hw->samples - hw->rpos;

        size_t samples_to_clip = MIN (len, samples_till_end_of_buf);



        hw->clip (dst, src, samples_to_clip);
@@ -576,14 +576,14 @@ int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf, 
/*

 * Soft voice (capture)

 */

static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw)

static size_t audio_pcm_sw_get_rpos_in(SWVoiceIn *sw)

{

    HWVoiceIn *hw = sw->hw;

    int live = hw->total_samples_captured - sw->total_hw_samples_acquired;

    int rpos;

    ssize_t live = hw->total_samples_captured - sw->total_hw_samples_acquired;

    ssize_t rpos;



    if (audio_bug(__func__, live < 0 || live > hw->samples)) {

        dolog ("live=%d hw->samples=%d\n", live, hw->samples);

        dolog("live=%zu hw->samples=%zu\n", live, hw->samples);

        return 0;

    }
@@ -596,17 +596,17 @@ static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw) 
    }

}



static int audio_pcm_sw_read(SWVoiceIn *sw, void *buf, int size)

static size_t audio_pcm_sw_read(SWVoiceIn *sw, void *buf, size_t size)

{

    HWVoiceIn *hw = sw->hw;

    int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;

    size_t samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;

    struct st_sample *src, *dst = sw->buf;



    rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples;



    live = hw->total_samples_captured - sw->total_hw_samples_acquired;

    if (audio_bug(__func__, live < 0 || live > hw->samples)) {

        dolog ("live_in=%d hw->samples=%d\n", live, hw->samples);

    if (audio_bug(__func__, live > hw->samples)) {

        dolog("live_in=%zu hw->samples=%zu\n", live, hw->samples);

        return 0;

    }
@@ -620,9 +620,9 @@ static int audio_pcm_sw_read(SWVoiceIn *sw, void *buf, int size) 


    while (swlim) {

        src = hw->conv_buf + rpos;

        if (hw->wpos > rpos) {

            isamp = hw->wpos - rpos;

        /* XXX: <= ? */

        if (isamp <= 0) {

        } else {

            isamp = hw->samples - rpos;

        }
@@ -631,11 +631,6 @@ static int audio_pcm_sw_read(SWVoiceIn *sw, void *buf, int size) 
        }

        osamp = swlim;



        if (audio_bug(__func__, osamp < 0)) {

            dolog ("osamp=%d\n", osamp);

            return 0;

        }



        st_rate_flow (sw->rate, src, dst, &isamp, &osamp);

        swlim -= osamp;

        rpos = (rpos + isamp) % hw->samples;
@@ -656,10 +651,10 @@ static int audio_pcm_sw_read(SWVoiceIn *sw, void *buf, int size) 
/*

 * Hard voice (playback)

 */

static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)

static size_t audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)

{

    SWVoiceOut *sw;

    int m = INT_MAX;

    size_t m = SIZE_MAX;

    int nb_live = 0;



    for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
@@ -673,9 +668,9 @@ static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep) 
    return m;

}



static int audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live)

static size_t audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live)

{

    int smin;

    size_t smin;

    int nb_live1;



    smin = audio_pcm_hw_find_min_out (hw, &nb_live1);
@@ -684,10 +679,10 @@ static int audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live) 
    }



    if (nb_live1) {

        int live = smin;

        size_t live = smin;



        if (audio_bug(__func__, live < 0 || live > hw->samples)) {

            dolog ("live=%d hw->samples=%d\n", live, hw->samples);

        if (audio_bug(__func__, live > hw->samples)) {

            dolog("live=%zu hw->samples=%zu\n", live, hw->samples);

            return 0;

        }

        return live;
@@ -698,10 +693,10 @@ static int audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live) 
/*

 * Soft voice (playback)

 */

static int audio_pcm_sw_write(SWVoiceOut *sw, void *buf, int size)

static size_t audio_pcm_sw_write(SWVoiceOut *sw, void *buf, size_t size)

{

    int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;

    int ret = 0, pos = 0, total = 0;

    size_t hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;

    size_t ret = 0, pos = 0, total = 0;



    if (!sw) {

        return size;
@@ -710,8 +705,8 @@ static int audio_pcm_sw_write(SWVoiceOut *sw, void *buf, int size) 
    hwsamples = sw->hw->samples;



    live = sw->total_hw_samples_mixed;

    if (audio_bug(__func__, live < 0 || live > hwsamples)) {

        dolog ("live=%d hw->samples=%d\n", live, hwsamples);

    if (audio_bug(__func__, live > hwsamples)) {

        dolog("live=%zu hw->samples=%zu\n", live, hwsamples);

        return 0;

    }
@@ -765,7 +760,7 @@ static int audio_pcm_sw_write(SWVoiceOut *sw, void *buf, int size) 


#ifdef DEBUG_OUT

    dolog (

        "%s: write size %d ret %d total sw %d\n",

        "%s: write size %zu ret %zu total sw %zu\n",

        SW_NAME (sw),

        size >> sw->info.shift,

        ret,
@@ -844,7 +839,7 @@ static void audio_timer (void *opaque) 
/*

 * Public API

 */

int AUD_write (SWVoiceOut *sw, void *buf, int size)

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

{

    if (!sw) {

        /* XXX: Consider options */
@@ -859,7 +854,7 @@ int AUD_write (SWVoiceOut *sw, void *buf, int size) 
    return audio_pcm_sw_write(sw, buf, size);

}



int AUD_read (SWVoiceIn *sw, void *buf, int size)

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

{

    if (!sw) {

        /* XXX: Consider options */
@@ -968,17 +963,17 @@ void AUD_set_active_in (SWVoiceIn *sw, int on) 
    }

}



static int audio_get_avail (SWVoiceIn *sw)

static size_t audio_get_avail (SWVoiceIn *sw)

{

    int live;

    size_t live;



    if (!sw) {

        return 0;

    }



    live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired;

    if (audio_bug(__func__, live < 0 || live > sw->hw->samples)) {

        dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);

    if (audio_bug(__func__, live > sw->hw->samples)) {

        dolog("live=%zu sw->hw->samples=%zu\n", live, sw->hw->samples);

        return 0;

    }
@@ -991,9 +986,9 @@ static int audio_get_avail (SWVoiceIn *sw) 
    return (((int64_t) live << 32) / sw->ratio) << sw->info.shift;

}



static int audio_get_free (SWVoiceOut *sw)

static size_t audio_get_free(SWVoiceOut *sw)

{

    int live, dead;

    size_t live, dead;



    if (!sw) {

        return 0;
@@ -1001,8 +996,8 @@ static int audio_get_free (SWVoiceOut *sw) 


    live = sw->total_hw_samples_mixed;



    if (audio_bug(__func__, live < 0 || live > sw->hw->samples)) {

        dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);

    if (audio_bug(__func__, live > sw->hw->samples)) {

        dolog("live=%zu sw->hw->samples=%zu\n", live, sw->hw->samples);

        return 0;

    }
@@ -1017,9 +1012,10 @@ static int audio_get_free (SWVoiceOut *sw) 
    return (((int64_t) dead << 32) / sw->ratio) << sw->info.shift;

}



static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples)

static void audio_capture_mix_and_clear(HWVoiceOut *hw, size_t rpos,

                                        size_t samples)

{

    int n;

    size_t n;



    if (hw->enabled) {

        SWVoiceCap *sc;
@@ -1030,16 +1026,16 @@ static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples) 


            n = samples;

            while (n) {

                int till_end_of_hw = hw->samples - rpos2;

                int to_write = MIN (till_end_of_hw, n);

                int bytes = to_write << hw->info.shift;

                int written;

                size_t till_end_of_hw = hw->samples - rpos2;

                size_t to_write = MIN(till_end_of_hw, n);

                size_t bytes = to_write << hw->info.shift;

                size_t written;



                sw->buf = hw->mix_buf + rpos2;

                written = audio_pcm_sw_write (sw, NULL, bytes);

                if (written - bytes) {

                    dolog ("Could not mix %d bytes into a capture "

                           "buffer, mixed %d\n",

                    dolog("Could not mix %zu bytes into a capture "

                          "buffer, mixed %zu\n",

                          bytes, written);

                    break;

                }
@@ -1060,16 +1056,16 @@ static void audio_run_out (AudioState *s) 
    SWVoiceOut *sw;



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

        int played;

        int live, free, nb_live, cleanup_required, prev_rpos;

        size_t played, live, prev_rpos, free;

        int nb_live, cleanup_required;



        live = audio_pcm_hw_get_live_out (hw, &nb_live);

        if (!nb_live) {

            live = 0;

        }



        if (audio_bug(__func__, live < 0 || live > hw->samples)) {

            dolog ("live=%d hw->samples=%d\n", live, hw->samples);

        if (audio_bug(__func__, live > hw->samples)) {

            dolog ("live=%zu hw->samples=%zu\n", live, hw->samples);

            continue;

        }
@@ -1104,13 +1100,13 @@ static void audio_run_out (AudioState *s) 
        played = hw->pcm_ops->run_out (hw, live);

        replay_audio_out(&played);

        if (audio_bug(__func__, hw->rpos >= hw->samples)) {

            dolog ("hw->rpos=%d hw->samples=%d played=%d\n",

            dolog("hw->rpos=%zu hw->samples=%zu played=%zu\n",

                  hw->rpos, hw->samples, played);

            hw->rpos = 0;

        }



#ifdef DEBUG_OUT

        dolog ("played=%d\n", played);

        dolog("played=%zu\n", played);

#endif



        if (played) {
@@ -1125,7 +1121,7 @@ static void audio_run_out (AudioState *s) 
            }



            if (audio_bug(__func__, played > sw->total_hw_samples_mixed)) {

                dolog ("played=%d sw->total_hw_samples_mixed=%d\n",

                dolog("played=%zu sw->total_hw_samples_mixed=%zu\n",

                      played, sw->total_hw_samples_mixed);

                played = sw->total_hw_samples_mixed;

            }
@@ -1166,7 +1162,7 @@ static void audio_run_in (AudioState *s) 


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

        SWVoiceIn *sw;

        int captured = 0, min;

        size_t captured = 0, min;



        if (replay_mode != REPLAY_MODE_PLAY) {

            captured = hw->pcm_ops->run_in(hw);
@@ -1181,7 +1177,7 @@ static void audio_run_in (AudioState *s) 
            sw->total_hw_samples_acquired -= min;



            if (sw->active) {

                int avail;

                size_t avail;



                avail = audio_get_avail (sw);

                if (avail > 0) {
@@ -1197,15 +1193,15 @@ static void audio_run_capture (AudioState *s) 
    CaptureVoiceOut *cap;



    for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {

        int live, rpos, captured;

        size_t live, rpos, captured;

        HWVoiceOut *hw = &cap->hw;

        SWVoiceOut *sw;



        captured = live = audio_pcm_hw_get_live_out (hw, NULL);

        rpos = hw->rpos;

        while (live) {

            int left = hw->samples - rpos;

            int to_capture = MIN (live, left);

            size_t left = hw->samples - rpos;

            size_t to_capture = MIN(live, left);

            struct st_sample *src;

            struct capture_callback *cb;
@@ -1228,7 +1224,7 @@ static void audio_run_capture (AudioState *s) 
            }



            if (audio_bug(__func__, captured > sw->total_hw_samples_mixed)) {

                dolog ("captured=%d sw->total_hw_samples_mixed=%d\n",

                dolog("captured=%zu sw->total_hw_samples_mixed=%zu\n",

                      captured, sw->total_hw_samples_mixed);

                captured = sw->total_hw_samples_mixed;

            }

audio/audio.h

+2 −2
Original line number Diff line number Diff line
@@ -113,7 +113,7 @@ SWVoiceOut *AUD_open_out ( 
    );



void AUD_close_out (QEMUSoundCard *card, SWVoiceOut *sw);

int  AUD_write (SWVoiceOut *sw, void *pcm_buf, int size);

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

int  AUD_get_buffer_size_out (SWVoiceOut *sw);

void AUD_set_active_out (SWVoiceOut *sw, int on);

int  AUD_is_active_out (SWVoiceOut *sw);
@@ -134,7 +134,7 @@ SWVoiceIn *AUD_open_in ( 
    );



void AUD_close_in (QEMUSoundCard *card, SWVoiceIn *sw);

int  AUD_read (SWVoiceIn *sw, void *pcm_buf, int size);

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

void AUD_set_active_in (SWVoiceIn *sw, int on);

int  AUD_is_active_in (SWVoiceIn *sw);

audio/audio_int.h

+13 −13
Original line number Diff line number Diff line
@@ -61,12 +61,12 @@ typedef struct HWVoiceOut { 


    f_sample *clip;



    int rpos;

    size_t rpos;

    uint64_t ts_helper;



    struct st_sample *mix_buf;



    int samples;

    size_t samples;

    QLIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head;

    QLIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head;

    int ctl_caps;
@@ -82,13 +82,13 @@ typedef struct HWVoiceIn { 


    t_sample *conv;



    int wpos;

    int total_samples_captured;

    size_t wpos;

    size_t total_samples_captured;

    uint64_t ts_helper;



    struct st_sample *conv_buf;



    int samples;

    size_t samples;

    QLIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head;

    int ctl_caps;

    struct audio_pcm_ops *pcm_ops;
@@ -103,7 +103,7 @@ struct SWVoiceOut { 
    int64_t ratio;

    struct st_sample *buf;

    void *rate;

    int total_hw_samples_mixed;

    size_t total_hw_samples_mixed;

    int active;

    int empty;

    HWVoiceOut *hw;
@@ -120,7 +120,7 @@ struct SWVoiceIn { 
    struct audio_pcm_info info;

    int64_t ratio;

    void *rate;

    int total_hw_samples_acquired;

    size_t total_hw_samples_acquired;

    struct st_sample *buf;

    f_sample *clip;

    HWVoiceIn *hw;
@@ -149,12 +149,12 @@ struct audio_driver { 
struct audio_pcm_ops {

    int  (*init_out)(HWVoiceOut *hw, struct audsettings *as, void *drv_opaque);

    void (*fini_out)(HWVoiceOut *hw);

    int  (*run_out) (HWVoiceOut *hw, int live);

    size_t (*run_out)(HWVoiceOut *hw, size_t live);

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



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

    void (*fini_in) (HWVoiceIn *hw);

    int  (*run_in)  (HWVoiceIn *hw);

    size_t (*run_in)(HWVoiceIn *hw);

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

};
@@ -208,10 +208,10 @@ audio_driver *audio_driver_lookup(const char *name); 
void audio_pcm_init_info (struct audio_pcm_info *info, struct audsettings *as);

void audio_pcm_info_clear_buf (struct audio_pcm_info *info, void *buf, int len);



int  audio_pcm_hw_get_live_in (HWVoiceIn *hw);

size_t audio_pcm_hw_get_live_in(HWVoiceIn *hw);



int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf,

                           int live, int pending);

size_t audio_pcm_hw_clip_out(HWVoiceOut *hw, void *pcm_buf,

                             size_t live, size_t pending);



int audio_bug (const char *funcname, int cond);

void *audio_calloc (const char *funcname, int nmemb, size_t size);
@@ -224,7 +224,7 @@ void audio_run(AudioState *s, const char *msg); 


#define VOICE_VOLUME_CAP (1 << VOICE_VOLUME)



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

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

+7 −7
Original line number Diff line number Diff line
@@ -75,16 +75,16 @@ static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw) 
    HWBUF = NULL;

}



static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw)

static bool glue(audio_pcm_hw_alloc_resources_, TYPE)(HW *hw)

{

    HWBUF = audio_calloc(__func__, hw->samples, sizeof(struct st_sample));

    if (!HWBUF) {

        dolog ("Could not allocate " NAME " buffer (%d samples)\n",

        dolog("Could not allocate " NAME " buffer (%zu samples)\n",

              hw->samples);

        return -1;

        return false;

    }



    return 0;

    return true;

}



static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw)
@@ -265,7 +265,7 @@ static HW *glue(audio_pcm_hw_add_new_, TYPE)(AudioState *s, 
    }



    if (audio_bug(__func__, hw->samples <= 0)) {

        dolog ("hw->samples=%d\n", hw->samples);

        dolog("hw->samples=%zd\n", hw->samples);

        goto err1;

    }
@@ -279,7 +279,7 @@ static HW *glue(audio_pcm_hw_add_new_, TYPE)(AudioState *s, 
        [hw->info.swap_endianness]

        [audio_bits_to_index (hw->info.bits)];



    if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {

    if (!glue(audio_pcm_hw_alloc_resources_, TYPE)(hw)) {

        goto err1;

    }