X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.cpp;h=780bd52573c3380404cd77a36aa1892bfa8642cf;hb=02f65224836f4e7ccecfb89ccd8dc38ee32f319a;hp=4035ea67351ec5abafd10337e538951910d26363;hpb=073bf315bd97c445e3e66e40d194881bbbaf9c85;p=nageru diff --git a/mixer.cpp b/mixer.cpp index 4035ea6..780bd52 100644 --- a/mixer.cpp +++ b/mixer.cpp @@ -14,73 +14,51 @@ #include #include #include -#include -#include +#include #include -#include +#include #include #include +#include #include #include +#include #include #include #include #include -#include -#include -#include +#include "DeckLinkAPI.h" +#include "LinuxCOM.h" +#include "alsa_output.h" #include "bmusb/bmusb.h" +#include "bmusb/fake_capture.h" #include "context.h" #include "decklink_capture.h" #include "defs.h" -#include "fake_capture.h" +#include "disk_space_estimator.h" #include "flags.h" -#include "video_encoder.h" +#include "input_mapping.h" #include "pbo_frame_allocator.h" #include "ref_counted_gl_sync.h" +#include "resampling_queue.h" #include "timebase.h" +#include "video_encoder.h" +class IDeckLink; class QOpenGLContext; using namespace movit; using namespace std; +using namespace std::chrono; using namespace std::placeholders; +using namespace bmusb; Mixer *global_mixer = nullptr; bool uses_mlock = false; namespace { -void convert_fixed24_to_fp32(float *dst, size_t out_channels, const uint8_t *src, size_t in_channels, size_t num_samples) -{ - assert(in_channels >= out_channels); - for (size_t i = 0; i < num_samples; ++i) { - for (size_t j = 0; j < out_channels; ++j) { - uint32_t s1 = *src++; - uint32_t s2 = *src++; - uint32_t s3 = *src++; - uint32_t s = s1 | (s1 << 8) | (s2 << 16) | (s3 << 24); - dst[i * out_channels + j] = int(s) * (1.0f / 4294967296.0f); - } - src += 3 * (in_channels - out_channels); - } -} - -void convert_fixed32_to_fp32(float *dst, size_t out_channels, const uint8_t *src, size_t in_channels, size_t num_samples) -{ - assert(in_channels >= out_channels); - for (size_t i = 0; i < num_samples; ++i) { - for (size_t j = 0; j < out_channels; ++j) { - // Note: Assumes little-endian. - int32_t s = *(int32_t *)src; - dst[i * out_channels + j] = s * (1.0f / 4294967296.0f); - src += 4; - } - src += 4 * (in_channels - out_channels); - } -} - void insert_new_frame(RefCountedFrame frame, unsigned field_num, bool interlaced, unsigned card_index, InputState *input_state) { if (interlaced) { @@ -130,10 +108,7 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards) num_cards(num_cards), mixer_surface(create_surface(format)), h264_encoder_surface(create_surface(format)), - correlation(OUTPUT_FREQUENCY), - level_compressor(OUTPUT_FREQUENCY), - limiter(OUTPUT_FREQUENCY), - compressor(OUTPUT_FREQUENCY) + audio_mixer(num_cards) { CHECK(init_movit(MOVIT_SHADER_DIR, MOVIT_DEBUG_OFF)); check_error(); @@ -143,7 +118,7 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards) movit_texel_subpixel_precision /= 2.0; resource_pool.reset(new ResourcePool); - theme.reset(new Theme(global_flags.theme_filename.c_str(), resource_pool.get(), num_cards)); + theme.reset(new Theme(global_flags.theme_filename, global_flags.theme_dirs, resource_pool.get(), num_cards)); for (unsigned i = 0; i < NUM_OUTPUTS; ++i) { output_channel[i].parent = this; output_channel[i].channel = i; @@ -162,29 +137,17 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards) display_chain->set_dither_bits(0); // Don't bother. display_chain->finalize(); - video_encoder.reset(new VideoEncoder(resource_pool.get(), h264_encoder_surface, global_flags.va_display, WIDTH, HEIGHT, &httpd)); + video_encoder.reset(new VideoEncoder(resource_pool.get(), h264_encoder_surface, global_flags.va_display, WIDTH, HEIGHT, &httpd, global_disk_space_estimator)); // Start listening for clients only once VideoEncoder has written its header, if any. httpd.start(9095); - // First try initializing the fake devices, then PCI devices, then USB, - // until we have the desired number of cards. - unsigned num_pci_devices = 0, num_usb_devices = 0; + // First try initializing the then PCI devices, then USB, then + // fill up with fake cards until we have the desired number of cards. + unsigned num_pci_devices = 0; unsigned card_index = 0; - assert(global_flags.num_fake_cards >= 0); // Enforced in flags.cpp. - unsigned num_fake_cards = global_flags.num_fake_cards; - - assert(num_fake_cards <= num_cards); // Enforced in flags.cpp. - for ( ; card_index < num_fake_cards; ++card_index) { - configure_card(card_index, new FakeCapture(card_index), /*is_fake_capture=*/true); - } - - if (global_flags.num_fake_cards > 0) { - fprintf(stderr, "Initialized %d fake cards.\n", global_flags.num_fake_cards); - } - - if (card_index < num_cards) { + { IDeckLinkIterator *decklink_iterator = CreateDeckLinkIteratorInstance(); if (decklink_iterator != nullptr) { for ( ; card_index < num_cards; ++card_index) { @@ -193,28 +156,36 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards) break; } - configure_card(card_index, new DeckLinkCapture(decklink, card_index - num_fake_cards), /*is_fake_capture=*/false); + configure_card(card_index, new DeckLinkCapture(decklink, card_index), /*is_fake_capture=*/false); ++num_pci_devices; } decklink_iterator->Release(); - fprintf(stderr, "Found %d DeckLink PCI card(s).\n", num_pci_devices); + fprintf(stderr, "Found %u DeckLink PCI card(s).\n", num_pci_devices); } else { fprintf(stderr, "DeckLink drivers not found. Probing for USB cards only.\n"); } } - for ( ; card_index < num_cards; ++card_index) { - BMUSBCapture *capture = new BMUSBCapture(card_index - num_pci_devices - num_fake_cards); + unsigned num_usb_devices = BMUSBCapture::num_cards(); + for (unsigned usb_card_index = 0; usb_card_index < num_usb_devices && card_index < num_cards; ++usb_card_index, ++card_index) { + BMUSBCapture *capture = new BMUSBCapture(usb_card_index); capture->set_card_disconnected_callback(bind(&Mixer::bm_hotplug_remove, this, card_index)); configure_card(card_index, capture, /*is_fake_capture=*/false); - ++num_usb_devices; + } + fprintf(stderr, "Found %u USB card(s).\n", num_usb_devices); + + unsigned num_fake_cards = 0; + for ( ; card_index < num_cards; ++card_index, ++num_fake_cards) { + FakeCapture *capture = new FakeCapture(WIDTH, HEIGHT, FAKE_FPS, OUTPUT_FREQUENCY, card_index, global_flags.fake_cards_audio); + configure_card(card_index, capture, /*is_fake_capture=*/true); } - if (num_usb_devices > 0) { - has_bmusb_thread = true; - BMUSBCapture::set_card_connected_callback(bind(&Mixer::bm_hotplug_add, this, _1)); - BMUSBCapture::start_bm_thread(); + if (num_fake_cards > 0) { + fprintf(stderr, "Initialized %u fake cards.\n", num_fake_cards); } + BMUSBCapture::set_card_connected_callback(bind(&Mixer::bm_hotplug_add, this, _1)); + BMUSBCapture::start_bm_thread(); + for (card_index = 0; card_index < num_cards; ++card_index) { cards[card_index].queue_length_policy.reset(card_index); cards[card_index].capture->start_bm_capture(); @@ -263,24 +234,6 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards) cbcr_position_attribute_index = glGetAttribLocation(cbcr_program_num, "position"); cbcr_texcoord_attribute_index = glGetAttribLocation(cbcr_program_num, "texcoord"); - r128.init(2, OUTPUT_FREQUENCY); - r128.integr_start(); - - locut.init(FILTER_HPF, 2); - - // If --flat-audio is given, turn off everything that messes with the sound, - // except the final makeup gain. - if (global_flags.flat_audio) { - set_locut_enabled(false); - set_gain_staging_auto(false); - set_limiter_enabled(false); - set_compressor_enabled(false); - } - - // hlen=16 is pretty low quality, but we use quite a bit of CPU otherwise, - // and there's a limit to how important the peak meter is. - peak_resampler.setup(OUTPUT_FREQUENCY, OUTPUT_FREQUENCY * 4, /*num_channels=*/2, /*hlen=*/16, /*frel=*/1.0); - if (global_flags.enable_alsa_output) { alsa.reset(new ALSAOutput(OUTPUT_FREQUENCY, /*num_channels=*/2)); } @@ -290,9 +243,7 @@ Mixer::~Mixer() { resource_pool->release_glsl_program(cbcr_program_num); glDeleteBuffers(1, &cbcr_vbo); - if (has_bmusb_thread) { - BMUSBCapture::stop_bm_thread(); - } + BMUSBCapture::stop_bm_thread(); for (unsigned card_index = 0; card_index < num_cards; ++card_index) { { @@ -325,15 +276,15 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, bool if (card->surface == nullptr) { card->surface = create_surface_with_same_format(mixer_surface); } - { - unique_lock lock(cards[card_index].audio_mutex); - card->resampling_queue.reset(new ResamplingQueue(card_index, OUTPUT_FREQUENCY, OUTPUT_FREQUENCY, 2)); - } while (!card->new_frames.empty()) card->new_frames.pop(); card->fractional_samples = 0; card->last_timecode = -1; - card->next_local_pts = 0; card->capture->configure_card(); + + DeviceSpec device{InputSourceType::CAPTURE_CARD, card_index}; + audio_mixer.reset_resampler(device); + audio_mixer.set_display_name(device, card->capture->get_description()); + audio_mixer.trigger_state_changed_callback(); } @@ -349,36 +300,13 @@ int unwrap_timecode(uint16_t current_wrapped, int last) } } -float find_peak(const float *samples, size_t num_samples) -{ - float m = fabs(samples[0]); - for (size_t i = 1; i < num_samples; ++i) { - m = max(m, fabs(samples[i])); - } - return m; -} - -void deinterleave_samples(const vector &in, vector *out_l, vector *out_r) -{ - size_t num_samples = in.size() / 2; - out_l->resize(num_samples); - out_r->resize(num_samples); - - const float *inptr = in.data(); - float *lptr = &(*out_l)[0]; - float *rptr = &(*out_r)[0]; - for (size_t i = 0; i < num_samples; ++i) { - *lptr++ = *inptr++; - *rptr++ = *inptr++; - } -} - } // namespace void Mixer::bm_frame(unsigned card_index, uint16_t timecode, FrameAllocator::Frame video_frame, size_t video_offset, VideoFormat video_format, FrameAllocator::Frame audio_frame, size_t audio_offset, AudioFormat audio_format) { + DeviceSpec device{InputSourceType::CAPTURE_CARD, card_index}; CaptureCard *card = &cards[card_index]; if (is_mode_scanning[card_index]) { @@ -387,10 +315,8 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode, is_mode_scanning[card_index] = false; } else { static constexpr double switch_time_s = 0.5; // Should be enough time for the signal to stabilize. - timespec now; - clock_gettime(CLOCK_MONOTONIC, &now); - double sec_since_last_switch = (now.tv_sec - last_mode_scan_change[card_index].tv_sec) + - 1e-9 * (now.tv_nsec - last_mode_scan_change[card_index].tv_nsec); + steady_clock::time_point now = steady_clock::now(); + double sec_since_last_switch = duration(steady_clock::now() - last_mode_scan_change[card_index]).count(); if (sec_since_last_switch > switch_time_s) { // It isn't this mode; try the next one. mode_scanlist_index[card_index]++; @@ -418,71 +344,40 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode, return; } - int64_t local_pts = card->next_local_pts; int dropped_frames = 0; if (card->last_timecode != -1) { dropped_frames = unwrap_timecode(timecode, card->last_timecode) - card->last_timecode - 1; } - // Convert the audio to stereo fp32 and add it. - vector audio; - audio.resize(num_samples * 2); - switch (audio_format.bits_per_sample) { - case 0: - assert(num_samples == 0); - break; - case 24: - convert_fixed24_to_fp32(&audio[0], 2, audio_frame.data + audio_offset, audio_format.num_channels, num_samples); - break; - case 32: - convert_fixed32_to_fp32(&audio[0], 2, audio_frame.data + audio_offset, audio_format.num_channels, num_samples); - break; - default: - fprintf(stderr, "Cannot handle audio with %u bits per sample\n", audio_format.bits_per_sample); - assert(false); - } + // Number of samples per frame if we need to insert silence. + // (Could be nonintegral, but resampling will save us then.) + const int silence_samples = OUTPUT_FREQUENCY * video_format.frame_rate_den / video_format.frame_rate_nom; - // Add the audio. - { - unique_lock lock(card->audio_mutex); - - // Number of samples per frame if we need to insert silence. - // (Could be nonintegral, but resampling will save us then.) - int silence_samples = OUTPUT_FREQUENCY * video_format.frame_rate_den / video_format.frame_rate_nom; - - if (dropped_frames > MAX_FPS * 2) { - fprintf(stderr, "Card %d lost more than two seconds (or time code jumping around; from 0x%04x to 0x%04x), resetting resampler\n", - card_index, card->last_timecode, timecode); - card->resampling_queue.reset(new ResamplingQueue(card_index, OUTPUT_FREQUENCY, OUTPUT_FREQUENCY, 2)); - dropped_frames = 0; - } else if (dropped_frames > 0) { - // Insert silence as needed. - fprintf(stderr, "Card %d dropped %d frame(s) (before timecode 0x%04x), inserting silence.\n", - card_index, dropped_frames, timecode); - vector silence(silence_samples * 2, 0.0f); - for (int i = 0; i < dropped_frames; ++i) { - card->resampling_queue->add_input_samples(local_pts / double(TIMEBASE), silence.data(), silence_samples); - // Note that if the format changed in the meantime, we have - // no way of detecting that; we just have to assume the frame length - // is always the same. - local_pts += frame_length; - } - } - if (num_samples == 0) { - audio.resize(silence_samples * 2); - num_samples = silence_samples; - } - card->resampling_queue->add_input_samples(local_pts / double(TIMEBASE), audio.data(), num_samples); - card->next_local_pts = local_pts + frame_length; + if (dropped_frames > MAX_FPS * 2) { + fprintf(stderr, "Card %d lost more than two seconds (or time code jumping around; from 0x%04x to 0x%04x), resetting resampler\n", + card_index, card->last_timecode, timecode); + audio_mixer.reset_resampler(device); + dropped_frames = 0; + } else if (dropped_frames > 0) { + // Insert silence as needed. + fprintf(stderr, "Card %d dropped %d frame(s) (before timecode 0x%04x), inserting silence.\n", + card_index, dropped_frames, timecode); + + bool success; + do { + success = audio_mixer.add_silence(device, silence_samples, dropped_frames, frame_length); + } while (!success); } - card->last_timecode = timecode; + audio_mixer.add_audio(device, audio_frame.data + audio_offset, num_samples, audio_format, frame_length); // Done with the audio, so release it. if (audio_frame.owner) { audio_frame.owner->release_frame(audio_frame); } + card->last_timecode = timecode; + size_t expected_length = video_format.width * (video_format.height + video_format.extra_lines_top + video_format.extra_lines_bottom) * 2; if (video_frame.len - video_offset == 0 || video_frame.len - video_offset != expected_length) { @@ -512,7 +407,7 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode, PBOFrameAllocator::Userdata *userdata = (PBOFrameAllocator::Userdata *)video_frame.userdata; unsigned num_fields = video_format.interlaced ? 2 : 1; - timespec frame_upload_start; + steady_clock::time_point frame_upload_start; if (video_format.interlaced) { // Send the two fields along as separate frames; the other side will need to add // a deinterlacer to actually get this right. @@ -521,7 +416,7 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode, assert(frame_length % 2 == 0); frame_length /= 2; num_fields = 2; - clock_gettime(CLOCK_MONOTONIC, &frame_upload_start); + frame_upload_start = steady_clock::now(); } userdata->last_interlaced = video_format.interlaced; userdata->last_has_signal = video_format.has_signal; @@ -602,16 +497,9 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode, // against the video display, although the latter is not as critical.) // This requires our system clock to be reasonably close to the // video clock, but that's not an unreasonable assumption. - timespec second_field_start; - second_field_start.tv_nsec = frame_upload_start.tv_nsec + - frame_length * 1000000000 / TIMEBASE; - second_field_start.tv_sec = frame_upload_start.tv_sec + - second_field_start.tv_nsec / 1000000000; - second_field_start.tv_nsec %= 1000000000; - - while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, - &second_field_start, nullptr) == -1 && - errno == EINTR) ; + steady_clock::time_point second_field_start = frame_upload_start + + nanoseconds(frame_length * 1000000000 / TIMEBASE); + this_thread::sleep_until(second_field_start); } { @@ -649,16 +537,16 @@ void Mixer::thread_func() exit(1); } - struct timespec start, now; - clock_gettime(CLOCK_MONOTONIC, &start); + steady_clock::time_point start, now; + start = steady_clock::now(); int frame = 0; int stats_dropped_frames = 0; while (!should_quit) { - CaptureCard::NewFrame new_frames[MAX_CARDS]; - bool has_new_frame[MAX_CARDS] = { false }; - int num_samples[MAX_CARDS] = { 0 }; + CaptureCard::NewFrame new_frames[MAX_VIDEO_CARDS]; + bool has_new_frame[MAX_VIDEO_CARDS] = { false }; + int num_samples[MAX_VIDEO_CARDS] = { 0 }; unsigned master_card_index = theme->map_signal(master_clock_channel); assert(master_card_index < num_cards); @@ -666,7 +554,6 @@ void Mixer::thread_func() get_one_frame_from_each_card(master_card_index, new_frames, has_new_frame, num_samples); schedule_audio_resampling_tasks(new_frames[master_card_index].dropped_frames, num_samples[master_card_index], new_frames[master_card_index].length); stats_dropped_frames += new_frames[master_card_index].dropped_frames; - send_audio_level_callback(); handle_hotplugged_cards(); @@ -707,14 +594,13 @@ void Mixer::thread_func() } } - int64_t duration = new_frames[master_card_index].length; - render_one_frame(duration); + int64_t frame_duration = new_frames[master_card_index].length; + render_one_frame(frame_duration); ++frame; - pts_int += duration; + pts_int += frame_duration; - clock_gettime(CLOCK_MONOTONIC, &now); - double elapsed = now.tv_sec - start.tv_sec + - 1e-9 * (now.tv_nsec - start.tv_nsec); + now = steady_clock::now(); + double elapsed = duration(now - start).count(); if (frame % 100 == 0) { printf("%d frames (%d dropped) in %.3f seconds = %.1f fps (%.1f ms/frame)", frame, stats_dropped_frames, elapsed, frame / elapsed, @@ -769,7 +655,7 @@ void Mixer::thread_func() resource_pool->clean_context(); } -void Mixer::get_one_frame_from_each_card(unsigned master_card_index, CaptureCard::NewFrame new_frames[MAX_CARDS], bool has_new_frame[MAX_CARDS], int num_samples[MAX_CARDS]) +void Mixer::get_one_frame_from_each_card(unsigned master_card_index, CaptureCard::NewFrame new_frames[MAX_VIDEO_CARDS], bool has_new_frame[MAX_VIDEO_CARDS], int num_samples[MAX_VIDEO_CARDS]) { start: // The first card is the master timer, so wait for it to have a new frame. @@ -825,7 +711,8 @@ void Mixer::handle_hotplugged_cards() CaptureCard *card = &cards[card_index]; if (card->capture->get_disconnected()) { fprintf(stderr, "Card %u went away, replacing with a fake card.\n", card_index); - configure_card(card_index, new FakeCapture(card_index), /*is_fake_capture=*/true); + FakeCapture *capture = new FakeCapture(WIDTH, HEIGHT, FAKE_FPS, OUTPUT_FREQUENCY, card_index, global_flags.fake_cards_audio); + configure_card(card_index, capture, /*is_fake_capture=*/true); card->queue_length_policy.reset(card_index); card->capture->start_bm_capture(); } @@ -869,13 +756,27 @@ void Mixer::schedule_audio_resampling_tasks(unsigned dropped_frames, int num_sam // Resample the audio as needed, including from previously dropped frames. assert(num_cards > 0); for (unsigned frame_num = 0; frame_num < dropped_frames + 1; ++frame_num) { + const bool dropped_frame = (frame_num != dropped_frames); { // Signal to the audio thread to process this frame. + // Note that if the frame is a dropped frame, we signal that + // we don't want to use this frame as base for adjusting + // the resampler rate. The reason for this is that the timing + // of these frames is often way too late; they typically don't + // “arrive” before we synthesize them. Thus, we could end up + // in a situation where we have inserted e.g. five audio frames + // into the queue before we then start pulling five of them + // back out. This makes ResamplingQueue overestimate the delay, + // causing undue resampler changes. (We _do_ use the last, + // non-dropped frame; perhaps we should just discard that as well, + // since dropped frames are expected to be rare, and it might be + // better to just wait until we have a slightly more normal situation). unique_lock lock(audio_mutex); - audio_task_queue.push(AudioTask{pts_int, num_samples_per_frame}); + bool adjust_rate = !dropped_frame; + audio_task_queue.push(AudioTask{pts_int, num_samples_per_frame, adjust_rate}); audio_task_queue_changed.notify_one(); } - if (frame_num != dropped_frames) { + if (dropped_frame) { // For dropped frames, increase the pts. Note that if the format changed // in the meantime, we have no way of detecting that; we just have to // assume the frame length is always the same. @@ -942,24 +843,6 @@ void Mixer::render_one_frame(int64_t duration) } } -void Mixer::send_audio_level_callback() -{ - if (audio_level_callback == nullptr) { - return; - } - - unique_lock lock(compressor_mutex); - double loudness_s = r128.loudness_S(); - double loudness_i = r128.integrated(); - double loudness_range_low = r128.range_min(); - double loudness_range_high = r128.range_max(); - - audio_level_callback(loudness_s, 20.0 * log10(peak), - loudness_i, loudness_range_low, loudness_range_high, - gain_staging_db, 20.0 * log10(final_makeup_gain), - correlation.get_correlation()); -} - void Mixer::audio_thread_func() { while (!should_quit) { @@ -975,169 +858,19 @@ void Mixer::audio_thread_func() audio_task_queue.pop(); } - process_audio_one_frame(task.pts_int, task.num_samples); - } -} - -void Mixer::process_audio_one_frame(int64_t frame_pts_int, int num_samples) -{ - vector samples_card; - vector samples_out; - - // TODO: Allow mixing audio from several sources. - unsigned selected_audio_card = theme->map_signal(audio_source_channel); - assert(selected_audio_card < num_cards); - - for (unsigned card_index = 0; card_index < num_cards; ++card_index) { - samples_card.resize(num_samples * 2); - { - unique_lock lock(cards[card_index].audio_mutex); - cards[card_index].resampling_queue->get_output_samples(double(frame_pts_int) / TIMEBASE, &samples_card[0], num_samples); - } - if (card_index == selected_audio_card) { - samples_out = move(samples_card); - } - } - - // Cut away everything under 120 Hz (or whatever the cutoff is); - // we don't need it for voice, and it will reduce headroom - // and confuse the compressor. (In particular, any hums at 50 or 60 Hz - // should be dampened.) - if (locut_enabled) { - locut.render(samples_out.data(), samples_out.size() / 2, locut_cutoff_hz * 2.0 * M_PI / OUTPUT_FREQUENCY, 0.5f); - } - - // Apply a level compressor to get the general level right. - // Basically, if it's over about -40 dBFS, we squeeze it down to that level - // (or more precisely, near it, since we don't use infinite ratio), - // then apply a makeup gain to get it to -14 dBFS. -14 dBFS is, of course, - // entirely arbitrary, but from practical tests with speech, it seems to - // put ut around -23 LUFS, so it's a reasonable starting point for later use. - { - unique_lock lock(compressor_mutex); - if (level_compressor_enabled) { - float threshold = 0.01f; // -40 dBFS. - float ratio = 20.0f; - float attack_time = 0.5f; - float release_time = 20.0f; - float makeup_gain = pow(10.0f, (ref_level_dbfs - (-40.0f)) / 20.0f); // +26 dB. - level_compressor.process(samples_out.data(), samples_out.size() / 2, threshold, ratio, attack_time, release_time, makeup_gain); - gain_staging_db = 20.0 * log10(level_compressor.get_attenuation() * makeup_gain); - } else { - // Just apply the gain we already had. - float g = pow(10.0f, gain_staging_db / 20.0f); - for (size_t i = 0; i < samples_out.size(); ++i) { - samples_out[i] *= g; - } - } - } - -#if 0 - printf("level=%f (%+5.2f dBFS) attenuation=%f (%+5.2f dB) end_result=%+5.2f dB\n", - level_compressor.get_level(), 20.0 * log10(level_compressor.get_level()), - level_compressor.get_attenuation(), 20.0 * log10(level_compressor.get_attenuation()), - 20.0 * log10(level_compressor.get_level() * level_compressor.get_attenuation() * makeup_gain)); -#endif - -// float limiter_att, compressor_att; - - // The real compressor. - if (compressor_enabled) { - float threshold = pow(10.0f, compressor_threshold_dbfs / 20.0f); - float ratio = 20.0f; - float attack_time = 0.005f; - float release_time = 0.040f; - float makeup_gain = 2.0f; // +6 dB. - compressor.process(samples_out.data(), samples_out.size() / 2, threshold, ratio, attack_time, release_time, makeup_gain); -// compressor_att = compressor.get_attenuation(); - } - - // Finally a limiter at -4 dB (so, -10 dBFS) to take out the worst peaks only. - // Note that since ratio is not infinite, we could go slightly higher than this. - if (limiter_enabled) { - float threshold = pow(10.0f, limiter_threshold_dbfs / 20.0f); - float ratio = 30.0f; - float attack_time = 0.0f; // Instant. - float release_time = 0.020f; - float makeup_gain = 1.0f; // 0 dB. - limiter.process(samples_out.data(), samples_out.size() / 2, threshold, ratio, attack_time, release_time, makeup_gain); -// limiter_att = limiter.get_attenuation(); - } - -// printf("limiter=%+5.1f compressor=%+5.1f\n", 20.0*log10(limiter_att), 20.0*log10(compressor_att)); - - // Upsample 4x to find interpolated peak. - peak_resampler.inp_data = samples_out.data(); - peak_resampler.inp_count = samples_out.size() / 2; - - vector interpolated_samples_out; - interpolated_samples_out.resize(samples_out.size()); - while (peak_resampler.inp_count > 0) { // About four iterations. - peak_resampler.out_data = &interpolated_samples_out[0]; - peak_resampler.out_count = interpolated_samples_out.size() / 2; - peak_resampler.process(); - size_t out_stereo_samples = interpolated_samples_out.size() / 2 - peak_resampler.out_count; - peak = max(peak, find_peak(interpolated_samples_out.data(), out_stereo_samples * 2)); - peak_resampler.out_data = nullptr; - } - - // At this point, we are most likely close to +0 LU, but all of our - // measurements have been on raw sample values, not R128 values. - // So we have a final makeup gain to get us to +0 LU; the gain - // adjustments required should be relatively small, and also, the - // offset shouldn't change much (only if the type of audio changes - // significantly). Thus, we shoot for updating this value basically - // “whenever we process buffers”, since the R128 calculation isn't exactly - // something we get out per-sample. - // - // Note that there's a feedback loop here, so we choose a very slow filter - // (half-time of 100 seconds). - double target_loudness_factor, alpha; - { - unique_lock lock(compressor_mutex); - double loudness_lu = r128.loudness_M() - ref_level_lufs; - double current_makeup_lu = 20.0f * log10(final_makeup_gain); - target_loudness_factor = pow(10.0f, -loudness_lu / 20.0f); - - // If we're outside +/- 5 LU uncorrected, we don't count it as - // a normal signal (probably silence) and don't change the - // correction factor; just apply what we already have. - if (fabs(loudness_lu - current_makeup_lu) >= 5.0 || !final_makeup_gain_auto) { - alpha = 0.0; - } else { - // Formula adapted from - // https://en.wikipedia.org/wiki/Low-pass_filter#Simple_infinite_impulse_response_filter. - const double half_time_s = 100.0; - const double fc_mul_2pi_delta_t = 1.0 / (half_time_s * OUTPUT_FREQUENCY); - alpha = fc_mul_2pi_delta_t / (fc_mul_2pi_delta_t + 1.0); - } + ResamplingQueue::RateAdjustmentPolicy rate_adjustment_policy = + task.adjust_rate ? ResamplingQueue::ADJUST_RATE : ResamplingQueue::DO_NOT_ADJUST_RATE; + vector samples_out = audio_mixer.get_output( + double(task.pts_int) / TIMEBASE, + task.num_samples, + rate_adjustment_policy); - double m = final_makeup_gain; - for (size_t i = 0; i < samples_out.size(); i += 2) { - samples_out[i + 0] *= m; - samples_out[i + 1] *= m; - m += (target_loudness_factor - m) * alpha; + // Send the samples to the sound card, then add them to the output. + if (alsa) { + alsa->write(samples_out); } - final_makeup_gain = m; - } - - // Find R128 levels and L/R correlation. - vector left, right; - deinterleave_samples(samples_out, &left, &right); - float *ptrs[] = { left.data(), right.data() }; - { - unique_lock lock(compressor_mutex); - r128.process(left.size(), ptrs); - correlation.process_samples(samples_out); + video_encoder->add_audio(task.pts_int, move(samples_out)); } - - // Send the samples to the sound card. - if (alsa) { - alsa->write(samples_out); - } - - // And finally add them to the output. - video_encoder->add_audio(frame_pts_int, move(samples_out)); } void Mixer::subsample_chroma(GLuint src_tex, GLuint dst_tex) @@ -1233,15 +966,6 @@ void Mixer::channel_clicked(int preview_num) theme->channel_clicked(preview_num); } -void Mixer::reset_meters() -{ - peak_resampler.reset(); - peak = 0.0f; - r128.reset(); - r128.integr_start(); - correlation.reset(); -} - void Mixer::start_mode_scanning(unsigned card_index) { assert(card_index < num_cards); @@ -1256,7 +980,7 @@ void Mixer::start_mode_scanning(unsigned card_index) assert(!mode_scanlist[card_index].empty()); mode_scanlist_index[card_index] = 0; cards[card_index].capture->set_video_mode(mode_scanlist[card_index][0]); - clock_gettime(CLOCK_MONOTONIC, &last_mode_scan_change[card_index]); + last_mode_scan_change[card_index] = steady_clock::now(); } Mixer::OutputChannel::~OutputChannel()