Wirecast is a great tool for live streaming. At Fellowship Greenville, we use it as our encoder to stream to YouTube Live, whether it be the regular Sunday morning sermon live stream, or for special events, conferences, funerals, etc.
Lately, I’ve been working specifically on some improvements to make it easier for me to operate a live stream from our second auditorium, where we typically host funeral services and special events. Our live stream server is located in our control rooms in the main building, so when I am working tech for an event in the second auditorium, I am completely separated from the control rooms.
For regular Sunday services, that’s not a problem to be separated because we have a great team of volunteers working in both areas who stay in communication with and support each other. But for smaller services like a funeral, where it is typically only me and one other staff member running everything, it can be challenging to run a full production while I am sitting in the tech booth, far away from the control room areas where the live stream server and video switcher are located.
This is where my Stream Deck Production Controller software is going to be a great help. I have created a button set that allows me to send RossTalk commands to the Ross Carbonite switcher, change the necessary routes on the BlackMagic VideoHub router, and start/stop the Wirecast live stream.
So how does this work? The Stream Deck software is sending a GPI trigger request to Dashboard, where I have these buttons in my production control custom panel:
Clicking the “Wirecast – Start Streaming” button runs a custom ogscript function that runs this AppleScript:
And that’s it! By using the existing infrastructure I’ve designed for our production control, I’m now able to easily run the live stream but still maintain high value in what is streamed. By using the stream deck to operate not only Wirecast, but the video switcher remotely, I can change sources as needed, play videos, show cameras, etc. I even have a button that jumps to my PTZ camera control where I can recall presets that I’ve designed specifically for special events like this!
My Stream Deck software is available on Github if you would like to use it, and feel free to reach out if I can help!
In Part 1 of this post, I wrote about the technical side of how to use Ross Dashboard to send a TCP message to a Blackmagic VideoHub video router.
I thought I would expand on that recently and now I have made available a panel that, when set up with the IP address and port of the router, will automatically load the input (source) and output (destination) names into dropdown lists where the user can easily choose a source and destination to make a route.
We have a Panasonic AW-HE40 located in each auditorium at my church to allow the control room operators to see the space. We also occasionally use them as on-screen cameras since they have HD-SDI outputs. The quality is surprising for the size of the device.
The cameras come with a fully functional webpage that allows you to control them.
By peeking around at the code some, I was able to figure out how to send HTTP requests to change presets of the camera.
Here is my Ross Dashboard custom panel that allows our volunteers to quickly pull up presets:
The panel allows the user to see the camera’s viewing angle and select a pre-defined preset. Presets can be modified within the existing web interface for the camera. A Setup tab is also available to configure the IP address of the camera you wish to control.
If you use my panel, you’ll still need to manage/modify the presets using the existing interface. We don’t change our presets often, so I didn’t feel the need to recreate any other functionality than recalling presets.
At my church, we use Unity Intercom to expand our wired intercom system. It is very useful to have users who can be mobile and still stay in communication.
We wanted to have the ability for our directors to see who is currently logged into Unity without having to log into the server or be logged into a Unity client on a device.
After doing some digging and consulting the forums, I found out that if you go to this address:
http://unityserverIPaddr:20101/userconfig
The Unity server will return a JSON dataset of the server information including the list of users.
I’ve had a few people ask about my custom panel in Ross Dashboard that controls Aja Ki Pro recorders using their built-in RESTful API, so I thought I would write a quick post about how that works.
AJA has done an excellent job of creating an accessible device with their API. The web browser interface is great and you can edit or control nearly every aspect of the device from there. The main reason I created the Dashboard interface was to limit that control and simplify the use for volunteers who may not want to get into the complexity of it all.
This is a screenshot of the built-in web interface of the Ki Pro.
Their RESTful API takes simple parameters as querystrings and returns JSON data that can be easily parsed for the results and manipulated.
My panel in Dashboard just takes advantage of this API to make all of the requests to get and set the data. By using a timer function, I am also able to keep the Dashboard panel in sync with the physical state of the actual Ki Pro deck, which is helpful in case someone manually presses a transport button or otherwise makes a change.
The setup tab is fairly basic, you can set the IP address of the Ki Pro and default video/audio input options. The API itself supports many more changes, so if you need to change those options more often, the panel could be modified to support that.Full transport control as well as custom clip names, changing slots (drives), etc. This will follow the state of the actual Ki Pro and update itself if the Ki Pro is armed or changed outside of the Dashboard panel.
Here is a screenshot of one of the functions that gets the current transport state.
If you are interested in everything the Aja Ki Pro API supports, you can get a list of all available parameters by going to:
A few months ago, I picked up this nifty device called a Stream Deck made by Elgato Gaming. It’s a 15-button USB keyboard with LCD buttons. It’s primarily marketed towards gamers who live stream so they can have quick access to commands and functions as they stream. The programmer in me couldn’t resist trying it out to help us with our production setup.
The Stream Deck sells for about $140.
Using the base software provided, I was able to fairly quickly implement a workflow to allow volunteers to have easy access to buttons that then fire commands on our Ross Dashboard Production Control ecosystem. If you’ve not used Dashboard before, you can read about how we use it at my church here. It’s fairly easy to set up a custom panel in Dashboard that runs an HTTP web server at a specific port, which in turns allow you to “click” a button on the panel by calling that button’s trigger ID remotely via a specific URL.
Using the “URL” method provided in the base software, we are able to make web calls to the Dashboard custom panels to fire the commands. All the logic/code remains in Dashboard, and this just becomes a method of executing those commands remotely via an HTTP request.
Here is a screenshot of the base software provided by Elgato. It’s very functional as is.
We used the base software for a few months without issue, however quickly realized the limitation of not being able to have bi-directional communication between our Dashboard Production Control and the individual Stream Decks. For example, several of our commands act as “toggles”, meaning we can have a few different state options that represent the current status of a device. If I only had one person making changes or operating the system, it wouldn’t be a huge issue. That person would hopefully remember what button they pressed last. However, when there are a lot of moving parts and multiple people controlling systems, the ability to update status on all devices becomes very helpful.
Enter NodeJS. People smarter than me took the time to write a base NodeJS library to control the Stream Deck. I hadn’t written in NodeJS before, but being a programmer, I was ready to learn something new. I downloaded and installed all the necessary libraries, IDE, etc. and quickly whipped up some code using the base library to control our stream decks. In just a few hours, I had something operational and started running it from the command line. I then spent a couple of weeks refining it and now we have a fully functional, self contained app that can run on Mac, Windows or Linux. It’s packaged using the Electron libraries made freely available with the Node platform.
This was the quick icon I whipped up for the software.
My controller software uses a base JSON file which defines the button structure of the stream deck. This makes it very flexible and expandable as our needs grow as I can just modify the JSON file to change the button structure.
Here’s an example screenshot of one of my button files, written in JavaScript Object Notation. This allows me to add or remove buttons very easily and also programmatically.
The software then parses that JSON and builds the buttons on the Stream Deck in real time. If a button has a trigger action assigned, the command is sent to the corresponding device. I’ve written support for several protocols, including the Dashboard Web Call, RossTalk (good for sending messages to your Ross equipment), OSC, VideoHub routing, and more. You can even do internal stuff like jumping from one button page to another, changing button images during actions, etc. Each button can support an unlimited number of button actions, which I called triggers.
The app runs completely in the tray with a simple context menu.
It also supports defining a set of devices, so if there’s a device you want to send messages to often, you can define the device in a separate file along with its host, port, type, etc. and then only refer to that device in the button structure. That way, if any of those related variables change, you only have to change it in one place.
The software also runs a basic TCP listener server on a specific port, and this is where the bi-directional communication comes into play. Anytime a command is run on the master Dashboard Custom Panel Production Control, it relays a message to the remote Stream Deck via the TCP listener and updates the state of the button.
The settings menu allows you to choose the button/device files you want to use as well as whether the TCP listener service and notifications are turned on.A sample notification that can appear when a button is pressed. You can determine which triggers sent notifications.
This means that we can run commands from any originating location, whether it is the web-based production control (that I’m still developing), one of the remote Dashboard panels that connects to Production Control, one of the Stream Decks (we currently have 2 of them, one in each control room), or even the Master Control panel and every device will receive an updated status.
I also added a “Virtual Deck” option, which allows you to operate the software with or without having a physical Stream Deck attached. You can also choose to have the Virtual Deck operate independently of your physical Stream Deck, so it’s like having two decks in one!
Here is a screenshot of the Virtual Deck in action.Here is what some buttons that have been toggled look like on the Virtual Deck. It’s very clear to see the current state of those buttons!
I am making this software freely available to anyone who can benefit from it. My hope is that the local church can make use of this to allow their volunteers to more easily operate tech equipment during services.
I’ve only built a Mac binary, but you can easily package it for Windows or Linux if needed.
I am working on an Editor function right now that will allow you to add/edit buttons without having to write them in JSON, but until then, you’ll have to make do with that option. Here’s a good tutorial on learning JSON if you need help: https://www.codecademy.com/courses/javascript-beginner-en-xTAfX/0/1
If I can help you out along the way, don’t hesitate to reach out!
Here’s a quick post to share how to control your BlackMagic VideoHub from a Ross Dashboard Custom Panel.
If you have any BlackMagic VideoHub router, it comes with software that allows you to make routing changes over the network. It’s pretty simple and easy to use.
What you may not know is that it can also accept telnet commands by default over port 9990. This means you can control it from a command line, or by sending TCP messages.
Ross Dashboard has a built in function, rosstalk.sendMessage which is designed for sending simple TCP messages. Combine these two things together, and now you can have a button on your own custom panel where you can make a video route easily.
In Dashboard, create a new custom panel, and add a button to that panel.
Under Tasks, click “Add”, and type in this code:
var command = "VIDEO OUTPUT ROUTING:\r\n";
var videoHub_address = "192.168.1.100";
var destination = 5;
var source = 25;
command = command + (destination -1) + " " + (source - 1) + "\r\n\r\n";
rosstalk.sendMessage(videoHub_address, 9990, command, null);
The router operates with zero based indexes, which means if your destination number is 5, for example, the router treats it internally as 4. So, this script just substracts those numbers internally before submitting the command to the router.
