Beispiel #1
0
int setup_maps()
{
    mapper_map map = mapper_map_new(num_sources, sendsigs, 1, &recvsig);
    if (!map) {
        eprintf("Failed to create map\n");
        return 1;
    }
    mapper_map_set_mode(map, MAPPER_MODE_EXPRESSION);

    // build expression string
    int i, offset = 2, len = num_sources * 3 + 3;
    char expr[len];
    snprintf(expr, 3, "y=");
    for (i = 0; i < num_sources; i++) {
        mapper_slot slot = mapper_map_slot_by_signal(map, sendsigs[i]);
        snprintf(expr + offset, len - offset, "-x%d", mapper_slot_index(slot));
        if (i > 0)
            mapper_slot_set_causes_update(slot, 0);
        offset += 3;
    }
    mapper_map_set_expression(map, expr);
    mapper_map_push(map);

    // wait until mappings have been established
    while (!done && !mapper_map_ready(map)) {
        for (i = 0; i < num_sources; i++)
            mapper_device_poll(sources[i], 10);
        mapper_device_poll(destination, 10);
    }

    return 0;
}
Beispiel #2
0
void map_signals()
{
    mapper_map map = mapper_map_new(1, &sendsig, 1, &recvsig);
    mapper_map_set_mode(map, MAPPER_MODE_EXPRESSION);
    mapper_map_set_expression(map, "y{-1}=-10;y=y{-1}+1");
    mapper_map_push(map);

    // wait until mapping has been established
    while (!done && !mapper_map_ready(map)) {
        mapper_device_poll(source, 10);
        mapper_device_poll(destination, 10);
    }
}
Beispiel #3
0
int setup_maps()
{
    mapper_map map = mapper_map_new(1, &sendsig, 1, &recvsig);
    mapper_map_set_mode(map, MAPPER_MODE_EXPRESSION);
    mapper_map_set_expression(map, "y=x*10");
    mapper_map_push(map);

    // wait until mapping has been established
    while (!done && !mapper_map_ready(map)) {
        mapper_device_poll(source, 10);
        mapper_device_poll(destination, 10);
    }

    return 0;
}
Beispiel #4
0
// *********************************************************
// -(connection handler)------------------------------------
void impmap_on_map(mapper_device dev, mapper_map map, mapper_record_event e)
{
    // if connected involves current generic signal, create a new generic signal
    impmap *x = (void*)mapper_device_user_data(dev);
    if (!x) {
        post("error in connect handler: user_data is NULL");
        return;
    }
    if (!x->ready) {
        post("error in connect handler: device not ready");
        return;
    }

    // retrieve devices and signals
    mapper_slot slot = mapper_map_slot(map, MAPPER_LOC_SOURCE, 0);
    mapper_signal src_sig = mapper_slot_signal(slot);
    mapper_device src_dev = mapper_signal_device(src_sig);
    slot = mapper_map_slot(map, MAPPER_LOC_DESTINATION, 0);
    mapper_signal dst_sig = mapper_slot_signal(slot);
    mapper_device dst_dev = mapper_signal_device(dst_sig);

    // sanity check: don't allow self-connections
    if (src_dev == dst_dev) {
        mapper_map_release(map);
        return;
    }

    char full_name[256];

    if (e == MAPPER_ADDED) {
        if (src_dev == x->device) {
            snprintf(full_name, 256, "%s/%s", mapper_device_name(dst_dev),
                     mapper_signal_name(dst_sig));
            if (strcmp(mapper_signal_name(src_sig), full_name) == 0) {
                // <thisDev>:<dstDevName>/<dstSigName> -> <dstDev>:<dstSigName>
                return;
            }
            if (mapper_device_num_signals(x->device, MAPPER_DIR_OUTGOING) >= MAX_LIST) {
                post("Max outputs reached!");
                return;
            }
            // unmap the generic signal
            mapper_map_release(map);

            // add a matching output signal
            int i, length = mapper_signal_length(dst_sig);
            char type = mapper_signal_type(dst_sig);
            void *min = mapper_signal_minimum(dst_sig);
            void *max = mapper_signal_maximum(dst_sig);

            float *minf = 0, *maxf = 0;
            if (type == 'f') {
                minf = (float*)min;
                maxf = (float*)max;
            }
            else {
                if (min) {
                    minf = alloca(length * sizeof(float));
                    if (type == 'i') {
                        int *mini = (int*)min;
                        for (i = 0; i < length; i++)
                            minf[i] = (float)mini[i];
                    }
                    else if (type == 'd') {
                        double *mind = (double*)min;
                        for (i = 0; i < length; i++)
                            minf[i] = (float)mind[i];
                    }
                    else
                        minf = 0;
                }
                if (max) {
                    maxf = alloca(length * sizeof(float));
                    if (type == 'i') {
                        int *maxi = (int*)max;
                        for (i = 0; i < length; i++)
                            maxf[i] = (float)maxi[i];
                    }
                    else if (type == 'd') {
                        double *maxd = (double*)max;
                        for (i = 0; i < length; i++)
                            maxf[i] = (float)maxd[i];
                    }
                    else
                        maxf = 0;
                }
            }
            src_sig = mapper_device_add_output_signal(x->device, full_name,
                                                      length, 'f', 0, minf, maxf);
            if (!src_sig) {
                post("error creating new source signal!");
                return;
            }
            mapper_signal_set_callback(src_sig, impmap_on_query);

            // map the new signal
            map = mapper_map_new(1, &src_sig, 1, &dst_sig);
            mapper_map_set_mode(map, MAPPER_MODE_EXPRESSION);
            mapper_map_set_expression(map, "y=x");
            mapper_map_push(map);

            impmap_update_output_vector_positions(x);

            //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);
        }
        else if (dst_dev == x->device) {
            snprintf(full_name, 256, "%s/%s", mapper_device_name(src_dev),
                     mapper_signal_name(src_sig));
            if (strcmp(mapper_signal_name(dst_sig), full_name) == 0) {
                // <srcDevName>:<srcSigName> -> <thisDev>:<srcDevName>/<srcSigName>
                return;
            }
            if (mapper_device_num_signals(x->device, MAPPER_DIR_INCOMING) >= MAX_LIST) {
                post("Max inputs reached!");
                return;
            }
            // unmap the generic signal
            mapper_map_release(map);

            // add a matching input signal
            int i, length = mapper_signal_length(src_sig);
            char type = mapper_signal_type(src_sig);
            void *min = mapper_signal_minimum(src_sig);
            void *max = mapper_signal_maximum(src_sig);

            float *minf = 0, *maxf = 0;
            if (type == 'f') {
                minf = (float*)min;
                maxf = (float*)max;
            }
            else {
                if (min) {
                    minf = alloca(length * sizeof(float));
                    if (type == 'i') {
                        int *mini = (int*)min;
                        for (i = 0; i < length; i++)
                        minf[i] = (float)mini[i];
                    }
                    else if (type == 'd') {
                        double *mind = (double*)min;
                        for (i = 0; i < length; i++)
                        minf[i] = (float)mind[i];
                    }
                    else
                        minf = 0;
                }
                if (max) {
                    maxf = alloca(length * sizeof(float));
                    if (type == 'i') {
                        int *maxi = (int*)max;
                        for (i = 0; i < length; i++)
                        maxf[i] = (float)maxi[i];
                    }
                    else if (type == 'd') {
                        double *maxd = (double*)max;
                        for (i = 0; i < length; i++)
                        maxf[i] = (float)maxd[i];
                    }
                    else
                        maxf = 0;
                }
            }
            dst_sig = mapper_device_add_input_signal(x->device, full_name,
                                                     length, 'f', 0, minf, maxf,
                                                     impmap_on_input, 0);
            if (!dst_sig) {
                post("error creating new destination signal!");
                return;
            }

            // map the new signal
            map = mapper_map_new(1, &src_sig, 1, &dst_sig);
            mapper_map_set_mode(map, MAPPER_MODE_EXPRESSION);
            mapper_map_set_expression(map, "y=x");
            mapper_map_push(map);

            impmap_update_input_vector_positions(x);

            //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);
        }
    }
    else if (e == MAPPER_REMOVED) {
        if (src_sig == x->dummy_input || src_sig == x->dummy_output
            || dst_sig == x->dummy_input || dst_sig == x->dummy_output)
            return;
        if (src_dev == x->device) {
            snprintf(full_name, 256, "%s/%s", mapper_device_name(dst_dev),
                     mapper_signal_name(dst_sig));
            if (strcmp(mapper_signal_name(src_sig), full_name) != 0)
                return;
            // remove signal
            mapper_device_remove_signal(x->device, src_sig);
            impmap_update_input_vector_positions(x);

            //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);
        }
        else if (dst_dev == x->device) {
            snprintf(full_name, 256, "%s/%s", mapper_device_name(src_dev),
                     mapper_signal_name(src_sig));
            if (strcmp(mapper_signal_name(dst_sig), full_name) != 0)
                return;
            // remove signal
            mapper_device_remove_signal(x->device, dst_sig);
            impmap_update_input_vector_positions(x);

            //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);
        }
    }
}