scale.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   This file is part of jack_mixer
   5  *
   6  *   Copyright (C) 2006 Nedko Arnaudov <nedko@arnaudov.name>
   7  *
   8  *   This program is free software; you can redistribute it and/or modify
   9  *   it under the terms of the GNU General Public License as published by
  10  *   the Free Software Foundation; version 2 of the License
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  *****************************************************************************/
  22
  23 #include <stddef.h>
  24 #include <stdbool.h>
  25 #include <stdlib.h>
  26 #include <math.h>
  27 #include <assert.h>
  28
  29 #include "jack_mixer.h"
  30 //#define LOG_LEVEL LOG_LEVEL_DEBUG
  31 #include "log.h"
  32 #include "list.h"
  33
  34 struct threshold
  35 {
  36   struct list_head scale_siblings;
  37   double db;
  38   double scale;
  39   double a;
  40   double b;
  41 };
  42
  43 struct scale
  44 {
  45   struct list_head thresholds;
  46   double max_db;
  47 };
  48
  49 jack_mixer_scale_t
  50 scale_create()
  51 {
  52   struct scale * scale_ptr;
  53
  54   scale_ptr = malloc(sizeof(struct scale));
  55   if (scale_ptr == NULL)
  56   {
  57     return NULL;
  58   }
  59
  60   INIT_LIST_HEAD(&scale_ptr->thresholds);
  61   scale_ptr->max_db = -INFINITY;
  62
  63   LOG_DEBUG("Scale %p created", scale_ptr);
  64
  65   return (jack_mixer_scale_t)scale_ptr;
  66 }
  67
  68 #define scale_ptr ((struct scale *)scale)
  69
  70 void
  71 scale_destroy(
  72   jack_mixer_scale_t scale)
  73 {
  74   free(scale_ptr);
  75 }
  76
  77 bool
  78 scale_add_threshold(
  79   jack_mixer_scale_t scale,
  80   float db,
  81   float scale_value)
  82 {
  83   struct threshold * threshold_ptr;
  84
  85   LOG_DEBUG("Adding threshold (%f dBFS -> %f) to scale %p", db, scale, scale_ptr);
  86
  87   threshold_ptr = malloc(sizeof(struct threshold));
  88   LOG_DEBUG("Threshold %p created ", threshold_ptr, db, scale);
  89
  90   if (threshold_ptr == NULL)
  91   {
  92     return false;
  93   }
  94
  95   threshold_ptr->db = db;
  96   threshold_ptr->scale = scale_value;
  97
  98   list_add_tail(&threshold_ptr->scale_siblings, &scale_ptr->thresholds);
  99
 100   if (db > scale_ptr->max_db)
 101   {
 102     scale_ptr->max_db = db;
 103   }
 104
 105   return true;
 106 }
 107
 108 #undef threshold_ptr
 109
 110 void
 111 scale_calculate_coefficients(
 112   jack_mixer_scale_t scale)
 113 {
 114   struct threshold * threshold_ptr;
 115   struct threshold * prev_ptr;
 116   struct list_head * node_ptr;
 117
 118   prev_ptr = NULL;
 119
 120   list_for_each(node_ptr, &scale_ptr->thresholds)
 121   {
 122     threshold_ptr = list_entry(node_ptr, struct threshold, scale_siblings);
 123
 124     LOG_DEBUG("Calculating coefficients for threshold %p", threshold_ptr);
 125
 126     if (prev_ptr != NULL)
 127     {
 128       threshold_ptr->a = (prev_ptr->scale - threshold_ptr->scale) / (prev_ptr->db - threshold_ptr->db);
 129       threshold_ptr->b = threshold_ptr->scale - threshold_ptr->a * threshold_ptr->db;
 130       LOG_DEBUG("%.0f dB - %.0f dB: scale = %f * dB + %f", prev_ptr->db, threshold_ptr->db, threshold_ptr->a, threshold_ptr->b);
 131     }
 132
 133     prev_ptr = threshold_ptr;
 134   }
 135 }
 136
 137 /* Convert dBFS value to number in range 0.0-1.0 */
 138 double
 139 scale_db_to_scale(
 140   jack_mixer_scale_t scale,
 141   double db)
 142 {
 143   struct threshold * threshold_ptr;
 144   struct threshold * prev_ptr;
 145   struct list_head * node_ptr;
 146
 147   prev_ptr = NULL;
 148
 149   list_for_each(node_ptr, &scale_ptr->thresholds)
 150   {
 151     threshold_ptr = list_entry(node_ptr, struct threshold, scale_siblings);
 152
 153     if (db < threshold_ptr->db)
 154     {
 155       LOG_DEBUG("Match at %f dB treshold", threshold_ptr->db);
 156       if (prev_ptr == NULL)
 157       {
 158         return 0.0;
 159       }
 160
 161       return threshold_ptr->a * db + threshold_ptr->b;
 162     }
 163
 164     prev_ptr = threshold_ptr;
 165   }
 166
 167   return 1.0;
 168 }
 169
 170 /* Convert number in range 0.0-1.0 to dBFS value */
 171 double
 172 scale_scale_to_db(
 173   jack_mixer_scale_t scale,
 174   double scale_value)
 175 {
 176   struct threshold * threshold_ptr;
 177   struct threshold * prev_ptr;
 178   struct list_head * node_ptr;
 179
 180   prev_ptr = NULL;
 181
 182   list_for_each(node_ptr, &scale_ptr->thresholds)
 183   {
 184     threshold_ptr = list_entry(node_ptr, struct threshold, scale_siblings);
 185
 186     if (scale_value <= threshold_ptr->scale)
 187     {
 188       if (prev_ptr == NULL)
 189       {
 190         return -INFINITY;
 191       }
 192
 193       return (scale_value - threshold_ptr->b) / threshold_ptr->a;
 194     }
 195
 196     prev_ptr = threshold_ptr;
 197   }
 198
 199   return scale_ptr->max_db;
 200 }