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