jack_mixer.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 <stdlib.h>
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <math.h>
  27 #include <jack/jack.h>
  28
  29 #include "jack_mixer.h"
  30 #include "list.h"
  31
  32 jack_client_t * g_jack_client;
  33
  34 #define PEAK_FRAMES_CHUNK 4800
  35
  36 struct list_head g_channels_list;
  37
  38 struct channel
  39 {
  40   struct list_head siblings;
  41   char * name;
  42   int stereo;                   /* boolean */
  43   float volume;
  44   float balance;
  45   int muted;
  46   int soloed;
  47   float volume_left;
  48   float volume_right;
  49   float meter_left;
  50   float meter_right;
  51   float abspeak;
  52   jack_port_t * port_left;
  53   jack_port_t * port_right;
  54
  55   jack_nframes_t peak_frames;
  56   float peak_left;
  57   float peak_right;
  58 };
  59
  60 struct channel g_main_mix_channel;
  61
  62 int g_channels_count;
  63 int g_soloed_channels_count;
  64
  65 float value_to_db(float value)
  66 {
  67   if (value <= 0)
  68   {
  69     return -INFINITY;
  70   }
  71
  72   return 20.0 * log10f(value);
  73 }
  74
  75 float db_to_value(float db)
  76 {
  77   return powf(10.0, db/20.0);
  78 }
  79
  80 void * get_main_mix_channel()
  81 {
  82   return &g_main_mix_channel;
  83 }
  84
  85 int get_channels_count()
  86 {
  87   return g_channels_count;
  88 }
  89
  90 void
  91 calc_channel_volumes(struct channel * channel_ptr)
  92 {
  93   if (channel_ptr->muted)
  94   {
  95     channel_ptr->volume_left = 0;
  96     channel_ptr->volume_right = 0;
  97     return;
  98   }
  99
 100   if (g_soloed_channels_count > 0 && !channel_ptr->soloed) /* there are soloed channels but we are not one of them */
 101   {
 102     channel_ptr->volume_left = 0;
 103     channel_ptr->volume_right = 0;
 104     return;
 105   }
 106
 107   if (channel_ptr->stereo)
 108   {
 109     if (channel_ptr->balance > 0)
 110     {
 111       channel_ptr->volume_left = channel_ptr->volume * (1 - channel_ptr->balance);
 112       channel_ptr->volume_right = channel_ptr->volume;
 113     }
 114     else
 115     {
 116       channel_ptr->volume_left = channel_ptr->volume;
 117       channel_ptr->volume_right = channel_ptr->volume * (1 + channel_ptr->balance);
 118     }
 119   }
 120   else
 121   {
 122     channel_ptr->volume_left = channel_ptr->volume * (1 - channel_ptr->balance);
 123     channel_ptr->volume_right = channel_ptr->volume * (1 + channel_ptr->balance);
 124   }
 125 }
 126
 127 void
 128 calc_all_channel_volumes()
 129 {
 130   struct list_head * node_ptr;
 131   struct channel * channel_ptr;
 132
 133   list_for_each(node_ptr, &g_channels_list)
 134   {
 135     channel_ptr = list_entry(node_ptr, struct channel, siblings);
 136     calc_channel_volumes(channel_ptr);
 137   }
 138 }
 139
 140 void * add_channel(const char * channel_name, int stereo)
 141 {
 142   struct channel * channel_ptr;
 143   char * port_name;
 144   size_t channel_name_size;
 145
 146   channel_ptr = malloc(sizeof(struct channel));
 147   if (channel_ptr == NULL)
 148   {
 149     goto exit;
 150   }
 151
 152   channel_ptr->name = strdup(channel_name);
 153   if (channel_ptr->name == NULL)
 154   {
 155     goto exit_free_channel;
 156   }
 157
 158   if (stereo)
 159   {
 160     channel_name_size = strlen(channel_name);
 161     port_name = malloc(channel_name_size + 3);
 162     memcpy(port_name, channel_name, channel_name_size);
 163     port_name[channel_name_size] = ' ';
 164     port_name[channel_name_size+1] = 'L';
 165     port_name[channel_name_size+2] = 0;
 166     channel_ptr->port_left = jack_port_register(g_jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 167     port_name[channel_name_size+1] = 'R';
 168     channel_ptr->port_right = jack_port_register(g_jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 169     free(port_name);
 170   }
 171   else
 172   {
 173     channel_ptr->port_left = jack_port_register(g_jack_client, channel_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 174   }
 175
 176   channel_ptr->stereo = stereo;
 177
 178   channel_ptr->volume = 0.0;
 179   channel_ptr->balance = 0.0;
 180   channel_ptr->muted = 0;
 181   channel_ptr->soloed = 0;
 182   channel_ptr->meter_left = -1.0;
 183   channel_ptr->meter_right = -1.0;
 184   channel_ptr->abspeak = 0.0;
 185
 186   channel_ptr->peak_left = 0.0;
 187   channel_ptr->peak_right = 0.0;
 188   channel_ptr->peak_frames = 0;
 189
 190   calc_channel_volumes(channel_ptr);
 191
 192   list_add_tail(&channel_ptr->siblings, &g_channels_list);
 193   g_channels_count++;
 194
 195   goto exit;
 196
 197 exit_free_channel:
 198   free(channel_ptr);
 199
 200 exit:
 201   return channel_ptr;
 202 }
 203
 204 #define channel_ptr ((struct channel *)channel)
 205
 206 const char * channel_get_name(void * channel)
 207 {
 208   return channel_ptr->name;
 209 }
 210
 211 void channel_rename(void * channel, const char * name)
 212 {
 213   char * new_name;
 214   size_t channel_name_size;
 215   char * port_name;
 216   int ret;
 217
 218   new_name = strdup(name);
 219   if (new_name == NULL)
 220   {
 221     return;
 222   }
 223
 224   if (channel_ptr->name)
 225   {
 226     free(channel_ptr->name);
 227   }
 228
 229   channel_ptr->name = new_name;
 230
 231   if (channel_ptr->stereo)
 232   {
 233     channel_name_size = strlen(name);
 234     port_name = malloc(channel_name_size + 3);
 235     memcpy(port_name, name, channel_name_size);
 236
 237     port_name[channel_name_size] = ' ';
 238     port_name[channel_name_size+1] = 'L';
 239     port_name[channel_name_size+2] = 0;
 240
 241     ret = jack_port_set_name(channel_ptr->port_left, port_name);
 242     if (ret != 0)
 243     {
 244       /* what could we do here? */
 245     }
 246
 247     port_name[channel_name_size+1] = 'R';
 248
 249     ret = jack_port_set_name(channel_ptr->port_right, port_name);
 250     if (ret != 0)
 251     {
 252       /* what could we do here? */
 253     }
 254
 255     free(port_name);
 256   }
 257   else
 258   {
 259     ret = jack_port_set_name(channel_ptr->port_left, port_name);
 260     if (ret != 0)
 261     {
 262       /* what could we do here? */
 263     }
 264   }
 265 }
 266
 267 int channel_is_stereo(void * channel)
 268 {
 269   return channel_ptr->stereo;
 270 }
 271
 272 void remove_channel(void * channel)
 273 {
 274   list_del(&channel_ptr->siblings);
 275   free(channel_ptr->name);
 276
 277   jack_port_unregister(g_jack_client, channel_ptr->port_left);
 278   if (channel_ptr->stereo)
 279   {
 280     jack_port_unregister(g_jack_client, channel_ptr->port_right);
 281   }
 282
 283   free(channel_ptr);
 284
 285   g_channels_count--;
 286 }
 287
 288 void channel_stereo_meter_read(void * channel, double * left_ptr, double * right_ptr)
 289 {
 290   *left_ptr = value_to_db(channel_ptr->meter_left);
 291   *right_ptr = value_to_db(channel_ptr->meter_right);
 292 }
 293
 294 void channel_mono_meter_read(void * channel, double * mono_ptr)
 295 {
 296   *mono_ptr = value_to_db(channel_ptr->meter_left);
 297 }
 298
 299 void channel_volume_write(void * channel, double volume)
 300 {
 301   channel_ptr->volume = db_to_value(volume);
 302   calc_channel_volumes(channel_ptr);
 303 }
 304
 305 void channel_balance_write(void * channel, double balance)
 306 {
 307   channel_ptr->balance = balance;
 308   calc_channel_volumes(channel_ptr);
 309 }
 310
 311 double channel_abspeak_read(void * channel)
 312 {
 313   return value_to_db(channel_ptr->abspeak);
 314 }
 315
 316 void channel_abspeak_reset(void * channel)
 317 {
 318   channel_ptr->abspeak = 0;
 319 }
 320
 321 void channel_mute(void * channel)
 322 {
 323   channel_ptr->muted = 1;
 324   calc_channel_volumes(channel_ptr);
 325 }
 326
 327 void channel_unmute(void * channel)
 328 {
 329   channel_ptr->muted = 0;
 330   calc_channel_volumes(channel_ptr);
 331 }
 332
 333 void channel_solo(void * channel)
 334 {
 335   if (!channel_ptr->soloed)
 336   {
 337     channel_ptr->soloed = 1;
 338     g_soloed_channels_count++;
 339
 340     if (g_soloed_channels_count == 1)
 341     {
 342       calc_all_channel_volumes();
 343     }
 344     else
 345     {
 346       calc_channel_volumes(channel_ptr);
 347     }
 348   }
 349 }
 350
 351 void channel_unsolo(void * channel)
 352 {
 353   if (channel_ptr->soloed)
 354   {
 355     channel_ptr->soloed = 0;
 356     g_soloed_channels_count--;
 357
 358     if (g_soloed_channels_count == 0)
 359     {
 360       calc_all_channel_volumes();
 361     }
 362     else
 363     {
 364       calc_channel_volumes(channel_ptr);
 365     }
 366   }
 367 }
 368
 369 int channel_is_muted(void * channel)
 370 {
 371   return channel_ptr->muted;
 372 }
 373
 374 int channel_is_soloed(void * channel)
 375 {
 376   return channel_ptr->soloed;
 377 }
 378
 379 #undef channel_ptr
 380
 381 int
 382 process(jack_nframes_t nframes, void *arg)
 383 {
 384   jack_default_audio_sample_t * out_left;
 385   jack_default_audio_sample_t * out_right;
 386   jack_default_audio_sample_t * in_left;
 387   jack_default_audio_sample_t * in_right;
 388   jack_nframes_t i;
 389   struct list_head * node_ptr;
 390   struct channel * channel_ptr;
 391   jack_default_audio_sample_t frame_left;
 392   jack_default_audio_sample_t frame_right;
 393
 394   out_left = jack_port_get_buffer(g_main_mix_channel.port_left, nframes);
 395   out_right = jack_port_get_buffer(g_main_mix_channel.port_right, nframes);
 396
 397   for (i = 0 ; i < nframes ; i++)
 398   {
 399     out_left[i] = 0.0;
 400     out_right[i] = 0.0;
 401   }
 402
 403   /* process input channels and mix them into main mix */
 404   list_for_each(node_ptr, &g_channels_list)
 405   {
 406     channel_ptr = list_entry(node_ptr, struct channel, siblings);
 407
 408     in_left = jack_port_get_buffer(channel_ptr->port_left, nframes);
 409
 410     if (channel_ptr->stereo)
 411     {
 412       in_right = jack_port_get_buffer(channel_ptr->port_right, nframes);
 413     }
 414
 415     for (i = 0 ; i < nframes ; i++)
 416     {
 417       frame_left = in_left[i] * channel_ptr->volume_left;
 418       out_left[i] += frame_left;
 419
 420       if (channel_ptr->stereo)
 421       {
 422         frame_right = in_right[i] * channel_ptr->volume_right;
 423       }
 424       else
 425       {
 426         frame_right = in_left[i] * channel_ptr->volume_right;
 427       }
 428       out_right[i] += frame_right;
 429
 430       if (channel_ptr->stereo)
 431       {
 432         frame_left = fabsf(frame_left);
 433         frame_right = fabsf(frame_right);
 434
 435         if (channel_ptr->peak_left < frame_left)
 436         {
 437           channel_ptr->peak_left = frame_left;
 438
 439           if (frame_left > channel_ptr->abspeak)
 440           {
 441             channel_ptr->abspeak = frame_left;
 442           }
 443         }
 444
 445         if (channel_ptr->peak_right < frame_right)
 446         {
 447           channel_ptr->peak_right = frame_right;
 448
 449           if (frame_right > channel_ptr->abspeak)
 450           {
 451             channel_ptr->abspeak = frame_right;
 452           }
 453         }
 454       }
 455       else
 456       {
 457         frame_left = (fabsf(frame_left) + fabsf(frame_right)) / 2;
 458
 459         if (channel_ptr->peak_left < frame_left)
 460         {
 461           channel_ptr->peak_left = frame_left;
 462
 463           if (frame_left > channel_ptr->abspeak)
 464           {
 465             channel_ptr->abspeak = frame_left;
 466           }
 467         }
 468       }
 469
 470       channel_ptr->peak_frames++;
 471       if (channel_ptr->peak_frames >= PEAK_FRAMES_CHUNK)
 472       {
 473         channel_ptr->meter_left = channel_ptr->peak_left;
 474         channel_ptr->peak_left = 0.0;
 475
 476         if (channel_ptr->stereo)
 477         {
 478           channel_ptr->meter_right = channel_ptr->peak_right;
 479           channel_ptr->peak_right = 0.0;
 480         }
 481
 482         channel_ptr->peak_frames = 0;
 483       }
 484     }
 485   }
 486
 487   /* process main mix channel */
 488   for (i = 0 ; i < nframes ; i++)
 489   {
 490     out_left[i] = out_left[i] * g_main_mix_channel.volume_left;
 491     out_right[i] = out_right[i] * g_main_mix_channel.volume_right;
 492
 493     frame_left = fabsf(out_left[i]);
 494     if (g_main_mix_channel.peak_left < frame_left)
 495     {
 496       g_main_mix_channel.peak_left = frame_left;
 497
 498       if (frame_left > g_main_mix_channel.abspeak)
 499       {
 500         g_main_mix_channel.abspeak = frame_left;
 501       }
 502     }
 503
 504     frame_right = fabsf(out_right[i]);
 505     if (g_main_mix_channel.peak_right < frame_right)
 506     {
 507       g_main_mix_channel.peak_right = frame_right;
 508
 509       if (frame_right > g_main_mix_channel.abspeak)
 510       {
 511         g_main_mix_channel.abspeak = frame_right;
 512       }
 513     }
 514
 515     g_main_mix_channel.peak_frames++;
 516     if (g_main_mix_channel.peak_frames >= PEAK_FRAMES_CHUNK)
 517     {
 518       g_main_mix_channel.meter_left = g_main_mix_channel.peak_left;
 519       g_main_mix_channel.peak_left = 0.0;
 520
 521       g_main_mix_channel.meter_right = g_main_mix_channel.peak_right;
 522       g_main_mix_channel.peak_right = 0.0;
 523
 524       g_main_mix_channel.peak_frames = 0;
 525     }
 526   }
 527
 528   return 0;
 529 }
 530
 531 int init(const char * jack_client_name_ptr)
 532 {
 533   int ret;
 534
 535   INIT_LIST_HEAD(&g_channels_list);
 536
 537   printf("Initializing JACK\n");
 538   g_jack_client = jack_client_new(jack_client_name_ptr);
 539   if (g_jack_client == NULL)
 540   {
 541     fprintf(stderr, "Cannot create JACK client.\n");
 542     fprintf(stderr, "Please make sure JACK daemon is running.\n");
 543     goto exit;
 544   }
 545
 546   printf("JACK client created\n");
 547
 548   printf("Sample rate: %" PRIu32 "\n", jack_get_sample_rate(g_jack_client));
 549
 550   g_main_mix_channel.port_left = jack_port_register(g_jack_client, "main out L", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 551   if (g_main_mix_channel.port_left == NULL)
 552   {
 553     fprintf(stderr, "Cannot create JACK port");
 554     goto close_jack;
 555   }
 556
 557   g_main_mix_channel.port_right = jack_port_register(g_jack_client, "main out R", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 558   if (g_main_mix_channel.port_right == NULL)
 559   {
 560     fprintf(stderr, "Cannot create JACK port");
 561     goto close_jack;
 562   }
 563
 564   g_main_mix_channel.stereo = 1; /* true */
 565
 566   g_main_mix_channel.volume = 0.0;
 567   g_main_mix_channel.balance = 0.0;
 568   g_main_mix_channel.muted = 0;
 569   g_main_mix_channel.soloed = 0;
 570   g_main_mix_channel.meter_left = 0.0;
 571   g_main_mix_channel.meter_right = 0.0;
 572   g_main_mix_channel.abspeak = 0.0;
 573
 574   g_main_mix_channel.peak_left = 0.0;
 575   g_main_mix_channel.peak_right = 0.0;
 576   g_main_mix_channel.peak_frames = 0;
 577
 578   calc_channel_volumes(&g_main_mix_channel);
 579
 580         ret = jack_set_process_callback(g_jack_client, process, NULL);
 581   if (ret != 0)
 582   {
 583     fprintf(stderr, "Cannot set JACK process callback");
 584     goto close_jack;
 585   }
 586
 587   ret = jack_activate(g_jack_client);
 588   if (ret != 0)
 589   {
 590     fprintf(stderr, "Cannot activate JACK client");
 591     goto close_jack;
 592   }
 593
 594   return 1;                     /* true */
 595
 596 close_jack:
 597   jack_client_close(g_jack_client); /* this should clear all other resources we obtained through the client handle */
 598
 599 exit:
 600   return 0;                     /* false */
 601 }
 602
 603 void uninit()
 604 {
 605   printf("Uninitializing JACK\n");
 606   if (g_jack_client != NULL)
 607   {
 608     jack_client_close(g_jack_client);
 609   }
 610 }