pulse.c

Bug Summary

File:	pulse.c
Warning:	line 462, column 17 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pulse.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/src -resource-dir /usr/lib/llvm-14/lib/clang/14.0.6 -D HAVE_CONFIG_H -I . -I .. -D _REENTRANT -D driver_open=pulse_driver_open -D driver_destroy=pulse_driver_destroy -D driver_change_device=pulse_driver_change_device -D driver_change_props=pulse_driver_change_props -D driver_play=pulse_driver_play -D driver_cancel=pulse_driver_cancel -D driver_cache=pulse_driver_cache -D PIC -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.6/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/12/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir=/rootdir/src -ferror-limit 19 -fgnuc-version=4.2.1 -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2022-12-24-113535-18449-1 -x c pulse.c
1/*-*- Mode: C; c-basic-offset: 8 -*-*/

3/***
This file is part of libkanberra.

Copyright 2008 Lennart Poettering

libkanberra is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 2.1 of the
License, or (at your option) any later version.

libkanberra is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with libkanberra. If not, see
<http://www.gnu.org/licenses/>.
21***/

23#ifdef HAVE_CONFIG_H1
24#include <config.h>
25#endif

27/* The locking order needs to be strictly followed! First take the
* mainloop mutex, only then take outstanding_mutex if you need both!
* Not the other way round, beacause we might then enter a
* deadlock!  */

32#include <errno(*__errno_location ()).h>
33#include <stdlib.h>

35#include <pulse/thread-mainloop.h>
36#include <pulse/context.h>
37#include <pulse/scache.h>
38#include <pulse/subscribe.h>
39#include <pulse/introspect.h>

41#include "kanberra.h"
42#include "common.h"
43#include "driver.h"
44#include "llist.h"
45#include "read-sound-file.h"
46#include "sound-theme-spec.h"
47#include "malloc.h"

49enum outstanding_type {
      OUTSTANDING_SAMPLE,
      OUTSTANDING_STREAM,
      OUTSTANDING_UPLOAD
53};

55struct outstanding {
      KA_LLIST_FIELDS(struct outstanding)struct outstanding *next, *prev;
      enum outstanding_type type;
      ka_context *context;
      uint32_t id;
      uint32_t sink_input;
      pa_stream *stream;
      pa_operation *drain_operation;
      ka_finish_callback_t callback;
      void *userdata;
      ka_sound_file *file;
      int error;
      unsigned clean_up:1; /* Handler needs to clean up the outstanding struct */
      unsigned finished:1; /* finished playing */
69};

71struct private {
      pa_threaded_mainloop *mainloop;
      pa_context *context;
      ka_theme_data *theme;
      ka_bool_t subscribed;
      ka_bool_t reconnect;

      ka_mutex *outstanding_mutex;
      KA_LLIST_HEAD(struct outstanding, outstanding)struct outstanding *outstanding;
80};

82#define PRIVATE(c)((struct private *) ((c)->private)) ((struct private *) ((c)->private))

84static void context_state_cb(pa_context *pc, void *userdata);
85static void context_subscribe_cb(pa_context *pc, pa_subscription_event_type_t t, uint32_t idx, void *userdata);

87static void outstanding_disconnect(struct outstanding *o) {
      ka_assert(o)do { if ((__builtin_expect((!(o)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "o" , "pulse.c", 88, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      if (o->stream) {
              if (o->drain_operation) {
                      pa_operation_cancel(o->drain_operation);
                      pa_operation_unref(o->drain_operation);
                      o->drain_operation = NULL((void*)0);
              }

              pa_stream_set_write_callback(o->stream, NULL((void*)0), NULL((void*)0));
              pa_stream_set_state_callback(o->stream, NULL((void*)0), NULL((void*)0));
              pa_stream_disconnect(o->stream);
              pa_stream_unref(o->stream);
              o->stream = NULL((void*)0);
      }
103}

105static void outstanding_free(struct outstanding *o) {
      ka_assert(o)do { if ((__builtin_expect((!(o)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "o" , "pulse.c", 106, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
40
←
Taking false branch→
41
←
Loop condition is false.  Exiting loop→

      outstanding_disconnect(o);

      if (o->file)
42
←
Assuming field 'file' is null→
43
←
Taking false branch→
              ka_sound_file_close(o->file);

      ka_freefree(o);
44
←
Memory is released→
114}

116static int convert_proplist(pa_proplist **_l, ka_proplist *c) {
      pa_proplist *l;
      ka_prop *i;

      ka_return_val_if_fail(_l, KA_ERROR_INVALID)do { if ((__builtin_expect((!(_l)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "_l"
 , "pulse.c", 120, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 121, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));

      if (!(l = pa_proplist_new()))
              return KA_ERROR_OOM;

      ka_mutex_lock(c->mutex);

      for (i = c->first_item; i; i = i->next_item)
              if (pa_proplist_set(l, i->key, KA_PROP_DATA(i)((void*) ((char*) (i) + (ka_align(sizeof(ka_prop))))), i->nbytes) < 0) {
                      ka_mutex_unlock(c->mutex);
                      pa_proplist_free(l);
                      return KA_ERROR_INVALID;
              }

      ka_mutex_unlock(c->mutex);

      *_l = l;

      return KA_SUCCESS;
140}

142static pa_proplist *strip_prefix(pa_proplist *l, const char *prefix) {
      const char *key;
      void *state = NULL((void*)0);
      ka_assert(l)do { if ((__builtin_expect((!(l)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "l" , "pulse.c", 145, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      while ((key = pa_proplist_iterate(l, &state)))
              if (strncmp(key, prefix, strlen(prefix)) == 0)
                      pa_proplist_unset(l, key);

      return l;
152}

154static void add_common(pa_proplist *l) {
      ka_assert(l)do { if ((__builtin_expect((!(l)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "l" , "pulse.c", 155, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      if (!pa_proplist_contains(l, KA_PROP_MEDIA_ROLE"media.role"))
              pa_proplist_sets(l, KA_PROP_MEDIA_ROLE"media.role", "event");

      if (!pa_proplist_contains(l, KA_PROP_MEDIA_NAME"media.name")) {
              const char *t;

              if ((t = pa_proplist_gets(l, KA_PROP_EVENT_ID"event.id")))
                      pa_proplist_sets(l, KA_PROP_MEDIA_NAME"media.name", t);
              else if ((t = pa_proplist_gets(l, KA_PROP_MEDIA_FILENAME"media.filename")))
                      pa_proplist_sets(l, KA_PROP_MEDIA_NAME"media.name", t);
              else
                      pa_proplist_sets(l, KA_PROP_MEDIA_NAME"media.name", "libkanberra");
      }
170}

172static int translate_error(int error) {
      static const int table[PA_ERR_MAXPA_ERR_MAX] = {
              [PA_OKPA_OK]                       = KA_SUCCESS,
              [PA_ERR_ACCESSPA_ERR_ACCESS]               = KA_ERROR_ACCESS,
              [PA_ERR_COMMANDPA_ERR_COMMAND]              = KA_ERROR_IO,
              [PA_ERR_INVALIDPA_ERR_INVALID]              = KA_ERROR_INVALID,
              [PA_ERR_EXISTPA_ERR_EXIST]                = KA_ERROR_IO,
              [PA_ERR_NOENTITYPA_ERR_NOENTITY]             = KA_ERROR_NOTFOUND,
              [PA_ERR_CONNECTIONREFUSEDPA_ERR_CONNECTIONREFUSED]    = KA_ERROR_NOTAVAILABLE,
              [PA_ERR_PROTOCOLPA_ERR_PROTOCOL]             = KA_ERROR_IO,
              [PA_ERR_TIMEOUTPA_ERR_TIMEOUT]              = KA_ERROR_IO,
              [PA_ERR_AUTHKEYPA_ERR_AUTHKEY]              = KA_ERROR_ACCESS,
              [PA_ERR_INTERNALPA_ERR_INTERNAL]             = KA_ERROR_IO,
              [PA_ERR_CONNECTIONTERMINATEDPA_ERR_CONNECTIONTERMINATED] = KA_ERROR_IO,
              [PA_ERR_KILLEDPA_ERR_KILLED]               = KA_ERROR_DESTROYED,
              [PA_ERR_INVALIDSERVERPA_ERR_INVALIDSERVER]        = KA_ERROR_INVALID,
              [PA_ERR_MODINITFAILEDPA_ERR_MODINITFAILED]        = KA_ERROR_NODRIVER,
              [PA_ERR_BADSTATEPA_ERR_BADSTATE]             = KA_ERROR_STATE,
              [PA_ERR_NODATAPA_ERR_NODATA]               = KA_ERROR_IO,
              [PA_ERR_VERSIONPA_ERR_VERSION]              = KA_ERROR_NOTSUPPORTED,
              [PA_ERR_TOOLARGEPA_ERR_TOOLARGE]             = KA_ERROR_TOOBIG,
193#ifdef PA_ERR_NOTSUPPORTEDPA_ERR_NOTSUPPORTED
              [PA_ERR_NOTSUPPORTEDPA_ERR_NOTSUPPORTED]         = KA_ERROR_NOTSUPPORTED,
195#endif
196#ifdef PA_ERR_UNKNOWNPA_ERR_UNKNOWN
              [PA_ERR_UNKNOWNPA_ERR_UNKNOWN]              = KA_ERROR_IO,
198#endif
199#ifdef PA_ERR_NOEXTENSIONPA_ERR_NOEXTENSION
              [PA_ERR_NOEXTENSIONPA_ERR_NOEXTENSION]          = KA_ERROR_NOTSUPPORTED,
201#endif
202#ifdef PA_ERR_OBSOLETEPA_ERR_OBSOLETE
              [PA_ERR_OBSOLETEPA_ERR_OBSOLETE]             = KA_ERROR_NOTSUPPORTED,
204#endif
205#ifdef PA_ERR_NOTIMPLEMENTEDPA_ERR_NOTIMPLEMENTED
              [PA_ERR_NOTIMPLEMENTEDPA_ERR_NOTIMPLEMENTED]       = KA_ERROR_NOTSUPPORTED
207#endif
      };

      ka_assert(error >= 0)do { if ((__builtin_expect((!(error >= 0)),0))) { fprintf(
stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "error >= 0" , "pulse.c", 210, __PRETTY_FUNCTION__); abort
(); } } while ((0));

      if (error >= PA_ERR_MAXPA_ERR_MAX || !table[error])
              return KA_ERROR_IO;

      return table[error];
216}

218static int context_connect(ka_context *c, ka_bool_t nofail) {
      pa_proplist *l;
      struct private *p;
      int ret;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 223, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(p = c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(p = c->private)),0))) { if (
ka_debug()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "p = c->private" , "pulse.c", 224, __PRETTY_FUNCTION__);
 return (KA_ERROR_STATE); } } while((0));
      ka_return_val_if_fail(p->mainloop, KA_ERROR_STATE)do { if ((__builtin_expect((!(p->mainloop)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "p->mainloop" , "pulse.c", 225, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));
      ka_return_val_if_fail(!p->context, KA_ERROR_STATE)do { if ((__builtin_expect((!(!p->context)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "!p->context" , "pulse.c", 226, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      /* If this immediate attempt fails, don't try to reconnect. */
      p->reconnect = FALSE(0);

      if ((ret = convert_proplist(&l, c->props)) < 0)
              return ret;

      strip_prefix(l, "kanberra.");

      if (!pa_proplist_contains(l, PA_PROP_APPLICATION_NAME"application.name")) {
              pa_proplist_sets(l, PA_PROP_APPLICATION_NAME"application.name", "libkanberra");
              pa_proplist_sets(l, PA_PROP_APPLICATION_VERSION"application.version", PACKAGE_VERSION"0.31");

              if (!pa_proplist_contains(l, PA_PROP_APPLICATION_ID"application.id"))
                      pa_proplist_sets(l, PA_PROP_APPLICATION_ID"application.id", "org.freedesktop.libkanberra");

      }

      if (!(p->context = pa_context_new_with_proplist(pa_threaded_mainloop_get_api(p->mainloop), NULL((void*)0), l))) {
              pa_proplist_free(l);
              return KA_ERROR_OOM;
      }

      pa_proplist_free(l);

      pa_context_set_state_callback(p->context, context_state_cb, c);
      pa_context_set_subscribe_callback(p->context, context_subscribe_cb, c);

      if (pa_context_connect(p->context, NULL((void*)0), nofail ? PA_CONTEXT_NOFAILPA_CONTEXT_NOFAIL : 0, NULL((void*)0)) < 0) {
              ret = translate_error(p->context ? pa_context_errno(p->context) : PA_ERR_CONNECTIONREFUSEDPA_ERR_CONNECTIONREFUSED);

              if (p->context) {
                      pa_context_disconnect(p->context);
                      pa_context_unref(p->context);
                      p->context = NULL((void*)0);
              }

              return ret;
      }

      return KA_SUCCESS;
268}

270static void context_state_cb(pa_context *pc, void *userdata) {
      ka_context *c = userdata;
      pa_context_state_t state;
      struct private *p;

      ka_assert(pc)do { if ((__builtin_expect((!(pc)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "pc" , "pulse.c", 275, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(c)do { if ((__builtin_expect((!(c)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "c" , "pulse.c", 276, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      p = PRIVATE(c)((struct private *) ((c)->private));

      state = pa_context_get_state(pc);
      if (state == PA_CONTEXT_FAILEDPA_CONTEXT_FAILED || state == PA_CONTEXT_TERMINATEDPA_CONTEXT_TERMINATED) {
              struct outstanding *out;
              int ret;

              if (state == PA_CONTEXT_TERMINATEDPA_CONTEXT_TERMINATED)
                      ret = KA_ERROR_DESTROYED;
              else
                      ret = translate_error(pa_context_errno(pc));

              ka_mutex_lock(p->outstanding_mutex);

              while ((out = p->outstanding)) {

                      outstanding_disconnect(out);
                      KA_LLIST_REMOVE(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 295, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if (_item->next) _item->next->prev = _item
->prev; if (_item->prev) _item->prev->next = _item
->next; else { do { if ((__builtin_expect((!(*_head == _item
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 295, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);

                      ka_mutex_unlock(p->outstanding_mutex);

                      if (out->callback)
                              out->callback(c, out->id, ret, out->userdata);

                      outstanding_free(out);

                      ka_mutex_lock(p->outstanding_mutex);
              }

              ka_mutex_unlock(p->outstanding_mutex);

              if (state == PA_CONTEXT_FAILEDPA_CONTEXT_FAILED && p->reconnect) {

                      if (p->context) {
                              pa_context_disconnect(p->context);
                              pa_context_unref(p->context);
                              p->context = NULL((void*)0);
                      }

                      p->subscribed = FALSE(0);

                      /* If we managed to connect once, then let's try to
                       * reconnect, and pass NOFAIL */
                      context_connect(c, TRUE(!(0)));
              }

      } else if (state == PA_CONTEXT_READYPA_CONTEXT_READY)
              /* OK, the connection suceeded once, if it dies now try to
               * reconnect */
              p->reconnect = TRUE(!(0));

      pa_threaded_mainloop_signal(p->mainloop, FALSE(0));
330}

332static void context_subscribe_cb(pa_context *pc, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
      struct outstanding *out, *n;
      KA_LLIST_HEAD(struct outstanding, l)struct outstanding *l;
      ka_context *c = userdata;
      struct private *p;

      ka_assert(pc)do { if ((__builtin_expect((!(pc)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "pc" , "pulse.c", 338, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(c)do { if ((__builtin_expect((!(c)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "c" , "pulse.c", 339, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      if (t != (PA_SUBSCRIPTION_EVENT_SINK_INPUTPA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVEPA_SUBSCRIPTION_EVENT_REMOVE))
              return;

      p = PRIVATE(c)((struct private *) ((c)->private));

      KA_LLIST_HEAD_INIT(struct outstanding, l)do { (l) = (struct outstanding*) ((void*)0); } while(0);

      ka_mutex_lock(p->outstanding_mutex);

      for (out = p->outstanding; out; out = n) {
              n = out->next;

              if (!out->clean_up || out->type != OUTSTANDING_SAMPLE || out->sink_input != idx)
                      continue;

              outstanding_disconnect(out);
              KA_LLIST_REMOVE(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 357, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if (_item->next) _item->next->prev = _item
->prev; if (_item->prev) _item->prev->next = _item
->next; else { do { if ((__builtin_expect((!(*_head == _item
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 357, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);

              KA_LLIST_PREPEND(struct outstanding, l, out)do { struct outstanding **_head = &(l), *_item = (out); do
 { if ((__builtin_expect((!(_item)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 359, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if ((_item->next = *_head)) _item->next->
prev = _item; _item->prev = ((void*)0); *_head = _item; } while
 (0);
      }

      ka_mutex_unlock(p->outstanding_mutex);

      while (l) {
              out = l;

              KA_LLIST_REMOVE(struct outstanding, l, out)do { struct outstanding **_head = &(l), *_item = (out); do
 { if ((__builtin_expect((!(_item)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 367, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if (_item->next) _item->next->prev = _item
->prev; if (_item->prev) _item->prev->next = _item
->next; else { do { if ((__builtin_expect((!(*_head == _item
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 367, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);

              if (out->callback)
                      out->callback(c, out->id, KA_SUCCESS, out->userdata);

              outstanding_free(out);
      }
374}

376int driver_openpulse_driver_open(ka_context *c) {
      struct private *p;
      int ret;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 380, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
1
Assuming 'c' is non-null→
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→
      ka_return_val_if_fail(!c->driver || ka_streq(c->driver, "pulse"), KA_ERROR_NODRIVER)do { if ((__builtin_expect((!(!c->driver || (strcmp((c->
driver),("pulse")) == 0))),0))) { if (ka_debug()) fprintf(stderr
, "Assertion '%s' failed at %s:%u, function %s().\n", "!c->driver || ka_streq(c->driver, \"pulse\")"
 , "pulse.c", 381, __PRETTY_FUNCTION__); return (KA_ERROR_NODRIVER
); } } while((0));
4
←
Assuming field 'driver' is non-null→
5
←
Taking false branch→
6
←
Loop condition is false.  Exiting loop→
      ka_return_val_if_fail(!PRIVATE(c), KA_ERROR_STATE)do { if ((__builtin_expect((!(!((struct private *) ((c)->private
)))),0))) { if (ka_debug()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "!PRIVATE(c)" , "pulse.c", 382, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));
7
←
Assuming field 'private' is null→
8
←
Taking false branch→
9
←
Loop condition is false.  Exiting loop→

      if (!(c->private = p = ka_new0(struct private, 1)((struct private*) calloc(1, (sizeof(struct private)*(1))))))
10
←
Assuming field 'private' is non-null→
11
←
Taking false branch→
              return KA_ERROR_OOM;

      if (!(p->outstanding_mutex = ka_mutex_new())) {
12
←
Assuming field 'outstanding_mutex' is non-null→
13
←
Taking false branch→
              driver_destroypulse_driver_destroy(c);
              return KA_ERROR_OOM;
      }

      if (!(p->mainloop = pa_threaded_mainloop_new())) {
14
←
Assuming field 'mainloop' is non-null→
15
←
Taking false branch→
              driver_destroypulse_driver_destroy(c);
              return KA_ERROR_OOM;
      }

      /* The initial connection is without NOFAIL, since we want to have
       * this call fail cleanly if we cannot connect. */
      if ((ret = context_connect(c, FALSE(0))) != KA_SUCCESS) {
16
←
Taking false branch→
              driver_destroypulse_driver_destroy(c);
              return ret;
      }

      pa_threaded_mainloop_lock(p->mainloop);

      if (pa_threaded_mainloop_start(p->mainloop) < 0) {
17
←
Assuming the condition is true→
18
←
Taking true branch→
              pa_threaded_mainloop_unlock(p->mainloop);
              driver_destroypulse_driver_destroy(c);
19
←
Calling 'pulse_driver_destroy'→
              return KA_ERROR_OOM;
      }

      for (;;) {
              pa_context_state_t state;

              if (!p->context) {
                      ret = translate_error(PA_ERR_CONNECTIONREFUSEDPA_ERR_CONNECTIONREFUSED);
                      pa_threaded_mainloop_unlock(p->mainloop);
                      driver_destroypulse_driver_destroy(c);
                      return ret;
              }

              state = pa_context_get_state(p->context);

              if (state == PA_CONTEXT_READYPA_CONTEXT_READY)
                      break;

              if (state == PA_CONTEXT_FAILEDPA_CONTEXT_FAILED) {
                      ret = translate_error(pa_context_errno(p->context));
                      pa_threaded_mainloop_unlock(p->mainloop);
                      driver_destroypulse_driver_destroy(c);
                      return ret;
              }

              ka_assert(state != PA_CONTEXT_TERMINATED)do { if ((__builtin_expect((!(state != PA_CONTEXT_TERMINATED)
),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "state != PA_CONTEXT_TERMINATED" , "pulse.c", 434, __PRETTY_FUNCTION__
); abort(); } } while ((0));

              pa_threaded_mainloop_wait(p->mainloop);
      }

      pa_threaded_mainloop_unlock(p->mainloop);

      return KA_SUCCESS;
442}

444int driver_destroypulse_driver_destroy(ka_context *c) {
      struct private *p;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 447, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
20
←
Taking false branch→
21
←
Loop condition is false.  Exiting loop→
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 448, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));
22
←
Assuming field 'private' is non-null→
23
←
Taking false branch→
24
←
Loop condition is false.  Exiting loop→

      p = PRIVATE(c)((struct private *) ((c)->private));

      if (p->mainloop)
25
←
Assuming field 'mainloop' is null→
26
←
Taking false branch→
              pa_threaded_mainloop_stop(p->mainloop);

      if (p->context) {
27
←
Assuming field 'context' is null→
28
←
Taking false branch→
              pa_context_disconnect(p->context);
              pa_context_unref(p->context);
      }

      while (p->outstanding) {
29
←
Loop condition is true.  Entering loop body→
46
←
Loop condition is true.  Entering loop body→
              struct outstanding *out = p->outstanding;
              KA_LLIST_REMOVE(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 462, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if (_item->next) _item->next->prev = _item
->prev; if (_item->prev) _item->prev->next = _item
->next; else { do { if ((__builtin_expect((!(*_head == _item
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 462, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);
30
←
Taking false branch→
31
←
Loop condition is false.  Exiting loop→
32
←
Assuming field 'next' is null→
33
←
Taking false branch→
34
←
Assuming field 'prev' is non-null→
35
←
Taking true branch→
36
←
Loop condition is false.  Exiting loop→
47
←
Taking false branch→
48
←
Loop condition is false.  Exiting loop→
49
←
Use of memory after it is freed

              if (out->callback)
37
←
Assuming field 'callback' is null→
38
←
Taking false branch→
                      out->callback(c, out->id, KA_ERROR_DESTROYED, out->userdata);

              outstanding_free(out);
39
←
Calling 'outstanding_free'→
45
←
Returning; memory was released via 1st parameter→
      }

      if (p->mainloop)
              pa_threaded_mainloop_free(p->mainloop);

      if (p->theme)
              ka_theme_data_free(p->theme);

      if (p->outstanding_mutex)
              ka_mutex_free(p->outstanding_mutex);

      ka_freefree(p);

      c->private = NULL((void*)0);

      return KA_SUCCESS;
484}

486int driver_change_devicepulse_driver_change_device(ka_context *c, const char *device) {
      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 487, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 488, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      /* We're happy with any device change. We might however add code
       * here eventually to move all currently played back event sounds
       * to the new device. */

      return KA_SUCCESS;
495}

497int driver_change_propspulse_driver_change_props(ka_context *c, ka_proplist *changed, ka_proplist *merged) {
      struct private *p;
      pa_operation *o;
      pa_proplist *l;
      int ret = KA_SUCCESS;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 503, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(changed, KA_ERROR_INVALID)do { if ((__builtin_expect((!(changed)),0))) { if (ka_debug()
) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "changed" , "pulse.c", 504, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(merged, KA_ERROR_INVALID)do { if ((__builtin_expect((!(merged)),0))) { if (ka_debug())
 fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "merged" , "pulse.c", 505, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 506, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      p = PRIVATE(c)((struct private *) ((c)->private));

      ka_return_val_if_fail(p->mainloop, KA_ERROR_STATE)do { if ((__builtin_expect((!(p->mainloop)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "p->mainloop" , "pulse.c", 510, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      pa_threaded_mainloop_lock(p->mainloop);

      if (!p->context) {
              pa_threaded_mainloop_unlock(p->mainloop);
              return KA_ERROR_STATE; /* can be silently ignored */
      }

      if ((ret = convert_proplist(&l, changed)) < 0)
              return ret;

      strip_prefix(l, "kanberra.");

      /* We start these asynchronously and don't care about the return
       * value */

      if (!(o = pa_context_proplist_update(p->context, PA_UPDATE_REPLACEPA_UPDATE_REPLACE, l, NULL((void*)0), NULL((void*)0))))
              ret = translate_error(pa_context_errno(p->context));
      else
              pa_operation_unref(o);

      pa_threaded_mainloop_unlock(p->mainloop);

      pa_proplist_free(l);

      return ret;
537}

539static int subscribe(ka_context *c) {
      struct private *p;
      pa_operation *o;
      int ret = KA_SUCCESS;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 544, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 545, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));
      p = PRIVATE(c)((struct private *) ((c)->private));

      ka_return_val_if_fail(p->mainloop, KA_ERROR_STATE)do { if ((__builtin_expect((!(p->mainloop)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "p->mainloop" , "pulse.c", 548, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      if (p->subscribed)
              return KA_SUCCESS;

      pa_threaded_mainloop_lock(p->mainloop);

      if (!p->context) {
              pa_threaded_mainloop_unlock(p->mainloop);
              return KA_ERROR_STATE;
      }

      /* We start these asynchronously and don't care about the return
       * value */

      if (!(o = pa_context_subscribe(p->context, PA_SUBSCRIPTION_MASK_SINK_INPUTPA_SUBSCRIPTION_MASK_SINK_INPUT, NULL((void*)0), NULL((void*)0))))
              ret = translate_error(pa_context_errno(p->context));
      else
              pa_operation_unref(o);

      pa_threaded_mainloop_unlock(p->mainloop);

      p->subscribed = TRUE(!(0));

      return ret;
573}

575static void play_sample_cb(pa_context *c, uint32_t idx, void *userdata) {
      struct private *p;
      struct outstanding *out = userdata;

      ka_assert(c)do { if ((__builtin_expect((!(c)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "c" , "pulse.c", 579, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(out)do { if ((__builtin_expect((!(out)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "out" , "pulse.c", 580, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      p = PRIVATE(out->context)((struct private *) ((out->context)->private));

      if (idx != PA_INVALID_INDEX((uint32_t) -1)) {
              out->error = KA_SUCCESS;
              out->sink_input = idx;
      } else
              out->error = translate_error(pa_context_errno(c));

      pa_threaded_mainloop_signal(p->mainloop, FALSE(0));
591}

593static void stream_state_cb(pa_stream *s, void *userdata) {
      struct private *p;
      struct outstanding *out = userdata;
      pa_stream_state_t state;

      ka_assert(s)do { if ((__builtin_expect((!(s)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "s" , "pulse.c", 598, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(out)do { if ((__builtin_expect((!(out)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "out" , "pulse.c", 599, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      p = PRIVATE(out->context)((struct private *) ((out->context)->private));

      state = pa_stream_get_state(s);

      switch (state) {
      case PA_STREAM_CREATINGPA_STREAM_CREATING:
      case PA_STREAM_UNCONNECTEDPA_STREAM_UNCONNECTED:
              break;

      case PA_STREAM_READYPA_STREAM_READY:
              out->sink_input = pa_stream_get_index(out->stream);
              break;

      case PA_STREAM_FAILEDPA_STREAM_FAILED:
      case PA_STREAM_TERMINATEDPA_STREAM_TERMINATED: {
              int err;

              err = state == PA_STREAM_FAILEDPA_STREAM_FAILED ? translate_error(pa_context_errno(pa_stream_get_context(s))) : KA_ERROR_DESTROYED;

              if (out->clean_up) {
                      ka_mutex_lock(p->outstanding_mutex);
                      outstanding_disconnect(out);
                      KA_LLIST_REMOVE(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 623, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if (_item->next) _item->next->prev = _item
->prev; if (_item->prev) _item->prev->next = _item
->next; else { do { if ((__builtin_expect((!(*_head == _item
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 623, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);
                      ka_mutex_unlock(p->outstanding_mutex);

                      if (out->callback)
                              out->callback(out->context, out->id, out->error, out->userdata);

                      outstanding_free(out);
              } else {
                      out->finished = TRUE(!(0));
                      out->error = err;
              }

              break;
      }
      }

      pa_threaded_mainloop_signal(p->mainloop, FALSE(0));
640}

642static void stream_drain_cb(pa_stream *s, int success, void *userdata) {
      struct private *p;
      struct outstanding *out = userdata;
      int err;

      ka_assert(s)do { if ((__builtin_expect((!(s)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "s" , "pulse.c", 647, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(out)do { if ((__builtin_expect((!(out)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "out" , "pulse.c", 648, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(out->type == OUTSTANDING_STREAM)do { if ((__builtin_expect((!(out->type == OUTSTANDING_STREAM
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "out->type == OUTSTANDING_STREAM" , "pulse.c", 649, __PRETTY_FUNCTION__
); abort(); } } while ((0));

      p = PRIVATE(out->context)((struct private *) ((out->context)->private));
      err = success ? KA_SUCCESS : translate_error(pa_context_errno(p->context));

      if (out->clean_up) {
              ka_mutex_lock(p->outstanding_mutex);
              outstanding_disconnect(out);
              KA_LLIST_REMOVE(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 657, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if (_item->next) _item->next->prev = _item
->prev; if (_item->prev) _item->prev->next = _item
->next; else { do { if ((__builtin_expect((!(*_head == _item
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 657, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);
              ka_mutex_unlock(p->outstanding_mutex);

              if (out->callback)
                      out->callback(out->context, out->id, err, out->userdata);

              outstanding_free(out);

      } else {
              pa_stream_disconnect(s);
              out->error = err;
              out->finished = TRUE(!(0));

              if (out->drain_operation) {
                      pa_operation_unref(out->drain_operation);
                      out->drain_operation = NULL((void*)0);
              }
      }

      pa_threaded_mainloop_signal(p->mainloop, FALSE(0));
677}

679static void stream_write_cb(pa_stream *s, size_t bytes, void *userdata) {
      struct outstanding *out = userdata;
      struct private *p;
      void *data;
      int ret;
      ka_bool_t eof = FALSE(0);

      ka_assert(s)do { if ((__builtin_expect((!(s)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "s" , "pulse.c", 686, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(bytes > 0)do { if ((__builtin_expect((!(bytes > 0)),0))) { fprintf(stderr
, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "bytes > 0" , "pulse.c", 687, __PRETTY_FUNCTION__); abort
(); } } while ((0));
      ka_assert(out)do { if ((__builtin_expect((!(out)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "out" , "pulse.c", 688, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      p = PRIVATE(out->context)((struct private *) ((out->context)->private));

      while (bytes > 0) {
              size_t rbytes = bytes;

              if (!(data = ka_mallocmalloc(rbytes))) {
                      ret = KA_ERROR_OOM;
                      goto finish;
              }

              if ((ret = ka_sound_file_read_arbitrary(out->file, data, &rbytes)) < 0)
                      goto finish;

              if (rbytes <= 0) {
                      eof = TRUE(!(0));
                      break;
              }

              ka_assert(rbytes <= bytes)do { if ((__builtin_expect((!(rbytes <= bytes)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "rbytes <= bytes" , "pulse.c", 708, __PRETTY_FUNCTION__)
; abort(); } } while ((0));

              if ((ret = pa_stream_write(s, data, rbytes, ka_freefree, 0, PA_SEEK_RELATIVEPA_SEEK_RELATIVE)) < 0) {
                      ret = translate_error(ret);
                      goto finish;
              }

              data = NULL((void*)0);

              bytes -= rbytes;
      }

      if (eof || ka_sound_file_get_size(out->file) <= 0) {

              /* We reached EOF */

              if (out->type == OUTSTANDING_UPLOAD) {

                      if (pa_stream_finish_upload(s) < 0) {
                              ret = translate_error(pa_context_errno(p->context));
                              goto finish;
                      }

                      /* Let's just signal driver_cache() which has been waiting for us */
                      pa_threaded_mainloop_signal(p->mainloop, FALSE(0));

              } else {
                      ka_assert(out->type == OUTSTANDING_STREAM)do { if ((__builtin_expect((!(out->type == OUTSTANDING_STREAM
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "out->type == OUTSTANDING_STREAM" , "pulse.c", 735, __PRETTY_FUNCTION__
); abort(); } } while ((0));

                      if (out->drain_operation) {
                              pa_operation_cancel(out->drain_operation);
                              pa_operation_unref(out->drain_operation);
                      }

                      if (!(out->drain_operation = pa_stream_drain(s, stream_drain_cb, out))) {
                              ret = translate_error(pa_context_errno(p->context));
                              goto finish;
                      }
              }

              pa_stream_set_write_callback(s, NULL((void*)0), NULL((void*)0));
      }

      ka_freefree(data);

      return;

755finish:

      ka_freefree(data);

      if (out->clean_up) {
              ka_mutex_lock(p->outstanding_mutex);
              outstanding_disconnect(out);
              KA_LLIST_REMOVE(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 762, __PRETTY_FUNCTION__); abort(); } }
 while ((0)); if (_item->next) _item->next->prev = _item
->prev; if (_item->prev) _item->prev->next = _item
->next; else { do { if ((__builtin_expect((!(*_head == _item
)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 762, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);
              ka_mutex_unlock(p->outstanding_mutex);

              if (out->callback)
                      out->callback(out->context, out->id, ret, out->userdata);

              outstanding_free(out);

      } else {
              pa_stream_disconnect(s);
              out->error = ret;
              out->finished = TRUE(!(0));
      }

      pa_threaded_mainloop_signal(p->mainloop, FALSE(0));
777}

779static const pa_sample_format_t sample_type_table[] = {
      [KA_SAMPLE_S16NE] = PA_SAMPLE_S16NEPA_SAMPLE_S16LE,
      [KA_SAMPLE_S16RE] = PA_SAMPLE_S16REPA_SAMPLE_S16BE,
      [KA_SAMPLE_U8] = PA_SAMPLE_U8PA_SAMPLE_U8
783};

785static const pa_channel_position_t channel_table[_KA_CHANNEL_POSITION_MAX] = {
      [KA_CHANNEL_MONO] = PA_CHANNEL_POSITION_MONOPA_CHANNEL_POSITION_MONO,
      [KA_CHANNEL_FRONT_LEFT] = PA_CHANNEL_POSITION_FRONT_LEFTPA_CHANNEL_POSITION_FRONT_LEFT,
      [KA_CHANNEL_FRONT_RIGHT] = PA_CHANNEL_POSITION_FRONT_RIGHTPA_CHANNEL_POSITION_FRONT_RIGHT,
      [KA_CHANNEL_FRONT_CENTER] = PA_CHANNEL_POSITION_FRONT_CENTERPA_CHANNEL_POSITION_FRONT_CENTER,
      [KA_CHANNEL_REAR_LEFT] = PA_CHANNEL_POSITION_REAR_LEFTPA_CHANNEL_POSITION_REAR_LEFT,
      [KA_CHANNEL_REAR_RIGHT] = PA_CHANNEL_POSITION_REAR_RIGHTPA_CHANNEL_POSITION_REAR_RIGHT,
      [KA_CHANNEL_REAR_CENTER] = PA_CHANNEL_POSITION_REAR_CENTERPA_CHANNEL_POSITION_REAR_CENTER,
      [KA_CHANNEL_LFE] = PA_CHANNEL_POSITION_LFEPA_CHANNEL_POSITION_LFE,
      [KA_CHANNEL_FRONT_LEFT_OF_CENTER] = PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTERPA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,
      [KA_CHANNEL_FRONT_RIGHT_OF_CENTER] = PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTERPA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,
      [KA_CHANNEL_SIDE_LEFT] = PA_CHANNEL_POSITION_SIDE_LEFTPA_CHANNEL_POSITION_SIDE_LEFT,
      [KA_CHANNEL_SIDE_RIGHT] = PA_CHANNEL_POSITION_SIDE_RIGHTPA_CHANNEL_POSITION_SIDE_RIGHT,
      [KA_CHANNEL_TOP_CENTER] = PA_CHANNEL_POSITION_TOP_CENTERPA_CHANNEL_POSITION_TOP_CENTER,
      [KA_CHANNEL_TOP_FRONT_LEFT] = PA_CHANNEL_POSITION_FRONT_LEFTPA_CHANNEL_POSITION_FRONT_LEFT,
      [KA_CHANNEL_TOP_FRONT_RIGHT] = PA_CHANNEL_POSITION_FRONT_RIGHTPA_CHANNEL_POSITION_FRONT_RIGHT,
      [KA_CHANNEL_TOP_FRONT_CENTER] = PA_CHANNEL_POSITION_FRONT_CENTERPA_CHANNEL_POSITION_FRONT_CENTER,
      [KA_CHANNEL_TOP_REAR_LEFT] = PA_CHANNEL_POSITION_REAR_LEFTPA_CHANNEL_POSITION_REAR_LEFT,
      [KA_CHANNEL_TOP_REAR_RIGHT] = PA_CHANNEL_POSITION_REAR_RIGHTPA_CHANNEL_POSITION_REAR_RIGHT,
      [KA_CHANNEL_TOP_REAR_CENTER] = PA_CHANNEL_POSITION_TOP_REAR_CENTERPA_CHANNEL_POSITION_TOP_REAR_CENTER
805};

807static ka_bool_t convert_channel_map(ka_sound_file *f, pa_channel_map *cm) {
      const ka_channel_position_t *positions;
      unsigned c;

      ka_assert(f)do { if ((__builtin_expect((!(f)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "f" , "pulse.c", 811, __PRETTY_FUNCTION__); abort(); } } while
 ((0));
      ka_assert(cm)do { if ((__builtin_expect((!(cm)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "cm" , "pulse.c", 812, __PRETTY_FUNCTION__); abort(); } } while
 ((0));

      if (!(positions = ka_sound_file_get_channel_map(f)))
              return FALSE(0);

      cm->channels = ka_sound_file_get_nchannels(f);
      for (c = 0; c < cm->channels; c++)
              cm->map[c] = channel_table[positions[c]];

      return TRUE(!(0));
822}

824int driver_playpulse_driver_play(ka_context *c, uint32_t id, ka_proplist *proplist, ka_finish_callback_t cb, void *userdata) {
      struct private *p;
      pa_proplist *l = NULL((void*)0);
      const char *n, *vol, *ct, *channel;
      char *name = NULL((void*)0);
829#if defined(PA_MAJOR16) && ((PA_MAJOR16 > 0) || (PA_MAJOR16 == 0 && PA_MINOR1 > 9) || (PA_MAJOR16 == 0 && PA_MINOR1 == 9 && PA_MICRO0 >= 15))
      pa_volume_t v = (pa_volume_t) -1;
831#else
      pa_volume_t v = PA_VOLUME_NORM((pa_volume_t) 0x10000U);
833#endif
      ka_bool_t volume_set = FALSE(0);
      pa_cvolume cvol;
      pa_sample_spec ss;
      pa_channel_map cm;
      pa_channel_position_t position = PA_CHANNEL_POSITION_INVALIDPA_CHANNEL_POSITION_INVALID;
      ka_bool_t cm_good;
      ka_cache_control_t cache_control = KA_CACHE_CONTROL_NEVER;
      struct outstanding *out = NULL((void*)0);
      int try = 3;
      int ret;
      pa_operation *o;
      char *sp;
      pa_buffer_attr ba;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 848, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(proplist, KA_ERROR_INVALID)do { if ((__builtin_expect((!(proplist)),0))) { if (ka_debug(
)) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "proplist" , "pulse.c", 849, __PRETTY_FUNCTION__); return (
KA_ERROR_INVALID); } } while((0));
      ka_return_val_if_fail(!userdata || cb, KA_ERROR_INVALID)do { if ((__builtin_expect((!(!userdata || cb)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "!userdata || cb" , "pulse.c", 850, __PRETTY_FUNCTION__); return
 (KA_ERROR_INVALID); } } while((0));
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 851, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      p = PRIVATE(c)((struct private *) ((c)->private));

      ka_return_val_if_fail(p->mainloop, KA_ERROR_STATE)do { if ((__builtin_expect((!(p->mainloop)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "p->mainloop" , "pulse.c", 855, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      if (!(out = ka_new0(struct outstanding, 1)((struct outstanding*) calloc(1, (sizeof(struct outstanding)*
(1)))))) {
              ret = KA_ERROR_OOM;
              goto finish_unlocked;
      }

      out->type = OUTSTANDING_SAMPLE;
      out->context = c;
      out->sink_input = PA_INVALID_INDEX((uint32_t) -1);
      out->id = id;
      out->callback = cb;
      out->userdata = userdata;

      if ((ret = convert_proplist(&l, proplist)) < 0)
              goto finish_unlocked;

      if ((n = pa_proplist_gets(l, KA_PROP_EVENT_ID"event.id")))
              if (!(name = ka_strdupstrdup(n))) {
                      ret = KA_ERROR_OOM;
                      goto finish_unlocked;
              }

      if ((vol = pa_proplist_gets(l, KA_PROP_KANBERRA_VOLUME"kanberra.volume"))) {
              char *e = NULL((void*)0);
              double dvol;

              errno(*__errno_location ()) = 0;
              dvol = strtod(vol, &e);
              if (errno(*__errno_location ()) != 0 || !e || *e) {
                      ret = KA_ERROR_INVALID;
                      goto finish_unlocked;
              }

              v = pa_sw_volume_from_dB(dvol);
              volume_set = TRUE(!(0));
      }

      if ((ct = pa_proplist_gets(l, KA_PROP_KANBERRA_CACHE_CONTROL"kanberra.cache-control")))
              if ((ret = ka_parse_cache_control(&cache_control, ct)) < 0) {
                      ret = KA_ERROR_INVALID;
                      goto finish_unlocked;
              }

      if ((channel = pa_proplist_gets(l, KA_PROP_KANBERRA_FORCE_CHANNEL"kanberra.force_channel"))) {
              pa_channel_map t;

              if (!pa_channel_map_parse(&t, channel) ||
                  t.channels != 1) {
                      ret = KA_ERROR_INVALID;
                      goto finish_unlocked;
              }

              position = t.map[0];

              /* We cannot remap cached samples, so let's fail when cacheing
               * shall be used */
              if (cache_control != KA_CACHE_CONTROL_NEVER) {
                      ret = KA_ERROR_NOTSUPPORTED;
                      goto finish_unlocked;
              }
      }

      strip_prefix(l, "kanberra.");
      add_common(l);

      if ((ret = subscribe(c)) < 0)
              goto finish_unlocked;

      if (name && cache_control != KA_CACHE_CONTROL_NEVER) {

              /* Ok, this sample has an event id, let's try to play it from the cache */

              for (;;) {
                      ka_bool_t canceled;

                      pa_threaded_mainloop_lock(p->mainloop);

                      if (!p->context) {
                              ret = KA_ERROR_STATE;
                              goto finish_locked;
                      }

                      /* Let's try to play the sample */
                      if (!(o = pa_context_play_sample_with_proplist(p->context, name, c->device, v, l, play_sample_cb, out))) {
                              ret = translate_error(pa_context_errno(p->context));
                              goto finish_locked;
                      }

                      for (;;) {
                              pa_operation_state_t state = pa_operation_get_state(o);

                              if (state == PA_OPERATION_DONEPA_OPERATION_DONE) {
                                      canceled = FALSE(0);
                                      break;
                              } else if (state == PA_OPERATION_CANCELEDPA_OPERATION_CANCELLED) {
                                      canceled = TRUE(!(0));
                                      break;
                              }

                              pa_threaded_mainloop_wait(p->mainloop);
                      }

                      pa_operation_unref(o);

                      if (!canceled && p->context && out->error == KA_SUCCESS) {
                              ret = KA_SUCCESS;
                              goto finish_locked;
                      }

                      pa_threaded_mainloop_unlock(p->mainloop);

                      /* The operation might have been canceled due to connection termination */
                      if (canceled || !p->context) {
                              ret = KA_ERROR_DISCONNECTED;
                              goto finish_unlocked;
                      }

                      /* Did some other error occur? */
                      if (out->error != KA_ERROR_NOTFOUND) {
                              ret = out->error;
                              goto finish_unlocked;
                      }

                      /* Hmm, we need to play it directly */
                      if (cache_control != KA_CACHE_CONTROL_PERMANENT)
                              break;

                      /* Don't loop forever */
                      if (--try <= 0)
                              break;

                      /* Let's upload the sample and retry playing */
                      if ((ret = driver_cachepulse_driver_cache(c, proplist)) < 0)
                              goto finish_unlocked;
              }
      }

      out->type = OUTSTANDING_STREAM;

      /* Let's stream the sample directly */
      if ((ret = ka_lookup_sound(&out->file, &sp, &p->theme, c->props, proplist)) < 0)
              goto finish_unlocked;

      if (sp)
              if (!pa_proplist_contains(l, KA_PROP_MEDIA_FILENAME"media.filename"))
                      pa_proplist_sets(l, KA_PROP_MEDIA_FILENAME"media.filename", sp);

      ka_freefree(sp);

      ss.format = sample_type_table[ka_sound_file_get_sample_type(out->file)];
      ss.channels = (uint8_t) ka_sound_file_get_nchannels(out->file);
      ss.rate = ka_sound_file_get_rate(out->file);

      if (position != PA_CHANNEL_POSITION_INVALIDPA_CHANNEL_POSITION_INVALID) {
              unsigned u;
              /* Apply kanberra.force_channel */

              cm.channels = ss.channels;
              for (u = 0; u < cm.channels; u++)
                      cm.map[u] = position;

              cm_good = TRUE(!(0));
      } else
              cm_good = convert_channel_map(out->file, &cm);

      pa_threaded_mainloop_lock(p->mainloop);

      if (!p->context) {
              ret = KA_ERROR_STATE;
              goto finish_locked;
      }

      if (!(out->stream = pa_stream_new_with_proplist(p->context, NULL((void*)0), &ss, cm_good ? &cm : NULL((void*)0), l))) {
              ret = translate_error(pa_context_errno(p->context));
              goto finish_locked;
      }

      pa_stream_set_state_callback(out->stream, stream_state_cb, out);
      pa_stream_set_write_callback(out->stream, stream_write_cb, out);

      if (volume_set)
              pa_cvolume_set(&cvol, ss.channels, v);

      /* Make sure we get the longest latency possible, to minimize CPU
       * consumption */
      ba.maxlength = (uint32_t) -1;
      ba.tlength = (uint32_t) -1;
      ba.prebuf = (uint32_t) -1;
      ba.minreq = (uint32_t) -1;
      ba.fragsize = (uint32_t) -1;

      if (pa_stream_connect_playback(out->stream, c->device, &ba,
1048#ifdef PA_STREAM_FAIL_ON_SUSPENDPA_STREAM_FAIL_ON_SUSPEND
                                     PA_STREAM_FAIL_ON_SUSPENDPA_STREAM_FAIL_ON_SUSPEND
1050#else
                                     0
1052#endif
                                     | (position != PA_CHANNEL_POSITION_INVALIDPA_CHANNEL_POSITION_INVALID ? PA_STREAM_NO_REMIX_CHANNELSPA_STREAM_NO_REMIX_CHANNELS : 0)
                                     , volume_set ? &cvol : NULL((void*)0), NULL((void*)0)) < 0) {
              ret = translate_error(pa_context_errno(p->context));
              goto finish_locked;
      }

      for (;;) {
              pa_stream_state_t state;

              if (!p->context || !out->stream) {
                      ret = KA_ERROR_STATE;
                      goto finish_locked;
              }

              state = pa_stream_get_state(out->stream);

              /* Stream sucessfully created */
              if (state == PA_STREAM_READYPA_STREAM_READY)
                      break;

              /* Check for failure */
              if (state == PA_STREAM_FAILEDPA_STREAM_FAILED) {
                      ret = translate_error(pa_context_errno(p->context));
                      goto finish_locked;
              }

              /* Prematurely ended */
              if (state == PA_STREAM_TERMINATEDPA_STREAM_TERMINATED) {
                      ret = out->error;
                      goto finish_locked;
              }

              pa_threaded_mainloop_wait(p->mainloop);
      }

      ret = KA_SUCCESS;

1090finish_locked:

      /* We keep the outstanding struct around to clean up later if the sound din't finish yet*/
      if (ret == KA_SUCCESS && !out->finished) {
              out->clean_up = TRUE(!(0));

              ka_mutex_lock(p->outstanding_mutex);
              KA_LLIST_PREPEND(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 1097, __PRETTY_FUNCTION__); abort(); }
 } while ((0)); if ((_item->next = *_head)) _item->next
->prev = _item; _item->prev = ((void*)0); *_head = _item
; } while (0);
              ka_mutex_unlock(p->outstanding_mutex);
      } else
              outstanding_free(out);

      out = NULL((void*)0);

      pa_threaded_mainloop_unlock(p->mainloop);

1106finish_unlocked:

      if (out)
              outstanding_free(out);

      if (l)
              pa_proplist_free(l);

      ka_freefree(name);

      return ret;
1117}

1119int driver_cancelpulse_driver_cancel(ka_context *c, uint32_t id) {
      struct private *p;
      pa_operation *o;
      int ret = KA_SUCCESS;
      struct outstanding *out, *n;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 1125, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 1126, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      p = PRIVATE(c)((struct private *) ((c)->private));

      ka_return_val_if_fail(p->mainloop, KA_ERROR_STATE)do { if ((__builtin_expect((!(p->mainloop)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "p->mainloop" , "pulse.c", 1130, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      pa_threaded_mainloop_lock(p->mainloop);

      if (!p->context) {
              pa_threaded_mainloop_unlock(p->mainloop);
              return KA_ERROR_STATE;
      }

      ka_mutex_lock(p->outstanding_mutex);

      /* We start these asynchronously and don't care about the return
       * value */

      for (out = p->outstanding; out; out = n) {
              int ret2 = KA_SUCCESS;
              n = out->next;

              if (out->type == OUTSTANDING_UPLOAD ||
                  out->id != id ||
                  out->sink_input == PA_INVALID_INDEX((uint32_t) -1))
                      continue;

              if (!(o = pa_context_kill_sink_input(p->context, out->sink_input, NULL((void*)0), NULL((void*)0))))
                      ret2 = translate_error(pa_context_errno(p->context));
              else
                      pa_operation_unref(o);

              /* We make sure here to kill all streams identified by the id
               * here. However, we will return only the first error we
               * encounter */

              if (ret2 && ret == KA_SUCCESS)
                      ret = ret2;

              if (out->callback)
                      out->callback(c, out->id, KA_ERROR_CANCELED, out->userdata);

              outstanding_disconnect(out);
              KA_LLIST_REMOVE(struct outstanding, p->outstanding, out)do { struct outstanding **_head = &(p->outstanding), *
_item = (out); do { if ((__builtin_expect((!(_item)),0))) { fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "_item" , "pulse.c", 1169, __PRETTY_FUNCTION__); abort(); }
 } while ((0)); if (_item->next) _item->next->prev =
 _item->prev; if (_item->prev) _item->prev->next =
 _item->next; else { do { if ((__builtin_expect((!(*_head ==
 _item)),0))) { fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s(). Aborting.\n"
, "*_head == _item" , "pulse.c", 1169, __PRETTY_FUNCTION__); abort
(); } } while ((0)); *_head = _item->next; } _item->next
 = _item->prev = ((void*)0); } while(0);
              outstanding_free(out);
      }

      ka_mutex_unlock(p->outstanding_mutex);

      pa_threaded_mainloop_unlock(p->mainloop);

      return ret;
1178}

1180int driver_cachepulse_driver_cache(ka_context *c, ka_proplist *proplist) {
      struct private *p;
      pa_proplist *l = NULL((void*)0);
      const char *n, *ct;
      pa_sample_spec ss;
      pa_channel_map cm;
      ka_bool_t cm_good;
      ka_cache_control_t cache_control = KA_CACHE_CONTROL_PERMANENT;
      struct outstanding *out;
      int ret;
      char *sp;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 1192, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(proplist, KA_ERROR_INVALID)do { if ((__builtin_expect((!(proplist)),0))) { if (ka_debug(
)) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "proplist" , "pulse.c", 1193, __PRETTY_FUNCTION__); return (
KA_ERROR_INVALID); } } while((0));
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 1194, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      p = PRIVATE(c)((struct private *) ((c)->private));

      ka_return_val_if_fail(p->mainloop, KA_ERROR_STATE)do { if ((__builtin_expect((!(p->mainloop)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "p->mainloop" , "pulse.c", 1198, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));

      if (!(out = ka_new0(struct outstanding, 1)((struct outstanding*) calloc(1, (sizeof(struct outstanding)*
(1)))))) {
              ret = KA_ERROR_OOM;
              goto finish_unlocked;
      }

      out->type = OUTSTANDING_UPLOAD;
      out->context = c;
      out->sink_input = PA_INVALID_INDEX((uint32_t) -1);

      if ((ret = convert_proplist(&l, proplist)) < 0)
              goto finish_unlocked;

      if (!(n = pa_proplist_gets(l, KA_PROP_EVENT_ID"event.id"))) {
              ret = KA_ERROR_INVALID;
              goto finish_unlocked;
      }

      if ((ct = pa_proplist_gets(l, KA_PROP_KANBERRA_CACHE_CONTROL"kanberra.cache-control")))
              if ((ret = ka_parse_cache_control(&cache_control, ct)) < 0) {
                      ret = KA_ERROR_INVALID;
                      goto finish_unlocked;
              }

      if (cache_control != KA_CACHE_CONTROL_PERMANENT) {
              ret = KA_ERROR_INVALID;
              goto finish_unlocked;
      }

      if ((ct = pa_proplist_gets(l, KA_PROP_KANBERRA_FORCE_CHANNEL"kanberra.force_channel"))) {
              ret = KA_ERROR_NOTSUPPORTED;
              goto finish_unlocked;
      }

      strip_prefix(l, "kanberra.");
      strip_prefix(l, "event.mouse.");
      strip_prefix(l, "window.");
      add_common(l);

      /* Let's stream the sample directly */
      if ((ret = ka_lookup_sound(&out->file, &sp, &p->theme, c->props, proplist)) < 0)
              goto finish_unlocked;

      if (sp)
              if (!pa_proplist_contains(l, KA_PROP_MEDIA_FILENAME"media.filename"))
                      pa_proplist_sets(l, KA_PROP_MEDIA_FILENAME"media.filename", sp);

      ka_freefree(sp);

      ss.format = sample_type_table[ka_sound_file_get_sample_type(out->file)];
      ss.channels = (uint8_t) ka_sound_file_get_nchannels(out->file);
      ss.rate = ka_sound_file_get_rate(out->file);

      cm_good = convert_channel_map(out->file, &cm);

      pa_threaded_mainloop_lock(p->mainloop);

      if (!p->context) {
              ret = KA_ERROR_STATE;
              goto finish_locked;
      }

      if (!(out->stream = pa_stream_new_with_proplist(p->context, NULL((void*)0), &ss, cm_good ? &cm : NULL((void*)0), l))) {
              ret = translate_error(pa_context_errno(p->context));
              goto finish_locked;
      }

      pa_stream_set_state_callback(out->stream, stream_state_cb, out);
      pa_stream_set_write_callback(out->stream, stream_write_cb, out);

      if (pa_stream_connect_upload(out->stream, (size_t) ka_sound_file_get_size(out->file)) < 0) {
              ret = translate_error(pa_context_errno(p->context));
              goto finish_locked;
      }

      for (;;) {
              pa_stream_state_t state;

              if (!p->context || !out->stream) {
                      ret = KA_ERROR_STATE;
                      goto finish_locked;
              }

              state = pa_stream_get_state(out->stream);

              /* Stream sucessfully created and uploaded */
              if (state == PA_STREAM_TERMINATEDPA_STREAM_TERMINATED)
                      break;

              /* Check for failure */
              if (state == PA_STREAM_FAILEDPA_STREAM_FAILED) {
                      ret = translate_error(pa_context_errno(p->context));
                      goto finish_locked;
              }

              pa_threaded_mainloop_wait(p->mainloop);
      }

      ret = KA_SUCCESS;

1299finish_locked:
      outstanding_free(out);
      out = NULL((void*)0);

      pa_threaded_mainloop_unlock(p->mainloop);

1305finish_unlocked:

      if (out)
              outstanding_free(out);

      if (l)
              pa_proplist_free(l);

      return ret;
1314}

1316int driver_playing(ka_context *c, uint32_t id, int *playing) {
      struct private *p;
      struct outstanding *out;

      ka_return_val_if_fail(c, KA_ERROR_INVALID)do { if ((__builtin_expect((!(c)),0))) { if (ka_debug()) fprintf
(stderr, "Assertion '%s' failed at %s:%u, function %s().\n", "c"
 , "pulse.c", 1320, __PRETTY_FUNCTION__); return (KA_ERROR_INVALID
); } } while((0));
      ka_return_val_if_fail(c->private, KA_ERROR_STATE)do { if ((__builtin_expect((!(c->private)),0))) { if (ka_debug
()) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "c->private" , "pulse.c", 1321, __PRETTY_FUNCTION__); return
 (KA_ERROR_STATE); } } while((0));
      ka_return_val_if_fail(playing, KA_ERROR_INVALID)do { if ((__builtin_expect((!(playing)),0))) { if (ka_debug()
) fprintf(stderr, "Assertion '%s' failed at %s:%u, function %s().\n"
, "playing" , "pulse.c", 1322, __PRETTY_FUNCTION__); return (
KA_ERROR_INVALID); } } while((0));

      p = PRIVATE(c)((struct private *) ((c)->private));

      *playing = 0;

      ka_mutex_lock(p->outstanding_mutex);

      for (out = p->outstanding; out; out = out->next) {

              if (out->type == OUTSTANDING_UPLOAD ||
                  out->id != id ||
                  out->sink_input == PA_INVALID_INDEX((uint32_t) -1))
                      continue;

              *playing = 1;
              break;
      }

      ka_mutex_unlock(p->outstanding_mutex);

      return KA_SUCCESS;
1344}