Exemplo n.º 1
0
// *********************************************************
// -(new)---------------------------------------------------
void *impmap_new(t_symbol *s, int argc, t_atom *argv)
{
    impmap *x = NULL;
    long i;
    const char *alias = NULL;
    const char *iface = NULL;

#ifdef MAXMSP
    if ((x = object_alloc(mapper_class))) {
        x->outlet3 = listout((t_object *)x);
        x->outlet2 = listout((t_object *)x);
        x->outlet1 = listout((t_object *)x);
#else
    if (x = (impmap *) pd_new(mapper_class) ) {
        x->outlet1 = outlet_new(&x->ob, gensym("list"));
        x->outlet2 = outlet_new(&x->ob, gensym("list"));
        x->outlet3 = outlet_new(&x->ob, gensym("list"));
#endif
        x->name = strdup("implicitmap");
        for (i = 0; i < argc; i++) {
            if ((argv + i)->a_type == A_SYM) {
                if(strcmp(maxpd_atom_get_string(argv+i), "@alias") == 0) {
                    if ((argv+i+1)->a_type == A_SYM) {
                        alias = maxpd_atom_get_string(argv+i+1);
                        i++;
                    }
                }
                else if(strcmp(maxpd_atom_get_string(argv+i), "@interface") == 0) {
                    if ((argv+i+1)->a_type == A_SYM) {
                        iface = maxpd_atom_get_string(argv+i+1);
                        i++;
                    }
                }
            }
        }

        if (alias) {
            free(x->name);
            x->name = *alias == '/' ? strdup(alias+1) : strdup(alias);
        }

        if (impmap_setup_mapper(x, iface)) {
            post("implicitmap: Error initializing.");
        }
        else {
            x->ready = 0;
            x->mute = 0;
            x->new_in = 0;
            x->query_count = 0;
            x->num_snapshots = 0;
            x->snapshots = 0;
            // initialize input and output buffers
            for (i = 0; i < MAX_LIST; i++) {
                maxpd_atom_set_float(x->buffer_in+i, 0);
                maxpd_atom_set_float(x->buffer_out+i, 0);
                x->signals_in[i].x = x;
                x->signals_out[i].x = x;
            }
            x->size_in = 0;
            x->size_out = 0;
#ifdef MAXMSP
            x->clock = clock_new(x, (method)impmap_poll);    // Create the timing clock
            x->timeout = clock_new(x, (method)impmap_output_snapshot);
#else
            x->clock = clock_new(x, (t_method)impmap_poll);
            x->timeout = clock_new(x, (t_method)impmap_output_snapshot);
#endif
            clock_delay(x->clock, INTERVAL);  // Set clock to go off after delay
        }
    }
    return (x);
}

// *********************************************************
// -(free)--------------------------------------------------
void impmap_free(impmap *x)
{
    if (x->clock) {
        clock_unset(x->clock);    // Remove clock routine from the scheduler
        clock_free(x->clock);     // Frees memory used by clock
    }
    if (x->device) {
        mapper_device_free(x->device);
    }
    if (x->name) {
        free(x->name);
    }
    impmap_clear_snapshots(x);
}

// *********************************************************
// -(print properties)--------------------------------------
void impmap_print_properties(impmap *x)
{
    if (x->ready) {
        //output name
        maxpd_atom_set_string(&x->msg_buffer, mapper_device_name(x->device));
        outlet_anything(x->outlet3, gensym("name"), 1, &x->msg_buffer);

        mapper_network net = mapper_device_network(x->device);
        //output interface
        maxpd_atom_set_string(&x->msg_buffer, (char *)mapper_network_interface(net));
        outlet_anything(x->outlet3, gensym("interface"), 1, &x->msg_buffer);

        //output IP
        const struct in_addr *ip = mapper_network_ip4(net);
        if (ip) {
            maxpd_atom_set_string(&x->msg_buffer, inet_ntoa(*ip));
            outlet_anything(x->outlet3, gensym("IP"), 1, &x->msg_buffer);
        }

        //output port
        maxpd_atom_set_int(&x->msg_buffer, mapper_device_port(x->device));
        outlet_anything(x->outlet3, gensym("port"), 1, &x->msg_buffer);

        //output numInputs
        maxpd_atom_set_int(&x->msg_buffer, mapper_device_num_signals(x->device, MAPPER_DIR_INCOMING) - 1);
        outlet_anything(x->outlet3, gensym("numInputs"), 1, &x->msg_buffer);

        //output numOutputs
        maxpd_atom_set_int(&x->msg_buffer, mapper_device_num_signals(x->device, MAPPER_DIR_OUTGOING) - 1);
        outlet_anything(x->outlet3, gensym("numOutputs"), 1, &x->msg_buffer);
    }
}

// *********************************************************
// -(inlet/outlet assist - maxmsp only)---------------------
#ifdef MAXMSP
void impmap_assist(impmap *x, void *b, long m, long a, char *s)
{
    if (m == ASSIST_INLET) { // inlet
        sprintf(s, "OSC input");
    }
    else {    // outlet
        if (a == 0) {
            sprintf(s, "Mapped OSC inputs");
        }
        else if (a == 1) {
            sprintf(s, "Snapshot data");
        }
        else {
            sprintf(s, "Device information");
        }
    }
}
#endif

// *********************************************************
// -(snapshot)----------------------------------------------
void impmap_snapshot(impmap *x)
{
    // if previous snapshot still in progress, output current snapshot status
    if (x->query_count) {
        post("still waiting for last snapshot");
        return;
    }

    mapper_signal *psig;
    x->query_count = 0;

    // allocate a new snapshot
    if (x->ready) {
        t_snapshot new_snapshot = (t_snapshot)malloc(sizeof(t_snapshot));
        new_snapshot->id = x->num_snapshots++;
        new_snapshot->next = x->snapshots;
        new_snapshot->inputs = calloc(x->size_in, sizeof(float));
        new_snapshot->outputs = calloc(x->size_out, sizeof(float));
        x->snapshots = new_snapshot;
    }

    // iterate through input signals and store their current values
    psig = mapper_device_signals(x->device, MAPPER_DIR_INCOMING);
    while (psig) {
        if (*psig != x->dummy_input) {
            void *value = (void*)mapper_signal_value(*psig, 0);
            t_signal_ref *ref = mapper_signal_user_data(*psig);
            int siglength = mapper_signal_length(*psig);
            int length = ref->offset + siglength < MAX_LIST ? siglength : MAX_LIST - ref->offset;
            // we can simply use memcpy here since all our signals are type 'f'
            memcpy(&x->snapshots->inputs[ref->offset], value, length * sizeof(float));
        }
        psig = mapper_signal_query_next(psig);
    }

    mapper_timetag_now(&x->tt);
    mapper_device_start_queue(x->device, x->tt);

    // iterate through output signals and query the remote ends
    psig = mapper_device_signals(x->device, MAPPER_DIR_OUTGOING);
    while (psig) {
        if (*psig != x->dummy_output) {
            // query the remote value
            x->query_count += mapper_signal_query_remotes(*psig, MAPPER_NOW);
        }
        psig = mapper_signal_query_next(psig);
    }
    mapper_device_send_queue(x->device, x->tt);
    post("sent %i queries", x->query_count);

    if (x->query_count)
        clock_delay(x->timeout, 1000);  // Set clock to go off after delay
}

// *********************************************************
// -(snapshot)----------------------------------------------
void impmap_output_snapshot(impmap *x)
{
    if (x->query_count) {
        post("query timeout! setting query count to 0 and outputting current values.");
        x->query_count = 0;
    }
    maxpd_atom_set_int(x->buffer_in, x->snapshots->id+1);
    outlet_anything(x->outlet3, gensym("numSnapshots"), 1, x->buffer_in);
    maxpd_atom_set_float_array(x->buffer_in, x->snapshots->inputs, x->size_in);
    outlet_anything(x->outlet2, gensym("in"), x->size_in, x->buffer_in);
    maxpd_atom_set_float_array(x->buffer_out, x->snapshots->outputs, x->size_out);
    outlet_anything(x->outlet2, gensym("out"), x->size_out, x->buffer_out);
    maxpd_atom_set_int(x->buffer_in, x->snapshots->id);
    outlet_anything(x->outlet2, gensym("snapshot"), 1, x->buffer_in);
}

// *********************************************************
// -(mute output)-------------------------------------------
void impmap_mute_output(impmap *x, t_symbol *s, int argc, t_atom *argv)
{
    if (argc) {
        if (argv->a_type == A_FLOAT)
            x->mute = (int)atom_getfloat(argv);
#ifdef MAXMSP
        else if (argv->a_type == A_LONG)
            x->mute = atom_getlong(argv);
#endif
    }
}

// *********************************************************
// -(process)-----------------------------------------------
void impmap_process(impmap *x)
{
    outlet_anything(x->outlet2, gensym("process"), 0, 0);
}
Exemplo n.º 2
0
// *********************************************************
// -(new)---------------------------------------------------
void *oscmulticast_new(t_symbol *s, int argc, t_atom *argv)
{
	t_oscmulticast *x = NULL;
    int i, got_port = 0;
    char address[64];

#ifdef MAXMSP
    if ((x = object_alloc(oscmulticast_class))) {
        x->outlet3 = listout((t_object *)x);
        x->outlet2 = listout((t_object *)x);
        x->outlet1 = listout((t_object *)x);
#else
    if (x = (t_oscmulticast *) pd_new(oscmulticast_class)) {
        x->outlet1 = outlet_new(&x->ob, gensym("list"));
        x->outlet2 = outlet_new(&x->ob, gensym("list"));
        x->outlet3 = outlet_new(&x->ob, gensym("list"));
#endif

        x->group = NULL;
        x->iface = NULL;

        if (argc < 4) {
            post("oscmulticast: not enough arguments!\n");
            return NULL;
        }
        for (i = 0; i < argc; i++) {
            if(strcmp(maxpd_atom_get_string(argv+i), "@group") == 0) {
                if ((argv+i+1)->a_type == A_SYM) {
                    x->group = strdup(maxpd_atom_get_string(argv+i+1));
                    i++;
                }
            }
            else if (strcmp(maxpd_atom_get_string(argv+i), "@port") == 0) {
                if ((argv+i+1)->a_type == A_FLOAT) {
                    snprintf(x->port, 10, "%i", (int)maxpd_atom_get_float(argv+i+1));
                    got_port = 1;
                    i++;
                }
#ifdef MAXMSP
                else if ((argv+i+1)->a_type == A_LONG) {
                    snprintf(x->port, 10, "%i", (int)atom_getlong(argv+i+1));
                    got_port = 1;
                    i++;
                }
#endif
            }
            else if(strcmp(maxpd_atom_get_string(argv+i), "@interface") == 0) {
                if ((argv+i+1)->a_type == A_SYM) {
                    x->iface = strdup(maxpd_atom_get_string(argv+i+1));
                    i++;
                }
            }
        }

        if (!x->group || !got_port) {
            post("oscmulticast: need to specify group and port!");
            return NULL;
        }

        /* Open address */
        snprintf(address, 64, "osc.udp://%s:%s", x->group, x->port);
        x->address = lo_address_new_from_url(address);
        if (!x->address) {
            post("oscmulticast: could not create lo_address.");
            return NULL;
        }

        /* Set TTL for packet to 1 -> local subnet */
        lo_address_set_ttl(x->address, 1);

        /* Specify the interface to use for multicasting */
        if (x->iface) {
            if (lo_address_set_iface(x->address, x->iface, 0)) {
                post("oscmulticast: could not create lo_address.");
                return NULL;
            }
            x->server = lo_server_new_multicast_iface(x->group, x->port, x->iface, 0, 0);
        }
        else {
            x->server = lo_server_new_multicast(x->group, x->port, 0);
        }

        if (!x->server) {
            post("oscmulticast: could not create lo_server");
            lo_address_free(x->address);
            return NULL;
        }

        // Disable liblo message queueing
        lo_server_enable_queue(x->server, 0, 1);

        if (x->iface)
            post("oscmulticast: using interface %s", lo_address_get_iface(x->address));
        else
            post("oscmulticast: using default interface");
        lo_server_add_method(x->server, NULL, NULL, oscmulticast_handler, x);

#ifdef MAXMSP
        x->clock = clock_new(x, (method)oscmulticast_poll);	// Create the timing clock
#else
        x->clock = clock_new(x, (t_method)oscmulticast_poll);
#endif
        clock_delay(x->clock, INTERVAL);  // Set clock to go off after delay
    }
	return (x);
}

// *********************************************************
// -(free)--------------------------------------------------
void oscmulticast_free(t_oscmulticast *x)
{
    if (x->clock) {
        clock_unset(x->clock);	// Remove clock routine from the scheduler
        clock_free(x->clock);		// Frees memory used by clock
    }
    if (x->server) {
        lo_server_free(x->server);
    }
    if (x->address) {
        lo_address_free(x->address);
    }
    if (x->iface) {
        free(x->iface);
    }
    if (x->group) {
        free(x->group);
    }
}

// *********************************************************
// -(inlet/outlet assist - maxmsp only)---------------------
#ifdef MAXMSP
void oscmulticast_assist(t_oscmulticast *x, void *b, long m, long a, char *s)
{
	if (m == ASSIST_INLET) { // inlet
		sprintf(s, "OSC to be sent to multicast bus");
	}
	else {	// outlet
        sprintf(s, "OSC from multicast bus");
	}
}
#endif

// *********************************************************
// -(interface)---------------------------------------------
static void oscmulticast_interface(t_oscmulticast *x, t_symbol *s, int argc, t_atom *argv)
{
    const char *iface = 0;

    if (argc < 1)
        return;

    if (argv->a_type != A_SYM)
        return;

    iface = maxpd_atom_get_string(argv);

    if (lo_address_set_iface(x->address, iface, 0)) {
        post("oscmulticast: could not create lo_address.");
        return;
    }

    if (x->server)
        lo_server_free(x->server);
    x->server = lo_server_new_multicast_iface(x->group, x->port, iface, 0, 0);

    if (!x->server) {
        post("oscmulticast: could not create lo_server");
        return;
    }

    post("oscmulticast: using interface %s", lo_address_get_iface(x->address));
    lo_server_add_method(x->server, NULL, NULL, oscmulticast_handler, x);
}

// *********************************************************
// -(anything)----------------------------------------------
void oscmulticast_anything(t_oscmulticast *x, t_symbol *s, int argc, t_atom *argv)
{
    lo_message m = lo_message_new();
    if (!m) {
        post("lo_message_new() error");
        return;
    }

    int i;
    for (i=0; i<argc; i++)
    {
        switch ((argv + i)->a_type)
        {
			case A_FLOAT:
                lo_message_add_float(m, atom_getfloat(argv + i));
                break;
#ifdef MAXMSP
            case A_LONG:
                lo_message_add_int32(m, (int)atom_getlong(argv + i));
                break;
#endif
            case A_SYM:
                lo_message_add_string(m, maxpd_atom_get_string(argv + i));
                break;
        }
    }
    //set timetag?

    lo_send_message(x->address, s->s_name, m);
    lo_message_free(m);
}