X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Fmixer.cpp;h=3ca249b1a5094ecf5003233f9fb1f5c3732bf680;hb=435d5e4f35ffd433e5cf9a6b372c9de662a9afa9;hp=1c64c985e1e719a09402f8392d487755f1ff2d92;hpb=47e3e5c8b00e3971a2fbd34de81463772278ce69;p=nageru diff --git a/nageru/mixer.cpp b/nageru/mixer.cpp index 1c64c98..3ca249b 100644 --- a/nageru/mixer.cpp +++ b/nageru/mixer.cpp @@ -41,6 +41,7 @@ #include "shared/context.h" #include "decklink_capture.h" #include "decklink_output.h" +#include "decklink_util.h" #include "defs.h" #include "shared/disk_space_estimator.h" #include "ffmpeg_capture.h" @@ -123,7 +124,7 @@ void ensure_texture_resolution(PBOFrameAllocator::Userdata *userdata, unsigned f cbcr_width != userdata->last_cbcr_width[field] || cbcr_height != userdata->last_cbcr_height[field]; const bool recreate_v210_texture = - global_flags.ten_bit_input && + global_flags.bit_depth > 8 && (first || v210_width != userdata->last_v210_width[field] || height != userdata->last_height[field]); if (recreate_main_texture) { @@ -233,6 +234,16 @@ void JitterHistory::unregister_metrics(const vector> &label void JitterHistory::frame_arrived(steady_clock::time_point now, int64_t frame_duration, size_t dropped_frames) { + if (frame_duration != last_duration) { + // If the frame rate changed, the input clock is also going to change, + // so our historical data doesn't make much sense anymore. + // Also, format changes typically introduce blips that are not representative + // of the typical frame stream. (We make the assumption that format changes + // don't happen all the time in regular use; if they did, we should probably + // rather keep the history so that we take jitter they may introduce into account.) + clear(); + last_duration = frame_duration; + } if (expected_timestamp > steady_clock::time_point::min()) { expected_timestamp += dropped_frames * nanoseconds(frame_duration * 1000000000 / TIMEBASE); double jitter_seconds = fabs(duration(expected_timestamp - now).count()); @@ -276,7 +287,7 @@ void QueueLengthPolicy::unregister_metrics(const vector> &l } void QueueLengthPolicy::update_policy(steady_clock::time_point now, - steady_clock::time_point expected_next_frame, + steady_clock::time_point expected_next_input_frame, int64_t input_frame_duration, int64_t master_frame_duration, double max_input_card_jitter_seconds, @@ -287,7 +298,7 @@ void QueueLengthPolicy::update_policy(steady_clock::time_point now, // Figure out when we can expect the next frame for this card, assuming // worst-case jitter (ie., the frame is maximally late). - double seconds_until_next_frame = max(duration(expected_next_frame - now).count() + max_input_card_jitter_seconds, 0.0); + double seconds_until_next_frame = max(duration(expected_next_input_frame - now).count() + max_input_card_jitter_seconds, 0.0); // How many times are the master card expected to tick in that time? // We assume the master clock has worst-case jitter but not any rate @@ -353,7 +364,7 @@ Mixer::Mixer(const QSurfaceFormat &format) ycbcr_format.luma_coefficients = YCBCR_REC_601; } ycbcr_format.full_range = false; - ycbcr_format.num_levels = 1 << global_flags.x264_bit_depth; + ycbcr_format.num_levels = 1 << global_flags.bit_depth; ycbcr_format.cb_x_position = 0.0f; ycbcr_format.cr_x_position = 0.0f; ycbcr_format.cb_y_position = 0.5f; @@ -367,7 +378,7 @@ Mixer::Mixer(const QSurfaceFormat &format) // Display chain; shows the live output produced by the main chain (or rather, a copy of it). display_chain.reset(new EffectChain(global_flags.width, global_flags.height, resource_pool.get())); check_error(); - GLenum type = global_flags.x264_bit_depth > 8 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE; + GLenum type = global_flags.bit_depth > 8 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE; display_input = new YCbCrInput(inout_format, ycbcr_format, global_flags.width, global_flags.height, YCBCR_INPUT_SPLIT_Y_AND_CBCR, type); display_chain->add_input(display_input); display_chain->add_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED); @@ -410,9 +421,15 @@ Mixer::Mixer(const QSurfaceFormat &format) break; } + if (!decklink_card_is_active(decklink, card_index)) { + fprintf(stderr, "DeckLink card %u is inactive in current profile, skipping (try changing it in Desktop Video Setup)\n", card_index); + decklink->Release(); + continue; + } + DeckLinkCapture *capture = new DeckLinkCapture(decklink, card_index); DeckLinkOutput *output = new DeckLinkOutput(resource_pool.get(), decklink_output_surface, global_flags.width, global_flags.height, card_index); - if (!output->set_device(decklink)) { + if (!output->set_device(decklink, capture->get_input())) { delete output; output = nullptr; } @@ -492,13 +509,9 @@ Mixer::Mixer(const QSurfaceFormat &format) } #endif - for (unsigned card_index = 0; card_index < MAX_VIDEO_CARDS; ++card_index) { - cards[card_index].queue_length_policy.reset(card_index); - } - chroma_subsampler.reset(new ChromaSubsampler(resource_pool.get())); - if (global_flags.ten_bit_input) { + if (global_flags.bit_depth > 8) { if (!v210Converter::has_hardware_support()) { fprintf(stderr, "ERROR: --ten-bit-input requires support for OpenGL compute shaders\n"); fprintf(stderr, " (OpenGL 4.3, or GL_ARB_compute_shader + GL_ARB_shader_image_load_store).\n"); @@ -515,7 +528,7 @@ Mixer::Mixer(const QSurfaceFormat &format) v210_converter->precompile_shader(3840); v210_converter->precompile_shader(4096); } - if (global_flags.ten_bit_output) { + if (global_flags.bit_depth > 8) { if (!v210Converter::has_hardware_support()) { fprintf(stderr, "ERROR: --ten-bit-output requires support for OpenGL compute shaders\n"); fprintf(stderr, " (OpenGL 4.3, or GL_ARB_compute_shader + GL_ARB_shader_image_load_store).\n"); @@ -530,6 +543,7 @@ Mixer::Mixer(const QSurfaceFormat &format) if (global_flags.enable_alsa_output) { alsa.reset(new ALSAOutput(OUTPUT_FREQUENCY, /*num_channels=*/2)); } + output_card_is_master = global_flags.output_card_is_master; if (global_flags.output_card != -1) { desired_output_card_index = global_flags.output_card; set_output_card_internal(global_flags.output_card); @@ -595,7 +609,7 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, CardT pixel_format = capture->get_current_pixel_format(); } else if (card_type == CardType::CEF_INPUT) { pixel_format = PixelFormat_8BitBGRA; - } else if (global_flags.ten_bit_input) { + } else if (global_flags.bit_depth > 8) { pixel_format = PixelFormat_10BitYCbCr; } else { pixel_format = PixelFormat_8BitYCbCr; @@ -604,7 +618,7 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, CardT if (is_active) { card->capture->set_frame_callback(bind(&Mixer::bm_frame, this, card_index, _1, _2, _3, _4, _5, _6, _7)); if (card->frame_allocator == nullptr) { - card->frame_allocator.reset(new PBOFrameAllocator(pixel_format, 8 << 20, global_flags.width, global_flags.height, card_index, mjpeg_encoder.get())); // 8 MB. + card->frame_allocator.reset(new PBOFrameAllocator(pixel_format, FRAME_SIZE, global_flags.width, global_flags.height, card_index, mjpeg_encoder.get())); } else { // The format could have changed, but we cannot reset the allocator // and create a new one from scratch, since there may be allocated @@ -613,7 +627,7 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, CardT // any old ones as they come back. This takes the mutex while // allocating, but nothing should really be sending frames in there // right now anyway (start_bm_capture() has not been called yet). - card->frame_allocator->reconfigure(pixel_format, 8 << 20, global_flags.width, global_flags.height, card_index, mjpeg_encoder.get()); + card->frame_allocator->reconfigure(pixel_format, FRAME_SIZE, global_flags.width, global_flags.height, card_index, mjpeg_encoder.get()); } card->capture->set_video_frame_allocator(card->frame_allocator.get()); if (card->surface == nullptr) { @@ -665,71 +679,7 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, CardT global_metrics.remove_if_exists("input_frame_rate_den", labels); global_metrics.remove_if_exists("input_sample_rate_hz", labels); - // SRT metrics. - - // Global measurements (counters). - global_metrics.remove_if_exists("srt_uptime_seconds", labels); - global_metrics.remove_if_exists("srt_send_duration_seconds", labels); - global_metrics.remove_if_exists("srt_sent_bytes", labels); - global_metrics.remove_if_exists("srt_received_bytes", labels); - - vector> packet_labels = card->labels; - packet_labels.emplace_back("type", "normal"); - global_metrics.remove_if_exists("srt_sent_packets", packet_labels); - global_metrics.remove_if_exists("srt_received_packets", packet_labels); - - packet_labels.back().second = "lost"; - global_metrics.remove_if_exists("srt_sent_packets", packet_labels); - global_metrics.remove_if_exists("srt_received_packets", packet_labels); - - packet_labels.back().second = "retransmitted"; - global_metrics.remove_if_exists("srt_sent_packets", packet_labels); - global_metrics.remove_if_exists("srt_sent_bytes", packet_labels); - - packet_labels.back().second = "ack"; - global_metrics.remove_if_exists("srt_sent_packets", packet_labels); - global_metrics.remove_if_exists("srt_received_packets", packet_labels); - - packet_labels.back().second = "nak"; - global_metrics.remove_if_exists("srt_sent_packets", packet_labels); - global_metrics.remove_if_exists("srt_received_packets", packet_labels); - - packet_labels.back().second = "dropped"; - global_metrics.remove_if_exists("srt_sent_packets", packet_labels); - global_metrics.remove_if_exists("srt_received_packets", packet_labels); - global_metrics.remove_if_exists("srt_sent_bytes", packet_labels); - global_metrics.remove_if_exists("srt_received_bytes", packet_labels); - - packet_labels.back().second = "undecryptable"; - global_metrics.remove_if_exists("srt_received_packets", packet_labels); - global_metrics.remove_if_exists("srt_received_bytes", packet_labels); - - global_metrics.remove_if_exists("srt_filter_sent_extra_packets", labels); - global_metrics.remove_if_exists("srt_filter_received_extra_packets", labels); - global_metrics.remove_if_exists("srt_filter_received_rebuilt_packets", labels); - global_metrics.remove_if_exists("srt_filter_received_lost_packets", labels); - - // Instant measurements (gauges). - global_metrics.remove_if_exists("srt_packet_sending_period_seconds", labels); - global_metrics.remove_if_exists("srt_flow_window_packets", labels); - global_metrics.remove_if_exists("srt_congestion_window_packets", labels); - global_metrics.remove_if_exists("srt_flight_size_packets", labels); - global_metrics.remove_if_exists("srt_rtt_seconds", labels); - global_metrics.remove_if_exists("srt_estimated_bandwidth_bits_per_second", labels); - global_metrics.remove_if_exists("srt_bandwidth_ceiling_bits_per_second", labels); - global_metrics.remove_if_exists("srt_send_buffer_available_bytes", labels); - global_metrics.remove_if_exists("srt_receive_buffer_available_bytes", labels); - global_metrics.remove_if_exists("srt_mss_bytes", labels); - - global_metrics.remove_if_exists("srt_sender_unacked_packets", labels); - global_metrics.remove_if_exists("srt_sender_unacked_bytes", labels); - global_metrics.remove_if_exists("srt_sender_unacked_timespan_seconds", labels); - global_metrics.remove_if_exists("srt_sender_delivery_delay_seconds", labels); - - global_metrics.remove_if_exists("srt_receiver_unacked_packets", labels); - global_metrics.remove_if_exists("srt_receiver_unacked_bytes", labels); - global_metrics.remove_if_exists("srt_receiver_unacked_timespan_seconds", labels); - global_metrics.remove_if_exists("srt_receiver_delivery_delay_seconds", labels); + card->srt_metrics.deinit(labels); } if (is_active) { @@ -778,69 +728,7 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, CardT global_metrics.add("input_sample_rate_hz", labels, &card->metric_input_sample_rate_hz, Metrics::TYPE_GAUGE); if (is_srt_card) { - // Global measurements (counters). - global_metrics.add("srt_uptime_seconds", labels, &card->metric_srt_uptime_seconds); - global_metrics.add("srt_send_duration_seconds", labels, &card->metric_srt_send_duration_seconds); - global_metrics.add("srt_sent_bytes", labels, &card->metric_srt_sent_bytes); - global_metrics.add("srt_received_bytes", labels, &card->metric_srt_received_bytes); - - vector> packet_labels = labels; - packet_labels.emplace_back("type", "normal"); - global_metrics.add("srt_sent_packets", packet_labels, &card->metric_srt_sent_packets_normal); - global_metrics.add("srt_received_packets", packet_labels, &card->metric_srt_received_packets_normal); - - packet_labels.back().second = "lost"; - global_metrics.add("srt_sent_packets", packet_labels, &card->metric_srt_sent_packets_lost); - global_metrics.add("srt_received_packets", packet_labels, &card->metric_srt_received_packets_lost); - - packet_labels.back().second = "retransmitted"; - global_metrics.add("srt_sent_packets", packet_labels, &card->metric_srt_sent_packets_retransmitted); - global_metrics.add("srt_sent_bytes", packet_labels, &card->metric_srt_sent_bytes_retransmitted); - - packet_labels.back().second = "ack"; - global_metrics.add("srt_sent_packets", packet_labels, &card->metric_srt_sent_packets_ack); - global_metrics.add("srt_received_packets", packet_labels, &card->metric_srt_received_packets_ack); - - packet_labels.back().second = "nak"; - global_metrics.add("srt_sent_packets", packet_labels, &card->metric_srt_sent_packets_nak); - global_metrics.add("srt_received_packets", packet_labels, &card->metric_srt_received_packets_nak); - - packet_labels.back().second = "dropped"; - global_metrics.add("srt_sent_packets", packet_labels, &card->metric_srt_sent_packets_dropped); - global_metrics.add("srt_received_packets", packet_labels, &card->metric_srt_received_packets_dropped); - global_metrics.add("srt_sent_bytes", packet_labels, &card->metric_srt_sent_bytes_dropped); - global_metrics.add("srt_received_bytes", packet_labels, &card->metric_srt_received_bytes_dropped); - - packet_labels.back().second = "undecryptable"; - global_metrics.add("srt_received_packets", packet_labels, &card->metric_srt_received_packets_undecryptable); - global_metrics.add("srt_received_bytes", packet_labels, &card->metric_srt_received_bytes_undecryptable); - - global_metrics.add("srt_filter_sent_extra_packets", labels, &card->metric_srt_filter_sent_packets); - global_metrics.add("srt_filter_received_extra_packets", labels, &card->metric_srt_filter_received_extra_packets); - global_metrics.add("srt_filter_received_rebuilt_packets", labels, &card->metric_srt_filter_received_rebuilt_packets); - global_metrics.add("srt_filter_received_lost_packets", labels, &card->metric_srt_filter_received_lost_packets); - - // Instant measurements (gauges). - global_metrics.add("srt_packet_sending_period_seconds", labels, &card->metric_srt_packet_sending_period_seconds, Metrics::TYPE_GAUGE); - global_metrics.add("srt_flow_window_packets", labels, &card->metric_srt_flow_window_packets, Metrics::TYPE_GAUGE); - global_metrics.add("srt_congestion_window_packets", labels, &card->metric_srt_congestion_window_packets, Metrics::TYPE_GAUGE); - global_metrics.add("srt_flight_size_packets", labels, &card->metric_srt_flight_size_packets, Metrics::TYPE_GAUGE); - global_metrics.add("srt_rtt_seconds", labels, &card->metric_srt_rtt_seconds, Metrics::TYPE_GAUGE); - global_metrics.add("srt_estimated_bandwidth_bits_per_second", labels, &card->metric_srt_estimated_bandwidth_bits_per_second, Metrics::TYPE_GAUGE); - global_metrics.add("srt_bandwidth_ceiling_bits_per_second", labels, &card->metric_srt_bandwidth_ceiling_bits_per_second, Metrics::TYPE_GAUGE); - global_metrics.add("srt_send_buffer_available_bytes", labels, &card->metric_srt_send_buffer_available_bytes, Metrics::TYPE_GAUGE); - global_metrics.add("srt_receive_buffer_available_bytes", labels, &card->metric_srt_receive_buffer_available_bytes, Metrics::TYPE_GAUGE); - global_metrics.add("srt_mss_bytes", labels, &card->metric_srt_mss_bytes, Metrics::TYPE_GAUGE); - - global_metrics.add("srt_sender_unacked_packets", labels, &card->metric_srt_sender_unacked_packets, Metrics::TYPE_GAUGE); - global_metrics.add("srt_sender_unacked_bytes", labels, &card->metric_srt_sender_unacked_bytes, Metrics::TYPE_GAUGE); - global_metrics.add("srt_sender_unacked_timespan_seconds", labels, &card->metric_srt_sender_unacked_timespan_seconds, Metrics::TYPE_GAUGE); - global_metrics.add("srt_sender_delivery_delay_seconds", labels, &card->metric_srt_sender_delivery_delay_seconds, Metrics::TYPE_GAUGE); - - global_metrics.add("srt_receiver_unacked_packets", labels, &card->metric_srt_receiver_unacked_packets, Metrics::TYPE_GAUGE); - global_metrics.add("srt_receiver_unacked_bytes", labels, &card->metric_srt_receiver_unacked_bytes, Metrics::TYPE_GAUGE); - global_metrics.add("srt_receiver_unacked_timespan_seconds", labels, &card->metric_srt_receiver_unacked_timespan_seconds, Metrics::TYPE_GAUGE); - global_metrics.add("srt_receiver_delivery_delay_seconds", labels, &card->metric_srt_receiver_delivery_delay_seconds, Metrics::TYPE_GAUGE); + card->srt_metrics.init(labels); } card->labels = labels; @@ -883,10 +771,10 @@ void Mixer::set_output_card_internal(int card_index) card->parked_capture = move(card->capture); CaptureInterface *fake_capture = new FakeCapture(global_flags.width, global_flags.height, FAKE_FPS, OUTPUT_FREQUENCY, card_index, global_flags.fake_cards_audio); configure_card(card_index, fake_capture, CardType::FAKE_CAPTURE, card->output.release(), /*is_srt_card=*/false); - card->queue_length_policy.reset(card_index); + card->jitter_history.clear(); card->capture->start_bm_capture(); desired_output_video_mode = output_video_mode = card->output->pick_video_mode(desired_output_video_mode); - card->output->start_output(desired_output_video_mode, pts_int); + card->output->start_output(desired_output_video_mode, pts_int, /*is_master_card=*/output_card_is_master); } output_card_index = card_index; output_jitter_history.clear(); @@ -967,7 +855,7 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode, // (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; - if (dropped_frames > MAX_FPS * 2) { + if (dropped_frames > TYPICAL_FPS * 2) { fprintf(stderr, "%s lost more than two seconds (or time code jumping around; from 0x%04x to 0x%04x), resetting resampler\n", description_for_card(card_index).c_str(), card->last_timecode, timecode); audio_mixer->reset_resampler(device); @@ -1035,7 +923,7 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode, if (card->type == CardType::FFMPEG_INPUT) { int srt_sock = static_cast(card->capture.get())->get_srt_sock(); if (srt_sock != -1) { - update_srt_stats(srt_sock, card); + card->srt_metrics.update_srt_stats(srt_sock); } } #endif @@ -1273,7 +1161,12 @@ void Mixer::thread_func() DeckLinkOutput *output = cards[output_card_index].output.get(); output->end_output(); desired_output_video_mode = output_video_mode = output->pick_video_mode(desired_output_video_mode); - output->start_output(desired_output_video_mode, pts_int); + output->start_output(desired_output_video_mode, pts_int, /*is_master_card=*/output_card_is_master); + } + + { + lock_guard lock(card_mutex); + handle_hotplugged_cards(); } CaptureCard::NewFrame new_frames[MAX_VIDEO_CARDS]; @@ -1281,7 +1174,7 @@ void Mixer::thread_func() bool master_card_is_output; unsigned master_card_index; - if (output_card_index != -1) { + if (output_card_index != -1 && output_card_is_master) { master_card_is_output = true; master_card_index = output_card_index; } else { @@ -1290,11 +1183,6 @@ void Mixer::thread_func() assert(master_card_index < MAX_VIDEO_CARDS); } - { - lock_guard lock(card_mutex); - handle_hotplugged_cards(); - } - vector raw_audio[MAX_VIDEO_CARDS]; // For MJPEG encoding. OutputFrameInfo output_frame_info = get_one_frame_from_each_card(master_card_index, master_card_is_output, new_frames, has_new_frame, raw_audio); schedule_audio_resampling_tasks(output_frame_info.dropped_frames, output_frame_info.num_samples, output_frame_info.frame_duration, output_frame_info.is_preroll, output_frame_info.frame_timestamp); @@ -1393,7 +1281,7 @@ void Mixer::thread_func() bool Mixer::input_card_is_master_clock(unsigned card_index, unsigned master_card_index) const { - if (output_card_index != -1) { + if (output_card_index != -1 && output_card_is_master) { // The output card (ie., cards[output_card_index].output) is the master clock, // so no input card (ie., cards[card_index].capture) is. return false; @@ -1471,7 +1359,7 @@ pair Mixer::get_channel_color_http(unsigned channel_idx) Mixer::OutputFrameInfo Mixer::get_one_frame_from_each_card(unsigned master_card_index, bool master_card_is_output, CaptureCard::NewFrame new_frames[MAX_VIDEO_CARDS], bool has_new_frame[MAX_VIDEO_CARDS], vector raw_audio[MAX_VIDEO_CARDS]) { OutputFrameInfo output_frame_info; - constexpr steady_clock::duration master_card_timeout = milliseconds(100); + constexpr steady_clock::duration master_card_timeout = milliseconds(200); start: unique_lock lock(card_mutex, defer_lock); bool timed_out = false; @@ -1485,14 +1373,20 @@ start: lock.lock(); timed_out = !cards[master_card_index].new_frames_changed.wait_for(lock, master_card_timeout, - [this, master_card_index]{ + [this, master_card_index] { return !cards[master_card_index].new_frames.empty() || + cards[master_card_index].capture == nullptr || cards[master_card_index].capture->get_disconnected(); }); + if (timed_out) { + fprintf(stderr, "WARNING: Master card (%s) did not deliver a frame for %u ms, creating a fake one.\n", + description_for_card(master_card_index).c_str(), + unsigned(duration_cast(master_card_timeout).count())); + } } if (timed_out) { - // The master card stalled for 100 ms (possible when it's e.g. + // The master card stalled for 200 ms (possible when it's e.g. // an SRT card). Send a frame no matter what; this also makes sure // any other cards get to empty their queues, and in general, // that we make _some_ sort of forward progress. @@ -1502,7 +1396,8 @@ start: } else if (cards[master_card_index].new_frames.empty()) { // We were woken up, but not due to a new frame. Deal with it // and then restart. - assert(cards[master_card_index].capture->get_disconnected()); + assert(cards[master_card_index].capture == nullptr || + cards[master_card_index].capture->get_disconnected()); handle_hotplugged_cards(); lock.unlock(); goto start; @@ -1572,6 +1467,14 @@ start: fractional_samples = num_samples_times_timebase % TIMEBASE; assert(output_frame_info.num_samples >= 0); + if (timed_out) { + DeviceSpec device{InputSourceType::CAPTURE_CARD, master_card_index}; + bool success; + do { + success = audio_mixer->add_silence(device, output_frame_info.num_samples, /*dropped_frames=*/0); + } while (!success); + } + return output_frame_info; } @@ -1581,11 +1484,23 @@ void Mixer::handle_hotplugged_cards() for (unsigned card_index = 0; card_index < MAX_VIDEO_CARDS; ++card_index) { CaptureCard *card = &cards[card_index]; if (card->capture != nullptr && card->capture->get_disconnected()) { - fprintf(stderr, "Card %u went away, replacing with a fake card.\n", card_index); - FakeCapture *capture = new FakeCapture(global_flags.width, global_flags.height, FAKE_FPS, OUTPUT_FREQUENCY, card_index, global_flags.fake_cards_audio); - configure_card(card_index, capture, CardType::FAKE_CAPTURE, /*output=*/nullptr, /*is_srt_card=*/false); - card->queue_length_policy.reset(card_index); - card->capture->start_bm_capture(); + bool is_active = card_index < unsigned(global_flags.min_num_cards) || cards[card_index].force_active; + if (is_active) { + fprintf(stderr, "Card %u went away, replacing with a fake card.\n", card_index); + FakeCapture *capture = new FakeCapture(global_flags.width, global_flags.height, FAKE_FPS, OUTPUT_FREQUENCY, card_index, global_flags.fake_cards_audio); + configure_card(card_index, capture, CardType::FAKE_CAPTURE, /*output=*/nullptr, /*is_srt_card=*/false); + card->jitter_history.clear(); + card->capture->start_bm_capture(); + } else { + // NOTE: The theme might end up forcing the card back at some later point + // (ie., force_active is false now, but might immediately be true again on + // e.g. the next frame). That should be rare, though, so we don't bother + // adjusting the message. + fprintf(stderr, "Card %u went away, removing. (To keep a fake card, increase --num-cards.)\n", card_index); + theme->remove_card(card_index); + configure_card(card_index, /*capture=*/nullptr, CardType::FAKE_CAPTURE, /*output=*/nullptr, /*is_srt_card=*/false); + card->jitter_history.clear(); + } } } @@ -1631,7 +1546,7 @@ void Mixer::handle_hotplugged_cards() CaptureCard *card = &cards[free_card_index]; BMUSBCapture *capture = new BMUSBCapture(free_card_index, new_dev); configure_card(free_card_index, capture, CardType::LIVE_CARD, /*output=*/nullptr, /*is_srt_card=*/false); - card->queue_length_policy.reset(free_card_index); + card->jitter_history.clear(); capture->set_card_disconnected_callback(bind(&Mixer::bm_hotplug_remove, this, free_card_index)); capture->start_bm_capture(); } @@ -1685,9 +1600,9 @@ void Mixer::handle_hotplugged_cards() FFmpegCapture *capture = new FFmpegCapture(sock, stream_id); capture->set_card_index(free_card_index); configure_card(free_card_index, capture, CardType::FFMPEG_INPUT, /*output=*/nullptr, /*is_srt_card=*/true); - update_srt_stats(sock, card); // Initial zero stats. + card->srt_metrics.update_srt_stats(sock); // Initial zero stats. card->last_srt_stream_id = stream_id; - card->queue_length_policy.reset(free_card_index); + card->jitter_history.clear(); capture->set_card_disconnected_callback(bind(&Mixer::bm_hotplug_remove, this, free_card_index)); capture->start_bm_capture(); } @@ -1700,7 +1615,7 @@ void Mixer::handle_hotplugged_cards() if (card->capture == nullptr && card->force_active) { FakeCapture *capture = new FakeCapture(global_flags.width, global_flags.height, FAKE_FPS, OUTPUT_FREQUENCY, card_index, global_flags.fake_cards_audio); configure_card(card_index, capture, CardType::FAKE_CAPTURE, /*output=*/nullptr, /*is_srt_card=*/false); - card->queue_length_policy.reset(card_index); + card->jitter_history.clear(); card->capture->start_bm_capture(); } } @@ -1780,7 +1695,7 @@ void Mixer::render_one_frame(int64_t duration) output_ycbcr_format.chroma_subsampling_y = 1; output_ycbcr_format.luma_coefficients = ycbcr_output_coefficients; output_ycbcr_format.full_range = false; - output_ycbcr_format.num_levels = 1 << global_flags.x264_bit_depth; + output_ycbcr_format.num_levels = 1 << global_flags.bit_depth; chain->change_ycbcr_output_format(output_ycbcr_format); // Render main chain. If we're using zerocopy Quick Sync encoding @@ -1793,8 +1708,8 @@ void Mixer::render_one_frame(int64_t duration) GLuint y_tex, cbcr_full_tex, cbcr_tex; GLuint y_copy_tex, cbcr_copy_tex = 0; GLuint y_display_tex, cbcr_display_tex; - GLenum y_type = (global_flags.x264_bit_depth > 8) ? GL_R16 : GL_R8; - GLenum cbcr_type = (global_flags.x264_bit_depth > 8) ? GL_RG16 : GL_RG8; + GLenum y_type = (global_flags.bit_depth > 8) ? GL_R16 : GL_R8; + GLenum cbcr_type = (global_flags.bit_depth > 8) ? GL_RG16 : GL_RG8; const bool is_zerocopy = video_encoder->is_zerocopy(); if (is_zerocopy) { cbcr_full_tex = resource_pool->create_2d_texture(cbcr_type, global_flags.width, global_flags.height); @@ -1946,7 +1861,7 @@ void Mixer::quit() if (global_flags.srt_port >= 0) { // There's seemingly no other reasonable way to wake up the thread // (libsrt's epoll equivalent is busy-waiting). - int sock = srt_socket(AF_INET6, 0, 0); + int sock = srt_create_socket(); if (sock != -1) { sockaddr_in6 addr; memset(&addr, 0, sizeof(addr)); @@ -1986,7 +1901,7 @@ void Mixer::set_input_ycbcr_interpretation(unsigned card_index, const YCbCrInter void Mixer::start_mode_scanning(unsigned card_index) { assert(card_index < MAX_VIDEO_CARDS); - if (cards[card_index].capture != nullptr) { + if (cards[card_index].capture == nullptr) { // Inactive card. Should never happen. return; } @@ -2155,13 +2070,19 @@ void Mixer::OutputChannel::set_color_updated_callback(Mixer::color_updated_callb #ifdef HAVE_SRT void Mixer::start_srt() { - SRTSOCKET sock = srt_socket(AF_INET6, 0, 0); + SRTSOCKET sock = srt_create_socket(); sockaddr_in6 addr; memset(&addr, 0, sizeof(addr)); addr.sin6_family = AF_INET6; addr.sin6_port = htons(global_flags.srt_port); - int err = srt_bind(sock, (sockaddr *)&addr, sizeof(addr)); + int zero = 0; + int err = srt_setsockopt(sock, /*level=*/0, SRTO_IPV6ONLY, &zero, sizeof(zero)); + if (err != 0) { + fprintf(stderr, "srt_setsockopt(SRTO_IPV6ONLY): %s\n", srt_getlasterror_str()); + abort(); + } + err = srt_bind(sock, (sockaddr *)&addr, sizeof(addr)); if (err != 0) { fprintf(stderr, "srt_bind: %s\n", srt_getlasterror_str()); abort(); @@ -2197,59 +2118,6 @@ void Mixer::start_srt() } #endif -#ifdef HAVE_SRT -void Mixer::update_srt_stats(int srt_sock, Mixer::CaptureCard *card) -{ - SRT_TRACEBSTATS stats; - srt_bistats(srt_sock, &stats, /*clear=*/0, /*instantaneous=*/1); - - card->metric_srt_uptime_seconds = stats.msTimeStamp * 1e-3; - card->metric_srt_send_duration_seconds = stats.usSndDurationTotal * 1e-6; - card->metric_srt_sent_bytes = stats.byteSentTotal; - card->metric_srt_received_bytes = stats.byteRecvTotal; - card->metric_srt_sent_packets_normal = stats.pktSentTotal; - card->metric_srt_received_packets_normal = stats.pktRecvTotal; - card->metric_srt_sent_packets_lost = stats.pktSndLossTotal; - card->metric_srt_received_packets_lost = stats.pktRcvLossTotal; - card->metric_srt_sent_packets_retransmitted = stats.pktRetransTotal; - card->metric_srt_sent_bytes_retransmitted = stats.byteRetransTotal; - card->metric_srt_sent_packets_ack = stats.pktSentACKTotal; - card->metric_srt_received_packets_ack = stats.pktRecvACKTotal; - card->metric_srt_sent_packets_nak = stats.pktSentNAKTotal; - card->metric_srt_received_packets_nak = stats.pktRecvNAKTotal; - card->metric_srt_sent_packets_dropped = stats.pktSndDropTotal; - card->metric_srt_received_packets_dropped = stats.pktRcvDropTotal; - card->metric_srt_sent_bytes_dropped = stats.byteSndDropTotal; - card->metric_srt_received_bytes_dropped = stats.byteRcvDropTotal; - card->metric_srt_received_packets_undecryptable = stats.pktRcvUndecryptTotal; - card->metric_srt_received_bytes_undecryptable = stats.byteRcvUndecryptTotal; - card->metric_srt_filter_sent_packets = stats.pktSndFilterExtraTotal; - card->metric_srt_filter_received_extra_packets = stats.pktRcvFilterExtraTotal; - card->metric_srt_filter_received_rebuilt_packets = stats.pktRcvFilterSupplyTotal; - card->metric_srt_filter_received_lost_packets = stats.pktRcvFilterLossTotal; - - // Gauges. - card->metric_srt_packet_sending_period_seconds = stats.usPktSndPeriod * 1e-6; - card->metric_srt_flow_window_packets = stats.pktFlowWindow; - card->metric_srt_congestion_window_packets = stats.pktCongestionWindow; - card->metric_srt_flight_size_packets = stats.pktFlightSize; - card->metric_srt_rtt_seconds = stats.msRTT * 1e-3; - card->metric_srt_estimated_bandwidth_bits_per_second = stats.mbpsBandwidth * 1e6; - card->metric_srt_bandwidth_ceiling_bits_per_second = stats.mbpsMaxBW * 1e6; - card->metric_srt_send_buffer_available_bytes = stats.byteAvailSndBuf; - card->metric_srt_receive_buffer_available_bytes = stats.byteAvailRcvBuf; - card->metric_srt_mss_bytes = stats.byteMSS; - card->metric_srt_sender_unacked_packets = stats.pktSndBuf; - card->metric_srt_sender_unacked_bytes = stats.byteSndBuf; - card->metric_srt_sender_unacked_timespan_seconds = stats.msSndBuf * 1e-3; - card->metric_srt_sender_delivery_delay_seconds = stats.msSndTsbPdDelay * 1e-3; - card->metric_srt_receiver_unacked_packets = stats.pktRcvBuf; - card->metric_srt_receiver_unacked_bytes = stats.byteRcvBuf; - card->metric_srt_receiver_unacked_timespan_seconds = stats.msRcvBuf * 1e-3; - card->metric_srt_receiver_delivery_delay_seconds = stats.msRcvTsbPdDelay * 1e-3; -} -#endif - string Mixer::description_for_card(unsigned card_index) { CaptureCard *card = &cards[card_index];