Triggering Wirecast Remotely using Elgato Stream Deck

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.

IMG_5668.JPG-1.jpeg

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:

Screen Shot 2018-06-15 at 11.18.59 AM

Clicking the “Wirecast – Start Streaming” button runs a custom ogscript function that runs this AppleScript:

Screen Shot 2018-06-15 at 11.23.04 AM

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!

Controlling BlackMagic VideoHub from Ross Dashboard, Part 2

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.

Screen Shot 2018-06-14 at 2.32.25 PM

Screen Shot 2018-06-14 at 2.32.39 PM

Screen Shot 2018-06-14 at 2.32.31 PM

It’s up on my Github respository if you can benefit from it!

Remote Control of Panasonic AW-HE40 PTZ Camera through Dashboard

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.

aw-he40swpj_2_1024_0

The cameras come with a fully functional webpage that allows you to control them.

Screen Shot 2018-06-12 at 9.26.40 AM

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:

 

Screen Shot 2018-06-12 at 11.41.45 AM
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.

I’ve made this panel available on Github here if you can benefit from it: https://github.com/josephdadams/RossDashboardPanels

Getting A List of Active Users in Unity Intercom

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.

"users":[{"username":"josephadams", "title":"Joseph Adams", "allowedrcv":"63", "online":"0", "notify":"yes", "locksettings":"no", "lockchannels":"no", "groups":[{"groupNumber":"0", "transmit":"63", "receive":"63"}]},{"username":"technician", "title":"FG Tech User", "allowedrcv":"63", "online":"0", "notify":"yes", "locksettings":"no", "lockchannels":"no", "groups":[{"groupNumber":"0", "transmit":"9", "receive":"63"}]}]

Once you’ve parsed that JSON into objects, you just have to check if the “online” property is 0 (false) or 1 (true) and you now know who is logged in!

I added this to our director’s dashboard so now they can easily see who is available.

Screen Shot 2018-06-12 at 9.10.05 AM

It’s great when we can extend software like this! I wish more software developers exposed REST API’s for their users. Great job, Unity!

Controlling Aja Ki Pro in Ross Dashboard

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.

Screen Shot 2018-06-11 at 12.30.33 PM

 

Screen Shot 2018-06-11 at 12.30.46 PM
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.

For example, if you make this request:

http://kiproIPaddr/config?action=get&paramid=eParamID_TransportState

You will get a response like this, showing the current transport state of the Ki Pro:

{"paramid":"2097217802","name":"eParamID_TransportState","value":"1","value_name":"Idle"}

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.

 

Screen Shot 2018-06-11 at 12.21.30 PM
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.
Screen Shot 2018-06-11 at 12.22.26 PM
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.

 

 

Screen Shot 2018-06-11 at 12.34.35 PM
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:

http://kiproIPaddr/descriptors

I hope this is helpful! If you would like to download my custom panel, it is available on Github: https://github.com/josephdadams/RossDashboardPanels

Elgato Stream Deck as Production Controller

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.

elgato-strream-deck-boxshot-tecs
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.

Screen Shot 2018-05-01 at 8.16.41 PM
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.

1024x1024
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.

Screen Shot 2018-05-01 at 8.25.25 PM
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.

Screen Shot 2018-05-01 at 8.17.40 PM
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.

screen-shot-2018-05-01-at-8-18-05-pm.png
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.
Screen Shot 2018-05-01 at 8.18.13 PM
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!

Screen Shot 2018-05-01 at 8.17.26 PM
Here is a screenshot of the Virtual Deck in action.
Screen Shot 2018-05-01 at 8.18.26 PM
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.

It’s currently up on GitHub here: https://github.com/josephdadams/StreamDeckProductionController

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!

Controlling BlackMagic VideoHub from Ross Dashboard

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.

Screen Shot 2018-04-30 at 2.54.39 PM

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.

Happy routing!