zynadd_dynparam.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   Copyright (C) 2006,2007,2008,2009 Nedko Arnaudov <nedko@arnaudov.name>
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; version 2 of the License
   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
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  *****************************************************************************/
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <stdlib.h>
  24 #include <stdbool.h>
  25 #include <lv2.h>
  26
  27 #include "common.h"
  28 #include "addsynth.h"
  29 #include "lv2dynparam/lv2dynparam.h"
  30 #include "lv2dynparam/plugin.h"
  31 #include "list.h"
  32 #include "zynadd_internal.h"
  33 #include "zynadd_dynparam_value_changed_callbacks.h"
  34 #include "zynadd_dynparam_forest_map_top.h"
  35 #include "zynadd_dynparam_forest_map_voice.h"
  36
  37 #define LOG_LEVEL LOG_LEVEL_ERROR
  38 #include "log.h"
  39
  40 bool
  41 zynadd_appear_parameter(
  42   struct zynadd * zynadd_ptr,
  43   struct zynadd_parameter * parameter_ptr)
  44 {
  45   lv2dynparam_plugin_group parent_group;
  46
  47   LOG_DEBUG(
  48     "Appearing parameter \"%s\"/\"%s\" -> %u",
  49     parameter_ptr->parent_ptr ? parameter_ptr->parent_ptr->name_ptr : "",
  50     parameter_ptr->name_ptr,
  51     parameter_ptr->addsynth_parameter);
  52
  53   if (parameter_ptr->parent_ptr == NULL)
  54   {
  55     parent_group = NULL;
  56   }
  57   else
  58   {
  59     parent_group = parameter_ptr->parent_ptr->lv2group;
  60   }
  61
  62   switch (parameter_ptr->type)
  63   {
  64   case LV2DYNPARAM_PARAMETER_TYPE_BOOL:
  65     if (!lv2dynparam_plugin_param_boolean_add(
  66           zynadd_ptr->dynparams,
  67           parent_group,
  68           parameter_ptr->name_ptr,
  69           parameter_ptr->hints_ptr,
  70           zyn_addsynth_get_bool_parameter(
  71             parameter_ptr->addsynth_component,
  72             parameter_ptr->addsynth_parameter),
  73           zynadd_bool_parameter_changed,
  74           parameter_ptr,
  75           &parameter_ptr->lv2parameter))
  76     {
  77       return false;
  78     }
  79
  80     return true;
  81
  82   case LV2DYNPARAM_PARAMETER_TYPE_FLOAT:
  83     if (!lv2dynparam_plugin_param_float_add(
  84           zynadd_ptr->dynparams,
  85           parent_group,
  86           parameter_ptr->name_ptr,
  87           parameter_ptr->hints_ptr,
  88           zyn_addsynth_get_float_parameter(
  89             parameter_ptr->addsynth_component,
  90             parameter_ptr->addsynth_parameter),
  91           parameter_ptr->map_element_ptr->min.fpoint,
  92           parameter_ptr->map_element_ptr->max.fpoint,
  93           zynadd_float_parameter_changed,
  94           parameter_ptr,
  95           &parameter_ptr->lv2parameter))
  96     {
  97       return false;
  98     }
  99
 100     return true;
 101
 102   case LV2DYNPARAM_PARAMETER_TYPE_INT:
 103     if (!lv2dynparam_plugin_param_int_add(
 104           zynadd_ptr->dynparams,
 105           parent_group,
 106           parameter_ptr->name_ptr,
 107           parameter_ptr->hints_ptr,
 108           zyn_addsynth_get_int_parameter(
 109             parameter_ptr->addsynth_component,
 110             parameter_ptr->addsynth_parameter),
 111           parameter_ptr->map_element_ptr->min.integer,
 112           parameter_ptr->map_element_ptr->max.integer,
 113           zynadd_int_parameter_changed,
 114           parameter_ptr,
 115           &parameter_ptr->lv2parameter))
 116     {
 117       return false;
 118     }
 119
 120     return true;
 121
 122   case LV2DYNPARAM_PARAMETER_TYPE_ENUM:
 123     if (!lv2dynparam_plugin_param_enum_add(
 124           zynadd_ptr->dynparams,
 125           parent_group,
 126           parameter_ptr->name_ptr,
 127           parameter_ptr->hints_ptr,
 128           parameter_ptr->map_element_ptr->min.enum_values,
 129           parameter_ptr->map_element_ptr->max.enum_values_count,
 130           zyn_addsynth_get_int_parameter(
 131             parameter_ptr->addsynth_component,
 132             parameter_ptr->addsynth_parameter),
 133           zynadd_enum_parameter_changed,
 134           parameter_ptr,
 135           &parameter_ptr->lv2parameter))
 136     {
 137       LOG_ERROR("lv2dynparam_plugin_param_enum_add() failed.");
 138       return false;
 139     }
 140
 141     return true;
 142   }
 143
 144   assert(0);
 145   return false;
 146 }
 147
 148 /* create forest groups and parameters without exposing them */
 149 bool
 150 zynadd_dynparam_forest_initializer_prepare(
 151   struct zyn_forest_initializer * forest_ptr,
 152   struct zyn_forest_map * map_ptr,
 153   struct zynadd_group * root_group_ptr,
 154   zyn_addsynth_component * forest_components_array,
 155   struct zynadd * zynadd_ptr,
 156   struct list_head * groups_list_ptr,
 157   struct list_head * parameters_list_ptr)
 158 {
 159   int i;
 160   struct zynadd_group * group_ptr;
 161   struct zynadd_parameter * parameter_ptr;
 162
 163   LOG_DEBUG("Preparing forest with root \"%s\"/", root_group_ptr == NULL ? "" : root_group_ptr->name_ptr);
 164
 165   forest_ptr->map_ptr = map_ptr;
 166
 167   forest_ptr->groups_count = map_ptr->groups_count;
 168   forest_ptr->parameters_count = map_ptr->parameters_count;
 169
 170   forest_ptr->groups = malloc(sizeof(struct zynadd_group *) * forest_ptr->groups_count);
 171   if (forest_ptr->groups == NULL)
 172   {
 173     goto fail;
 174   }
 175
 176   forest_ptr->parameters = malloc(sizeof(struct zynadd_parameter *) * forest_ptr->parameters_count);
 177   if (forest_ptr->parameters == NULL)
 178   {
 179     goto fail_free_groups_array;
 180   }
 181
 182   for (i = 0 ; i < forest_ptr->groups_count ; i++)
 183   {
 184     LOG_DEBUG("Preparing group \"%s\"", forest_ptr->map_ptr->groups[i].name);
 185
 186     group_ptr = malloc(sizeof(struct zynadd_group));
 187     if (group_ptr == NULL)
 188     {
 189       goto fail_free_parameters_array;
 190     }
 191
 192     group_ptr->name_ptr = forest_ptr->map_ptr->groups[i].name;
 193     group_ptr->hints_ptr = &forest_ptr->map_ptr->groups[i].hints;
 194     group_ptr->lv2group = NULL;
 195
 196     if (forest_ptr->map_ptr->groups[i].parent == LV2DYNPARAM_GROUP_ROOT)
 197     {
 198       group_ptr->parent_ptr = root_group_ptr;
 199     }
 200     else
 201     {
 202       group_ptr->parent_ptr = forest_ptr->groups[forest_ptr->map_ptr->groups[i].parent];
 203     }
 204
 205     forest_ptr->groups[i] = group_ptr;
 206
 207     list_add_tail(&group_ptr->siblings, groups_list_ptr);
 208   }
 209
 210   for (i = 0 ; i < forest_ptr->parameters_count ; i++)
 211   {
 212     LOG_DEBUG(
 213       "Preparing parameter \"%s\"/\"%s\"",
 214       forest_ptr->map_ptr->parameters[i].parent == LV2DYNPARAM_GROUP_ROOT ?
 215       (root_group_ptr == NULL ?
 216        "" :
 217        root_group_ptr->name_ptr) :
 218       forest_ptr->groups[forest_ptr->map_ptr->parameters[i].parent]->name_ptr,
 219       forest_ptr->map_ptr->parameters[i].name);
 220
 221     parameter_ptr = malloc(sizeof(struct zynadd_parameter));
 222     if (parameter_ptr == NULL)
 223     {
 224       goto fail_free_parameters_array;
 225     }
 226
 227     if (forest_ptr->map_ptr->parameters[i].parent == LV2DYNPARAM_GROUP_ROOT)
 228     {
 229       parameter_ptr->parent_ptr = root_group_ptr;
 230     }
 231     else
 232     {
 233       parameter_ptr->parent_ptr = forest_ptr->groups[forest_ptr->map_ptr->parameters[i].parent];
 234     }
 235
 236     forest_ptr->parameters[i] = parameter_ptr;
 237
 238     parameter_ptr->synth_ptr = zynadd_ptr;
 239     parameter_ptr->addsynth_parameter = forest_ptr->map_ptr->parameters[i].addsynth_parameter;
 240     parameter_ptr->addsynth_component = forest_components_array[forest_ptr->map_ptr->parameters[i].addsynth_component];
 241     parameter_ptr->scope = forest_ptr->map_ptr->parameters[i].scope;
 242     parameter_ptr->other_parameter = NULL;
 243     parameter_ptr->lv2parameter = NULL;
 244     parameter_ptr->name_ptr = forest_ptr->map_ptr->parameters[i].name;
 245     parameter_ptr->type = forest_ptr->map_ptr->parameters[i].type;
 246     parameter_ptr->hints_ptr = &forest_ptr->map_ptr->parameters[i].hints;
 247     parameter_ptr->map_element_ptr = forest_ptr->map_ptr->parameters + i;
 248
 249     list_add_tail(&parameter_ptr->siblings, parameters_list_ptr);
 250   }
 251
 252   /* set other_parameter when needed */
 253   for (i = 0 ; i < forest_ptr->parameters_count ; i++)
 254   {
 255     if (forest_ptr->map_ptr->parameters[i].scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_HIDE_OTHER ||
 256         forest_ptr->map_ptr->parameters[i].scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_SHOW_OTHER)
 257     {
 258       forest_ptr->parameters[i]->other_parameter = forest_ptr->parameters[forest_ptr->map_ptr->parameters[i].scope_specific];
 259     }
 260   }
 261
 262   return true;
 263
 264 fail_free_parameters_array:
 265   free(forest_ptr->parameters);
 266
 267 fail_free_groups_array:
 268   free(forest_ptr->groups);
 269
 270 fail:
 271   return false;
 272 }
 273
 274 void
 275 zynadd_dynparam_forest_initializer_clear(
 276   struct zyn_forest_initializer * forest_ptr)
 277 {
 278   free(forest_ptr->groups);
 279   free(forest_ptr->parameters);
 280 }
 281
 282 void
 283 zynadd_dynparam_destroy_forests(
 284   struct zynadd * zynadd_ptr)
 285 {
 286   struct list_head * node_ptr;
 287   struct zynadd_group * group_ptr;
 288   struct zynadd_parameter * parameter_ptr;
 289
 290   while (!list_empty(&zynadd_ptr->parameters))
 291   {
 292     node_ptr = zynadd_ptr->parameters.next;
 293     parameter_ptr = list_entry(node_ptr, struct zynadd_parameter, siblings);
 294     list_del(node_ptr);
 295     free(parameter_ptr);
 296   }
 297
 298   while (!list_empty(&zynadd_ptr->groups))
 299   {
 300     node_ptr = zynadd_ptr->groups.next;
 301     group_ptr = list_entry(node_ptr, struct zynadd_group, siblings);
 302     list_del(node_ptr);
 303     free(group_ptr);
 304   }
 305 }
 306
 307 bool
 308 zynadd_dynparam_forests_appear(
 309   struct zynadd * zynadd_ptr)
 310 {
 311   bool tmp_bool;
 312   struct zynadd_group * group_ptr;
 313   struct zynadd_parameter * parameter_ptr;
 314   struct list_head * node_ptr;
 315
 316   list_for_each(node_ptr, &zynadd_ptr->groups)
 317   {
 318     group_ptr = list_entry(node_ptr, struct zynadd_group, siblings);
 319
 320     LOG_DEBUG("Adding group \"%s\"", group_ptr->name_ptr);
 321
 322     if (!lv2dynparam_plugin_group_add(
 323           zynadd_ptr->dynparams,
 324           group_ptr->parent_ptr == NULL ? NULL : group_ptr->parent_ptr->lv2group,
 325           group_ptr->name_ptr,
 326           group_ptr->hints_ptr,
 327           &group_ptr->lv2group))
 328     {
 329       return false;
 330     }
 331   }
 332
 333   list_for_each(node_ptr, &zynadd_ptr->parameters)
 334   {
 335     parameter_ptr = list_entry(node_ptr, struct zynadd_parameter, siblings);
 336
 337     LOG_DEBUG("Adding parameter \"%s\"", parameter_ptr->name_ptr);
 338
 339     if (parameter_ptr->scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_SEMI)
 340     {
 341       continue;
 342     }
 343
 344     if (parameter_ptr->scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_HIDE_OTHER ||
 345         parameter_ptr->scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_SHOW_OTHER)
 346     {
 347       LOG_DEBUG("Apearing show/hide parameter \"%s\"", parameter_ptr->name_ptr);
 348       assert(parameter_ptr->type == LV2DYNPARAM_PARAMETER_TYPE_BOOL);
 349
 350       tmp_bool = zyn_addsynth_get_bool_parameter(
 351         parameter_ptr->addsynth_component,
 352         parameter_ptr->addsynth_parameter);
 353
 354       if (!zynadd_appear_parameter(zynadd_ptr, parameter_ptr))
 355       {
 356         return false;
 357       }
 358
 359       if ((parameter_ptr->scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_HIDE_OTHER && !tmp_bool) ||
 360           (parameter_ptr->scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_SHOW_OTHER && tmp_bool))
 361       {
 362         LOG_DEBUG("Apearing semi parameter \"%s\"", parameter_ptr->other_parameter->name_ptr);
 363         if (!zynadd_appear_parameter(zynadd_ptr, parameter_ptr->other_parameter))
 364         {
 365           return false;
 366         }
 367       }
 368
 369       continue;
 370     }
 371
 372     assert(parameter_ptr->scope == LV2DYNPARAM_PARAMETER_SCOPE_TYPE_ALWAYS);
 373
 374     if (!zynadd_appear_parameter(zynadd_ptr, parameter_ptr))
 375     {
 376       LOG_ERROR("zynadd_appear_parameter() failed.");
 377       return false;
 378     }
 379   }
 380
 381   return true;
 382 }
 383
 384 bool
 385 zynadd_dynparam_init(
 386   struct zynadd * zynadd_ptr)
 387 {
 388   struct zyn_forest_initializer top_forest_initializer;
 389   struct zyn_forest_initializer voice_forest_initializer;
 390   unsigned int i;
 391
 392   INIT_LIST_HEAD(&zynadd_ptr->groups);
 393   INIT_LIST_HEAD(&zynadd_ptr->parameters);
 394
 395   for (i = 0 ; i < ZYNADD_GLOBAL_COMPONENTS_COUNT ; i++)
 396   {
 397     zynadd_ptr->synth_global_components[i] = zyn_addsynth_get_global_component(zynadd_ptr->synth, i);
 398   }
 399
 400   for (i = 0 ; i < ZYNADD_VOICE_COMPONENTS_COUNT ; i++)
 401   {
 402     zynadd_ptr->synth_voice0_components[i] = zyn_addsynth_get_voice_component(zynadd_ptr->synth, 0, i);
 403     //LOG_DEBUG("Voice component %p", zynadd_ptr->synth_voice0_components[i]);
 404   }
 405
 406   LOG_DEBUG("Preparing top forest...");
 407
 408   if (!zynadd_dynparam_forest_initializer_prepare(
 409         &top_forest_initializer,
 410         &g_top_forest_map,
 411         NULL,
 412         zynadd_ptr->synth_global_components,
 413         zynadd_ptr,
 414         &zynadd_ptr->groups,
 415         &zynadd_ptr->parameters))
 416   {
 417     goto fail_destroy_forests;
 418   }
 419
 420   LOG_DEBUG("Preparing voice forest...");
 421
 422   if (!zynadd_dynparam_forest_initializer_prepare(
 423         &voice_forest_initializer,
 424         &g_voice_forest_map,
 425         top_forest_initializer.groups[zynadd_top_forest_map_get_voices_group()],
 426         zynadd_ptr->synth_voice0_components,
 427         zynadd_ptr,
 428         &zynadd_ptr->groups,
 429         &zynadd_ptr->parameters))
 430   {
 431     goto fail_clear_top_forest_initializer;
 432   }
 433
 434   if (!lv2dynparam_plugin_instantiate(
 435         (LV2_Handle)zynadd_ptr,
 436         zynadd_ptr->host_features,
 437         "zynadd",
 438         &zynadd_ptr->dynparams))
 439   {
 440     goto fail_clear_voice_forest_initializer;
 441   }
 442
 443   if (!zynadd_dynparam_forests_appear(zynadd_ptr))
 444   {
 445     goto fail_clean_dynparams;
 446   }
 447
 448   zynadd_dynparam_forest_initializer_clear(&voice_forest_initializer);
 449   zynadd_dynparam_forest_initializer_clear(&top_forest_initializer);
 450
 451   return true;
 452
 453 fail_clean_dynparams:
 454   zynadd_dynparam_uninit(zynadd_ptr);
 455
 456 fail_clear_voice_forest_initializer:
 457   zynadd_dynparam_forest_initializer_clear(&voice_forest_initializer);
 458
 459 fail_clear_top_forest_initializer:
 460   zynadd_dynparam_forest_initializer_clear(&top_forest_initializer);
 461
 462 fail_destroy_forests:
 463   zynadd_dynparam_destroy_forests(zynadd_ptr);
 464
 465   return false;
 466 }
 467
 468 void
 469 zynadd_dynparam_uninit(struct zynadd * zynadd_ptr)
 470 {
 471   zynadd_dynparam_destroy_forests(zynadd_ptr);
 472
 473   lv2dynparam_plugin_cleanup(zynadd_ptr->dynparams);
 474 }