research.m1stereo.tv/gitweb/ - melted/blob - src/modules/jackrack/plugin_settings.c

   1 /*
   2  *   JACK Rack
   3  *
   4  *   Copyright (C) Robert Ham 2003 (node@users.sourceforge.net)
   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; either version 2 of the License, or
   9  *   (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
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #define _GNU_SOURCE
  22
  23 #include <math.h>
  24
  25 #include "plugin_settings.h"
  26
  27
  28 static void
  29 settings_set_to_default (settings_t * settings, guint32 sample_rate)
  30 {
  31   unsigned long control;
  32   guint copy;
  33   LADSPA_Data value;
  34
  35   for (control = 0; control < settings->desc->control_port_count; control++)
  36     {
  37       value = plugin_desc_get_default_control_value (settings->desc, control, sample_rate);
  38
  39       for (copy = 0; copy < settings->copies; copy++)
  40         {
  41           settings->control_values[copy][control] = value;
  42         }
  43
  44       settings->locks[control] = TRUE;
  45     }
  46 }
  47
  48 settings_t *
  49 settings_new     (plugin_desc_t * desc, unsigned long channels, guint32 sample_rate)
  50 {
  51   settings_t * settings;
  52   unsigned long channel;
  53   guint copies;
  54
  55   settings = g_malloc (sizeof (settings_t));
  56   copies = plugin_desc_get_copies (desc, channels);
  57
  58   settings->sample_rate = sample_rate;
  59   settings->desc = desc;
  60   settings->copies = copies;
  61   settings->channels = channels;
  62   settings->lock_all = TRUE;
  63   settings->enabled = FALSE;
  64   settings->locks = NULL;
  65   settings->control_values = NULL;
  66   settings->wet_dry_enabled = FALSE;
  67   settings->wet_dry_locked = TRUE;
  68
  69   /* control settings */
  70   if (desc->control_port_count > 0)
  71     {
  72       guint copy;
  73
  74       settings->locks = g_malloc (sizeof (gboolean) * desc->control_port_count);
  75
  76       settings->control_values = g_malloc (sizeof (LADSPA_Data *) * copies);
  77       for (copy = 0; copy < copies; copy++)
  78         {
  79           settings->control_values[copy] = g_malloc (sizeof (LADSPA_Data) * desc->control_port_count);
  80         }
  81
  82       settings_set_to_default (settings, sample_rate);
  83     }
  84
  85   /* wet/dry settings */
  86   settings->wet_dry_values = g_malloc (sizeof (LADSPA_Data) * channels);
  87   for (channel = 0; channel < channels; channel++)
  88     settings->wet_dry_values[channel] = 1.0;
  89
  90   return settings;
  91 }
  92
  93 settings_t *
  94 settings_dup     (settings_t * other)
  95 {
  96   settings_t * settings;
  97   plugin_desc_t * desc;
  98   unsigned long channel;
  99
 100   settings = g_malloc (sizeof (settings_t));
 101
 102   settings->sample_rate     = other->sample_rate;
 103   settings->desc            = other->desc;
 104   settings->copies          = settings_get_copies (other);
 105   settings->channels        = settings_get_channels (other);
 106   settings->wet_dry_enabled = settings_get_wet_dry_enabled (other);
 107   settings->wet_dry_locked  = settings_get_wet_dry_locked (other);
 108   settings->lock_all        = settings_get_lock_all (other);
 109   settings->enabled         = settings_get_enabled (other);
 110   settings->locks           = NULL;
 111   settings->control_values  = NULL;
 112
 113   desc = other->desc;
 114
 115   if (desc->control_port_count > 0)
 116     {
 117       guint copy;
 118       unsigned long control;
 119
 120       settings->locks = g_malloc (sizeof (gboolean) * desc->control_port_count);
 121       for (control = 0; control < desc->control_port_count; control++)
 122         settings_set_lock (settings, control, settings_get_lock (other, control));
 123
 124       settings->control_values = g_malloc (sizeof (LADSPA_Data *) * settings->copies);
 125       for (copy = 0; copy < settings->copies; copy++)
 126         {
 127           settings->control_values[copy] = g_malloc (sizeof (LADSPA_Data) * desc->control_port_count);
 128
 129           for (control = 0; control < desc->control_port_count; control++)
 130             {
 131               settings->control_values[copy][control] = settings_get_control_value (other, copy, control);
 132             }
 133         }
 134     }
 135
 136   settings->wet_dry_values = g_malloc (sizeof (LADSPA_Data) * settings->channels);
 137   for (channel = 0; channel < settings->channels; channel++)
 138     settings->wet_dry_values[channel] = settings_get_wet_dry_value (other, channel);
 139
 140   return settings;
 141 }
 142
 143 void
 144 settings_destroy (settings_t * settings)
 145 {
 146   if (settings->desc->control_port_count > 0)
 147     {
 148       guint i;
 149       for (i = 0; i < settings->copies; i++)
 150         g_free (settings->control_values[i]);
 151
 152       g_free (settings->control_values);
 153       g_free (settings->locks);
 154     }
 155
 156   g_free (settings->wet_dry_values);
 157
 158   g_free (settings);
 159 }
 160
 161 static void
 162 settings_set_copies (settings_t * settings, guint copies)
 163 {
 164   guint copy;
 165   guint last_copy;
 166   unsigned long control;
 167
 168   if (copies <= settings->copies)
 169     return;
 170
 171   last_copy = settings->copies - 1;
 172
 173   settings->control_values = g_realloc (settings->control_values,
 174                                         sizeof (LADSPA_Data *) * copies);
 175
 176   /* copy over the last settings to the new copies */
 177   for (copy = settings->copies; copy < copies; copy++)
 178     {
 179       for (control = 0; control < settings->desc->control_port_count; control++)
 180         {
 181           settings->control_values[copy][control] =
 182             settings->control_values[last_copy][control];
 183         }
 184     }
 185
 186   settings->copies = copies;
 187 }
 188
 189 static void
 190 settings_set_channels (settings_t * settings, unsigned long channels)
 191 {
 192   unsigned long channel;
 193   LADSPA_Data last_value;
 194
 195   if (channels <= settings->channels)
 196     return;
 197
 198   settings->wet_dry_values = g_realloc (settings->wet_dry_values, sizeof (LADSPA_Data) * channels);
 199
 200   last_value = settings->wet_dry_values[settings->channels - 1];
 201
 202   for (channel = settings->channels; channel < channels; channel++)
 203     settings->wet_dry_values[channel] = last_value;
 204
 205   settings->channels = channels;
 206 }
 207
 208 void
 209 settings_set_sample_rate (settings_t * settings, guint32 sample_rate)
 210 {
 211   LADSPA_Data old_sample_rate;
 212   LADSPA_Data new_sample_rate;
 213
 214   g_return_if_fail (settings != NULL);
 215
 216   if (settings->sample_rate == sample_rate)
 217     return;
 218
 219   if (settings->desc->control_port_count > 0)
 220     {
 221       unsigned long control;
 222       guint copy;
 223
 224       new_sample_rate = (LADSPA_Data) sample_rate;
 225       old_sample_rate = (LADSPA_Data) settings->sample_rate;
 226
 227       for (control = 0; control < settings->desc->control_port_count; control++)
 228         {
 229           for (copy = 0; copy < settings->copies; copy++)
 230             {
 231               if (LADSPA_IS_HINT_SAMPLE_RATE (settings->desc->port_range_hints[control].HintDescriptor))
 232                 {
 233                   settings->control_values[copy][control] =
 234                     (settings->control_values[copy][control] / old_sample_rate) * new_sample_rate;
 235                 }
 236             }
 237         }
 238     }
 239
 240   settings->sample_rate = sample_rate;
 241 }
 242
 243 void
 244 settings_set_control_value (settings_t * settings, guint copy, unsigned long control_index, LADSPA_Data value)
 245 {
 246   g_return_if_fail (settings != NULL);
 247   g_return_if_fail (control_index < settings->desc->control_port_count);
 248
 249   if (copy >= settings->copies)
 250     settings_set_copies (settings, copy + 1);
 251
 252   settings->control_values[copy][control_index] = value;
 253 }
 254
 255 void
 256 settings_set_lock          (settings_t * settings, unsigned long control_index, gboolean locked)
 257 {
 258   g_return_if_fail (settings != NULL);
 259   g_return_if_fail (control_index < settings->desc->control_port_count);
 260
 261   settings->locks[control_index] = locked;
 262 }
 263
 264 void
 265 settings_set_lock_all (settings_t * settings, gboolean lock_all)
 266 {
 267   g_return_if_fail (settings != NULL);
 268
 269   settings->lock_all = lock_all;
 270 }
 271
 272 void
 273 settings_set_enabled (settings_t * settings, gboolean enabled)
 274 {
 275   g_return_if_fail (settings != NULL);
 276
 277   settings->enabled = enabled;
 278 }
 279
 280 void
 281 settings_set_wet_dry_enabled (settings_t * settings, gboolean enabled)
 282 {
 283   g_return_if_fail (settings != NULL);
 284
 285   settings->wet_dry_enabled = enabled;
 286 }
 287
 288 void
 289 settings_set_wet_dry_locked  (settings_t * settings, gboolean locked)
 290 {
 291   g_return_if_fail (settings != NULL);
 292
 293   settings->wet_dry_locked = locked;
 294 }
 295
 296 void
 297 settings_set_wet_dry_value   (settings_t * settings, unsigned long channel, LADSPA_Data value)
 298 {
 299   g_return_if_fail (settings != NULL);
 300
 301   if (channel >= settings->channels)
 302     settings_set_channels (settings, channel + 1);
 303
 304   settings->wet_dry_values[channel] = value;
 305 }
 306
 307
 308 LADSPA_Data
 309 settings_get_control_value (settings_t * settings, guint copy, unsigned long control_index)
 310 {
 311   g_return_val_if_fail (settings != NULL, NAN);
 312   g_return_val_if_fail (control_index < settings->desc->control_port_count, NAN);
 313
 314   if (copy >= settings->copies)
 315     settings_set_copies (settings, copy - 1);
 316
 317   return settings->control_values[copy][control_index];
 318 }
 319
 320 gboolean
 321 settings_get_lock          (const settings_t * settings, unsigned long control_index)
 322 {
 323   g_return_if_fail (settings != NULL);
 324
 325   return settings->locks[control_index];
 326 }
 327
 328 gboolean
 329 settings_get_lock_all      (const settings_t * settings)
 330 {
 331   g_return_if_fail (settings != NULL);
 332
 333   return settings->lock_all;
 334 }
 335
 336 gboolean
 337 settings_get_enabled      (const settings_t * settings)
 338 {
 339   g_return_if_fail (settings != NULL);
 340
 341   return settings->enabled;
 342 }
 343
 344 guint
 345 settings_get_copies        (const settings_t * settings)
 346 {
 347   g_return_if_fail (settings != NULL);
 348
 349   return settings->copies;
 350 }
 351
 352
 353 unsigned long
 354 settings_get_channels        (const settings_t * settings)
 355 {
 356   g_return_if_fail (settings != NULL);
 357
 358   return settings->channels;
 359 }
 360
 361 gboolean
 362 settings_get_wet_dry_enabled (const settings_t * settings)
 363 {
 364   g_return_if_fail (settings != NULL);
 365
 366   return settings->wet_dry_enabled;
 367 }
 368
 369 gboolean
 370 settings_get_wet_dry_locked  (const settings_t * settings)
 371 {
 372   g_return_if_fail (settings != NULL);
 373
 374   return settings->wet_dry_locked;
 375 }
 376
 377 LADSPA_Data
 378 settings_get_wet_dry_value   (settings_t * settings, unsigned long channel)
 379 {
 380   g_return_if_fail (settings != NULL);
 381
 382   if (channel >= settings->channels)
 383     settings_set_channels (settings, channel + 1);
 384
 385   return settings->wet_dry_values[channel];
 386 }
 387
 388
 389
 390 /* EOF */