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 <stdlib.h>
  24 #include <math.h>
  25 #include <calf/giface.h>
  26 #include <calf/utils.h>
  27
  28 using namespace std;
  29 using namespace calf_utils;
  30 using namespace calf_plugins;
  31
  32 static const char automation_key_prefix[] = "automation_v1_";
  33
  34 void automation_range::send_configure(const plugin_metadata_iface *metadata, uint32_t from_controller, send_configure_iface *sci)
  35 {
  36     std::stringstream ss1, ss2;
  37     ss1 << automation_key_prefix << from_controller << "_to_" << metadata->get_param_props(param_no)->short_name;
  38     ss2 << min_value << " " << max_value;
  39     sci->send_configure(ss1.str().c_str(), ss2.str().c_str());
  40 }
  41
  42 automation_range *automation_range::new_from_configure(const plugin_metadata_iface *metadata, const char *key, const char *value, uint32_t &from_controller)
  43 {
  44     if (0 != strncmp(key, automation_key_prefix, sizeof(automation_key_prefix) - 1))
  45         return NULL;
  46     key += sizeof(automation_key_prefix) - 1;
  47     const char *totoken = strstr(key, "_to_");
  48     if (!totoken)
  49         return NULL;
  50     string from_ctl(key, totoken - key);
  51     for (size_t i = 0; i < from_ctl.length(); i++)
  52     {
  53         if (!isdigit(from_ctl[i]))
  54             return NULL;
  55     }
  56     from_controller = (uint32_t)atoi(from_ctl.c_str());
  57     key = totoken + 4;
  58
  59     size_t pcount = metadata->get_param_count();
  60     for (size_t i = 0; i < pcount; ++i) {
  61         const parameter_properties *props = metadata->get_param_props(i);
  62         if (!strcmp(key, props->short_name))
  63         {
  64             std::stringstream ss(value);
  65             double minv, maxv;
  66             ss >> minv >> maxv;
  67             return new automation_range(minv, maxv, i);
  68         }
  69     }
  70
  71     return NULL;
  72 }
  73
  74 float parameter_properties::from_01(double value01) const
  75 {
  76     double value = dsp::clip(value01, 0., 1.);
  77     switch(flags & PF_SCALEMASK)
  78     {
  79     case PF_SCALE_DEFAULT:
  80     case PF_SCALE_LINEAR:
  81     case PF_SCALE_PERC:
  82     default:
  83         value = min + (max - min) * value01;
  84         break;
  85     case PF_SCALE_QUAD:
  86         value = min + (max - min) * value01 * value01;
  87         break;
  88     case PF_SCALE_LOG:
  89         value = min * pow(double(max / min), value01);
  90         break;
  91     case PF_SCALE_GAIN:
  92         if (value01 < 0.00001)
  93             value = min;
  94         else {
  95             float rmin = std::max(1.0f / 1024.0f, min);
  96             value = rmin * pow(double(max / rmin), value01);
  97         }
  98         break;
  99     case PF_SCALE_LOG_INF:
 100         assert(step);
 101         if (value01 > (step - 1.0) / step)
 102             value = FAKE_INFINITY;
 103         else
 104             value = min * pow(double(max / min), value01 * step / (step - 1.0));
 105         break;
 106     }
 107     switch(flags & PF_TYPEMASK)
 108     {
 109     case PF_INT:
 110     case PF_BOOL:
 111     case PF_ENUM:
 112     case PF_ENUM_MULTI:
 113         if (value > 0)
 114             value = (int)(value + 0.5);
 115         else
 116             value = (int)(value - 0.5);
 117         break;
 118     }
 119     return value;
 120 }
 121
 122 double parameter_properties::to_01(float value) const
 123 {
 124     switch(flags & PF_SCALEMASK)
 125     {
 126     case PF_SCALE_DEFAULT:
 127     case PF_SCALE_LINEAR:
 128     case PF_SCALE_PERC:
 129     default:
 130         return double(value - min) / (max - min);
 131     case PF_SCALE_QUAD:
 132         return sqrt(double(value - min) / (max - min));
 133     case PF_SCALE_LOG:
 134         value /= min;
 135         return log((double)value) / log((double)max / min);
 136     case PF_SCALE_LOG_INF:
 137         if (IS_FAKE_INFINITY(value))
 138             return max;
 139         value /= min;
 140         assert(step);
 141         return (step - 1.0) * log((double)value) / (step * log((double)max / min));
 142     case PF_SCALE_GAIN:
 143         if (value < 1.0 / 1024.0) // new bottom limit - 60 dB
 144             return 0;
 145         double rmin = std::max(1.0f / 1024.0f, min);
 146         value /= rmin;
 147         return log((double)value) / log(max / rmin);
 148     }
 149 }
 150
 151 float parameter_properties::get_increment() const
 152 {
 153     float increment = 0.01;
 154     if (step > 1)
 155         increment = 1.0 / (step - 1);
 156     else
 157     if (step > 0 && step < 1)
 158         increment = step;
 159     else
 160     if ((flags & PF_TYPEMASK) != PF_FLOAT)
 161         increment = 1.0 / (max - min);
 162     return increment;
 163 }
 164 std::string human_readable(float value, uint32_t base, char *format)
 165 {
 166     // format is something like "%.2f%sB" for e.g. "1.23kB"
 167     // base is something like 1000 or 1024
 168     char buf[32];
 169     const char *suf[] = { "", "k", "m", "g", "t", "p", "e" };
 170     if (value == 0) {
 171         sprintf(buf, format, 0.f, "");
 172         return string(buf);
 173     }
 174     double val = abs(value);
 175     int place = (int)(log(val) / log(base));
 176     double num = val / pow(base, place);
 177     sprintf(buf, format, (float)((value > 0) - (value < 0)) * num, suf[place]);
 178     return string(buf);
 179 }
 180
 181 int parameter_properties::get_char_count() const
 182 {
 183     if ((flags & PF_SCALEMASK) == PF_SCALE_PERC)
 184         return 6;
 185     if ((flags & PF_SCALEMASK) == PF_SCALE_GAIN) {
 186         char buf[256];
 187         size_t len = 0;
 188         snprintf(buf, sizeof(buf), "%0.0f dB", 6.0 * log(min) / log(2));
 189         len = strlen(buf);
 190         snprintf(buf, sizeof(buf), "%0.0f dB", 6.0 * log(max) / log(2));
 191         len = std::max(len, strlen(buf)) + 2;
 192         return (int)len;
 193     }
 194     std::string min_ = to_string(min);
 195     std::string max_ = to_string(max);
 196     std::string mid_ = to_string(min + (max - min) * 1. / 3);
 197     return std::max((int)min_.length(), std::max((int)max_.length(), std::max((int)mid_.length(), 3)));
 198 }
 199
 200
 201 std::string parameter_properties::to_string(float value) const
 202 {
 203     char buf[32];
 204     if ((flags & PF_SCALEMASK) == PF_SCALE_PERC) {
 205         snprintf(buf, sizeof(buf), "%0.2f%%", 100.0 * value);
 206         return string(buf);
 207     }
 208     if ((flags & PF_SCALEMASK) == PF_SCALE_GAIN) {
 209         if (value < 1.0 / 1024.0) // new bottom limit - 60 dB
 210             return "-inf dB"; // XXXKF change to utf-8 infinity
 211         snprintf(buf, sizeof(buf), "%0.1f dB", dsp::amp2dB(value));
 212         return string(buf);
 213     }
 214     std::string s_;
 215     switch(flags & PF_TYPEMASK)
 216     {
 217     case PF_INT:
 218     case PF_BOOL:
 219     case PF_ENUM:
 220     case PF_ENUM_MULTI:
 221         value = (int)value;
 222         s_ = human_readable(value, 1000, (char*)"%g%s");
 223         snprintf(buf, sizeof(buf), "%s", s_.c_str());
 224         //printf("%.2f %s\n", value, buf);
 225         break;
 226     case PF_FLOAT:
 227         switch (flags & PF_DIGITMASK) {
 228             case PF_DIGIT_0:
 229                 snprintf(buf, sizeof(buf), "%.0f", value);
 230                 break;
 231             case PF_DIGIT_1:
 232                 snprintf(buf, sizeof(buf), "%.1f", value);
 233                 break;
 234             case PF_DIGIT_2:
 235                 snprintf(buf, sizeof(buf), "%.2f", value);
 236                 break;
 237             case PF_DIGIT_3:
 238                 snprintf(buf, sizeof(buf), "%.3f", value);
 239                 break;
 240             case PF_DIGIT_ALL:
 241             default:
 242                 snprintf(buf, sizeof(buf), "%g", value);
 243                 break;
 244         }
 245         break;
 246     default:
 247         snprintf(buf, sizeof(buf), "%g", value);
 248         break;
 249     }
 250
 251     if ((flags & PF_SCALEMASK) == PF_SCALE_LOG_INF && IS_FAKE_INFINITY(value))
 252         snprintf(buf, sizeof(buf), "∞"); // XXXKF change to utf-8 infinity
 253
 254     switch(flags & PF_UNITMASK) {
 255     case PF_UNIT_DB: return string(buf) + " dB";
 256     case PF_UNIT_HZ: return string(buf) + " Hz";
 257     case PF_UNIT_SEC: return string(buf) + " s";
 258     case PF_UNIT_MSEC: return string(buf) + " ms";
 259     case PF_UNIT_CENTS: return string(buf) + " ct";
 260     case PF_UNIT_SEMITONES: return string(buf) + "#";
 261     case PF_UNIT_BPM: return string(buf) + " bpm";
 262     case PF_UNIT_RPM: return string(buf) + " rpm";
 263     case PF_UNIT_DEG: return string(buf) + " deg";
 264     case PF_UNIT_SAMPLES: return string(buf) + " smpl";
 265     case PF_UNIT_NOTE:
 266         {
 267             static const char *notes = "C C#D D#E F F#G G#A A#B ";
 268             int note = (int)value;
 269             if (note < 0 || note > 127)
 270                 return "---";
 271             return string(notes + 2 * (note % 12), 2) + i2s(note / 12 - 2);
 272         }
 273     }
 274
 275     return string(buf);
 276 }
 277
 278 float parameter_properties::string_to_value(const char* string) const
 279 {
 280     float value = atof(string);
 281     if ((flags & PF_SCALEMASK) == PF_SCALE_PERC) {
 282         return value / 100.0;
 283     }
 284     if ((flags & PF_SCALEMASK) == PF_SCALE_GAIN) {
 285         return dsp::dB2amp(value);
 286     }
 287     return value;
 288 }
 289
 290 ////////////////////////////////////////////////////////////////////////
 291
 292 void calf_plugins::plugin_ctl_iface::clear_preset() {
 293     int param_count = get_metadata_iface()->get_param_count();
 294     for (int i = 0; i < param_count; i++)
 295     {
 296         const parameter_properties &pp = *get_metadata_iface()->get_param_props(i);
 297         set_param_value(i, pp.def_value);
 298     }
 299     vector<string> vars;
 300     get_metadata_iface()->get_configure_vars(vars);
 301     for (size_t i = 0; i < vars.size(); ++i)
 302         configure(vars[i].c_str(), NULL);
 303 }
 304
 305 const char *calf_plugins::load_gui_xml(const std::string &plugin_id)
 306 {
 307     try {
 308         return strdup(calf_utils::load_file((std::string(PKGLIBDIR) + "/gui-" + plugin_id + ".xml").c_str()).c_str());
 309     }
 310     catch(file_exception e)
 311     {
 312         return NULL;
 313     }
 314 }
 315
 316 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)
 317 {
 318     if (subindex < 0)
 319     return false;
 320     static const double dash[] = {2.0};
 321     // frequency grid
 322     if (use_frequencies)
 323     {
 324         if (subindex < 28)
 325         {
 326             vertical = true;
 327             if (subindex == 9) legend = "100 Hz";
 328             if (subindex == 18) legend = "1 kHz";
 329             if (subindex == 27) legend = "10 kHz";
 330
 331             float freq = subindex_to_freq(subindex);
 332             pos = log(freq / 20.0) / log(1000);
 333
 334             if (!legend.empty()) {
 335                 context->set_source_rgba(0, 0, 0, 0.1);
 336                 context->set_dash(dash, 0);
 337             } else {
 338                 context->set_source_rgba(0, 0, 0, 0.1);
 339                 context->set_dash(dash, 1);
 340             }
 341             return true;
 342         }
 343         subindex -= 28;
 344     }
 345
 346     if (subindex >= 32)
 347         return false;
 348
 349     // gain/dB grid
 350     float gain = 64.0 / (1 << subindex);
 351     pos = dB_grid(gain, res, ofs);
 352
 353     if (pos < -1)
 354         return false;
 355
 356     if (!(subindex & 1)) {
 357         std::stringstream ss;
 358         ss << (36 - 6 * subindex) << " dB";
 359         legend = ss.str();
 360     }
 361     if (!legend.empty() and subindex != 6) {
 362         context->set_source_rgba(0, 0, 0, 0.1);
 363         context->set_dash(dash, 0);
 364     } else if (subindex != 6) {
 365         context->set_source_rgba(0, 0, 0, 0.1);
 366         context->set_dash(dash, 1);
 367     } else {
 368         context->set_dash(dash, 0);
 369     }
 370     vertical = false;
 371     return true;
 372 }
 373
 374 void calf_plugins::set_channel_color(cairo_iface *context, int channel, float alpha)
 375 {
 376     if (channel & 1)
 377         context->set_source_rgba(0.25, 0.10, 0.0, alpha);
 378     else
 379         context->set_source_rgba(0.05, 0.25, 0.0, alpha);
 380 }
 381 void calf_plugins::set_channel_dash(cairo_iface *context, int channel)
 382 {
 383     double dash[] = {8,2};
 384     int length = 2;
 385     switch (channel) {
 386         case 0:
 387         default:
 388             dash[0] = 6;
 389             dash[1] = 1.5;
 390             length = 2;
 391             break;
 392         case 1:
 393             dash[0] = 4.5;
 394             dash[1] = 1.5;
 395             length = 2;
 396             break;
 397         case 2:
 398             dash[0] = 3;
 399             dash[1] = 1.5;
 400             length = 2;
 401             break;
 402         case 3:
 403             dash[0] = 1.5;
 404             dash[1] = 1.5;
 405             length = 2;
 406             break;
 407     }
 408     context->set_dash(dash, length);
 409 }
 410
 411 void calf_plugins::draw_cairo_label(cairo_iface *context, const char *label, float x, float y, int pos, float margin, float align)
 412 {
 413     context->draw_label(label, x, y, pos, margin, align);
 414 }
 415 ////////////////////////////////////////////////////////////////////////
 416
 417 bool frequency_response_line_graph::get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const
 418 {
 419     if (phase or subindex)
 420         return false;
 421     return ::get_graph(*this, subindex, data, points);
 422 }
 423 bool frequency_response_line_graph::get_gridline(int index, int subindex, int phase, float &pos, bool &vertical, std::string &legend, cairo_iface *context) const
 424 {
 425     if (phase)
 426         return false;
 427     return get_freq_gridline(subindex, pos, vertical, legend, context, true);
 428 }
 429 bool frequency_response_line_graph::get_layers(int index, int generation, unsigned int &layers) const
 430 {
 431     redraw_graph = redraw_graph || !generation;
 432     layers = (generation ? LG_NONE : LG_CACHE_GRID) | (redraw_graph ? LG_CACHE_GRAPH : LG_NONE);
 433     bool r = redraw_graph;
 434     redraw_graph = false;
 435     return r;
 436 }
 437 std::string frequency_response_line_graph::get_crosshair_label(int x, int y, int sx, int sy, cairo_iface *context) const
 438 {
 439     std::stringstream ss;
 440     float freq = exp((float(x) / float(sx)) * log(1000)) * 20.0;
 441     ss << int(freq) << " Hz";
 442     return ss.str();
 443 }
 444
 445
 446
 447 ////////////////////////////////////////////////////////////////////////
 448
 449 calf_plugins::plugin_registry &calf_plugins::plugin_registry::instance()
 450 {
 451     static calf_plugins::plugin_registry registry;
 452     return registry;
 453 }
 454
 455 const plugin_metadata_iface *calf_plugins::plugin_registry::get_by_uri(const char *plugin_uri)
 456 {
 457     static const char prefix[] = "http://calf.sourceforge.net/plugins/";
 458     if (strncmp(plugin_uri, prefix, sizeof(prefix) - 1))
 459         return NULL;
 460     const char *label = plugin_uri + sizeof(prefix) - 1;
 461     for (unsigned int i = 0; i < plugins.size(); i++)
 462     {
 463         if (!strcmp(plugins[i]->get_plugin_info().label, label))
 464             return plugins[i];
 465     }
 466     return NULL;
 467 }
 468
 469 const plugin_metadata_iface *calf_plugins::plugin_registry::get_by_id(const char *id, bool case_sensitive)
 470 {
 471     typedef int (*comparator)(const char *, const char *);
 472     comparator comp = case_sensitive ? strcmp : strcasecmp;
 473     for (unsigned int i = 0; i < plugins.size(); i++)
 474     {
 475         if (!comp(plugins[i]->get_id(), id))
 476             return plugins[i];
 477     }
 478     return NULL;
 479 }
 480
 481 ////////////////////////////////////////////////////////////////////////
 482
 483 bool calf_plugins::parse_table_key(const char *key, const char *prefix, bool &is_rows, int &row, int &column)
 484 {
 485     is_rows = false;
 486     row = -1;
 487     column = -1;
 488     if (0 != strncmp(key, prefix, strlen(prefix)))
 489         return false;
 490
 491     key += strlen(prefix);
 492
 493     if (!strcmp(key, "rows"))
 494     {
 495         is_rows = true;
 496         return true;
 497     }
 498
 499     const char *comma = strchr(key, ',');
 500     if (comma)
 501     {
 502         row = atoi(string(key, comma - key).c_str());
 503         column = atoi(comma + 1);
 504         return true;
 505     }
 506
 507     printf("Unknown key %s under prefix %s", key, prefix);
 508
 509     return false;
 510 }
 511
 512 ////////////////////////////////////////////////////////////////////////
 513
 514 const char *mod_mapping_names[] = { "0..1", "-1..1", "-1..0", "x^2", "2x^2-1", "ASqr", "ASqrBip", "Para", NULL };
 515
 516 mod_matrix_metadata::mod_matrix_metadata(unsigned int _rows, const char **_src_names, const char **_dest_names)
 517 : mod_src_names(_src_names)
 518 , mod_dest_names(_dest_names)
 519 , matrix_rows(_rows)
 520 {
 521     table_column_info tci[6] = {
 522         { "Source", TCT_ENUM, 0, 0, 0, mod_src_names },
 523         { "Mapping", TCT_ENUM, 0, 0, 0, mod_mapping_names },
 524         { "Modulator", TCT_ENUM, 0, 0, 0, mod_src_names },
 525         { "Amount", TCT_FLOAT, 0, 1, 1, NULL},
 526         { "Destination", TCT_ENUM, 0, 0, 0, mod_dest_names  },
 527         { NULL }
 528     };
 529     assert(sizeof(table_columns) == sizeof(tci));
 530     memcpy(table_columns, tci, sizeof(table_columns));
 531 }
 532
 533 const table_column_info *mod_matrix_metadata::get_table_columns() const
 534 {
 535     return table_columns;
 536 }
 537
 538 uint32_t mod_matrix_metadata::get_table_rows() const
 539 {
 540     return matrix_rows;
 541 }
 542
 543 /// Return a list of configure variables used by the modulation matrix
 544 void mod_matrix_metadata::get_configure_vars(std::vector<std::string> &names) const
 545 {
 546     for (unsigned int i = 0; i < matrix_rows; ++i)
 547     {
 548         for (int j = 0; j < 5; j++)
 549         {
 550             char buf[40];
 551             snprintf(buf, sizeof(buf), "mod_matrix:%d,%d", i, j);
 552             names.push_back(buf);
 553         }
 554     }
 555 }
 556
 557
 558
 559 ////////////////////////////////////////////////////////////////////////
 560
 561 #if USE_EXEC_GUI
 562
 563 table_via_configure::table_via_configure()
 564 {
 565     rows = 0;
 566 }
 567
 568 table_via_configure::~table_via_configure()
 569 {
 570 }
 571
 572 #endif