git.sesse.net Git - nageru/blob - audio_mixer.cpp

   1 #include "audio_mixer.h"
   2
   3 #include <assert.h>
   4 #include <endian.h>
   5 #include <bmusb/bmusb.h>
   6 #include <stdio.h>
   7 #include <endian.h>
   8 #include <cmath>
   9
  10 #include "db.h"
  11 #include "flags.h"
  12 #include "timebase.h"
  13
  14 using namespace bmusb;
  15 using namespace std;
  16 using namespace std::placeholders;
  17
  18 namespace {
  19
  20 // TODO: If these prove to be a bottleneck, they can be SSSE3-optimized
  21 // (usually including multiple channels at a time).
  22
  23 void convert_fixed16_to_fp32(float *dst, size_t out_channel, size_t out_num_channels,
  24                              const uint8_t *src, size_t in_channel, size_t in_num_channels,
  25                              size_t num_samples)
  26 {
  27         assert(in_channel < in_num_channels);
  28         assert(out_channel < out_num_channels);
  29         src += in_channel * 2;
  30         dst += out_channel;
  31
  32         for (size_t i = 0; i < num_samples; ++i) {
  33                 int16_t s = le16toh(*(int16_t *)src);
  34                 *dst = s * (1.0f / 32768.0f);
  35
  36                 src += 2 * in_num_channels;
  37                 dst += out_num_channels;
  38         }
  39 }
  40
  41 void convert_fixed24_to_fp32(float *dst, size_t out_channel, size_t out_num_channels,
  42                              const uint8_t *src, size_t in_channel, size_t in_num_channels,
  43                              size_t num_samples)
  44 {
  45         assert(in_channel < in_num_channels);
  46         assert(out_channel < out_num_channels);
  47         src += in_channel * 3;
  48         dst += out_channel;
  49
  50         for (size_t i = 0; i < num_samples; ++i) {
  51                 uint32_t s1 = src[0];
  52                 uint32_t s2 = src[1];
  53                 uint32_t s3 = src[2];
  54                 uint32_t s = s1 | (s1 << 8) | (s2 << 16) | (s3 << 24);
  55                 *dst = int(s) * (1.0f / 2147483648.0f);
  56
  57                 src += 3 * in_num_channels;
  58                 dst += out_num_channels;
  59         }
  60 }
  61
  62 void convert_fixed32_to_fp32(float *dst, size_t out_channel, size_t out_num_channels,
  63                              const uint8_t *src, size_t in_channel, size_t in_num_channels,
  64                              size_t num_samples)
  65 {
  66         assert(in_channel < in_num_channels);
  67         assert(out_channel < out_num_channels);
  68         src += in_channel * 4;
  69         dst += out_channel;
  70
  71         for (size_t i = 0; i < num_samples; ++i) {
  72                 int32_t s = le32toh(*(int32_t *)src);
  73                 *dst = s * (1.0f / 2147483648.0f);
  74
  75                 src += 4 * in_num_channels;
  76                 dst += out_num_channels;
  77         }
  78 }
  79
  80 float find_peak(const float *samples, size_t num_samples)
  81 {
  82         float m = fabs(samples[0]);
  83         for (size_t i = 1; i < num_samples; ++i) {
  84                 m = max(m, fabs(samples[i]));
  85         }
  86         return m;
  87 }
  88
  89 void deinterleave_samples(const vector<float> &in, vector<float> *out_l, vector<float> *out_r)
  90 {
  91         size_t num_samples = in.size() / 2;
  92         out_l->resize(num_samples);
  93         out_r->resize(num_samples);
  94
  95         const float *inptr = in.data();
  96         float *lptr = &(*out_l)[0];
  97         float *rptr = &(*out_r)[0];
  98         for (size_t i = 0; i < num_samples; ++i) {
  99                 *lptr++ = *inptr++;
 100                 *rptr++ = *inptr++;
 101         }
 102 }
 103
 104 }  // namespace
 105
 106 AudioMixer::AudioMixer(unsigned num_cards)
 107         : num_cards(num_cards),
 108           level_compressor(OUTPUT_FREQUENCY),
 109           limiter(OUTPUT_FREQUENCY),
 110           compressor(OUTPUT_FREQUENCY),
 111           correlation(OUTPUT_FREQUENCY)
 112 {
 113         locut.init(FILTER_HPF, 2);
 114
 115         set_locut_enabled(global_flags.locut_enabled);
 116         set_gain_staging_db(global_flags.initial_gain_staging_db);
 117         set_gain_staging_auto(global_flags.gain_staging_auto);
 118         set_compressor_enabled(global_flags.compressor_enabled);
 119         set_limiter_enabled(global_flags.limiter_enabled);
 120         set_final_makeup_gain_auto(global_flags.final_makeup_gain_auto);
 121
 122         // Generate a very simple, default input mapping.
 123         InputMapping::Bus input;
 124         input.name = "Main";
 125         input.device.type = InputSourceType::CAPTURE_CARD;
 126         input.device.index = 0;
 127         input.source_channel[0] = 0;
 128         input.source_channel[1] = 1;
 129
 130         InputMapping new_input_mapping;
 131         new_input_mapping.buses.push_back(input);
 132         set_input_mapping(new_input_mapping);
 133
 134         // Look for ALSA cards.
 135         available_alsa_cards = ALSAInput::enumerate_devices();
 136
 137         r128.init(2, OUTPUT_FREQUENCY);
 138         r128.integr_start();
 139
 140         // hlen=16 is pretty low quality, but we use quite a bit of CPU otherwise,
 141         // and there's a limit to how important the peak meter is.
 142         peak_resampler.setup(OUTPUT_FREQUENCY, OUTPUT_FREQUENCY * 4, /*num_channels=*/2, /*hlen=*/16, /*frel=*/1.0);
 143 }
 144
 145 AudioMixer::~AudioMixer()
 146 {
 147         for (unsigned card_index = 0; card_index < available_alsa_cards.size(); ++card_index) {
 148                 const AudioDevice &device = alsa_inputs[card_index];
 149                 if (device.alsa_device != nullptr) {
 150                         device.alsa_device->stop_capture_thread();
 151                 }
 152         }
 153 }
 154
 155
 156 void AudioMixer::reset_resampler(DeviceSpec device_spec)
 157 {
 158         lock_guard<timed_mutex> lock(audio_mutex);
 159         reset_resampler_mutex_held(device_spec);
 160 }
 161
 162 void AudioMixer::reset_resampler_mutex_held(DeviceSpec device_spec)
 163 {
 164         AudioDevice *device = find_audio_device(device_spec);
 165
 166         if (device->interesting_channels.empty()) {
 167                 device->resampling_queue.reset();
 168         } else {
 169                 // TODO: ResamplingQueue should probably take the full device spec.
 170                 // (It's only used for console output, though.)
 171                 device->resampling_queue.reset(new ResamplingQueue(device_spec.index, device->capture_frequency, OUTPUT_FREQUENCY, device->interesting_channels.size()));
 172         }
 173         device->next_local_pts = 0;
 174 }
 175
 176 void AudioMixer::reset_alsa_mutex_held(DeviceSpec device_spec)
 177 {
 178         assert(device_spec.type == InputSourceType::ALSA_INPUT);
 179         unsigned card_index = device_spec.index;
 180         AudioDevice *device = find_audio_device(device_spec);
 181
 182         if (device->alsa_device != nullptr) {
 183                 device->alsa_device->stop_capture_thread();
 184         }
 185         if (device->interesting_channels.empty()) {
 186                 device->alsa_device.reset();
 187         } else {
 188                 const ALSAInput::Device &alsa_dev = available_alsa_cards[card_index];
 189                 device->alsa_device.reset(new ALSAInput(alsa_dev.address.c_str(), OUTPUT_FREQUENCY, alsa_dev.num_channels, bind(&AudioMixer::add_audio, this, device_spec, _1, _2, _3, _4)));
 190                 device->capture_frequency = device->alsa_device->get_sample_rate();
 191                 device->alsa_device->start_capture_thread();
 192         }
 193 }
 194
 195 bool AudioMixer::add_audio(DeviceSpec device_spec, const uint8_t *data, unsigned num_samples, AudioFormat audio_format, int64_t frame_length)
 196 {
 197         AudioDevice *device = find_audio_device(device_spec);
 198
 199         unique_lock<timed_mutex> lock(audio_mutex, defer_lock);
 200         if (!lock.try_lock_for(chrono::milliseconds(10))) {
 201                 return false;
 202         }
 203         if (device->resampling_queue == nullptr) {
 204                 // No buses use this device; throw it away.
 205                 return true;
 206         }
 207
 208         unsigned num_channels = device->interesting_channels.size();
 209         assert(num_channels > 0);
 210
 211         // Convert the audio to fp32.
 212         vector<float> audio;
 213         audio.resize(num_samples * num_channels);
 214         unsigned channel_index = 0;
 215         for (auto channel_it = device->interesting_channels.cbegin(); channel_it != device->interesting_channels.end(); ++channel_it, ++channel_index) {
 216                 switch (audio_format.bits_per_sample) {
 217                 case 0:
 218                         assert(num_samples == 0);
 219                         break;
 220                 case 16:
 221                         convert_fixed16_to_fp32(&audio[0], channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
 222                         break;
 223                 case 24:
 224                         convert_fixed24_to_fp32(&audio[0], channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
 225                         break;
 226                 case 32:
 227                         convert_fixed32_to_fp32(&audio[0], channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
 228                         break;
 229                 default:
 230                         fprintf(stderr, "Cannot handle audio with %u bits per sample\n", audio_format.bits_per_sample);
 231                         assert(false);
 232                 }
 233         }
 234
 235         // Now add it.
 236         int64_t local_pts = device->next_local_pts;
 237         device->resampling_queue->add_input_samples(local_pts / double(TIMEBASE), audio.data(), num_samples);
 238         device->next_local_pts = local_pts + frame_length;
 239         return true;
 240 }
 241
 242 bool AudioMixer::add_silence(DeviceSpec device_spec, unsigned samples_per_frame, unsigned num_frames, int64_t frame_length)
 243 {
 244         AudioDevice *device = find_audio_device(device_spec);
 245
 246         unique_lock<timed_mutex> lock(audio_mutex, defer_lock);
 247         if (!lock.try_lock_for(chrono::milliseconds(10))) {
 248                 return false;
 249         }
 250         if (device->resampling_queue == nullptr) {
 251                 // No buses use this device; throw it away.
 252                 return true;
 253         }
 254
 255         unsigned num_channels = device->interesting_channels.size();
 256         assert(num_channels > 0);
 257
 258         vector<float> silence(samples_per_frame * num_channels, 0.0f);
 259         for (unsigned i = 0; i < num_frames; ++i) {
 260                 device->resampling_queue->add_input_samples(device->next_local_pts / double(TIMEBASE), silence.data(), samples_per_frame);
 261                 // Note that if the format changed in the meantime, we have
 262                 // no way of detecting that; we just have to assume the frame length
 263                 // is always the same.
 264                 device->next_local_pts += frame_length;
 265         }
 266         return true;
 267 }
 268
 269 AudioMixer::AudioDevice *AudioMixer::find_audio_device(DeviceSpec device)
 270 {
 271         switch (device.type) {
 272         case InputSourceType::CAPTURE_CARD:
 273                 return &video_cards[device.index];
 274         case InputSourceType::ALSA_INPUT:
 275                 return &alsa_inputs[device.index];
 276         case InputSourceType::SILENCE:
 277         default:
 278                 assert(false);
 279         }
 280         return nullptr;
 281 }
 282
 283 // Get a pointer to the given channel from the given device.
 284 // The channel must be picked out earlier and resampled.
 285 void AudioMixer::find_sample_src_from_device(const map<DeviceSpec, vector<float>> &samples_card, DeviceSpec device_spec, int source_channel, const float **srcptr, unsigned *stride)
 286 {
 287         static float zero = 0.0f;
 288         if (source_channel == -1 || device_spec.type == InputSourceType::SILENCE) {
 289                 *srcptr = &zero;
 290                 *stride = 0;
 291                 return;
 292         }
 293         AudioDevice *device = find_audio_device(device_spec);
 294         assert(device->interesting_channels.count(source_channel) != 0);
 295         unsigned channel_index = 0;
 296         for (int channel : device->interesting_channels) {
 297                 if (channel == source_channel) break;
 298                 ++channel_index;
 299         }
 300         assert(channel_index < device->interesting_channels.size());
 301         const auto it = samples_card.find(device_spec);
 302         assert(it != samples_card.end());
 303         *srcptr = &(it->second)[channel_index];
 304         *stride = device->interesting_channels.size();
 305 }
 306
 307 // TODO: Can be SSSE3-optimized if need be.
 308 void AudioMixer::fill_audio_bus(const map<DeviceSpec, vector<float>> &samples_card, const InputMapping::Bus &bus, unsigned num_samples, float *output)
 309 {
 310         if (bus.device.type == InputSourceType::SILENCE) {
 311                 memset(output, 0, num_samples * sizeof(*output));
 312         } else {
 313                 assert(bus.device.type == InputSourceType::CAPTURE_CARD ||
 314                        bus.device.type == InputSourceType::ALSA_INPUT);
 315                 const float *lsrc, *rsrc;
 316                 unsigned lstride, rstride;
 317                 float *dptr = output;
 318                 find_sample_src_from_device(samples_card, bus.device, bus.source_channel[0], &lsrc, &lstride);
 319                 find_sample_src_from_device(samples_card, bus.device, bus.source_channel[1], &rsrc, &rstride);
 320                 for (unsigned i = 0; i < num_samples; ++i) {
 321                         *dptr++ = *lsrc;
 322                         *dptr++ = *rsrc;
 323                         lsrc += lstride;
 324                         rsrc += rstride;
 325                 }
 326         }
 327 }
 328
 329 vector<float> AudioMixer::get_output(double pts, unsigned num_samples, ResamplingQueue::RateAdjustmentPolicy rate_adjustment_policy)
 330 {
 331         map<DeviceSpec, vector<float>> samples_card;
 332         vector<float> samples_bus;
 333
 334         lock_guard<timed_mutex> lock(audio_mutex);
 335
 336         // Pick out all the interesting channels from all the cards.
 337         // TODO: If the card has been hotswapped, the number of channels
 338         // might have changed; if so, we need to do some sort of remapping
 339         // to silence.
 340         for (const auto &spec_and_info : get_devices_mutex_held()) {
 341                 const DeviceSpec &device_spec = spec_and_info.first;
 342                 AudioDevice *device = find_audio_device(device_spec);
 343                 if (!device->interesting_channels.empty()) {
 344                         samples_card[device_spec].resize(num_samples * device->interesting_channels.size());
 345                         device->resampling_queue->get_output_samples(
 346                                 pts,
 347                                 &samples_card[device_spec][0],
 348                                 num_samples,
 349                                 rate_adjustment_policy);
 350                 }
 351         }
 352
 353         // TODO: Move lo-cut etc. into each bus.
 354         vector<float> samples_out, left, right;
 355         samples_out.resize(num_samples * 2);
 356         samples_bus.resize(num_samples * 2);
 357         for (unsigned bus_index = 0; bus_index < input_mapping.buses.size(); ++bus_index) {
 358                 fill_audio_bus(samples_card, input_mapping.buses[bus_index], num_samples, &samples_bus[0]);
 359
 360                 // TODO: We should measure post-fader.
 361                 deinterleave_samples(samples_bus, &left, &right);
 362                 measure_bus_levels(bus_index, left, right);
 363
 364                 float volume = from_db(fader_volume_db[bus_index]);
 365                 if (bus_index == 0) {
 366                         for (unsigned i = 0; i < num_samples * 2; ++i) {
 367                                 samples_out[i] = samples_bus[i] * volume;
 368                         }
 369                 } else {
 370                         for (unsigned i = 0; i < num_samples * 2; ++i) {
 371                                 samples_out[i] += samples_bus[i] * volume;
 372                         }
 373                 }
 374         }
 375
 376         // Cut away everything under 120 Hz (or whatever the cutoff is);
 377         // we don't need it for voice, and it will reduce headroom
 378         // and confuse the compressor. (In particular, any hums at 50 or 60 Hz
 379         // should be dampened.)
 380         if (locut_enabled) {
 381                 locut.render(samples_out.data(), samples_out.size() / 2, locut_cutoff_hz * 2.0 * M_PI / OUTPUT_FREQUENCY, 0.5f);
 382         }
 383
 384         {
 385                 lock_guard<mutex> lock(compressor_mutex);
 386
 387                 // Apply a level compressor to get the general level right.
 388                 // Basically, if it's over about -40 dBFS, we squeeze it down to that level
 389                 // (or more precisely, near it, since we don't use infinite ratio),
 390                 // then apply a makeup gain to get it to -14 dBFS. -14 dBFS is, of course,
 391                 // entirely arbitrary, but from practical tests with speech, it seems to
 392                 // put ut around -23 LUFS, so it's a reasonable starting point for later use.
 393                 {
 394                         if (level_compressor_enabled) {
 395                                 float threshold = 0.01f;   // -40 dBFS.
 396                                 float ratio = 20.0f;
 397                                 float attack_time = 0.5f;
 398                                 float release_time = 20.0f;
 399                                 float makeup_gain = from_db(ref_level_dbfs - (-40.0f));  // +26 dB.
 400                                 level_compressor.process(samples_out.data(), samples_out.size() / 2, threshold, ratio, attack_time, release_time, makeup_gain);
 401                                 gain_staging_db = to_db(level_compressor.get_attenuation() * makeup_gain);
 402                         } else {
 403                                 // Just apply the gain we already had.
 404                                 float g = from_db(gain_staging_db);
 405                                 for (size_t i = 0; i < samples_out.size(); ++i) {
 406                                         samples_out[i] *= g;
 407                                 }
 408                         }
 409                 }
 410
 411         #if 0
 412                 printf("level=%f (%+5.2f dBFS) attenuation=%f (%+5.2f dB) end_result=%+5.2f dB\n",
 413                         level_compressor.get_level(), to_db(level_compressor.get_level()),
 414                         level_compressor.get_attenuation(), to_db(level_compressor.get_attenuation()),
 415                         to_db(level_compressor.get_level() * level_compressor.get_attenuation() * makeup_gain));
 416         #endif
 417
 418         //      float limiter_att, compressor_att;
 419
 420                 // The real compressor.
 421                 if (compressor_enabled) {
 422                         float threshold = from_db(compressor_threshold_dbfs);
 423                         float ratio = 20.0f;
 424                         float attack_time = 0.005f;
 425                         float release_time = 0.040f;
 426                         float makeup_gain = 2.0f;  // +6 dB.
 427                         compressor.process(samples_out.data(), samples_out.size() / 2, threshold, ratio, attack_time, release_time, makeup_gain);
 428         //              compressor_att = compressor.get_attenuation();
 429                 }
 430
 431                 // Finally a limiter at -4 dB (so, -10 dBFS) to take out the worst peaks only.
 432                 // Note that since ratio is not infinite, we could go slightly higher than this.
 433                 if (limiter_enabled) {
 434                         float threshold = from_db(limiter_threshold_dbfs);
 435                         float ratio = 30.0f;
 436                         float attack_time = 0.0f;  // Instant.
 437                         float release_time = 0.020f;
 438                         float makeup_gain = 1.0f;  // 0 dB.
 439                         limiter.process(samples_out.data(), samples_out.size() / 2, threshold, ratio, attack_time, release_time, makeup_gain);
 440         //              limiter_att = limiter.get_attenuation();
 441                 }
 442
 443         //      printf("limiter=%+5.1f  compressor=%+5.1f\n", to_db(limiter_att), to_db(compressor_att));
 444         }
 445
 446         // At this point, we are most likely close to +0 LU, but all of our
 447         // measurements have been on raw sample values, not R128 values.
 448         // So we have a final makeup gain to get us to +0 LU; the gain
 449         // adjustments required should be relatively small, and also, the
 450         // offset shouldn't change much (only if the type of audio changes
 451         // significantly). Thus, we shoot for updating this value basically
 452         // “whenever we process buffers”, since the R128 calculation isn't exactly
 453         // something we get out per-sample.
 454         //
 455         // Note that there's a feedback loop here, so we choose a very slow filter
 456         // (half-time of 30 seconds).
 457         double target_loudness_factor, alpha;
 458         double loudness_lu = r128.loudness_M() - ref_level_lufs;
 459         double current_makeup_lu = to_db(final_makeup_gain);
 460         target_loudness_factor = final_makeup_gain * from_db(-loudness_lu);
 461
 462         // If we're outside +/- 5 LU uncorrected, we don't count it as
 463         // a normal signal (probably silence) and don't change the
 464         // correction factor; just apply what we already have.
 465         if (fabs(loudness_lu - current_makeup_lu) >= 5.0 || !final_makeup_gain_auto) {
 466                 alpha = 0.0;
 467         } else {
 468                 // Formula adapted from
 469                 // https://en.wikipedia.org/wiki/Low-pass_filter#Simple_infinite_impulse_response_filter.
 470                 const double half_time_s = 30.0;
 471                 const double fc_mul_2pi_delta_t = 1.0 / (half_time_s * OUTPUT_FREQUENCY);
 472                 alpha = fc_mul_2pi_delta_t / (fc_mul_2pi_delta_t + 1.0);
 473         }
 474
 475         {
 476                 lock_guard<mutex> lock(compressor_mutex);
 477                 double m = final_makeup_gain;
 478                 for (size_t i = 0; i < samples_out.size(); i += 2) {
 479                         samples_out[i + 0] *= m;
 480                         samples_out[i + 1] *= m;
 481                         m += (target_loudness_factor - m) * alpha;
 482                 }
 483                 final_makeup_gain = m;
 484         }
 485
 486         update_meters(samples_out);
 487
 488         return samples_out;
 489 }
 490
 491 void AudioMixer::measure_bus_levels(unsigned bus_index, const vector<float> &left, const vector<float> &right)
 492 {
 493         const float *ptrs[] = { left.data(), right.data() };
 494         {
 495                 lock_guard<mutex> lock(audio_measure_mutex);
 496                 bus_r128[bus_index]->process(left.size(), const_cast<float **>(ptrs));
 497         }
 498 }
 499
 500 void AudioMixer::update_meters(const vector<float> &samples)
 501 {
 502         // Upsample 4x to find interpolated peak.
 503         peak_resampler.inp_data = const_cast<float *>(samples.data());
 504         peak_resampler.inp_count = samples.size() / 2;
 505
 506         vector<float> interpolated_samples;
 507         interpolated_samples.resize(samples.size());
 508         {
 509                 lock_guard<mutex> lock(audio_measure_mutex);
 510
 511                 while (peak_resampler.inp_count > 0) {  // About four iterations.
 512                         peak_resampler.out_data = &interpolated_samples[0];
 513                         peak_resampler.out_count = interpolated_samples.size() / 2;
 514                         peak_resampler.process();
 515                         size_t out_stereo_samples = interpolated_samples.size() / 2 - peak_resampler.out_count;
 516                         peak = max<float>(peak, find_peak(interpolated_samples.data(), out_stereo_samples * 2));
 517                         peak_resampler.out_data = nullptr;
 518                 }
 519         }
 520
 521         // Find R128 levels and L/R correlation.
 522         vector<float> left, right;
 523         deinterleave_samples(samples, &left, &right);
 524         float *ptrs[] = { left.data(), right.data() };
 525         {
 526                 lock_guard<mutex> lock(audio_measure_mutex);
 527                 r128.process(left.size(), ptrs);
 528                 correlation.process_samples(samples);
 529         }
 530
 531         send_audio_level_callback();
 532 }
 533
 534 void AudioMixer::reset_meters()
 535 {
 536         lock_guard<mutex> lock(audio_measure_mutex);
 537         peak_resampler.reset();
 538         peak = 0.0f;
 539         r128.reset();
 540         r128.integr_start();
 541         correlation.reset();
 542 }
 543
 544 void AudioMixer::send_audio_level_callback()
 545 {
 546         if (audio_level_callback == nullptr) {
 547                 return;
 548         }
 549
 550         lock_guard<mutex> lock(audio_measure_mutex);
 551         double loudness_s = r128.loudness_S();
 552         double loudness_i = r128.integrated();
 553         double loudness_range_low = r128.range_min();
 554         double loudness_range_high = r128.range_max();
 555
 556         vector<float> bus_loudness;
 557         bus_loudness.resize(input_mapping.buses.size());
 558         for (unsigned bus_index = 0; bus_index < bus_r128.size(); ++bus_index) {
 559                 bus_loudness[bus_index] = bus_r128[bus_index]->loudness_S();
 560         }
 561
 562         audio_level_callback(loudness_s, to_db(peak), bus_loudness,
 563                 loudness_i, loudness_range_low, loudness_range_high,
 564                 gain_staging_db,
 565                 to_db(final_makeup_gain),
 566                 correlation.get_correlation());
 567 }
 568
 569 map<DeviceSpec, DeviceInfo> AudioMixer::get_devices() const
 570 {
 571         lock_guard<timed_mutex> lock(audio_mutex);
 572         return get_devices_mutex_held();
 573 }
 574
 575 map<DeviceSpec, DeviceInfo> AudioMixer::get_devices_mutex_held() const
 576 {
 577         map<DeviceSpec, DeviceInfo> devices;
 578         for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
 579                 const DeviceSpec spec{ InputSourceType::CAPTURE_CARD, card_index };
 580                 const AudioDevice *device = &video_cards[card_index];
 581                 DeviceInfo info;
 582                 info.name = device->name;
 583                 info.num_channels = 8;  // FIXME: This is wrong for fake cards.
 584                 devices.insert(make_pair(spec, info));
 585         }
 586         for (unsigned card_index = 0; card_index < available_alsa_cards.size(); ++card_index) {
 587                 const DeviceSpec spec{ InputSourceType::ALSA_INPUT, card_index };
 588                 const ALSAInput::Device &device = available_alsa_cards[card_index];
 589                 DeviceInfo info;
 590                 info.name = device.name + " (" + device.info + ")";
 591                 info.num_channels = device.num_channels;
 592                 devices.insert(make_pair(spec, info));
 593         }
 594         return devices;
 595 }
 596
 597 void AudioMixer::set_name(DeviceSpec device_spec, const string &name)
 598 {
 599         AudioDevice *device = find_audio_device(device_spec);
 600
 601         lock_guard<timed_mutex> lock(audio_mutex);
 602         device->name = name;
 603 }
 604
 605 void AudioMixer::set_input_mapping(const InputMapping &new_input_mapping)
 606 {
 607         lock_guard<timed_mutex> lock(audio_mutex);
 608
 609         map<DeviceSpec, set<unsigned>> interesting_channels;
 610         for (const InputMapping::Bus &bus : new_input_mapping.buses) {
 611                 if (bus.device.type == InputSourceType::CAPTURE_CARD ||
 612                     bus.device.type == InputSourceType::ALSA_INPUT) {
 613                         for (unsigned channel = 0; channel < 2; ++channel) {
 614                                 if (bus.source_channel[channel] != -1) {
 615                                         interesting_channels[bus.device].insert(bus.source_channel[channel]);
 616                                 }
 617                         }
 618                 }
 619         }
 620
 621         // Reset resamplers for all cards that don't have the exact same state as before.
 622         for (const auto &spec_and_info : get_devices_mutex_held()) {
 623                 const DeviceSpec &device_spec = spec_and_info.first;
 624                 AudioDevice *device = find_audio_device(device_spec);
 625                 if (device->interesting_channels != interesting_channels[device_spec]) {
 626                         device->interesting_channels = interesting_channels[device_spec];
 627                         if (device_spec.type == InputSourceType::ALSA_INPUT) {
 628                                 reset_alsa_mutex_held(device_spec);
 629                         }
 630                         reset_resampler_mutex_held(device_spec);
 631                 }
 632         }
 633
 634         {
 635                 lock_guard<mutex> lock(audio_measure_mutex);
 636                 bus_r128.resize(new_input_mapping.buses.size());
 637                 for (unsigned bus_index = 0; bus_index < bus_r128.size(); ++bus_index) {
 638                         if (bus_r128[bus_index] == nullptr) {
 639                                 bus_r128[bus_index].reset(new Ebu_r128_proc);
 640                         }
 641                         bus_r128[bus_index]->init(2, OUTPUT_FREQUENCY);
 642                 }
 643         }
 644
 645         input_mapping = new_input_mapping;
 646 }
 647
 648 InputMapping AudioMixer::get_input_mapping() const
 649 {
 650         lock_guard<timed_mutex> lock(audio_mutex);
 651         return input_mapping;
 652 }