Clear up inconsistencies, and avoid breaking standard compliance.

audio/alsa.c

@@ -32,7 +32,7 @@ typedef struct alsa
    bool has_float;
 } alsa_t;
 
-static bool __alsa_use_float(void *data)
+static bool alsa_use_float(void *data)
 {
    alsa_t *alsa = data;
    return alsa->has_float;
@@ -49,7 +49,7 @@ static bool find_float_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
    return false;
 }
 
-static void *__alsa_init(const char *device, unsigned rate, unsigned latency)
+static void *alsa_init(const char *device, unsigned rate, unsigned latency)
 {
    alsa_t *alsa = calloc(1, sizeof(alsa_t));
    if (!alsa)
@@ -117,7 +117,7 @@ error:
    return NULL;
 }
 
-static ssize_t __alsa_write(void *data, const void *buf, size_t size)
+static ssize_t alsa_write(void *data, const void *buf, size_t size)
 {
    alsa_t *alsa = data;
 
@@ -159,23 +159,23 @@ static ssize_t __alsa_write(void *data, const void *buf, size_t size)
    return snd_pcm_frames_to_bytes(alsa->pcm, size);
 }
 
-static bool __alsa_stop(void *data)
+static bool alsa_stop(void *data)
 {
    return true;
 }
 
-static void __alsa_set_nonblock_state(void *data, bool state)
+static void alsa_set_nonblock_state(void *data, bool state)
 {
    alsa_t *alsa = data;
    alsa->nonblock = state;
 }
 
-static bool __alsa_start(void *data)
+static bool alsa_start(void *data)
 {
    return true;
 }
 
-static void __alsa_free(void *data)
+static void alsa_free(void *data)
 {
    alsa_t *alsa = data;
    if (alsa)
@@ -190,13 +190,13 @@ static void __alsa_free(void *data)
 }
 
 const audio_driver_t audio_alsa = {
-   .init = __alsa_init,
+   .init = alsa_init,
-   .write = __alsa_write,
+   .write = alsa_write,
-   .stop = __alsa_stop,
+   .stop = alsa_stop,
-   .start = __alsa_start,
+   .start = alsa_start,
-   .use_float = __alsa_use_float,
+   .use_float = alsa_use_float,
-   .set_nonblock_state = __alsa_set_nonblock_state,
+   .set_nonblock_state = alsa_set_nonblock_state,
-   .free = __alsa_free,
+   .free = alsa_free,
    .ident = "alsa"
 };
 

audio/jack.c

@@ -124,7 +124,7 @@ static size_t find_buffersize(jack_t *jd, int latency)
    return buffer_frames * sizeof(jack_default_audio_sample_t);
 }
 
-static void *__jack_init(const char *device, unsigned rate, unsigned latency)
+static void *ja_init(const char *device, unsigned rate, unsigned latency)
 {
    jack_t *jd = calloc(1, sizeof(jack_t));
    if (!jd)
@@ -246,32 +246,32 @@ static size_t write_buffer(jack_t *jd, const float *buf, size_t size)
    return written * sizeof(float) * 2;
 }
 
-static ssize_t __jack_write(void *data, const void *buf, size_t size)
+static ssize_t ja_write(void *data, const void *buf, size_t size)
 {
    jack_t *jd = data;
 
    return write_buffer(jd, buf, size);
 }
 
-static bool __jack_stop(void *data)
+static bool ja_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_set_nonblock_state(void *data, bool state)
+static void ja_set_nonblock_state(void *data, bool state)
 {
    jack_t *jd = data;
    jd->nonblock = state;
 }
 
-static bool __jack_start(void *data)
+static bool ja_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_free(void *data)
+static void ja_free(void *data)
 {
    jack_t *jd = data;
 
@@ -292,20 +292,20 @@ static void __jack_free(void *data)
    free(jd);
 }
 
-static bool __jack_use_float(void *data)
+static bool ja_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
 const audio_driver_t audio_jack = {
-   .init = __jack_init,
+   .init = ja_init,
-   .write = __jack_write,
+   .write = ja_write,
-   .stop = __jack_stop,
+   .stop = ja_stop,
-   .start = __jack_start,
+   .start = ja_start,
-   .set_nonblock_state = __jack_set_nonblock_state,
+   .set_nonblock_state = ja_set_nonblock_state,
-   .free = __jack_free,
+   .free = ja_free,
-   .use_float = __jack_use_float,
+   .use_float = ja_use_float,
    .ident = "jack"
 };
 

audio/openal.c

@@ -56,7 +56,7 @@ typedef struct al
 
 } al_t;
 
-static void *__al_init(const char *device, unsigned rate, unsigned latency)
+static void *al_init(const char *device, unsigned rate, unsigned latency)
 {
    (void)device;
    al_t *al = calloc(1, sizeof(al_t));
@@ -161,7 +161,7 @@ static size_t al_fill_internal_buf(al_t *al, const void *buf, size_t size)
    return read_size;
 }
 
-static ssize_t __al_write(void *data, const void *buf, size_t size)
+static ssize_t al_write(void *data, const void *buf, size_t size)
 {
    al_t *al = data;
 
@@ -196,25 +196,25 @@ static ssize_t __al_write(void *data, const void *buf, size_t size)
    return size;
 }
 
-static bool __al_stop(void *data)
+static bool al_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __al_set_nonblock_state(void *data, bool state)
+static void al_set_nonblock_state(void *data, bool state)
 {
    al_t *al = data;
    al->nonblock = state;
 }
 
-static bool __al_start(void *data)
+static bool al_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __al_free(void *data)
+static void al_free(void *data)
 {
    al_t *al= data;
    if (al)
@@ -235,12 +235,12 @@ static void __al_free(void *data)
 }
 
 const audio_driver_t audio_openal = {
-   .init = __al_init,
+   .init = al_init,
-   .write = __al_write,
+   .write = al_write,
-   .stop = __al_stop,
+   .stop = al_stop,
-   .start = __al_start,
+   .start = al_start,
-   .set_nonblock_state = __al_set_nonblock_state,
+   .set_nonblock_state = al_set_nonblock_state,
-   .free = __al_free,
+   .free = al_free,
    .ident = "openal"
 };
 

audio/oss.c

@@ -41,7 +41,7 @@
 #define DEFAULT_OSS_DEV "/dev/dsp"
 #endif
 
-static void *__oss_init(const char *device, unsigned rate, unsigned latency)
+static void *oss_init(const char *device, unsigned rate, unsigned latency)
 {
    int *fd = calloc(1, sizeof(int));
    if (fd == NULL)
@@ -96,7 +96,7 @@ static void *__oss_init(const char *device, unsigned rate, unsigned latency)
    return fd;
 }
 
-static ssize_t __oss_write(void *data, const void *buf, size_t size)
+static ssize_t oss_write(void *data, const void *buf, size_t size)
 {
    int *fd = data;
 
@@ -114,19 +114,19 @@ static ssize_t __oss_write(void *data, const void *buf, size_t size)
    return ret;
 }
 
-static bool __oss_stop(void *data)
+static bool oss_stop(void *data)
 {
    int *fd = data;
    ioctl(*fd, SNDCTL_DSP_RESET, 0);
    return true;
 }
 
-static bool __oss_start(void *data)
+static bool oss_start(void *data)
 {
    return true;
 }
 
-static void __oss_set_nonblock_state(void *data, bool state)
+static void oss_set_nonblock_state(void *data, bool state)
 {
    int *fd = data;
    int rc;
@@ -138,7 +138,7 @@ static void __oss_set_nonblock_state(void *data, bool state)
       fprintf(stderr, "SSNES [ERROR]: Could not set nonblocking on OSS file descriptor. Will not be able to fast-forward.\n");
 }
 
-static void __oss_free(void *data)
+static void oss_free(void *data)
 {
    int *fd = data;
 
@@ -148,12 +148,12 @@ static void __oss_free(void *data)
 }
 
 const audio_driver_t audio_oss = {
-   .init = __oss_init,
+   .init = oss_init,
-   .write = __oss_write,
+   .write = oss_write,
-   .stop = __oss_stop,
+   .stop = oss_stop,
-   .start = __oss_start,
+   .start = oss_start,
-   .set_nonblock_state = __oss_set_nonblock_state,
+   .set_nonblock_state = oss_set_nonblock_state,
-   .free = __oss_free,
+   .free = oss_free,
    .ident = "oss"
 };
    

audio/pulse.c

@@ -32,7 +32,7 @@ typedef struct
    bool nonblock;
 } pa_t;
 
-static void __pulse_free(void *data)
+static void pulse_free(void *data)
 {
    pa_t *pa = data;
    if (pa)
@@ -103,7 +103,7 @@ static void stream_latency_update_cb(pa_stream *s, void *data)
    pa_threaded_mainloop_signal(pa->mainloop, 0);
 }
 
-static void *__pulse_init(const char *device, unsigned rate, unsigned latency)
+static void *pulse_init(const char *device, unsigned rate, unsigned latency)
 {
    pa_t *pa = calloc(1, sizeof(*pa));
    if (!pa)
@@ -168,11 +168,11 @@ static void *__pulse_init(const char *device, unsigned rate, unsigned latency)
 unlock_error:
    pa_threaded_mainloop_unlock(pa->mainloop);
 error:
-   __pulse_free(pa); 
+   pulse_free(pa); 
    return NULL;
 }
 
-static ssize_t __pulse_write(void *data, const void *buf, size_t size)
+static ssize_t pulse_write(void *data, const void *buf, size_t size)
 {
    pa_t *pa = data;
 
@@ -198,38 +198,38 @@ static ssize_t __pulse_write(void *data, const void *buf, size_t size)
    return write_size;
 }
 
-static bool __pulse_stop(void *data)
+static bool pulse_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static bool __pulse_start(void *data)
+static bool pulse_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __pulse_set_nonblock_state(void *data, bool state)
+static void pulse_set_nonblock_state(void *data, bool state)
 {
    pa_t *pa = data;
    pa->nonblock = state;
 }
 
-static bool __pulse_use_float(void *data)
+static bool pulse_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
 const audio_driver_t audio_pulse = {
-   .init = __pulse_init,
+   .init = pulse_init,
-   .write = __pulse_write,
+   .write = pulse_write,
-   .stop = __pulse_stop,
+   .stop = pulse_stop,
-   .start = __pulse_start,
+   .start = pulse_start,
-   .set_nonblock_state = __pulse_set_nonblock_state,
+   .set_nonblock_state = pulse_set_nonblock_state,
-   .use_float = __pulse_use_float,
+   .use_float = pulse_use_float,
-   .free = __pulse_free,
+   .free = pulse_free,
    .ident = "pulse"
 };
 

audio/roar.c

@@ -30,8 +30,9 @@ typedef struct
    bool nonblocking;
 } roar_t;
 
-static void *__roar_init(const char *device, unsigned rate, unsigned latency)
+static void *ra_init(const char *device, unsigned rate, unsigned latency)
 {
+   (void)latency;
    int err;
    roar_t *roar = calloc(1, sizeof(roar_t));
    if (roar == NULL)
@@ -51,7 +52,7 @@ static void *__roar_init(const char *device, unsigned rate, unsigned latency)
    return roar;
 }
 
-static ssize_t __roar_write(void *data, const void *buf, size_t size)
+static ssize_t ra_write(void *data, const void *buf, size_t size)
 {
    roar_t *roar = data;
    ssize_t rc;
@@ -77,13 +78,13 @@ static ssize_t __roar_write(void *data, const void *buf, size_t size)
    return size;
 }
 
-static bool __roar_stop(void *data)
+static bool ra_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __roar_set_nonblock_state(void *data, bool state)
+static void ra_set_nonblock_state(void *data, bool state)
 {
    roar_t *roar = data;
    if (roar_vs_blocking(roar->vss, (state) ? ROAR_VS_FALSE : ROAR_VS_TRUE, NULL) < 0)
@@ -91,13 +92,13 @@ static void __roar_set_nonblock_state(void *data, bool state)
    roar->nonblocking = state;
 }
 
-static bool __roar_start(void *data)
+static bool ra_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __roar_free(void *data)
+static void ra_free(void *data)
 {
    roar_t *roar = data;
    roar_vs_close(roar->vss, ROAR_VS_TRUE, NULL);
@@ -105,12 +106,12 @@ static void __roar_free(void *data)
 }
 
 const audio_driver_t audio_roar = {
-   .init = __roar_init,
+   .init = ra_init,
-   .write = __roar_write,
+   .write = ra_write,
-   .stop = __roar_stop,
+   .stop = ra_stop,
-   .start = __roar_start,
+   .start = ra_start,
-   .set_nonblock_state = __roar_set_nonblock_state,
+   .set_nonblock_state = ra_set_nonblock_state,
-   .free = __roar_free,
+   .free = ra_free,
    .ident = "roar"
 };
 

audio/rsound.c

@@ -54,7 +54,7 @@ static void err_cb(void *userdata)
    SDL_CondSignal(rsd->cond);
 }
 
-static void *__rsd_init(const char *device, unsigned rate, unsigned latency)
+static void *rs_init(const char *device, unsigned rate, unsigned latency)
 {
    rsd_t *rsd = calloc(1, sizeof(rsd_t));
    if (!rsd)
@@ -98,7 +98,7 @@ static void *__rsd_init(const char *device, unsigned rate, unsigned latency)
    return rsd;
 }
 
-static ssize_t __rsd_write(void *data, const void *buf, size_t size)
+static ssize_t rs_write(void *data, const void *buf, size_t size)
 {
    rsd_t *rsd = data;
 
@@ -144,7 +144,7 @@ static ssize_t __rsd_write(void *data, const void *buf, size_t size)
    }
 }
 
-static bool __rsd_stop(void *data)
+static bool rs_stop(void *data)
 {
    rsd_t *rsd = data;
    rsd_stop(rsd->rd);
@@ -152,13 +152,13 @@ static bool __rsd_stop(void *data)
    return true;
 }
 
-static void __rsd_set_nonblock_state(void *data, bool state)
+static void rs_set_nonblock_state(void *data, bool state)
 {
    rsd_t *rsd = data;
    rsd->nonblock = state;
 }
 
-static bool __rsd_start(void *data)
+static bool rs_start(void *data)
 {
    rsd_t *rsd = data;
    if (rsd_start(rsd->rd) < 0)
@@ -167,7 +167,7 @@ static bool __rsd_start(void *data)
    return true;
 }
 
-static void __rsd_free(void *data)
+static void rs_free(void *data)
 {
    rsd_t *rsd = data;
 
@@ -182,12 +182,12 @@ static void __rsd_free(void *data)
 }
 
 const audio_driver_t audio_rsound = {
-   .init = __rsd_init,
+   .init = rs_init,
-   .write = __rsd_write,
+   .write = rs_write,
-   .stop = __rsd_stop,
+   .stop = rs_stop,
-   .start = __rsd_start,
+   .start = rs_start,
-   .set_nonblock_state = __rsd_set_nonblock_state,
+   .set_nonblock_state = rs_set_nonblock_state,
-   .free = __rsd_free,
+   .free = rs_free,
    .ident = "rsound"
 };
    

audio/xaudio.c

@@ -26,7 +26,7 @@ typedef struct
    bool nonblock;
 } xa_t;
 
-static void *__xa_init(const char *device, unsigned rate, unsigned latency)
+static void *xa_init(const char *device, unsigned rate, unsigned latency)
 {
    if (latency < 8)
       latency = 8; // Do not allow shenanigans.
@@ -49,7 +49,7 @@ static void *__xa_init(const char *device, unsigned rate, unsigned latency)
    return xa;
 }
 
-static ssize_t __xa_write(void *data, const void *buf, size_t size)
+static ssize_t xa_write(void *data, const void *buf, size_t size)
 {
    xa_t *xa = data;
    if (xa->nonblock)
@@ -66,31 +66,31 @@ static ssize_t __xa_write(void *data, const void *buf, size_t size)
    return ret;
 }
 
-static bool __xa_stop(void *data)
+static bool xa_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __xa_set_nonblock_state(void *data, bool state)
+static void xa_set_nonblock_state(void *data, bool state)
 {
    xa_t *xa = data;
    xa->nonblock = state;
 }
 
-static bool __xa_start(void *data)
+static bool xa_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static bool __xa_use_float(void *data)
+static bool xa_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __xa_free(void *data)
+static void xa_free(void *data)
 {
    xa_t *xa = data;
    if (xa)
@@ -102,13 +102,13 @@ static void __xa_free(void *data)
 }
 
 const audio_driver_t audio_xa = {
-   .init = __xa_init,
+   .init = xa_init,
-   .write = __xa_write,
+   .write = xa_write,
-   .stop = __xa_stop,
+   .stop = xa_stop,
-   .start = __xa_start,
+   .start = xa_start,
-   .set_nonblock_state = __xa_set_nonblock_state,
+   .set_nonblock_state = xa_set_nonblock_state,
-   .use_float = __xa_use_float,
+   .use_float = xa_use_float,
-   .free = __xa_free,
+   .free = xa_free,
    .ident = "xaudio"
 };