X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Fmixer.h;h=af07f8896665044291a281918af5bbd51961cd0a;hb=911fc5867669e9808da80140b24c819b05471f73;hp=61db4a5c30857b06728d8dee0810a6caf3a06df1;hpb=0490c42536a845dd6d718a7c58cfb3e3ab02b1ab;p=nageru diff --git a/nageru/mixer.h b/nageru/mixer.h index 61db4a5..af07f88 100644 --- a/nageru/mixer.h +++ b/nageru/mixer.h @@ -331,6 +331,12 @@ public: bool card_is_ffmpeg(unsigned card_index) const { assert(card_index < num_cards + num_video_inputs); + if (card_index < num_cards) { + // SRT inputs are more like regular inputs than FFmpeg inputs, + // so show them as such. (This allows the user to right-click + // to select a different input.) + return false; + } return cards[card_index].type == CardType::FFMPEG_INPUT; } @@ -439,7 +445,7 @@ private: FFMPEG_INPUT, CEF_INPUT, }; - void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, CardType card_type, DeckLinkOutput *output); + void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, CardType card_type, DeckLinkOutput *output, bool is_srt_card = false); void set_output_card_internal(int card_index); // Should only be called from the mixer thread. void bm_frame(unsigned card_index, uint16_t timecode, bmusb::FrameAllocator::Frame video_frame, size_t video_offset, bmusb::VideoFormat video_format, @@ -454,6 +460,9 @@ private: void render_one_frame(int64_t duration); void audio_thread_func(); void release_display_frame(DisplayFrame *frame); +#ifdef HAVE_SRT + void start_srt(); +#endif double pts() { return double(pts_int) / TIMEBASE; } void trim_queue(CaptureCard *card, size_t safe_queue_length); std::pair get_channels_json(); @@ -501,11 +510,19 @@ private: // frame rate is integer, will always stay zero. unsigned fractional_samples = 0; + // Monotonic counter that lets us know which slot was last turned into + // a fake capture. Used for SRT re-plugging. + unsigned fake_capture_counter = 0; + mutable std::mutex card_mutex; bool has_bmusb_thread = false; struct CaptureCard { std::unique_ptr capture; bool is_fake_capture; + // If is_fake_capture is true, contains a monotonic timer value for when + // it was last changed. Otherwise undefined. Used for SRT re-plugging. + int fake_capture_counter; + std::string last_srt_stream_id = ""; // Used for SRT re-plugging. CardType type; std::unique_ptr output; @@ -573,6 +590,53 @@ private: std::atomic metric_input_frame_rate_nom{-1}; std::atomic metric_input_frame_rate_den{-1}; std::atomic metric_input_sample_rate_hz{-1}; + + // SRT metrics. + std::atomic metric_srt_uptime_seconds{0.0 / 0.0}; + std::atomic metric_srt_send_duration_seconds{0.0 / 0.0}; + std::atomic metric_srt_sent_bytes{-1}; + std::atomic metric_srt_received_bytes{-1}; + std::atomic metric_srt_sent_packets_normal{-1}; + std::atomic metric_srt_received_packets_normal{-1}; + std::atomic metric_srt_sent_packets_lost{-1}; + std::atomic metric_srt_received_packets_lost{-1}; + std::atomic metric_srt_sent_packets_retransmitted{-1}; + std::atomic metric_srt_sent_bytes_retransmitted{-1}; + std::atomic metric_srt_sent_packets_ack{-1}; + std::atomic metric_srt_received_packets_ack{-1}; + std::atomic metric_srt_sent_packets_nak{-1}; + std::atomic metric_srt_received_packets_nak{-1}; + std::atomic metric_srt_sent_packets_dropped{-1}; + std::atomic metric_srt_received_packets_dropped{-1}; + std::atomic metric_srt_sent_bytes_dropped{-1}; + std::atomic metric_srt_received_bytes_dropped{-1}; + std::atomic metric_srt_received_packets_undecryptable{-1}; + std::atomic metric_srt_received_bytes_undecryptable{-1}; + + std::atomic metric_srt_filter_received_extra_packets{-1}; + std::atomic metric_srt_filter_received_rebuilt_packets{-1}; + std::atomic metric_srt_filter_received_lost_packets{-1}; + + std::atomic metric_srt_packet_sending_period_seconds{0.0 / 0.0}; + std::atomic metric_srt_flow_window_packets{-1}; + std::atomic metric_srt_congestion_window_packets{-1}; + std::atomic metric_srt_flight_size_packets{-1}; + std::atomic metric_srt_rtt_seconds{0.0 / 0.0}; + std::atomic metric_srt_estimated_bandwidth_bits_per_second{0.0 / 0.0}; + std::atomic metric_srt_bandwidth_ceiling_bits_per_second{0.0 / 0.0}; + std::atomic metric_srt_send_buffer_available_bytes{-1}; + std::atomic metric_srt_receive_buffer_available_bytes{-1}; + std::atomic metric_srt_mss_bytes{-1}; + std::atomic metric_srt_sender_unacked_packets{-1}; + std::atomic metric_srt_sender_unacked_bytes{-1}; + std::atomic metric_srt_sender_unacked_timespan_seconds{0.0 / 0.0}; + std::atomic metric_srt_sender_delivery_delay_seconds{0.0 / 0.0}; + std::atomic metric_srt_receiver_unacked_packets{-1}; + std::atomic metric_srt_receiver_unacked_bytes{-1}; + std::atomic metric_srt_receiver_unacked_timespan_seconds{0.0 / 0.0}; + std::atomic metric_srt_receiver_delivery_delay_seconds{0.0 / 0.0}; + std::atomic metric_srt_filter_sent_packets{-1}; + }; JitterHistory output_jitter_history; CaptureCard cards[MAX_VIDEO_CARDS]; // Protected by . @@ -589,12 +653,19 @@ private: }; OutputFrameInfo 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], std::vector raw_audio[MAX_VIDEO_CARDS]); +#ifdef HAVE_SRT + void update_srt_stats(int srt_sock, Mixer::CaptureCard *card); +#endif + InputState input_state; // Cards we have been noticed about being hotplugged, but haven't tried adding yet. // Protected by its own mutex. std::mutex hotplug_mutex; std::vector hotplugged_cards; +#ifdef HAVE_SRT + std::vector hotplugged_srt_cards; +#endif class OutputChannel { public: @@ -627,6 +698,9 @@ private: std::thread mixer_thread; std::thread audio_thread; +#ifdef HAVE_SRT + std::thread srt_thread; +#endif std::atomic should_quit{false}; std::atomic should_cut{false};