int
jack_uuid_empty (const jack_uuid_t u)
{
jack_uuid_t empty;
VALGRIND_MEMSET(&empty, 0, sizeof(empty));
uuid_clear (empty);
if (jack_uuid_compare (u, empty) == 0) {
return 1;
}
return 0;
}
jack_port_t *
jack_port_new (const jack_client_t *client, jack_port_id_t port_id,
jack_control_t *control)
{
jack_port_shared_t *shared = &control->ports[port_id];
jack_port_type_id_t ptid = shared->ptype_id;
jack_port_t *port;
if ((port = (jack_port_t*)malloc (sizeof(jack_port_t))) == NULL) {
return NULL;
}
port->mix_buffer = NULL;
port->client_segment_base = NULL;
port->shared = shared;
port->type_info = &client->engine->port_types[ptid];
pthread_mutex_init (&port->connection_lock, NULL);
port->connections = 0;
port->tied = NULL;
if (jack_uuid_compare (client->control->uuid, port->shared->client_id) == 0) {
/* It's our port, so initialize the pointers to port
* functions within this address space. These builtin
* definitions can be overridden by the client.
*/
jack_port_functions_t *port_functions = jack_get_port_functions (ptid);
if (port_functions == NULL) {
port_functions = &jack_builtin_NULL_functions;
}
port->fptr = *port_functions;
port->shared->has_mixdown = (port->fptr.mixdown ? TRUE : FALSE);
}
/* set up a base address so that port->offset can be used to
compute the correct location. we don't store the location
directly, because port->client_segment_base and/or
port->offset can change if the buffer size or port counts
are changed.
*/
port->client_segment_base =
(void**)&client->port_segment[ptid].attached_at;
return port;
}
int
jack_port_is_mine (const jack_client_t *client, const jack_port_t *port)
{
return jack_uuid_compare (port->shared->client_id, client->control->uuid) == 0;
}
int
jack_get_all_properties (jack_description_t** descriptions)
{
DBT key;
DBT data;
DBC* cursor;
int ret;
size_t dcnt = 0;
size_t dsize = 0;
size_t n = 0;
jack_description_t* desc = NULL;
jack_uuid_t uuid;
jack_description_t* current_desc = NULL;
jack_property_t* current_prop = NULL;
size_t len1, len2;
if (jack_property_init (NULL)) {
return -1;
}
if ((ret = db->cursor (db, NULL, &cursor, 0)) != 0) {
jack_error ("Cannot create cursor for metadata search (%s)", db_strerror (ret));
return -1;
}
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
data.flags = DB_DBT_MALLOC;
dsize = 8; /* initial guess at number of descriptions we need */
dcnt = 0;
desc = (jack_description_t*) malloc (dsize * sizeof (jack_description_t));
while ((ret = cursor->get(cursor, &key, &data, DB_NEXT)) == 0) {
/* require 2 extra chars (data+null) for key,
which is composed of UUID str plus a key name
*/
if (key.size < JACK_UUID_STRING_SIZE + 2) {
if (data.size > 0) {
free (data.data);
}
continue;
}
if (jack_uuid_parse (key.data, uuid) != 0) {
continue;
}
/* do we have an existing description for this UUID */
for (n = 0; n < dcnt ; ++n) {
if (jack_uuid_compare (uuid, desc[n].subject) == 0) {
break;
}
}
if (n == dcnt) {
/* we do not have an existing description, so grow the array */
if (dcnt == dsize) {
dsize *= 2;
desc = (jack_description_t*) realloc (desc, sizeof (jack_description_t) * dsize);
}
/* initialize */
desc[n].property_size = 0;
desc[n].property_cnt = 0;
desc[n].properties = NULL;
/* set up UUID */
jack_uuid_copy (desc[n].subject, uuid);
dcnt++;
}
current_desc = &desc[n];
/* see if there is room for the new property or if we need to realloc
*/
if (current_desc->property_cnt == current_desc->property_size) {
if (current_desc->property_size == 0) {
current_desc->property_size = 8;
} else {
current_desc->property_size *= 2;
}
current_desc->properties = (jack_property_t*) realloc (current_desc->properties, sizeof (jack_property_t) * current_desc->property_size);
}
current_prop = ¤t_desc->properties[current_desc->property_cnt++];
/* copy key (without leading UUID) */
len1 = key.size - JACK_UUID_STRING_SIZE;
current_prop->key = malloc (len1);
memcpy ((char*) current_prop->key, key.data + JACK_UUID_STRING_SIZE, len1);
/* copy data (which contains 1 or 2 null terminated strings, the value
and optionally a MIME type.
*/
len1 = strlen (data.data) + 1;
current_prop->data = (char *) malloc (len1);
memcpy ((char*) current_prop->data, data.data, len1);
if (len1 < data.size) {
len2 = strlen (data.data+len1) + 1;
current_prop->type= (char *) malloc (len2);
memcpy ((char*) current_prop->type, data.data+len1, len2);
} else {
/* no type specified, assume default */
current_prop->type = NULL;
}
if (data.size) {
free (data.data);
}
}
cursor->close (cursor);
(*descriptions) = desc;
return dcnt;
}
