git-svn-id: file:///home/lennart/svn/public/pulseaudio/branches/lennart@1805
fefdeb5f-60dc-0310-8127-
8f9354f1896f
#include "config.h"
#endif
#include "config.h"
#endif
#include <string.h>
#include <avahi-client/lookup.h>
#include <string.h>
#include <avahi-client/lookup.h>
#include <pulsecore/log.h>
#include <pulsecore/core-util.h>
#include <pulsecore/log.h>
#include <pulsecore/core-util.h>
#include <pulsecore/avahi-wrap.h>
#include <pulsecore/avahi-wrap.h>
+#include <pulsecore/refcnt.h>
+#include <pulsecore/macro.h>
#define SERVICE_TYPE_SERVER "_pulse-server._tcp."
struct pa_browser {
#define SERVICE_TYPE_SERVER "_pulse-server._tcp."
struct pa_browser {
pa_mainloop_api *mainloop;
AvahiPoll* avahi_poll;
pa_mainloop_api *mainloop;
AvahiPoll* avahi_poll;
};
static int map_to_opcode(const char *type, int new) {
};
static int map_to_opcode(const char *type, int new) {
if (avahi_domain_equal(type, SERVICE_TYPE_SINK))
return new ? PA_BROWSE_NEW_SINK : PA_BROWSE_REMOVE_SINK;
else if (avahi_domain_equal(type, SERVICE_TYPE_SOURCE))
if (avahi_domain_equal(type, SERVICE_TYPE_SINK))
return new ? PA_BROWSE_NEW_SINK : PA_BROWSE_REMOVE_SINK;
else if (avahi_domain_equal(type, SERVICE_TYPE_SOURCE))
int ss_valid = 0;
char *key = NULL, *value = NULL;
int ss_valid = 0;
char *key = NULL, *value = NULL;
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
memset(&i, 0, sizeof(i));
i.name = name;
memset(&i, 0, sizeof(i));
i.name = name;
goto fail;
opcode = map_to_opcode(type, 1);
goto fail;
opcode = map_to_opcode(type, 1);
+ pa_assert(opcode >= 0);
if (aa->proto == AVAHI_PROTO_INET)
pa_snprintf(a, sizeof(a), "tcp:%s:%u", avahi_address_snprint(ip, sizeof(ip), aa), port);
else {
if (aa->proto == AVAHI_PROTO_INET)
pa_snprintf(a, sizeof(a), "tcp:%s:%u", avahi_address_snprint(ip, sizeof(ip), aa), port);
else {
- assert(aa->proto == AVAHI_PROTO_INET6);
+ pa_assert(aa->proto == AVAHI_PROTO_INET6);
pa_snprintf(a, sizeof(a), "tcp6:%s:%u", avahi_address_snprint(ip, sizeof(ip), aa), port);
}
i.server = a;
pa_snprintf(a, sizeof(a), "tcp6:%s:%u", avahi_address_snprint(ip, sizeof(ip), aa), port);
}
i.server = a;
value = NULL;
l = strlen(a);
value = NULL;
l = strlen(a);
- assert(l+1 <= sizeof(a));
+ pa_assert(l+1 <= sizeof(a));
strncat(a, " ", sizeof(a)-l-1);
strncat(a, i.fqdn, sizeof(a)-l-2);
} else if (!strcmp(key, "cookie")) {
strncat(a, " ", sizeof(a)-l-1);
strncat(a, i.fqdn, sizeof(a)-l-2);
} else if (!strcmp(key, "cookie")) {
static void handle_failure(pa_browser *b) {
const char *e = NULL;
static void handle_failure(pa_browser *b) {
const char *e = NULL;
+
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
if (b->sink_browser)
avahi_service_browser_free(b->sink_browser);
if (b->sink_browser)
avahi_service_browser_free(b->sink_browser);
void *userdata) {
pa_browser *b = userdata;
void *userdata) {
pa_browser *b = userdata;
+
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
switch (event) {
case AVAHI_BROWSER_NEW: {
switch (event) {
case AVAHI_BROWSER_NEW: {
i.name = name;
opcode = map_to_opcode(type, 0);
i.name = name;
opcode = map_to_opcode(type, 0);
+ pa_assert(opcode >= 0);
b->callback(b, opcode, &i, b->userdata);
}
b->callback(b, opcode, &i, b->userdata);
}
static void client_callback(AvahiClient *s, AvahiClientState state, void *userdata) {
pa_browser *b = userdata;
static void client_callback(AvahiClient *s, AvahiClientState state, void *userdata) {
pa_browser *b = userdata;
+
+ pa_assert(s);
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
if (state == AVAHI_CLIENT_FAILURE)
handle_failure(b);
if (state == AVAHI_CLIENT_FAILURE)
handle_failure(b);
pa_browser *b;
int error;
pa_browser *b;
int error;
if (flags & ~(PA_BROWSE_FOR_SERVERS|PA_BROWSE_FOR_SINKS|PA_BROWSE_FOR_SOURCES) || flags == 0)
return NULL;
b = pa_xnew(pa_browser, 1);
b->mainloop = mainloop;
if (flags & ~(PA_BROWSE_FOR_SERVERS|PA_BROWSE_FOR_SINKS|PA_BROWSE_FOR_SOURCES) || flags == 0)
return NULL;
b = pa_xnew(pa_browser, 1);
b->mainloop = mainloop;
b->callback = NULL;
b->userdata = NULL;
b->error_callback = NULL;
b->callback = NULL;
b->userdata = NULL;
b->error_callback = NULL;
}
static void browser_free(pa_browser *b) {
}
static void browser_free(pa_browser *b) {
- assert(b && b->mainloop);
+ pa_assert(b);
+ pa_assert(b->mainloop);
if (b->sink_browser)
avahi_service_browser_free(b->sink_browser);
if (b->sink_browser)
avahi_service_browser_free(b->sink_browser);
}
pa_browser *pa_browser_ref(pa_browser *b) {
}
pa_browser *pa_browser_ref(pa_browser *b) {
- assert(b);
- assert(b->ref >= 1);
- b->ref++;
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
+
+ PA_REFCNT_INC(b);
return b;
}
void pa_browser_unref(pa_browser *b) {
return b;
}
void pa_browser_unref(pa_browser *b) {
- assert(b);
- assert(b->ref >= 1);
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
- if ((-- (b->ref)) <= 0)
+ if (PA_REFCNT_DEC(b) <= 0)
browser_free(b);
}
void pa_browser_set_callback(pa_browser *b, pa_browse_cb_t cb, void *userdata) {
browser_free(b);
}
void pa_browser_set_callback(pa_browser *b, pa_browse_cb_t cb, void *userdata) {
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
b->callback = cb;
b->userdata = userdata;
}
void pa_browser_set_error_callback(pa_browser *b, pa_browser_error_cb_t cb, void *userdata) {
b->callback = cb;
b->userdata = userdata;
}
void pa_browser_set_error_callback(pa_browser *b, pa_browser_error_cb_t cb, void *userdata) {
+ pa_assert(b);
+ pa_assert(PA_REFCNT_VALUE(b) >= 1);
b->error_callback = cb;
b->error_userdata = userdata;
b->error_callback = cb;
b->error_userdata = userdata;
#endif
#include <stdio.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <pulsecore/log.h>
#include <pulsecore/socket-util.h>
#include <pulsecore/creds.h>
#include <pulsecore/log.h>
#include <pulsecore/socket-util.h>
#include <pulsecore/creds.h>
+#include <pulsecore/macro.h>
};
static void unlock_autospawn_lock_file(pa_context *c) {
};
static void unlock_autospawn_lock_file(pa_context *c) {
if (c->autospawn_lock_fd >= 0) {
char lf[PATH_MAX];
if (c->autospawn_lock_fd >= 0) {
char lf[PATH_MAX];
pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name) {
pa_context *c;
pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name) {
pa_context *c;
- assert(mainloop);
- assert(name);
+ pa_assert(mainloop);
+ pa_assert(name);
c = pa_xnew(pa_context, 1);
PA_REFCNT_INIT(c);
c = pa_xnew(pa_context, 1);
PA_REFCNT_INIT(c);
}
static void context_free(pa_context *c) {
}
static void context_free(pa_context *c) {
unlock_autospawn_lock_file(c);
unlock_autospawn_lock_file(c);
}
pa_context* pa_context_ref(pa_context *c) {
}
pa_context* pa_context_ref(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_REFCNT_INC(c);
return c;
}
void pa_context_unref(pa_context *c) {
PA_REFCNT_INC(c);
return c;
}
void pa_context_unref(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
if (PA_REFCNT_DEC(c) <= 0)
context_free(c);
}
void pa_context_set_state(pa_context *c, pa_context_state_t st) {
if (PA_REFCNT_DEC(c) <= 0)
context_free(c);
}
void pa_context_set_state(pa_context *c, pa_context_state_t st) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
if (c->state == st)
return;
if (c->state == st)
return;
}
void pa_context_fail(pa_context *c, int error) {
}
void pa_context_fail(pa_context *c, int error) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_context_set_error(c, error);
pa_context_set_state(c, PA_CONTEXT_FAILED);
}
int pa_context_set_error(pa_context *c, int error) {
pa_context_set_error(c, error);
pa_context_set_state(c, PA_CONTEXT_FAILED);
}
int pa_context_set_error(pa_context *c, int error) {
- assert(error >= 0);
- assert(error < PA_ERR_MAX);
+ pa_assert(error >= 0);
+ pa_assert(error < PA_ERR_MAX);
static void pstream_die_callback(pa_pstream *p, void *userdata) {
pa_context *c = userdata;
static void pstream_die_callback(pa_pstream *p, void *userdata) {
pa_context *c = userdata;
- assert(p);
- assert(c);
+ pa_assert(p);
+ pa_assert(c);
pa_context_fail(c, PA_ERR_CONNECTIONTERMINATED);
}
pa_context_fail(c, PA_ERR_CONNECTIONTERMINATED);
}
static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
pa_context *c = userdata;
static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
pa_context *c = userdata;
- assert(p);
- assert(packet);
- assert(c);
+ pa_assert(p);
+ pa_assert(packet);
+ pa_assert(c);
pa_context *c = userdata;
pa_stream *s;
pa_context *c = userdata;
pa_stream *s;
- assert(p);
- assert(chunk);
- assert(chunk->memblock);
- assert(chunk->length);
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(p);
+ pa_assert(chunk);
+ pa_assert(chunk->memblock);
+ pa_assert(chunk->length);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_context_ref(c);
if ((s = pa_dynarray_get(c->record_streams, channel))) {
pa_context_ref(c);
if ((s = pa_dynarray_get(c->record_streams, channel))) {
- assert(seek == PA_SEEK_RELATIVE && offset == 0);
+ pa_assert(seek == PA_SEEK_RELATIVE);
+ pa_assert(offset == 0);
pa_memblockq_seek(s->record_memblockq, offset, seek);
pa_memblockq_push_align(s->record_memblockq, chunk);
pa_memblockq_seek(s->record_memblockq, offset, seek);
pa_memblockq_push_align(s->record_memblockq, chunk);
}
int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t) {
}
int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
if (command == PA_COMMAND_ERROR) {
if (command == PA_COMMAND_ERROR) {
if (pa_tagstruct_getu32(t, &c->error) < 0) {
pa_context_fail(c, PA_ERR_PROTOCOL);
if (pa_tagstruct_getu32(t, &c->error) < 0) {
pa_context_fail(c, PA_ERR_PROTOCOL);
static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_context *c = userdata;
static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_context *c = userdata;
- assert(pd);
- assert(c);
- assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
+ pa_assert(pd);
+ pa_assert(c);
+ pa_assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
pa_tagstruct *t;
uint32_t tag;
pa_tagstruct *t;
uint32_t tag;
- assert(c);
- assert(io);
+ pa_assert(c);
+ pa_assert(io);
+ pa_assert(!c->pstream);
c->pstream = pa_pstream_new(c->mainloop, io, c->mempool);
pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
c->pstream = pa_pstream_new(c->mainloop, io, c->mempool);
pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
+ pa_assert(!c->pdispatch);
c->pdispatch = pa_pdispatch_new(c->mainloop, command_table, PA_COMMAND_MAX);
if (!c->conf->cookie_valid)
c->pdispatch = pa_pdispatch_new(c->mainloop, command_table, PA_COMMAND_MAX);
if (!c->conf->cookie_valid)
char *u = NULL;
int r = -1;
char *u = NULL;
int r = -1;
- assert(c);
- assert(!c->client);
+ pa_assert(c);
+ pa_assert(!c->client);
static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata) {
pa_context *c = userdata;
static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata) {
pa_context *c = userdata;
- assert(client);
- assert(c);
- assert(c->state == PA_CONTEXT_CONNECTING);
+ pa_assert(client);
+ pa_assert(c);
+ pa_assert(c->state == PA_CONTEXT_CONNECTING);
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY(c, c->state == PA_CONTEXT_UNCONNECTED, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY(c, !(flags & ~PA_CONTEXT_NOAUTOSPAWN), PA_ERR_INVALID);
PA_CHECK_VALIDITY(c, c->state == PA_CONTEXT_UNCONNECTED, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY(c, !(flags & ~PA_CONTEXT_NOAUTOSPAWN), PA_ERR_INVALID);
- assert(!c->server_list);
+ pa_assert(!c->server_list);
if (server) {
if (!(c->server_list = pa_strlist_parse(server))) {
if (server) {
if (!(c->server_list = pa_strlist_parse(server))) {
pa_runtime_path(AUTOSPAWN_LOCK, lf, sizeof(lf));
pa_make_secure_parent_dir(lf, 0700, (uid_t)-1, (gid_t)-1);
pa_runtime_path(AUTOSPAWN_LOCK, lf, sizeof(lf));
pa_make_secure_parent_dir(lf, 0700, (uid_t)-1, (gid_t)-1);
- assert(c->autospawn_lock_fd <= 0);
+ pa_assert(c->autospawn_lock_fd <= 0);
c->autospawn_lock_fd = pa_lock_lockfile(lf);
if (api)
c->autospawn_lock_fd = pa_lock_lockfile(lf);
if (api)
}
void pa_context_disconnect(pa_context *c) {
}
void pa_context_disconnect(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_context_set_state(c, PA_CONTEXT_TERMINATED);
}
pa_context_state_t pa_context_get_state(pa_context *c) {
pa_context_set_state(c, PA_CONTEXT_TERMINATED);
}
pa_context_state_t pa_context_get_state(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
return c->state;
}
int pa_context_errno(pa_context *c) {
return c->state;
}
int pa_context_errno(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
return c->error;
}
void pa_context_set_state_callback(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
return c->error;
}
void pa_context_set_state_callback(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
c->state_callback = cb;
c->state_userdata = userdata;
}
int pa_context_is_pending(pa_context *c) {
c->state_callback = cb;
c->state_userdata = userdata;
}
int pa_context_is_pending(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY(c,
c->state == PA_CONTEXT_CONNECTING ||
PA_CHECK_VALIDITY(c,
c->state == PA_CONTEXT_CONNECTING ||
static void set_dispatch_callbacks(pa_operation *o) {
int done = 1;
static void set_dispatch_callbacks(pa_operation *o) {
int done = 1;
- assert(o);
- assert(PA_REFCNT_VALUE(o) >= 1);
- assert(o->context);
- assert(PA_REFCNT_VALUE(o->context) >= 1);
- assert(o->context->state == PA_CONTEXT_READY);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+ pa_assert(o->context);
+ pa_assert(PA_REFCNT_VALUE(o->context) >= 1);
+ pa_assert(o->context->state == PA_CONTEXT_READY);
pa_pstream_set_drain_callback(o->context->pstream, NULL, NULL);
pa_pdispatch_set_drain_callback(o->context->pdispatch, NULL, NULL);
pa_pstream_set_drain_callback(o->context->pstream, NULL, NULL);
pa_pdispatch_set_drain_callback(o->context->pdispatch, NULL, NULL);
pa_operation* pa_context_drain(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
pa_operation *o;
pa_operation* pa_context_drain(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
pa_operation *o;
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, pa_context_is_pending(c), PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, pa_context_is_pending(c), PA_ERR_BADSTATE);
pa_operation *o = userdata;
int success = 1;
pa_operation *o = userdata;
int success = 1;
- assert(pd);
- assert(o);
- assert(PA_REFCNT_VALUE(o) >= 1);
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
if (!o->context)
goto finish;
if (!o->context)
goto finish;
pa_operation *o;
uint32_t tag;
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
pa_operation *o;
uint32_t tag;
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
pa_operation *o;
uint32_t tag;
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
pa_operation *o;
uint32_t tag;
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
}
int pa_context_is_local(pa_context *c) {
}
int pa_context_is_local(pa_context *c) {
pa_operation *o;
uint32_t tag;
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
- assert(name);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(name);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
}
const char* pa_context_get_server(pa_context *c) {
}
const char* pa_context_get_server(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
if (!c->server)
return NULL;
if (!c->server)
return NULL;
}
uint32_t pa_context_get_server_protocol_version(pa_context *c) {
}
uint32_t pa_context_get_server_protocol_version(pa_context *c) {
- assert(c);
- assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag) {
pa_tagstruct *t;
pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag) {
pa_tagstruct *t;
- assert(c);
- assert(tag);
+ pa_assert(c);
+ pa_assert(tag);
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, command);
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, command);
struct sigaction sa;
#endif
struct sigaction sa;
#endif
- pa_assert(sig > 0 && _callback);
+ pa_assert(sig > 0);
+ pa_assert(_callback);
for (e = signals; e; e = e->next)
if (e->sig == sig)
for (e = signals; e; e = e->next)
if (e->sig == sig)
if (e->dead || !e->pollfd || !e->pollfd->revents)
continue;
if (e->dead || !e->pollfd || !e->pollfd->revents)
continue;
- pa_assert(e->pollfd->fd == e->fd && e->callback);
+ pa_assert(e->pollfd->fd == e->fd);
+ pa_assert(e->callback);
e->callback(&m->api, e, e->fd, map_flags_from_libc(e->pollfd->revents), e->userdata);
e->pollfd->revents = 0;
r++;
e->callback(&m->api, e, e->fd, map_flags_from_libc(e->pollfd->revents), e->userdata);
e->pollfd->revents = 0;
r++;
#include <stdio.h>
#include <string.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pulse/pulseaudio.h>
#include <stdlib.h>
#include <pulse/pulseaudio.h>
#include <pulsecore/native-common.h>
#include <pulsecore/log.h>
#include <pulsecore/native-common.h>
#include <pulsecore/log.h>
+#include <pulsecore/macro.h>
static void context_state_cb(pa_context *c, void *userdata) {
pa_simple *p = userdata;
static void context_state_cb(pa_context *c, void *userdata) {
pa_simple *p = userdata;
- assert(c);
- assert(p);
+ pa_assert(c);
+ pa_assert(p);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_READY:
switch (pa_context_get_state(c)) {
case PA_CONTEXT_READY:
static void stream_state_cb(pa_stream *s, void * userdata) {
pa_simple *p = userdata;
static void stream_state_cb(pa_stream *s, void * userdata) {
pa_simple *p = userdata;
- assert(s);
- assert(p);
+ pa_assert(s);
+ pa_assert(p);
switch (pa_stream_get_state(s)) {
switch (pa_stream_get_state(s)) {
static void stream_request_cb(pa_stream *s, size_t length, void *userdata) {
pa_simple *p = userdata;
static void stream_request_cb(pa_stream *s, size_t length, void *userdata) {
pa_simple *p = userdata;
pa_threaded_mainloop_signal(p->mainloop, 0);
}
pa_threaded_mainloop_signal(p->mainloop, 0);
}
static void stream_latency_update_cb(pa_stream *s, void *userdata) {
pa_simple *p = userdata;
static void stream_latency_update_cb(pa_stream *s, void *userdata) {
pa_simple *p = userdata;
pa_threaded_mainloop_signal(p->mainloop, 0);
}
pa_simple* pa_simple_new(
pa_threaded_mainloop_signal(p->mainloop, 0);
}
pa_simple* pa_simple_new(
- const char *server,
- const char *name,
- pa_stream_direction_t dir,
- const char *dev,
- const char *stream_name,
- const pa_sample_spec *ss,
- const pa_channel_map *map,
- const pa_buffer_attr *attr,
- int *rerror) {
+ const char *server,
+ const char *name,
+ pa_stream_direction_t dir,
+ const char *dev,
+ const char *stream_name,
+ const pa_sample_spec *ss,
+ const pa_channel_map *map,
+ const pa_buffer_attr *attr,
+ int *rerror) {
pa_simple *p;
int error = PA_ERR_INTERNAL, r;
pa_simple *p;
int error = PA_ERR_INTERNAL, r;
}
void pa_simple_free(pa_simple *s) {
}
void pa_simple_free(pa_simple *s) {
if (s->mainloop)
pa_threaded_mainloop_stop(s->mainloop);
if (s->mainloop)
pa_threaded_mainloop_stop(s->mainloop);
}
int pa_simple_write(pa_simple *p, const void*data, size_t length, int *rerror) {
}
int pa_simple_write(pa_simple *p, const void*data, size_t length, int *rerror) {
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, data && length, PA_ERR_INVALID, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, data && length, PA_ERR_INVALID, -1);
}
int pa_simple_read(pa_simple *p, void*data, size_t length, int *rerror) {
}
int pa_simple_read(pa_simple *p, void*data, size_t length, int *rerror) {
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_RECORD, PA_ERR_BADSTATE, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, data && length, PA_ERR_INVALID, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_RECORD, PA_ERR_BADSTATE, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, data && length, PA_ERR_INVALID, -1);
static void success_cb(pa_stream *s, int success, void *userdata) {
pa_simple *p = userdata;
static void success_cb(pa_stream *s, int success, void *userdata) {
pa_simple *p = userdata;
- assert(s);
- assert(p);
+ pa_assert(s);
+ pa_assert(p);
p->operation_success = success;
pa_threaded_mainloop_signal(p->mainloop, 0);
p->operation_success = success;
pa_threaded_mainloop_signal(p->mainloop, 0);
int pa_simple_drain(pa_simple *p, int *rerror) {
pa_operation *o = NULL;
int pa_simple_drain(pa_simple *p, int *rerror) {
pa_operation *o = NULL;
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
int pa_simple_flush(pa_simple *p, int *rerror) {
pa_operation *o = NULL;
int pa_simple_flush(pa_simple *p, int *rerror) {
pa_operation *o = NULL;
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
pa_usec_t t;
int negative;
pa_usec_t t;
int negative;
pa_threaded_mainloop_lock(p->mainloop);
pa_threaded_mainloop_lock(p->mainloop);