src: reindent for 8ch indenting

I am slowly moving all my projects to kernel-inspired 8ch indenting.
This will break patches that haven't been merged yet, which I am aware
of, but OTOH in times of git's --ignore-space-change shouldn't be too
problematic.

Yes, I am aware that reindenting like this sucks, but I cannot stand 4ch
indenting anymore. Sorry.

1 files changed, 331 insertions, 329 deletions

diff --git a/src/alsa.c b/src/alsa.c
index e9647c5..d982203 100644
--- a/src/alsa.c
+++ b/src/alsa.c
@@ -1,3 +1,5 @@
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
 /***
   This file is part of libcanberra.
 
@@ -40,513 +42,513 @@
 struct private;
 
 struct outstanding {
-    CA_LLIST_FIELDS(struct outstanding);
-    ca_bool_t dead;
-    uint32_t id;
-    ca_finish_callback_t callback;
-    void *userdata;
-    ca_sound_file *file;
-    snd_pcm_t *pcm;
-    int pipe_fd[2];
-    ca_context *context;
+        CA_LLIST_FIELDS(struct outstanding);
+        ca_bool_t dead;
+        uint32_t id;
+        ca_finish_callback_t callback;
+        void *userdata;
+        ca_sound_file *file;
+        snd_pcm_t *pcm;
+        int pipe_fd[2];
+        ca_context *context;
 };
 
 struct private {
-    ca_theme_data *theme;
-    ca_mutex *outstanding_mutex;
-    ca_bool_t signal_semaphore;
-    sem_t semaphore;
-    ca_bool_t semaphore_allocated;
-    CA_LLIST_HEAD(struct outstanding, outstanding);
+        ca_theme_data *theme;
+        ca_mutex *outstanding_mutex;
+        ca_bool_t signal_semaphore;
+        sem_t semaphore;
+        ca_bool_t semaphore_allocated;
+        CA_LLIST_HEAD(struct outstanding, outstanding);
 };
 
 #define PRIVATE(c) ((struct private *) ((c)->private))
 
 static void outstanding_free(struct outstanding *o) {
-    ca_assert(o);
+        ca_assert(o);
 
-    if (o->pipe_fd[1] >= 0)
-        close(o->pipe_fd[1]);
+        if (o->pipe_fd[1] >= 0)
+                close(o->pipe_fd[1]);
 
-    if (o->pipe_fd[0] >= 0)
-        close(o->pipe_fd[0]);
+        if (o->pipe_fd[0] >= 0)
+                close(o->pipe_fd[0]);
 
-    if (o->file)
-        ca_sound_file_close(o->file);
+        if (o->file)
+                ca_sound_file_close(o->file);
 
-    if (o->pcm)
-        snd_pcm_close(o->pcm);
+        if (o->pcm)
+                snd_pcm_close(o->pcm);
 
-    ca_free(o);
+        ca_free(o);
 }
 
 int driver_open(ca_context *c) {
-    struct private *p;
+        struct private *p;
 
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(!c->driver || ca_streq(c->driver, "alsa"), CA_ERROR_NODRIVER);
-    ca_return_val_if_fail(!PRIVATE(c), CA_ERROR_STATE);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(!c->driver || ca_streq(c->driver, "alsa"), CA_ERROR_NODRIVER);
+        ca_return_val_if_fail(!PRIVATE(c), CA_ERROR_STATE);
 
-    if (!(c->private = p = ca_new0(struct private, 1)))
-        return CA_ERROR_OOM;
+        if (!(c->private = p = ca_new0(struct private, 1)))
+                return CA_ERROR_OOM;
 
-    if (!(p->outstanding_mutex = ca_mutex_new())) {
-        driver_destroy(c);
-        return CA_ERROR_OOM;
-    }
+        if (!(p->outstanding_mutex = ca_mutex_new())) {
+                driver_destroy(c);
+                return CA_ERROR_OOM;
+        }
 
-    if (sem_init(&p->semaphore, 0, 0) < 0) {
-        driver_destroy(c);
-        return CA_ERROR_OOM;
-    }
+        if (sem_init(&p->semaphore, 0, 0) < 0) {
+                driver_destroy(c);
+                return CA_ERROR_OOM;
+        }
 
-    p->semaphore_allocated = TRUE;
+        p->semaphore_allocated = TRUE;
 
-    return CA_SUCCESS;
+        return CA_SUCCESS;
 }
 
 int driver_destroy(ca_context *c) {
-    struct private *p;
-    struct outstanding *out;
+        struct private *p;
+        struct outstanding *out;
 
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(c->private, CA_ERROR_STATE);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c->private, CA_ERROR_STATE);
 
-    p = PRIVATE(c);
+        p = PRIVATE(c);
 
-    if (p->outstanding_mutex) {
-        ca_mutex_lock(p->outstanding_mutex);
+        if (p->outstanding_mutex) {
+                ca_mutex_lock(p->outstanding_mutex);
 
-        /* Tell all player threads to terminate */
-        for (out = p->outstanding; out; out = out->next) {
+                /* Tell all player threads to terminate */
+                for (out = p->outstanding; out; out = out->next) {
 
-            if (out->dead)
-                continue;
+                        if (out->dead)
+                                continue;
 
-            out->dead = TRUE;
+                        out->dead = TRUE;
 
-            if (out->callback)
-                out->callback(c, out->id, CA_ERROR_DESTROYED, out->userdata);
+                        if (out->callback)
+                                out->callback(c, out->id, CA_ERROR_DESTROYED, out->userdata);
 
-            /* This will cause the thread to wakeup and terminate */
-            if (out->pipe_fd[1] >= 0) {
-                close(out->pipe_fd[1]);
-                out->pipe_fd[1] = -1;
-            }
-        }
+                        /* This will cause the thread to wakeup and terminate */
+                        if (out->pipe_fd[1] >= 0) {
+                                close(out->pipe_fd[1]);
+                                out->pipe_fd[1] = -1;
+                        }
+                }
+
+                if (p->semaphore_allocated) {
+                        /* Now wait until all players are destroyed */
+                        p->signal_semaphore = TRUE;
+                        while (p->outstanding) {
+                                ca_mutex_unlock(p->outstanding_mutex);
+                                sem_wait(&p->semaphore);
+                                ca_mutex_lock(p->outstanding_mutex);
+                        }
+                }
 
-        if (p->semaphore_allocated) {
-            /* Now wait until all players are destroyed */
-            p->signal_semaphore = TRUE;
-            while (p->outstanding) {
                 ca_mutex_unlock(p->outstanding_mutex);
-                sem_wait(&p->semaphore);
-                ca_mutex_lock(p->outstanding_mutex);
-            }
+                ca_mutex_free(p->outstanding_mutex);
         }
 
-        ca_mutex_unlock(p->outstanding_mutex);
-        ca_mutex_free(p->outstanding_mutex);
-    }
-
-    if (p->theme)
-        ca_theme_data_free(p->theme);
+        if (p->theme)
+                ca_theme_data_free(p->theme);
 
-    if (p->semaphore_allocated)
-        sem_destroy(&p->semaphore);
+        if (p->semaphore_allocated)
+                sem_destroy(&p->semaphore);
 
-    ca_free(p);
+        ca_free(p);
 
-    c->private = NULL;
+        c->private = NULL;
 
-    snd_config_update_free_global();
+        snd_config_update_free_global();
 
-    return CA_SUCCESS;
+        return CA_SUCCESS;
 }
 
 int driver_change_device(ca_context *c, const char *device) {
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(c->private, CA_ERROR_STATE);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c->private, CA_ERROR_STATE);
 
-    return CA_SUCCESS;
+        return CA_SUCCESS;
 }
 
 int driver_change_props(ca_context *c, ca_proplist *changed, ca_proplist *merged) {
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(changed, CA_ERROR_INVALID);
-    ca_return_val_if_fail(merged, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(changed, CA_ERROR_INVALID);
+        ca_return_val_if_fail(merged, CA_ERROR_INVALID);
 
-    return CA_SUCCESS;
+        return CA_SUCCESS;
 }
 
 int driver_cache(ca_context *c, ca_proplist *proplist) {
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(proplist, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(proplist, CA_ERROR_INVALID);
 
-    return CA_ERROR_NOTSUPPORTED;
+        return CA_ERROR_NOTSUPPORTED;
 }
 
 static int translate_error(int error) {
 
-    switch (error) {
+        switch (error) {
         case -ENODEV:
         case -ENOENT:
-            return CA_ERROR_NOTFOUND;
+                return CA_ERROR_NOTFOUND;
         case -EACCES:
         case -EPERM:
-            return CA_ERROR_ACCESS;
+                return CA_ERROR_ACCESS;
         case -ENOMEM:
-            return CA_ERROR_OOM;
+                return CA_ERROR_OOM;
         case -EBUSY:
-            return CA_ERROR_NOTAVAILABLE;
+                return CA_ERROR_NOTAVAILABLE;
         case -EINVAL:
-            return CA_ERROR_INVALID;
+                return CA_ERROR_INVALID;
         case -ENOSYS:
-            return CA_ERROR_NOTSUPPORTED;
+                return CA_ERROR_NOTSUPPORTED;
         default:
-            if (ca_debug())
-                fprintf(stderr, "Got unhandled error from ALSA: %s\n", snd_strerror(error));
-            return CA_ERROR_IO;
-    }
+                if (ca_debug())
+                        fprintf(stderr, "Got unhandled error from ALSA: %s\n", snd_strerror(error));
+                return CA_ERROR_IO;
+        }
 }
 
 static const snd_pcm_format_t sample_type_table[] = {
 #ifdef WORDS_BIGENDIAN
-    [CA_SAMPLE_S16NE] = SND_PCM_FORMAT_S16_BE,
-    [CA_SAMPLE_S16RE] = SND_PCM_FORMAT_S16_LE,
+        [CA_SAMPLE_S16NE] = SND_PCM_FORMAT_S16_BE,
+        [CA_SAMPLE_S16RE] = SND_PCM_FORMAT_S16_LE,
 #else
-    [CA_SAMPLE_S16NE] = SND_PCM_FORMAT_S16_LE,
-    [CA_SAMPLE_S16RE] = SND_PCM_FORMAT_S16_BE,
+        [CA_SAMPLE_S16NE] = SND_PCM_FORMAT_S16_LE,
+        [CA_SAMPLE_S16RE] = SND_PCM_FORMAT_S16_BE,
 #endif
-    [CA_SAMPLE_U8] = SND_PCM_FORMAT_U8
+        [CA_SAMPLE_U8] = SND_PCM_FORMAT_U8
 };
 
 static int open_alsa(ca_context *c, struct outstanding *out) {
-    struct private *p;
-    int ret;
-    snd_pcm_hw_params_t *hwparams;
-    unsigned rate;
+        struct private *p;
+        int ret;
+        snd_pcm_hw_params_t *hwparams;
+        unsigned rate;
 
-    snd_pcm_hw_params_alloca(&hwparams);
+        snd_pcm_hw_params_alloca(&hwparams);
 
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(c->private, CA_ERROR_STATE);
-    ca_return_val_if_fail(out, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c->private, CA_ERROR_STATE);
+        ca_return_val_if_fail(out, CA_ERROR_INVALID);
 
-    /* In ALSA we need to open different devices for doing
-     * multichannel audio. This cnnot be done in a backend-independant
-     * wa, hence we limit ourselves to mono/stereo only. */
-    ca_return_val_if_fail(ca_sound_file_get_nchannels(out->file) <= 2, CA_ERROR_NOTSUPPORTED);
+        /* In ALSA we need to open different devices for doing
+         * multichannel audio. This cnnot be done in a backend-independant
+         * wa, hence we limit ourselves to mono/stereo only. */
+        ca_return_val_if_fail(ca_sound_file_get_nchannels(out->file) <= 2, CA_ERROR_NOTSUPPORTED);
 
-    p = PRIVATE(c);
+        p = PRIVATE(c);
 
-    if ((ret = snd_pcm_open(&out->pcm, c->device ? c->device : "default", SND_PCM_STREAM_PLAYBACK, 0)) < 0)
-        goto finish;
+        if ((ret = snd_pcm_open(&out->pcm, c->device ? c->device : "default", SND_PCM_STREAM_PLAYBACK, 0)) < 0)
+                goto finish;
 
-    if ((ret = snd_pcm_hw_params_any(out->pcm, hwparams)) < 0)
-        goto finish;
+        if ((ret = snd_pcm_hw_params_any(out->pcm, hwparams)) < 0)
+                goto finish;
 
-    if ((ret = snd_pcm_hw_params_set_access(out->pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
-        goto finish;
+        if ((ret = snd_pcm_hw_params_set_access(out->pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
+                goto finish;
 
-    if ((ret = snd_pcm_hw_params_set_format(out->pcm, hwparams, sample_type_table[ca_sound_file_get_sample_type(out->file)])) < 0)
-        goto finish;
+        if ((ret = snd_pcm_hw_params_set_format(out->pcm, hwparams, sample_type_table[ca_sound_file_get_sample_type(out->file)])) < 0)
+                goto finish;
 
-    rate = ca_sound_file_get_rate(out->file);
-    if ((ret = snd_pcm_hw_params_set_rate_near(out->pcm, hwparams, &rate, 0)) < 0)
-        goto finish;
+        rate = ca_sound_file_get_rate(out->file);
+        if ((ret = snd_pcm_hw_params_set_rate_near(out->pcm, hwparams, &rate, 0)) < 0)
+                goto finish;
 
-    if ((ret = snd_pcm_hw_params_set_channels(out->pcm, hwparams, ca_sound_file_get_nchannels(out->file))) < 0)
-        goto finish;
+        if ((ret = snd_pcm_hw_params_set_channels(out->pcm, hwparams, ca_sound_file_get_nchannels(out->file))) < 0)
+                goto finish;
 
-    if ((ret = snd_pcm_hw_params(out->pcm, hwparams)) < 0)
-        goto finish;
+        if ((ret = snd_pcm_hw_params(out->pcm, hwparams)) < 0)
+                goto finish;
 
-    if ((ret = snd_pcm_prepare(out->pcm)) < 0)
-        goto finish;
+        if ((ret = snd_pcm_prepare(out->pcm)) < 0)
+                goto finish;
 
-    return CA_SUCCESS;
+        return CA_SUCCESS;
 
 finish:
 
-    return translate_error(ret);
+        return translate_error(ret);
 }
 
 #define BUFSIZE (16*1024)
 
 static void* thread_func(void *userdata) {
-    struct outstanding *out = userdata;
-    int ret;
-    void *data, *d = NULL;
-    size_t fs, data_size;
-    size_t nbytes = 0;
-    struct pollfd *pfd = NULL;
-    nfds_t n_pfd;
-    struct private *p;
-
-    p = PRIVATE(out->context);
-
-    pthread_detach(pthread_self());
-
-    fs = ca_sound_file_frame_size(out->file);
-    data_size = (BUFSIZE/fs)*fs;
-
-    if (!(data = ca_malloc(data_size))) {
-        ret = CA_ERROR_OOM;
-        goto finish;
-    }
-
-    if ((ret = snd_pcm_poll_descriptors_count(out->pcm)) < 0) {
-        ret = translate_error(ret);
-        goto finish;
-    }
-
-    n_pfd = (nfds_t) ret + 1;
-    if (!(pfd = ca_new(struct pollfd, n_pfd))) {
-        ret = CA_ERROR_OOM;
-        goto finish;
-    }
-
-    if ((ret = snd_pcm_poll_descriptors(out->pcm, pfd+1, (unsigned) n_pfd-1)) < 0) {
-        ret = translate_error(ret);
-        goto finish;
-    }
-
-    pfd[0].fd = out->pipe_fd[0];
-    pfd[0].events = POLLIN;
-    pfd[0].revents = 0;
-
-    for (;;) {
-        unsigned short revents;
-        snd_pcm_sframes_t sframes;
-
-        if (out->dead)
-            break;
-
-        if (poll(pfd, n_pfd, -1) < 0) {
-            ret = CA_ERROR_SYSTEM;
-            goto finish;
+        struct outstanding *out = userdata;
+        int ret;
+        void *data, *d = NULL;
+        size_t fs, data_size;
+        size_t nbytes = 0;
+        struct pollfd *pfd = NULL;
+        nfds_t n_pfd;
+        struct private *p;
+
+        p = PRIVATE(out->context);
+
+        pthread_detach(pthread_self());
+
+        fs = ca_sound_file_frame_size(out->file);
+        data_size = (BUFSIZE/fs)*fs;
+
+        if (!(data = ca_malloc(data_size))) {
+                ret = CA_ERROR_OOM;
+                goto finish;
         }
 
-        /* We have been asked to shut down */
-        if (pfd[0].revents)
-            break;
+        if ((ret = snd_pcm_poll_descriptors_count(out->pcm)) < 0) {
+                ret = translate_error(ret);
+                goto finish;
+        }
 
-        if ((ret = snd_pcm_poll_descriptors_revents(out->pcm, pfd+1, (unsigned) n_pfd-1, &revents)) < 0) {
-            ret = translate_error(ret);
-            goto finish;
+        n_pfd = (nfds_t) ret + 1;
+        if (!(pfd = ca_new(struct pollfd, n_pfd))) {
+                ret = CA_ERROR_OOM;
+                goto finish;
         }
 
-        if (revents != POLLOUT) {
+        if ((ret = snd_pcm_poll_descriptors(out->pcm, pfd+1, (unsigned) n_pfd-1)) < 0) {
+                ret = translate_error(ret);
+                goto finish;
+        }
 
-            switch (snd_pcm_state(out->pcm)) {
+        pfd[0].fd = out->pipe_fd[0];
+        pfd[0].events = POLLIN;
+        pfd[0].revents = 0;
 
-                case SND_PCM_STATE_XRUN:
+        for (;;) {
+                unsigned short revents;
+                snd_pcm_sframes_t sframes;
 
-                    if ((ret = snd_pcm_recover(out->pcm, -EPIPE, 1)) != 0) {
-                        ret = translate_error(ret);
+                if (out->dead)
+                        break;
+
+                if (poll(pfd, n_pfd, -1) < 0) {
+                        ret = CA_ERROR_SYSTEM;
                         goto finish;
-                    }
-                    break;
+                }
 
-                case SND_PCM_STATE_SUSPENDED:
+                /* We have been asked to shut down */
+                if (pfd[0].revents)
+                        break;
 
-                    if ((ret = snd_pcm_recover(out->pcm, -ESTRPIPE, 1)) != 0) {
+                if ((ret = snd_pcm_poll_descriptors_revents(out->pcm, pfd+1, (unsigned) n_pfd-1, &revents)) < 0) {
                         ret = translate_error(ret);
                         goto finish;
-                    }
-                    break;
+                }
 
-                default:
+                if (revents != POLLOUT) {
 
-                    snd_pcm_drop(out->pcm);
+                        switch (snd_pcm_state(out->pcm)) {
 
-                    if ((ret = snd_pcm_prepare(out->pcm)) < 0) {
-                        ret = translate_error(ret);
-                        goto finish;
-                    }
-                    break;
-            }
+                        case SND_PCM_STATE_XRUN:
 
-            continue;
-        }
+                                if ((ret = snd_pcm_recover(out->pcm, -EPIPE, 1)) != 0) {
+                                        ret = translate_error(ret);
+                                        goto finish;
+                                }
+                                break;
 
-        if (nbytes <= 0) {
+                        case SND_PCM_STATE_SUSPENDED:
 
-            nbytes = data_size;
+                                if ((ret = snd_pcm_recover(out->pcm, -ESTRPIPE, 1)) != 0) {
+                                        ret = translate_error(ret);
+                                        goto finish;
+                                }
+                                break;
 
-            if ((ret = ca_sound_file_read_arbitrary(out->file, data, &nbytes)) < 0)
-                goto finish;
+                        default:
 
-            d = data;
-        }
+                                snd_pcm_drop(out->pcm);
 
-        if (nbytes <= 0) {
-            snd_pcm_drain(out->pcm);
-            break;
-        }
+                                if ((ret = snd_pcm_prepare(out->pcm)) < 0) {
+                                        ret = translate_error(ret);
+                                        goto finish;
+                                }
+                                break;
+                        }
 
-        if ((sframes = snd_pcm_writei(out->pcm, d, nbytes/fs)) < 0) {
+                        continue;
+                }
 
-            if ((ret = snd_pcm_recover(out->pcm, (int) sframes, 1)) < 0) {
-                ret = translate_error(ret);
-                goto finish;
-            }
+                if (nbytes <= 0) {
 
-            continue;
-        }
+                        nbytes = data_size;
+
+                        if ((ret = ca_sound_file_read_arbitrary(out->file, data, &nbytes)) < 0)
+                                goto finish;
 
-        nbytes -= (size_t) sframes*fs;
-        d = (uint8_t*) d + (size_t) sframes*fs;
-    }
+                        d = data;
+                }
 
-    ret = CA_SUCCESS;
+                if (nbytes <= 0) {
+                        snd_pcm_drain(out->pcm);
+                        break;
+                }
+
+                if ((sframes = snd_pcm_writei(out->pcm, d, nbytes/fs)) < 0) {
+
+                        if ((ret = snd_pcm_recover(out->pcm, (int) sframes, 1)) < 0) {
+                                ret = translate_error(ret);
+                                goto finish;
+                        }
+
+                        continue;
+                }
+
+                nbytes -= (size_t) sframes*fs;
+                d = (uint8_t*) d + (size_t) sframes*fs;
+        }
+
+        ret = CA_SUCCESS;
 
 finish:
 
-    ca_free(data);
-    ca_free(pfd);
+        ca_free(data);
+        ca_free(pfd);
 
-    if (!out->dead)
-        if (out->callback)
-            out->callback(out->context, out->id, ret, out->userdata);
+        if (!out->dead)
+                if (out->callback)
+                        out->callback(out->context, out->id, ret, out->userdata);
 
-    ca_mutex_lock(p->outstanding_mutex);
+        ca_mutex_lock(p->outstanding_mutex);
 
-    CA_LLIST_REMOVE(struct outstanding, p->outstanding, out);
+        CA_LLIST_REMOVE(struct outstanding, p->outstanding, out);
 
-    if (!p->outstanding && p->signal_semaphore)
-        sem_post(&p->semaphore);
+        if (!p->outstanding && p->signal_semaphore)
+                sem_post(&p->semaphore);
 
-    outstanding_free(out);
+        outstanding_free(out);
 
-    ca_mutex_unlock(p->outstanding_mutex);
+        ca_mutex_unlock(p->outstanding_mutex);
 
-    return NULL;
+        return NULL;
 }
 
 int driver_play(ca_context *c, uint32_t id, ca_proplist *proplist, ca_finish_callback_t cb, void *userdata) {
-    struct private *p;
-    struct outstanding *out = NULL;
-    int ret;
-    pthread_t thread;
+        struct private *p;
+        struct outstanding *out = NULL;
+        int ret;
+        pthread_t thread;
 
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(proplist, CA_ERROR_INVALID);
-    ca_return_val_if_fail(!userdata || cb, CA_ERROR_INVALID);
-    ca_return_val_if_fail(c->private, CA_ERROR_STATE);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(proplist, CA_ERROR_INVALID);
+        ca_return_val_if_fail(!userdata || cb, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c->private, CA_ERROR_STATE);
 
-    p = PRIVATE(c);
+        p = PRIVATE(c);
 
-    if (!(out = ca_new0(struct outstanding, 1))) {
-        ret = CA_ERROR_OOM;
-        goto finish;
-    }
-
-    out->context = c;
-    out->id = id;
-    out->callback = cb;
-    out->userdata = userdata;
-    out->pipe_fd[0] = out->pipe_fd[1] = -1;
-
-    if (pipe(out->pipe_fd) < 0) {
-        ret = CA_ERROR_SYSTEM;
-        goto finish;
-    }
+        if (!(out = ca_new0(struct outstanding, 1))) {
+                ret = CA_ERROR_OOM;
+                goto finish;
+        }
 
-    if ((ret = ca_lookup_sound(&out->file, NULL, &p->theme, c->props, proplist)) < 0)
-        goto finish;
+        out->context = c;
+        out->id = id;
+        out->callback = cb;
+        out->userdata = userdata;
+        out->pipe_fd[0] = out->pipe_fd[1] = -1;
 
-    if ((ret = open_alsa(c, out)) < 0)
-        goto finish;
+        if (pipe(out->pipe_fd) < 0) {
+                ret = CA_ERROR_SYSTEM;
+                goto finish;
+        }
 
-    /* OK, we're ready to go, so let's add this to our list */
-    ca_mutex_lock(p->outstanding_mutex);
-    CA_LLIST_PREPEND(struct outstanding, p->outstanding, out);
-    ca_mutex_unlock(p->outstanding_mutex);
+        if ((ret = ca_lookup_sound(&out->file, NULL, &p->theme, c->props, proplist)) < 0)
+                goto finish;
 
-    if (pthread_create(&thread, NULL, thread_func, out) < 0) {
-        ret = CA_ERROR_OOM;
+        if ((ret = open_alsa(c, out)) < 0)
+                goto finish;
 
+        /* OK, we're ready to go, so let's add this to our list */
         ca_mutex_lock(p->outstanding_mutex);
-        CA_LLIST_REMOVE(struct outstanding, p->outstanding, out);
+        CA_LLIST_PREPEND(struct outstanding, p->outstanding, out);
         ca_mutex_unlock(p->outstanding_mutex);
 
-        goto finish;
-    }
+        if (pthread_create(&thread, NULL, thread_func, out) < 0) {
+                ret = CA_ERROR_OOM;
 
-    ret = CA_SUCCESS;
+                ca_mutex_lock(p->outstanding_mutex);
+                CA_LLIST_REMOVE(struct outstanding, p->outstanding, out);
+                ca_mutex_unlock(p->outstanding_mutex);
+
+                goto finish;
+        }
+
+        ret = CA_SUCCESS;
 
 finish:
 
-    /* We keep the outstanding struct around if we need clean up later to */
-    if (ret != CA_SUCCESS)
-        outstanding_free(out);
+        /* We keep the outstanding struct around if we need clean up later to */
+        if (ret != CA_SUCCESS)
+                outstanding_free(out);
 
-    return ret;
+        return ret;
 }
 
 int driver_cancel(ca_context *c, uint32_t id) {
-    struct private *p;
-    struct outstanding *out;
+        struct private *p;
+        struct outstanding *out;
 
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(c->private, CA_ERROR_STATE);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c->private, CA_ERROR_STATE);
 
-    p = PRIVATE(c);
+        p = PRIVATE(c);
 
-    ca_mutex_lock(p->outstanding_mutex);
+        ca_mutex_lock(p->outstanding_mutex);
 
-    for (out = p->outstanding; out; out = out->next) {
+        for (out = p->outstanding; out; out = out->next) {
 
-        if (out->id != id)
-            continue;
+                if (out->id != id)
+                        continue;
 
-        if (out->dead)
-            continue;
+                if (out->dead)
+                        continue;
 
-        out->dead = TRUE;
+                out->dead = TRUE;
 
-        if (out->callback)
-            out->callback(c, out->id, CA_ERROR_CANCELED, out->userdata);
+                if (out->callback)
+                        out->callback(c, out->id, CA_ERROR_CANCELED, out->userdata);
 
-        /* This will cause the thread to wakeup and terminate */
-        if (out->pipe_fd[1] >= 0) {
-            close(out->pipe_fd[1]);
-            out->pipe_fd[1] = -1;
+                /* This will cause the thread to wakeup and terminate */
+                if (out->pipe_fd[1] >= 0) {
+                        close(out->pipe_fd[1]);
+                        out->pipe_fd[1] = -1;
+                }
         }
-    }
 
-    ca_mutex_unlock(p->outstanding_mutex);
+        ca_mutex_unlock(p->outstanding_mutex);
 
-    return CA_SUCCESS;
+        return CA_SUCCESS;
 }
 
 int driver_playing(ca_context *c, uint32_t id, int *playing) {
-    struct private *p;
-    struct outstanding *out;
+        struct private *p;
+        struct outstanding *out;
 
-    ca_return_val_if_fail(c, CA_ERROR_INVALID);
-    ca_return_val_if_fail(c->private, CA_ERROR_STATE);
-    ca_return_val_if_fail(playing, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c, CA_ERROR_INVALID);
+        ca_return_val_if_fail(c->private, CA_ERROR_STATE);
+        ca_return_val_if_fail(playing, CA_ERROR_INVALID);
 
-    p = PRIVATE(c);
+        p = PRIVATE(c);
 
-    *playing = 0;
+        *playing = 0;
 
-    ca_mutex_lock(p->outstanding_mutex);
+        ca_mutex_lock(p->outstanding_mutex);
 
-    for (out = p->outstanding; out; out = out->next) {
+        for (out = p->outstanding; out; out = out->next) {
 
-        if (out->dead ||
-            out->id != id)
-            continue;
+                if (out->dead ||
+                    out->id != id)
+                        continue;
 
-        *playing = 1;
-        break;
-    }
+                *playing = 1;
+                break;
+        }
 
-    ca_mutex_unlock(p->outstanding_mutex);
+        ca_mutex_unlock(p->outstanding_mutex);
 
-    return CA_SUCCESS;
+        return CA_SUCCESS;
 }