src/giface.cpp

   1 /* Calf DSP Library
   2  * Implementation of various helpers for the plugin interface.
   3  *
   4  * Copyright (C) 2001-2010 Krzysztof Foltman
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  */
  21 #include <config.h>
  22 #include <limits.h>
  23 #include <calf/giface.h>
  24 #include <calf/utils.h>
  25
  26 using namespace std;
  27 using namespace calf_utils;
  28 using namespace calf_plugins;
  29
  30 static const char automation_key_prefix[] = "automation_v1_";
  31
  32 void automation_range::send_configure(const plugin_metadata_iface *metadata, uint32_t from_controller, send_configure_iface *sci)
  33 {
  34     std::stringstream ss1, ss2;
  35     ss1 << automation_key_prefix << from_controller << "_to_" << metadata->get_param_props(param_no)->short_name;
  36     ss2 << min_value << " " << max_value;
  37     sci->send_configure(ss1.str().c_str(), ss2.str().c_str());
  38 }
  39
  40 automation_range *automation_range::new_from_configure(const plugin_metadata_iface *metadata, const char *key, const char *value, uint32_t &from_controller)
  41 {
  42     if (0 != strncmp(key, automation_key_prefix, sizeof(automation_key_prefix) - 1))
  43         return NULL;
  44     key += sizeof(automation_key_prefix) - 1;
  45     const char *totoken = strstr(key, "_to_");
  46     if (!totoken)
  47         return NULL;
  48     string from_ctl(key, totoken - key);
  49     for (size_t i = 0; i < from_ctl.length(); i++)
  50     {
  51         if (!isdigit(from_ctl[i]))
  52             return NULL;
  53     }
  54     from_controller = (uint32_t)atoi(from_ctl.c_str());
  55     key = totoken + 4;
  56
  57     size_t pcount = metadata->get_param_count();
  58     for (size_t i = 0; i < pcount; ++i) {
  59         const parameter_properties *props = metadata->get_param_props(i);
  60         if (!strcmp(key, props->short_name))
  61         {
  62             std::stringstream ss(value);
  63             double minv, maxv;
  64             ss >> minv >> maxv;
  65             return new automation_range(minv, maxv, i);
  66         }
  67     }
  68
  69     return NULL;
  70 }
  71
  72 float parameter_properties::from_01(double value01) const
  73 {
  74     double value = dsp::clip(value01, 0., 1.);
  75     switch(flags & PF_SCALEMASK)
  76     {
  77     case PF_SCALE_DEFAULT:
  78     case PF_SCALE_LINEAR:
  79     case PF_SCALE_PERC:
  80     default:
  81         value = min + (max - min) * value01;
  82         break;
  83     case PF_SCALE_QUAD:
  84         value = min + (max - min) * value01 * value01;
  85         break;
  86     case PF_SCALE_LOG:
  87         value = min * pow(double(max / min), value01);
  88         break;
  89     case PF_SCALE_GAIN:
  90         if (value01 < 0.00001)
  91             value = min;
  92         else {
  93             float rmin = std::max(1.0f / 1024.0f, min);
  94             value = rmin * pow(double(max / rmin), value01);
  95         }
  96         break;
  97     case PF_SCALE_LOG_INF:
  98         assert(step);
  99         if (value01 > (step - 1.0) / step)
 100             value = FAKE_INFINITY;
 101         else
 102             value = min * pow(double(max / min), value01 * step / (step - 1.0));
 103         break;
 104     }
 105     switch(flags & PF_TYPEMASK)
 106     {
 107     case PF_INT:
 108     case PF_BOOL:
 109     case PF_ENUM:
 110     case PF_ENUM_MULTI:
 111         if (value > 0)
 112             value = (int)(value + 0.5);
 113         else
 114             value = (int)(value - 0.5);
 115         break;
 116     }
 117     return value;
 118 }
 119
 120 double parameter_properties::to_01(float value) const
 121 {
 122     switch(flags & PF_SCALEMASK)
 123     {
 124     case PF_SCALE_DEFAULT:
 125     case PF_SCALE_LINEAR:
 126     case PF_SCALE_PERC:
 127     default:
 128         return double(value - min) / (max - min);
 129     case PF_SCALE_QUAD:
 130         return sqrt(double(value - min) / (max - min));
 131     case PF_SCALE_LOG:
 132         value /= min;
 133         return log((double)value) / log((double)max / min);
 134     case PF_SCALE_LOG_INF:
 135         if (IS_FAKE_INFINITY(value))
 136             return max;
 137         value /= min;
 138         assert(step);
 139         return (step - 1.0) * log((double)value) / (step * log((double)max / min));
 140     case PF_SCALE_GAIN:
 141         if (value < 1.0 / 1024.0) // new bottom limit - 60 dB
 142             return 0;
 143         double rmin = std::max(1.0f / 1024.0f, min);
 144         value /= rmin;
 145         return log((double)value) / log(max / rmin);
 146     }
 147 }
 148
 149 float parameter_properties::get_increment() const
 150 {
 151     float increment = 0.01;
 152     if (step > 1)
 153         increment = 1.0 / (step - 1);
 154     else
 155     if (step > 0 && step < 1)
 156         increment = step;
 157     else
 158     if ((flags & PF_TYPEMASK) != PF_FLOAT)
 159         increment = 1.0 / (max - min);
 160     return increment;
 161 }
 162
 163 int parameter_properties::get_char_count() const
 164 {
 165     if ((flags & PF_SCALEMASK) == PF_SCALE_PERC)
 166         return 6;
 167     if ((flags & PF_SCALEMASK) == PF_SCALE_GAIN) {
 168         char buf[256];
 169         size_t len = 0;
 170         sprintf(buf, "%0.0f dB", 6.0 * log(min) / log(2));
 171         len = strlen(buf);
 172         sprintf(buf, "%0.0f dB", 6.0 * log(max) / log(2));
 173         len = std::max(len, strlen(buf)) + 2;
 174         return (int)len;
 175     }
 176     return std::max(to_string(min).length(), std::max(to_string(max).length(), to_string(min + (max-min) * 0.987654).length()));
 177 }
 178
 179 std::string parameter_properties::to_string(float value) const
 180 {
 181     char buf[32];
 182     if ((flags & PF_SCALEMASK) == PF_SCALE_PERC) {
 183         sprintf(buf, "%0.f%%", 100.0 * value);
 184         return string(buf);
 185     }
 186     if ((flags & PF_SCALEMASK) == PF_SCALE_GAIN) {
 187         if (value < 1.0 / 1024.0) // new bottom limit - 60 dB
 188             return "-inf dB"; // XXXKF change to utf-8 infinity
 189         sprintf(buf, "%0.1f dB", dsp::amp2dB(value));
 190         return string(buf);
 191     }
 192     switch(flags & PF_TYPEMASK)
 193     {
 194     case PF_INT:
 195     case PF_BOOL:
 196     case PF_ENUM:
 197     case PF_ENUM_MULTI:
 198         value = (int)value;
 199         break;
 200     }
 201
 202     if ((flags & PF_SCALEMASK) == PF_SCALE_LOG_INF && IS_FAKE_INFINITY(value))
 203         sprintf(buf, "+inf"); // XXXKF change to utf-8 infinity
 204     else
 205         sprintf(buf, "%g", value);
 206
 207     switch(flags & PF_UNITMASK) {
 208     case PF_UNIT_DB: return string(buf) + " dB";
 209     case PF_UNIT_HZ: return string(buf) + " Hz";
 210     case PF_UNIT_SEC: return string(buf) + " s";
 211     case PF_UNIT_MSEC: return string(buf) + " ms";
 212     case PF_UNIT_CENTS: return string(buf) + " ct";
 213     case PF_UNIT_SEMITONES: return string(buf) + "#";
 214     case PF_UNIT_BPM: return string(buf) + " bpm";
 215     case PF_UNIT_RPM: return string(buf) + " rpm";
 216     case PF_UNIT_DEG: return string(buf) + " deg";
 217     case PF_UNIT_NOTE:
 218         {
 219             static const char *notes = "C C#D D#E F F#G G#A A#B ";
 220             int note = (int)value;
 221             if (note < 0 || note > 127)
 222                 return "---";
 223             return string(notes + 2 * (note % 12), 2) + i2s(note / 12 - 2);
 224         }
 225     }
 226
 227     return string(buf);
 228 }
 229
 230 float parameter_properties::string_to_value(const char* string) const
 231 {
 232     float value = atof(string);
 233     if ((flags & PF_SCALEMASK) == PF_SCALE_PERC) {
 234         return value / 100.0;
 235     }
 236     if ((flags & PF_SCALEMASK) == PF_SCALE_GAIN) {
 237         return dsp::dB2amp(value);
 238     }
 239     return value;
 240 }
 241
 242 ////////////////////////////////////////////////////////////////////////
 243
 244 void calf_plugins::plugin_ctl_iface::clear_preset() {
 245     int param_count = get_metadata_iface()->get_param_count();
 246     for (int i = 0; i < param_count; i++)
 247     {
 248         const parameter_properties &pp = *get_metadata_iface()->get_param_props(i);
 249         set_param_value(i, pp.def_value);
 250     }
 251     const char *const *vars = get_metadata_iface()->get_configure_vars();
 252     if (vars)
 253     {
 254         for (int i = 0; vars[i]; i++)
 255             configure(vars[i], NULL);
 256     }
 257 }
 258
 259 const char *calf_plugins::load_gui_xml(const std::string &plugin_id)
 260 {
 261     try {
 262         return strdup(calf_utils::load_file((std::string(PKGLIBDIR) + "/gui-" + plugin_id + ".xml").c_str()).c_str());
 263     }
 264     catch(file_exception e)
 265     {
 266         return NULL;
 267     }
 268 }
 269
 270 bool calf_plugins::get_freq_gridline(int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context, bool use_frequencies, float res, float ofs)
 271 {
 272     if (subindex < 0)
 273     return false;
 274     static const double dash[] = {2.0};
 275     // frequency grid
 276     if (use_frequencies)
 277     {
 278         if (subindex < 28)
 279         {
 280             vertical = true;
 281             if (subindex == 9) legend = "100 Hz";
 282             if (subindex == 18) legend = "1 kHz";
 283             if (subindex == 27) legend = "10 kHz";
 284
 285             float freq = subindex_to_freq(subindex);
 286             pos = log(freq / 20.0) / log(1000);
 287
 288             if (!legend.empty()) {
 289                 context->set_source_rgba(0, 0, 0, 0.1);
 290                 context->set_dash(dash, 0);
 291             } else {
 292                 context->set_source_rgba(0, 0, 0, 0.1);
 293                 context->set_dash(dash, 1);
 294             }
 295             return true;
 296         }
 297         subindex -= 28;
 298     }
 299
 300     if (subindex >= 32)
 301         return false;
 302
 303     // gain/dB grid
 304     float gain = 64.0 / (1 << subindex);
 305     pos = dB_grid(gain, res, ofs);
 306
 307     if (pos < -1)
 308         return false;
 309
 310     if (!(subindex & 1)) {
 311         std::stringstream ss;
 312         ss << (36 - 6 * subindex) << " dB";
 313         legend = ss.str();
 314     }
 315     if (!legend.empty() and subindex != 6) {
 316         context->set_source_rgba(0, 0, 0, 0.1);
 317         context->set_dash(dash, 0);
 318     } else if (subindex != 6) {
 319         context->set_source_rgba(0, 0, 0, 0.1);
 320         context->set_dash(dash, 1);
 321     } else {
 322         context->set_dash(dash, 0);
 323     }
 324     vertical = false;
 325     return true;
 326 }
 327
 328 void calf_plugins::set_channel_color(cairo_iface *context, int channel, float alpha)
 329 {
 330     if (channel & 1)
 331         context->set_source_rgba(0.25, 0.10, 0.0, alpha);
 332     else
 333         context->set_source_rgba(0.05, 0.25, 0.0, alpha);
 334 }
 335 void calf_plugins::set_channel_dash(cairo_iface *context, int channel)
 336 {
 337     double dash[] = {8,2};
 338     int length = 2;
 339     switch (channel) {
 340         case 0:
 341         default:
 342             dash[0] = 6;
 343             dash[1] = 2;
 344             length = 2;
 345             break;
 346         case 1:
 347             dash[0] = 4;
 348             dash[1] = 2;
 349             length = 2;
 350             break;
 351         case 2:
 352             dash[0] = 2;
 353             dash[1] = 2;
 354             length = 2;
 355             break;
 356         case 3:
 357             dash[0] = 1;
 358             dash[1] = 2;
 359             length = 2;
 360             break;
 361     }
 362     context->set_dash(dash, length);
 363 }
 364 ////////////////////////////////////////////////////////////////////////
 365
 366 bool frequency_response_line_graph::get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const
 367 {
 368     if (phase or subindex)
 369         return false;
 370     return ::get_graph(*this, subindex, data, points);
 371 }
 372 bool frequency_response_line_graph::get_gridline(int index, int subindex, int phase, float &pos, bool &vertical, std::string &legend, cairo_iface *context) const
 373 {
 374     if (phase)
 375         return false;
 376     return get_freq_gridline(subindex, pos, vertical, legend, context, true);
 377 }
 378 bool frequency_response_line_graph::get_layers(int index, int generation, unsigned int &layers) const
 379 {
 380     redraw_graph = redraw_graph || !generation;
 381     layers = (generation ? LG_NONE : LG_CACHE_GRID) | (redraw_graph ? LG_CACHE_GRAPH : LG_NONE);
 382     bool r = redraw_graph;
 383     redraw_graph = false;
 384     return r;
 385 }
 386 std::string frequency_response_line_graph::get_crosshair_label(int x, int y, int sx, int sy, cairo_iface *context) const
 387 {
 388     std::stringstream ss;
 389     float freq = exp((float(x) / float(sx)) * log(1000)) * 20.0;
 390     ss << int(freq) << " Hz";
 391     return ss.str();
 392 }
 393
 394
 395
 396 ////////////////////////////////////////////////////////////////////////
 397
 398 calf_plugins::plugin_registry &calf_plugins::plugin_registry::instance()
 399 {
 400     static calf_plugins::plugin_registry registry;
 401     return registry;
 402 }
 403
 404 const plugin_metadata_iface *calf_plugins::plugin_registry::get_by_uri(const char *plugin_uri)
 405 {
 406     static const char prefix[] = "http://calf.sourceforge.net/plugins/";
 407     if (strncmp(plugin_uri, prefix, sizeof(prefix) - 1))
 408         return NULL;
 409     const char *label = plugin_uri + sizeof(prefix) - 1;
 410     for (unsigned int i = 0; i < plugins.size(); i++)
 411     {
 412         if (!strcmp(plugins[i]->get_plugin_info().label, label))
 413             return plugins[i];
 414     }
 415     return NULL;
 416 }
 417
 418 const plugin_metadata_iface *calf_plugins::plugin_registry::get_by_id(const char *id, bool case_sensitive)
 419 {
 420     typedef int (*comparator)(const char *, const char *);
 421     comparator comp = case_sensitive ? strcmp : strcasecmp;
 422     for (unsigned int i = 0; i < plugins.size(); i++)
 423     {
 424         if (!comp(plugins[i]->get_id(), id))
 425             return plugins[i];
 426     }
 427     return NULL;
 428 }
 429
 430 ////////////////////////////////////////////////////////////////////////
 431
 432 bool calf_plugins::parse_table_key(const char *key, const char *prefix, bool &is_rows, int &row, int &column)
 433 {
 434     is_rows = false;
 435     row = -1;
 436     column = -1;
 437     if (0 != strncmp(key, prefix, strlen(prefix)))
 438         return false;
 439
 440     key += strlen(prefix);
 441
 442     if (!strcmp(key, "rows"))
 443     {
 444         is_rows = true;
 445         return true;
 446     }
 447
 448     const char *comma = strchr(key, ',');
 449     if (comma)
 450     {
 451         row = atoi(string(key, comma - key).c_str());
 452         column = atoi(comma + 1);
 453         return true;
 454     }
 455
 456     printf("Unknown key %s under prefix %s", key, prefix);
 457
 458     return false;
 459 }
 460
 461 ////////////////////////////////////////////////////////////////////////
 462
 463 const char *mod_mapping_names[] = { "0..1", "-1..1", "-1..0", "x^2", "2x^2-1", "ASqr", "ASqrBip", "Para", NULL };
 464
 465 mod_matrix_metadata::mod_matrix_metadata(unsigned int _rows, const char **_src_names, const char **_dest_names)
 466 : mod_src_names(_src_names)
 467 , mod_dest_names(_dest_names)
 468 , matrix_rows(_rows)
 469 {
 470     table_column_info tci[6] = {
 471         { "Source", TCT_ENUM, 0, 0, 0, mod_src_names },
 472         { "Mapping", TCT_ENUM, 0, 0, 0, mod_mapping_names },
 473         { "Modulator", TCT_ENUM, 0, 0, 0, mod_src_names },
 474         { "Amount", TCT_FLOAT, 0, 1, 1, NULL},
 475         { "Destination", TCT_ENUM, 0, 0, 0, mod_dest_names  },
 476         { NULL }
 477     };
 478     assert(sizeof(table_columns) == sizeof(tci));
 479     memcpy(table_columns, tci, sizeof(table_columns));
 480 }
 481
 482 const table_column_info *mod_matrix_metadata::get_table_columns() const
 483 {
 484     return table_columns;
 485 }
 486
 487 uint32_t mod_matrix_metadata::get_table_rows() const
 488 {
 489     return matrix_rows;
 490 }
 491
 492 ////////////////////////////////////////////////////////////////////////
 493
 494 #if USE_EXEC_GUI
 495
 496 table_via_configure::table_via_configure()
 497 {
 498     rows = 0;
 499 }
 500
 501 table_via_configure::~table_via_configure()
 502 {
 503 }
 504
 505 #endif