git.sesse.net Git - mlt/blob - src/modules/jackrack/plugin_settings.c

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