示例#1
0
static int
_jack_init(prog_t *handle, const char *id)
{
	jack_options_t opts = JackNullOption | JackNoStartServer;
	if(handle->server_name)
		opts |= JackServerName;
	if(handle->session_id)
		opts |= JackSessionID;

	jack_status_t status;
	if(!(handle->client = jack_client_open(id, opts, &status,
		handle->server_name ? handle->server_name : handle->session_id,
		handle->server_name ? handle->session_id : NULL)))
	{
		return -1;
	}

	//TODO check status

	// set client pretty name
#if defined(JACK_HAS_METADATA_API)
	jack_uuid_t uuid;
	const char *client_name = jack_get_client_name(handle->client);
	const char *uuid_str = jack_get_uuid_for_client_name(handle->client, client_name);
	if(uuid_str)
		jack_uuid_parse(uuid_str, &uuid);
	else
		jack_uuid_clear(&uuid);

	if(!jack_uuid_empty(uuid))
	{
		jack_set_property(handle->client, uuid,
			JACK_METADATA_PRETTY_NAME, "Synthpod", "text/plain");
	}
#endif

	// set client process callback
	if(jack_set_process_callback(handle->client, _process, handle))
		return -1;
	if(jack_set_session_callback(handle->client, _session, handle))
		return -1;
	if(jack_set_sample_rate_callback(handle->client, _sample_rate, handle))
		return -1;
	if(jack_set_buffer_size_callback(handle->client, _buffer_size, handle))
		return -1;
	jack_on_shutdown(handle->client, _shutdown, handle);
	jack_set_xrun_callback(handle->client, _xrun, handle);

	return 0;
}
示例#2
0
static void
_jack_deinit(prog_t *handle)
{
	if(handle->client)
	{
		// remove client properties
#if defined(JACK_HAS_METADATA_API)
		jack_uuid_t uuid;
		const char *client_name = jack_get_client_name(handle->client);
		const char *uuid_str = jack_get_uuid_for_client_name(handle->client, client_name);
		if(uuid_str)
			jack_uuid_parse(uuid_str, &uuid);
		else
			jack_uuid_clear(&uuid);

		if(!jack_uuid_empty(uuid))
			jack_remove_properties(handle->client, uuid);
#endif

		jack_deactivate(handle->client);
		jack_client_close(handle->client);
		handle->client = NULL;
	}
}
示例#3
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 = &current_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;
}