Q-SYS Corner

[Steve Guttag]

Q-SYS For Cinema Blog-21 Plugins and User Components

_9/13/25

image.png

Current QDS Versions: 10.0.1 and 9.13.1 LTS Introduction

A continual theme in my blogs about Q-SYS is that it is not just a sound system. It is an entire ecosystem that includes audio, control, and video. Plugins and User Components are one of the means to better integrate Q-SYS in your cinema environment and tie everything together.
Additionally, note that QDS 9.13.1 LTS has been released and should be, in my opinion, the QDS of choice, if your Core choice so permits. There are a LOT of bug fixes included in this release.

Disclosure

I do not, in any way, work for QSC/Q-SYS. These thoughts are my own based on my own interactions with the product(s) and implementing Q-SYS within actual cinema environments. I do work for a dealer that has sold QSC products since the 1980s, including Q-SYS and its predecessors. For the purposes of this blog, I represent only myself and not my employer(s) or any other company.

The Hierarchy

User Components

User Components are a bit of a broad area. Anything can be a user component. If you have a single component or an entire schematic*, you can store it as a “User Component.”

*Left Side Pane items, like snapshots or speakers, and amplifiers, will not be stored in the User Component.

Key Concept: User Components can be passed between QDS versions (and between users). So long as the components used in the User Component are available in a lesser QDS version, you can pass a User Component from a newer QDS version to an older one. So, if you are going to share a creation of yours, share it as a User Component rather than as a Schematic (unless you are both on the same QDS version).

When it comes to making your own components, be they just a single component, a schematic, like your “test kit,” a collection of logic components, a script you’ve made using the Block Controller, or even via LUA scripting (Control Script or Text Controller). These all are stored as “User Components.”

Plugins

Plugins are scripts (they all start as scripts) that have gone through the extra steps to finish them off as a plugin. If you are interested in turning your LUA script into a plugin, information on that process can be found here:
https://q-syshelp.qsc.com/DeveloperHelp/
https://developers.qsc.com/s/resourcespage
A key advantage of a plugin over a mere script is the ability to revise it without having to remove/reapply the component within your designs. Let’s say you’ve deployed a bunch of your favorite plugin and you decide to update it for a new feature or to fix a bug. You can update the plugin and the next time you open designer with the updated plugin and a design that uses the plugin, you’ll be greeted with a question of if you want to continue to use the version that is in the design or if you want to use the newer version that is part of your QDS. This can save a lot of time and reduce mistakes caused by remove/replace of user components.

If you want to be a Q-SYS partner (where you develop plugins, as a business), then you can also get them listed in Asset Manager and have them certified for use with things like “Reflect.” But that is beyond the scope of this blog.

I will note, however, just because you have a plugin within Asset Manager, it does not mean that it is “free.” Asset Manager can be just like the various App Stores for phones where the plugins can be free or require some form of payment. Generally, if they are made to support a particular manufacturer (where the manufacturer had a hand in its creation), they are free. Those that are not brand specific or are made by an entity other than the manufacturer, then they are often with some form of payment (license keys obtained from the company that made the plugin).

Cinema Plugins

There are, already, a collection of cinema-specific plugins, within Asset Manager, that can help greatly with Q-SYS integration.
At the time of this writing:

• Barco Series 2 Projectors.
• Barco Series 4 Projectors.
• Christie Series 2 Projectors.
• NEC (Sharp) Series 2 Projectors (which includes the current laser ones).
• Dolby IMS3000 Server.
• Integ JNIOR.

If you want to see more plugins for cinema, you’ll need to convince the manufacturers to create them (or you can create them yourselves, if you have access to the API).
So, what do the cinema plugins do? Let’s look at the Barco Series 4 plugin, as an example:

Blog21_Image1.png

It covers a lot of ground. All of those buttons and text boxes can be brought out to your UCIs. So, you can create a full user interface for the projector that goes beyond the mere 9 presets the projector itself offers. Here is what it looks like on one of my UCIs:

Blog21_Image2.png

So, the user has control over the laser/dowser, preset, test pattern and we provide the “taillight” that Barco omitted. We, clearly, also have more than 9 presets available on the physical projector. But this is just one example.
Here is an example of the Dolby IMS3000 plugin turned into a UCI:

Blog21_Image3.png

You can get all of the information that you would, normally, have to login with a web browser right there on the UCI, including full manual control. The IMS3000 plugin is pretty feature laden. I highly encourage you to check it out. An entire blog could be done on everything it can do.

Blog21_Image4.png

[Blog-21, Page 1 of 4]

[Steve Guttag]

The Christie Series 2 projector plugin looks pretty much like the Christie UI on the Christie TPC:

Blog21_Image5.png

Again, these are all draggable controls so you can make it into whatever suits your needs. The same goes for the NEC (Sharp) projector plugin.

Blog21_Image6.png Blog21_Image7.png

All of the temperatures are there. When you put them in a UCI, you can format the window as desired. On one of my UCIs with the Sharp/NEC projector, it looks like this:

Blog21_Image8.png

Remember, you can use as much or as little of a plugin as you want/need. And you can augment that if there are features/information you desire that are not covered by a plugin. Additionally, not shown, are the properties section, where you can specify your needs even more. Like what flavor of projector you are using, how many Titles/Presets/Channels/Macros do you need.

The other cinema-specific plugin in Asset Manager is Integ’s JNIOR:

Blog21_Image9.png Blog21_Image10.png

User Components

You should not feel left out. Q-SYS has three levels of being able to make your own stuff. Good old-fashioned Right-Side Pane components wired up/configured as you want them (I use this quite a bit). You can use Block Controller to fashion your own “scripting” type components (I use this one a lot). And then there is scripting (Text Controller/Control Script) where you will use LUA coding.

Q-SYS has entire training courses (videos) for all three tiers. Here is a link:

https://training.qsc.com/mod/page/view.php?id=2527

Q-SYS is making these available to you for free. Take advantage of them!

So, what can you do with just components and logic blocks? Quite a bit, actually. Here is one of mine that I did during the whole C19 times where I had a bit more time to experiment.:

Blog21_Image11.png

So, what does it do? It calculates the surround delays needed for both digital cinema as well as for Pro-Logic (surrounds derived via a 2:4 decoder). The delays are different because they are doing different things. The digital cinema delay is to merely have the side surrounds arrive at the same time as the screen channels. The Pro-Logic delay is trying to ensure that one does not get an echo due to crosstalk between the screen and surround channels. So, it doesn’t just protect for just the person sitting in the reference position of the theatre (2/3rds back, centered).

You just need to enter the theatre’s dimensions in feet or meters and out comes the delays you need. You can use wire tags (Signal Names) to link them up in your design.
So, how does it work? Any guesses? It’s all done with logic blocks. No scripting was done, including the metric/imperial measurements (and the text for the units).

Blog21_Image12.png

Let’s work through the digital delay path:

Blog21_Image13.png

We take the theatre length and multiply it by 2/3 to locate the standard reference position. If the theatre is 100-feet long, it will locate the reference position to be 66.7-feet. Likewise, for the theatre width, we want the middle of the theatre so we multiply by ½. So, for a 40-foot-wide theatre, it will result in 20-feet. To figure the delay, we need to subtract the width from the length since the time it takes for the sound to travel from the side wall to the center of the theatre already is a delay and we don’t want to add that in twice. This is what the Value Difference block does. We need to then convert these distances into time. Sound, nominally, travels at 1130-feet/second. So, we divide our distance by 1130 to provide a result in seconds. So, if it is a 100 x 40 theatre, the equation is (100x0.667) – (40x0.500) = 47-feet. We need to divide that by the speed of sound so 47-feet/1130-(feet/seconds) = 0.416-seconds or 41.6-miliseconds.

Blog21_Image14.png

You can certainly do this sort of math on a calculator (phone) but with a User Component, you can drop this sort of thing in to any design and for as many screens as are in the design and merely input the theatre size and ta-da, it’s all figured out. You don’t have to revisit this sort of thing over and over. And this applies to any User Component.

It doesn’t have to be something that calculates or controls some apparatus. Let’s say you have a set of components you like to use for your equalization. Perhaps, you always want a high-pass filter, bass and treble controls (high and low shelving filters) and equalizers. Great, make that once. Then slide it over to the User Components and you have that for every design you do down the road. Heck, you could set up your entire 5.1 or 7.1 (or immersive) “B-chain” as a User Component that you just drag out for each design. User Components make such repetitive things a 1-and-done proposition.

To make a User Component, select the parts of your design you want to make into the component (it can be just a single thing or a collection of them, like the B-chain section). Once they are selected, drag it over to the “User Components” on the Right-Side Pane and QDS will prompt you to give your new User Component a name and that is about it. To use it, just drag it from the User Component section from the Right-Side Pane into your next design. It is that easy.

Any creations you make via conventional Q-SYS supplied “components” or Block Controller or even full scripting, are made into User Components in the same manner. If you want to share them with others, you will find them in your Documents>QSC>Q-SYS Designer>User Components directory of your PC. Note, your home-made Plugins will be stored in the Plugins folder. The plugins that came from Asset Manager are in the “Assets” folder. However, let Asset Manager take care of those. Remember, anyone with QDS can get those via their own Asset Manager.

Blog21_Image15.png

[Blog-21, Page 2 of 4]

[Steve Guttag]

Scripting (including Block Controller) versus Non-Scripting

With normal components, you can do quite a bit, as shown above. However, it can start to get rather large and confusing. You will also hit limitations based on what components are available. To go beyond that, scripting will open up entire categories of what you can do, if a plugin or other suitable component doesn’t exist.

Let’s use one of my favorite subjects, the linear fader versus dB fader. I’m choosing this one because I have the essentials of it in logic, Block Controller and LUA scripting.

Again, in 2020, I decided to see if I could make a linear fader based on nothing but logic blocks. The answer is, yes, I could:

Blog21_Image16.png

To start, what are the parameters? Well, from 0-4, we move in 10dB increments but from 4-10 we move in 3.33dB increments. It looks like this, inside:

Blog21_Image17.png

How about if this was scripted? I’m going to use the “Classic Cinema Fader” by Jay Wyatt:

Blog21_Image18.png

Note, in the properties section, one can change the channel count, as desired (up to 128-channels)…which is another advantage of scripting. They’re more flexible. But let’s look at the code behind it. Instead of assembling math blocks, we define the math in, relatively, simple code:

Blog21_Image19.png

The last bit “chopDecimal” just handles the formatting overhead of displaying the number as 7.0 instead of some never-ending fraction and to always put one unit past the decimal point. Did you notice that on my logic blocks, it has 2-digits past the decimal point?

Which do you think takes more time to construct for this sort of thing (logic blocks or scripting)? But you need to learn LUA scripting to know how to put it together and use the right commands.
The full plugin is much more lengthy to support it as a plugin (including the graphical properties) but this is the part that is doing the “math.”

And, speaking of blocks, what if you don’t know how to script but you do know what you want? There is the Block Controller. And I use the Block Controller a lot!

So, here is the linear fader done as a block controller.

Blog21_Image20.png

Now, since I made it for my uses, it has additional inputs/outputs to suit my needs. This is one of the great things about being able to use some form of User Component…you can make things to suit your needs and not be constrained to what someone else thought was sufficient. So, let’s look inside:

Blog21_Image21.png

To be clear, this is not all that is going on in the component (and I have a routine that formats the output as desired, that is the “Update 0-10 Text” function). There are press-and-hold aspects to the ramp buttons as well as the various conversions, inputs/outputs but you can see, in this case, the Block Controller has about the same number of parts as the script for doing the math of the dB to linear conversion. The Block Controller is all drag and drop and there are excellent videos on its use.

3^rd Party Control

I’d say that the bulk of the time one is making some form of Scripting, it is to control or monitor some 3^rd Party device.

Something to keep in mind, while audio signal flow cannot be simulated while “Emulating.” Ethernet control is fully functional while emulating. You can send and receive commands while emulating as if you had a Core present. So, you can test your creations without needing a Core.

Command Buttons

If you just want to send commands (ASCII type) to a device to control it. Q-SYS has “Command Buttons” which can send TCP, UDP and even Serial commands. So, if you have the API ASCII command set for a device, you don’t need to know any scripting, just input the information and you are pretty much done.

Blog21_Image22.png

So, if you have a Blu-ray player or some other device you’ve set up Command Buttons to control, once you are done, drag it into your User Components and you’ve got it forever.

The downside of Command Buttons is that you can’t monitor the device. Command Buttons are 1-way…they send and ignore all responses. What if the device wants a dialog where you establish a connection and it wants a password…etc.? You could, I suppose, use a stepper that times out presuming the timing and responses (have the stepper press the password command or whatever the device wants). But this can get very kludgy very quickly and prone to not being reliable.

There is a, relatively, new plugin in Asset Manager for a “Command Send And Receive Utility.”

It is just like Command Buttons but, it can receive and parse the responses.

Blog21_Image23.png Blog21_Image24.png

Then, you can determine if some known/desired response has occurred and then act upon that.

[Blog-21, Page 3 of 4]

[Steve Guttag]

Scripting/Block Controller

With Scripting, including Block controller, you can absolutely have bi-directional communication. With Block Controller, you are limited to what blocks are available, unless you can LUA script, at some level (there is a LUA block so you can insert LUA scripts within a Block Controller design).

Scripting really opens up the world to 3^rd Party control. You can do a lot with Block Controller. Examples of some of the 3^rd Party components I’ve made Block Controllers for include:
The CP950/CP950A:

Blog21_Image25.png

Yup, I had it look like the CP55. It polls the CP950 for the format names and what preset is selected for full bi-directional control/response.

CP650:

Do you have a CP650 in your system handling film projectors? Chas Phillips developed a way-cool CP650 Script (User Component, based on a Text Controller):

Blog21_Image26.png

This is one I developed for the Tascam BD-MP4K Blu-ray player using the Block Controller:

Blog21_Image27.png

It shows up my UCIs like this:

Blog21_Image28.png

So, you have full control over the player, without the remote. You can even set the credit start time to trigger your lights just like a DCP.

This sort of thing is the power of scripting. And, if you master LUA scripting, you have even more possibilities for what you can communicate with.

You shouldn’t feel like you can’t do this stuff. Just the opposite. Unlike many other systems, Q-SYS provides the tools/training to allow anyone to utilize it as a sophisticated control system.

Summary

Hopefully, I’ve shown that Q-SYS can be a very powerful control platform. Furthermore, it is a platform that allows you, the Q-SYS designer to customize it to control whatever devices you encounter.
There is an ever-growing list of plugins that make 3^rd Party control just about plug-n-play, including cinema-specific plugins.

If what you want does not exist, it can be created by you, relatively quickly/easily Click on the link I provided near the top of this blog. You can choose from three different paths (logic/no-code, block controller/low-code and LUA/full code).

This is the link to the Block Controller Videos:
https://training.qsc.com/course/view.php?id=152

Q-SYS is not just a sound system. It is a full sound, control and video platform. Don’t underestimate its control portion. It is every bit as powerful as its sound. I’ve only provided some examples of what I’ve done with it. I’m sure you will have your own needs that Q-SYS could satisfy.

©2025 by Steve Guttag

[Blog-21, Page 4 of 4, End of Blog]

[Steve Guttag]

From Post #483: To start, what are the parameters? Well, from 0-4, we move in 10dB increments

The statement in the post above is incorrect, The correct amount is 20dB between the values of 0-4 on a linear fader using the standard Dolby fader characteristic.