src/dssigui.cpp

   1 /* Calf DSP Library utility application.
   2  * DSSI GUI application.
   3  * Copyright (C) 2007 Krzysztof Foltman
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20 #include <assert.h>
  21 #include <getopt.h>
  22 #include <stdint.h>
  23 #include <stdlib.h>
  24 #include <config.h>
  25 #include <calf/giface.h>
  26 #include <calf/gui.h>
  27 #include <calf/main_win.h>
  28 #include <calf/osctl.h>
  29 #include <calf/osctlnet.h>
  30 #include <calf/osctlserv.h>
  31
  32 using namespace std;
  33 using namespace dsp;
  34 using namespace calf_plugins;
  35 using namespace osctl;
  36
  37 #define debug_printf(...)
  38
  39 #if 0
  40 void osctl_test()
  41 {
  42     string sdata = string("\000\000\000\003123\000test\000\000\000\000\000\000\000\001\000\000\000\002", 24);
  43     osc_stream is(sdata);
  44     vector<osc_data> data;
  45     is.read("bsii", data);
  46     assert(is.pos == sdata.length());
  47     assert(data.size() == 4);
  48     assert(data[0].type == osc_blob);
  49     assert(data[1].type == osc_string);
  50     assert(data[2].type == osc_i32);
  51     assert(data[3].type == osc_i32);
  52     assert(data[0].strval == "123");
  53     assert(data[1].strval == "test");
  54     assert(data[2].i32val == 1);
  55     assert(data[3].i32val == 2);
  56     osc_stream os("");
  57     os.write(data);
  58     assert(os.buffer == sdata);
  59     osc_server srv;
  60     srv.bind("0.0.0.0", 4541);
  61
  62     osc_client cli;
  63     cli.bind("0.0.0.0", 0);
  64     cli.set_addr("0.0.0.0", 4541);
  65     if (!cli.send("/blah", data))
  66         g_error("Could not send the OSC message");
  67
  68     g_main_loop_run(g_main_loop_new(NULL, FALSE));
  69 }
  70 #endif
  71
  72 struct cairo_params
  73 {
  74     enum { HAS_COLOR = 1, HAS_WIDTH = 2 };
  75     uint32_t flags;
  76     float r, g, b, a;
  77     float line_width;
  78
  79     cairo_params()
  80     : flags(0)
  81     , r(0.f)
  82     , g(0.f)
  83     , b(0.f)
  84     , a(1.f)
  85     , line_width(1)
  86     {
  87     }
  88 };
  89
  90 struct graph_item: public cairo_params
  91 {
  92     float data[128];
  93 };
  94
  95 struct dot_item: public cairo_params
  96 {
  97     float x, y;
  98     int32_t size;
  99 };
 100
 101 struct gridline_item: public cairo_params
 102 {
 103     float pos;
 104     int32_t vertical;
 105     std::string text;
 106 };
 107
 108 struct param_line_graphs
 109 {
 110     vector<graph_item *> graphs;
 111     vector<dot_item *> dots;
 112     vector<gridline_item *> gridlines;
 113
 114     void clear();
 115 };
 116
 117 void param_line_graphs::clear()
 118 {
 119     for (size_t i = 0; i < graphs.size(); i++)
 120         delete graphs[i];
 121     graphs.clear();
 122
 123     for (size_t i = 0; i < dots.size(); i++)
 124         delete dots[i];
 125     dots.clear();
 126
 127     for (size_t i = 0; i < gridlines.size(); i++)
 128         delete gridlines[i];
 129     gridlines.clear();
 130
 131 }
 132
 133 struct plugin_proxy: public plugin_ctl_iface, public plugin_metadata_proxy, public line_graph_iface
 134 {
 135     osc_client *client;
 136     bool send_osc;
 137     plugin_gui *gui;
 138     map<string, string> cfg_vars;
 139     int param_count;
 140     float *params;
 141     map<int, param_line_graphs> graphs;
 142     bool update_graphs;
 143
 144     plugin_proxy(plugin_metadata_iface *md)
 145     : plugin_metadata_proxy(md)
 146     {
 147         client = NULL;
 148         send_osc = false;
 149         update_graphs = true;
 150         gui = NULL;
 151         param_count = md->get_param_count();
 152         params = new float[param_count];
 153         for (int i = 0; i < param_count; i++)
 154             params[i] = get_param_props(i)->def_value;
 155     }
 156     virtual float get_param_value(int param_no) {
 157         if (param_no < 0 || param_no >= param_count)
 158             return 0;
 159         return params[param_no];
 160     }
 161     virtual void set_param_value(int param_no, float value) {
 162         if (param_no < 0 || param_no >= param_count)
 163             return;
 164         update_graphs = true;
 165         params[param_no] = value;
 166         if (send_osc)
 167         {
 168             osc_inline_typed_strstream str;
 169             str << (uint32_t)(param_no + get_param_port_offset()) << value;
 170             client->send("/control", str);
 171         }
 172     }
 173     virtual bool activate_preset(int bank, int program) {
 174         if (send_osc) {
 175             osc_inline_typed_strstream str;
 176             str << (uint32_t)(bank) << (uint32_t)(program);
 177             client->send("/program", str);
 178             return false;
 179         }
 180         return false;
 181     }
 182     virtual float get_level(unsigned int port) { return 0.f; }
 183     virtual void execute(int command_no) {
 184         if (send_osc) {
 185             stringstream ss;
 186             ss << command_no;
 187
 188             osc_inline_typed_strstream str;
 189             str << "ExecCommand" << ss.str();
 190             client->send("/configure", str);
 191
 192             str.clear();
 193             str << "ExecCommand" << "";
 194             client->send("/configure", str);
 195         }
 196     }
 197     char *configure(const char *key, const char *value) {
 198         cfg_vars[key] = value;
 199         osc_inline_typed_strstream str;
 200         str << key << value;
 201         client->send("/configure", str);
 202         return NULL;
 203     }
 204     void send_configures(send_configure_iface *sci) {
 205         for (map<string, string>::iterator i = cfg_vars.begin(); i != cfg_vars.end(); i++)
 206             sci->send_configure(i->first.c_str(), i->second.c_str());
 207     }
 208     virtual line_graph_iface *get_line_graph_iface() { return this; }
 209     virtual bool get_graph(int index, int subindex, float *data, int points, cairo_iface *context);
 210     virtual bool get_dot(int index, int subindex, float &x, float &y, int &size, cairo_iface *context);
 211     virtual bool get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context);
 212     void update_cairo_context(cairo_iface *context, cairo_params &item);
 213 };
 214
 215 bool plugin_proxy::get_graph(int index, int subindex, float *data, int points, cairo_iface *context)
 216 {
 217     if (!graphs.count(index))
 218         return false;
 219     param_line_graphs &g = graphs[index];
 220     if (subindex < (int)g.graphs.size())
 221     {
 222         float *sdata = g.graphs[subindex]->data;
 223         for (int i = 0; i < points; i++) {
 224             float pos = i * 127.0 / points;
 225             int ipos = i * 127 / points;
 226             data[i] = sdata[ipos] + (sdata[ipos + 1] - sdata[ipos]) * (pos-ipos);
 227         }
 228         update_cairo_context(context, *g.graphs[subindex]);
 229         return true;
 230     }
 231     return false;
 232 }
 233
 234 bool plugin_proxy::get_dot(int index, int subindex, float &x, float &y, int &size, cairo_iface *context)
 235 {
 236     if (!graphs.count(index))
 237         return false;
 238     param_line_graphs &g = graphs[index];
 239     if (subindex < (int)g.dots.size())
 240     {
 241         dot_item &item = *g.dots[subindex];
 242         x = item.x;
 243         y = item.y;
 244         size = item.size;
 245         update_cairo_context(context, item);
 246         return true;
 247     }
 248     return false;
 249 }
 250
 251 bool plugin_proxy::get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context)
 252 {
 253     if (!graphs.count(index))
 254         return false;
 255     param_line_graphs &g = graphs[index];
 256     if (subindex < (int)g.gridlines.size())
 257     {
 258         gridline_item &item = *g.gridlines[subindex];
 259         pos = item.pos;
 260         vertical = item.vertical != 0;
 261         legend = item.text;
 262         update_cairo_context(context, item);
 263         return true;
 264     }
 265     return false;
 266 }
 267
 268 void plugin_proxy::update_cairo_context(cairo_iface *context, cairo_params &item)
 269 {
 270     if (item.flags & cairo_params::HAS_COLOR)
 271         context->set_source_rgba(item.r, item.g, item.b, item.a);
 272     if (item.flags & cairo_params::HAS_WIDTH)
 273         context->set_line_width(item.line_width);
 274 }
 275
 276 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 277
 278 GMainLoop *mainloop;
 279
 280 static bool osc_debug = false;
 281
 282 struct dssi_osc_server: public osc_server, public osc_message_sink<osc_strstream>
 283 {
 284     plugin_proxy *plugin;
 285     main_window *main_win;
 286     plugin_gui_window *window;
 287     string effect_name, title;
 288     osc_client cli;
 289     bool in_program, enable_dump;
 290     vector<plugin_preset> presets;
 291     /// Timeout callback source ID
 292     int source_id;
 293     bool osc_link_active;
 294
 295     dssi_osc_server()
 296     : plugin(NULL)
 297     , main_win(new main_window)
 298     , window(new plugin_gui_window(main_win))
 299     {
 300         sink = this;
 301         source_id = 0;
 302         osc_link_active = false;
 303     }
 304
 305     static void on_destroy(GtkWindow *window, dssi_osc_server *self)
 306     {
 307         debug_printf("on_destroy, have to send \"exiting\"\n");
 308         bool result = self->cli.send("/exiting");
 309         debug_printf("result = %d\n", result ? 1 : 0);
 310         g_main_loop_quit(mainloop);
 311         // eliminate a warning with empty debug_printf
 312         result = false;
 313     }
 314
 315     void create_window()
 316     {
 317         plugin = NULL;
 318         vector<plugin_metadata_iface *> plugins;
 319         get_all_plugins(plugins);
 320         for (unsigned int i = 0; i < plugins.size(); i++)
 321         {
 322             if (!strcmp(plugins[i]->get_id(), effect_name.c_str()))
 323             {
 324                 plugin = new plugin_proxy(plugins[i]);
 325                 break;
 326             }
 327         }
 328         if (!plugin)
 329         {
 330             fprintf(stderr, "Unknown plugin: %s\n", effect_name.c_str());
 331             exit(1);
 332         }
 333         plugin->client = &cli;
 334         plugin->send_osc = true;
 335         ((main_window *)window->main)->conditions.insert("dssi");
 336         ((main_window *)window->main)->conditions.insert("directlink");
 337         window->create(plugin, title.c_str(), effect_name.c_str());
 338         plugin->gui = window->gui;
 339         gtk_signal_connect(GTK_OBJECT(window->toplevel), "destroy", G_CALLBACK(on_destroy), this);
 340         vector<plugin_preset> tmp_presets;
 341         get_builtin_presets().get_for_plugin(presets, effect_name.c_str());
 342         get_user_presets().get_for_plugin(tmp_presets, effect_name.c_str());
 343         presets.insert(presets.end(), tmp_presets.begin(), tmp_presets.end());
 344         source_id = g_timeout_add_full(G_PRIORITY_LOW, 1000/30, on_idle, this, NULL);
 345     }
 346
 347     static gboolean on_idle(void *self)
 348     {
 349         ((dssi_osc_server *)(self))->send_osc_update();
 350         return TRUE;
 351     }
 352
 353     void set_osc_update(bool enabled)
 354     {
 355         osc_link_active = enabled;
 356         osc_inline_typed_strstream data;
 357         data << "OSC:FEEDBACK_URI";
 358         data << (enabled ? get_uri() : "");
 359         cli.send("/configure", data);
 360     }
 361     void send_osc_update()
 362     {
 363         static int serial_no = 0;
 364         osc_inline_typed_strstream data;
 365         data << "OSC:UPDATE";
 366         data << calf_utils::i2s(serial_no++);
 367         cli.send("/configure", data);
 368     }
 369
 370     virtual void receive_osc_message(std::string address, std::string args, osc_strstream &buffer);
 371     void unmarshal_line_graph(osc_strstream &buffer);
 372 };
 373
 374 void dssi_osc_server::unmarshal_line_graph(osc_strstream &buffer)
 375 {
 376     uint32_t cmd;
 377
 378     do {
 379         buffer >> cmd;
 380         if (cmd == LGI_GRAPH)
 381         {
 382             uint32_t param;
 383             buffer >> param;
 384             param_line_graphs &graphs = plugin->graphs[param];
 385
 386             graphs.clear();
 387             cairo_params params;
 388
 389             do {
 390                 buffer >> cmd;
 391                 if (cmd == LGI_SET_RGBA)
 392                 {
 393                     params.flags |= cairo_params::HAS_COLOR;
 394                     buffer >> params.r >> params.g >> params.b >> params.a;
 395                 }
 396                 else
 397                 if (cmd == LGI_SET_WIDTH)
 398                 {
 399                     params.flags |= cairo_params::HAS_WIDTH;
 400                     buffer >> params.line_width;
 401                 }
 402                 else
 403                 if (cmd == LGI_SUBGRAPH)
 404                 {
 405                     buffer >> param; // ignore number of points
 406                     graph_item *gi = new graph_item;
 407                     (cairo_params &)*gi = params;
 408                     for (int i = 0; i < 128; i++)
 409                         buffer >> gi->data[i];
 410                     graphs.graphs.push_back(gi);
 411                     params.flags = 0;
 412                 }
 413                 else
 414                 if (cmd == LGI_DOT)
 415                 {
 416                     dot_item *di = new dot_item;
 417                     (cairo_params &)*di = params;
 418                     buffer >> di->x >> di->y >> di->size;
 419                     graphs.dots.push_back(di);
 420                     params.flags = 0;
 421                 }
 422                 else
 423                 if (cmd == LGI_LEGEND)
 424                 {
 425                     gridline_item *li = new gridline_item;
 426                     (cairo_params &)*li = params;
 427                     buffer >> li->pos >> li->vertical >> li->text;
 428                     graphs.gridlines.push_back(li);
 429                     params.flags = 0;
 430                 }
 431                 else
 432                     break;
 433             } while(1);
 434
 435         }
 436         else
 437             break;
 438     } while(1);
 439 }
 440
 441 void dssi_osc_server::receive_osc_message(std::string address, std::string args, osc_strstream &buffer)
 442 {
 443     if (osc_debug)
 444         dump.receive_osc_message(address, args, buffer);
 445     if (address == prefix + "/update" && args == "s")
 446     {
 447         string str;
 448         buffer >> str;
 449         debug_printf("UPDATE: %s\n", str.c_str());
 450         set_osc_update(true);
 451         send_osc_update();
 452         return;
 453     }
 454     else if (address == prefix + "/quit")
 455     {
 456         set_osc_update(false);
 457         debug_printf("QUIT\n");
 458         g_main_loop_quit(mainloop);
 459         return;
 460     }
 461     else if (address == prefix + "/configure"&& args == "ss")
 462     {
 463         string key, value;
 464         buffer >> key >> value;
 465         plugin->cfg_vars[key] = value;
 466         // XXXKF perhaps this should be queued !
 467         window->gui->refresh();
 468         return;
 469     }
 470     else if (address == prefix + "/program"&& args == "ii")
 471     {
 472         uint32_t bank, program;
 473
 474         buffer >> bank >> program;
 475
 476         unsigned int nr = bank * 128 + program;
 477         debug_printf("PROGRAM %d\n", nr);
 478         if (nr == 0)
 479         {
 480             bool sosc = plugin->send_osc;
 481             plugin->send_osc = false;
 482             int count = plugin->get_param_count();
 483             for (int i =0 ; i < count; i++)
 484                 plugin->set_param_value(i, plugin->get_param_props(i)->def_value);
 485             plugin->send_osc = sosc;
 486             window->gui->refresh();
 487             // special handling for default preset
 488             return;
 489         }
 490         nr--;
 491         if (nr >= presets.size())
 492             return;
 493         bool sosc = plugin->send_osc;
 494         plugin->send_osc = false;
 495         presets[nr].activate(plugin);
 496         plugin->send_osc = sosc;
 497         window->gui->refresh();
 498
 499         // cli.send("/update", data);
 500         return;
 501     }
 502     else if (address == prefix + "/control" && args == "if")
 503     {
 504         uint32_t port;
 505         float val;
 506
 507         buffer >> port >> val;
 508
 509         int idx = port - plugin->get_param_port_offset();
 510         debug_printf("CONTROL %d %f\n", idx, val);
 511         bool sosc = plugin->send_osc;
 512         plugin->send_osc = false;
 513         window->gui->set_param_value(idx, val);
 514         plugin->send_osc = sosc;
 515         if (plugin->get_param_props(idx)->flags & PF_PROP_GRAPH)
 516             plugin->update_graphs = true;
 517         return;
 518     }
 519     else if (address == prefix + "/show")
 520     {
 521         set_osc_update(true);
 522
 523         gtk_widget_show_all(GTK_WIDGET(window->toplevel));
 524         return;
 525     }
 526     else if (address == prefix + "/hide")
 527     {
 528         set_osc_update(false);
 529
 530         gtk_widget_hide(GTK_WIDGET(window->toplevel));
 531         return;
 532     }
 533     else if (address == prefix + "/lineGraph")
 534     {
 535         unmarshal_line_graph(buffer);
 536         if (plugin->update_graphs) {
 537             // updates graphs that are only redrawn on startup and parameter changes
 538             // (the OSC message may come a while after the parameter has been changed,
 539             // so the redraw triggered by parameter change usually shows stale values)
 540             window->gui->refresh();
 541             plugin->update_graphs = false;
 542         }
 543         return;
 544     }
 545     else
 546         printf("Unknown OSC address: %s\n", address.c_str());
 547 }
 548
 549 //////////////////////////////////////////////////////////////////////////////////
 550
 551 void help(char *argv[])
 552 {
 553     printf("GTK+ user interface for Calf DSSI plugins\nSyntax: %s [--help] [--version] <osc-url> <so-file> <plugin-label> <instance-name>\n", argv[0]);
 554 }
 555
 556 static struct option long_options[] = {
 557     {"help", 0, 0, 'h'},
 558     {"version", 0, 0, 'v'},
 559     {"debug", 0, 0, 'd'},
 560     {0,0,0,0},
 561 };
 562
 563 int main(int argc, char *argv[])
 564 {
 565     char *debug_var = getenv("OSC_DEBUG");
 566     if (debug_var && atoi(debug_var))
 567         osc_debug = true;
 568
 569     gtk_init(&argc, &argv);
 570     while(1) {
 571         int option_index;
 572         int c = getopt_long(argc, argv, "dhv", long_options, &option_index);
 573         if (c == -1)
 574             break;
 575         switch(c) {
 576             case 'd':
 577                 osc_debug = true;
 578                 break;
 579             case 'h':
 580                 help(argv);
 581                 return 0;
 582             case 'v':
 583                 printf("%s\n", PACKAGE_STRING);
 584                 return 0;
 585         }
 586     }
 587     if (argc - optind != 4)
 588     {
 589         help(argv);
 590         exit(0);
 591     }
 592
 593     try {
 594         get_builtin_presets().load_defaults(true);
 595         get_user_presets().load_defaults(false);
 596     }
 597     catch(calf_plugins::preset_exception &e)
 598     {
 599         fprintf(stderr, "Error while loading presets: %s\n", e.what());
 600         exit(1);
 601     }
 602
 603     dssi_osc_server srv;
 604     srv.prefix = "/dssi/"+string(argv[optind + 1]) + "/" + string(argv[optind + 2]);
 605     for (char *p = argv[optind + 2]; *p; p++)
 606         *p = tolower(*p);
 607     srv.effect_name = argv[optind + 2];
 608     srv.title = argv[optind + 3];
 609
 610     srv.bind();
 611     srv.create_window();
 612
 613     mainloop = g_main_loop_new(NULL, FALSE);
 614
 615     srv.cli.bind();
 616     srv.cli.set_url(argv[optind]);
 617
 618     debug_printf("URI = %s\n", srv.get_uri().c_str());
 619
 620     string data_buf, type_buf;
 621     osc_inline_typed_strstream data;
 622     data << srv.get_uri();
 623     if (!srv.cli.send("/update", data))
 624     {
 625         g_error("Could not send the initial update message via OSC to %s", argv[optind]);
 626         return 1;
 627     }
 628
 629     g_main_loop_run(mainloop);
 630     if (srv.source_id)
 631         g_source_remove(srv.source_id);
 632
 633     srv.set_osc_update(false);
 634     debug_printf("exited\n");
 635
 636     return 0;
 637 }