#include <google/protobuf/util/json_util.h>
#include "json.pb.h"
+#ifdef HAVE_SRT
+// Must come after CEF, since it includes <syslog.h>, which has #defines
+// that conflict with CEF logging constants.
+#include <srt/srt.h>
+#endif
+
class IDeckLink;
class QOpenGLContext;
BMUSBCapture::set_card_connected_callback(bind(&Mixer::bm_hotplug_add, this, _1));
BMUSBCapture::start_bm_thread();
+#ifdef HAVE_SRT
+ if (global_flags.srt_port >= 0) {
+ start_srt();
+ }
+#endif
+
for (unsigned card_index = 0; card_index < num_cards + num_video_inputs + num_html_inputs; ++card_index) {
cards[card_index].queue_length_policy.reset(card_index);
}
video_encoder.reset(nullptr);
}
-void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, CardType card_type, DeckLinkOutput *output)
+void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, CardType card_type, DeckLinkOutput *output, bool override_card_as_live)
{
printf("Configuring card %d...\n", card_index);
// NOTE: start_bm_capture() happens in thread_func().
+ if (override_card_as_live) {
+ assert(card_type == CardType::FFMPEG_INPUT);
+ }
+
DeviceSpec device;
- if (card_type == CardType::FFMPEG_INPUT) {
+ if (card_type == CardType::FFMPEG_INPUT && !override_card_as_live) {
device = DeviceSpec{InputSourceType::FFMPEG_VIDEO_INPUT, card_index - num_cards};
} else {
device = DeviceSpec{InputSourceType::CAPTURE_CARD, card_index};
assert(master_card_index < num_cards + num_video_inputs);
}
+ handle_hotplugged_cards();
+
vector<int32_t> 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);
stats_dropped_frames += output_frame_info.dropped_frames;
- handle_hotplugged_cards();
-
for (unsigned card_index = 0; card_index < num_cards + num_video_inputs + num_html_inputs; ++card_index) {
DeviceSpec device = card_index_to_device(card_index, num_cards);
if (card_index == master_card_index || !has_new_frame[card_index]) {
// Check for cards that have been connected since last frame.
vector<libusb_device *> hotplugged_cards_copy;
+#ifdef HAVE_SRT
+ vector<int> hotplugged_srt_cards_copy;
+#endif
{
lock_guard<mutex> lock(hotplug_mutex);
swap(hotplugged_cards, hotplugged_cards_copy);
+#ifdef HAVE_SRT
+ swap(hotplugged_srt_cards, hotplugged_srt_cards_copy);
+#endif
}
for (libusb_device *new_dev : hotplugged_cards_copy) {
// Look for a fake capture card where we can stick this in.
capture->start_bm_capture();
}
}
+
+#ifdef HAVE_SRT
+ // Same, for SRT inputs.
+ // TODO: On disconnect and reconnect, we might want to use the stream ID
+ // to find the slot it used to go into?
+ for (SRTSOCKET sock : hotplugged_srt_cards_copy) {
+ // Look for a fake capture card where we can stick this in.
+ int free_card_index = -1;
+ for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
+ if (cards[card_index].is_fake_capture) {
+ free_card_index = card_index;
+ break;
+ }
+ }
+
+ char name[256];
+ int namelen = sizeof(name);
+ srt_getsockopt(sock, /*ignored=*/0, SRTO_STREAMID, name, &namelen);
+ string stream_id(name, namelen);
+
+ if (free_card_index == -1) {
+ if (stream_id.empty()) {
+ stream_id = "no name";
+ }
+ fprintf(stderr, "New SRT stream connected (%s), but no free slots -- ignoring.\n", stream_id.c_str());
+ srt_close(sock);
+ } else {
+ // FFmpegCapture takes ownership.
+ if (stream_id.empty()) {
+ fprintf(stderr, "New unnamed SRT stream connected, choosing slot %d.\n", free_card_index);
+ } else {
+ fprintf(stderr, "New SRT stream connected (%s), choosing slot %d.\n", stream_id.c_str(), free_card_index);
+ }
+ CaptureCard *card = &cards[free_card_index];
+ 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, /*override_card_as_live=*/true);
+ card->queue_length_policy.reset(free_card_index);
+ capture->set_card_disconnected_callback(bind(&Mixer::bm_hotplug_remove, this, free_card_index));
+ capture->start_bm_capture();
+ }
+ }
+#endif
}
audio_task_queue_changed.notify_one();
mixer_thread.join();
audio_thread.join();
+#ifdef HAVE_SRT
+ 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);
+ if (sock != -1) {
+ sockaddr_in6 addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.sin6_family = AF_INET6;
+ addr.sin6_addr = IN6ADDR_LOOPBACK_INIT;
+ addr.sin6_port = htons(global_flags.srt_port);
+ srt_connect(sock, (sockaddr *)&addr, sizeof(addr));
+ srt_close(sock);
+ }
+ srt_thread.join();
+ }
+#endif
}
void Mixer::transition_clicked(int transition_num)
color_updated_callback = callback;
}
+#ifdef HAVE_SRT
+void Mixer::start_srt()
+{
+ SRTSOCKET sock = srt_socket(AF_INET6, 0, 0);
+ 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));
+ if (err != 0) {
+ fprintf(stderr, "srt_bind: %s\n", srt_getlasterror_str());
+ abort();
+ }
+ err = srt_listen(sock, MAX_VIDEO_CARDS);
+ if (err != 0) {
+ fprintf(stderr, "srt_listen: %s\n", srt_getlasterror_str());
+ abort();
+ }
+
+ srt_thread = thread([this, sock] {
+ sockaddr_in6 addr;
+ for ( ;; ) {
+ int sa_len = sizeof(addr);
+ int clientsock = srt_accept(sock, (sockaddr *)&addr, &sa_len);
+ if (should_quit) {
+ if (clientsock != -1) {
+ srt_close(clientsock);
+ }
+ break;
+ }
+ lock_guard<mutex> lock(hotplug_mutex);
+ hotplugged_srt_cards.push_back(clientsock);
+ }
+ srt_close(sock);
+ });
+}
+#endif
+
mutex RefCountedGLsync::fence_lock;
projects / nageru / blobdiff