Merge pull request #38 from bitfocus/jaw/add-talkback

Add Talkback Functionality

Author: janikwitzig

src/actions/config.ts

@@ -4,20 +4,29 @@ import { SetRequired } from 'type-fest' // eslint-disable-line n/no-missing-impo
 export type CompanionActionWithCallback = SetRequired<CompanionActionDefinition, 'callback'>
 
 import { CompanionActionDefinitions } from '@companion-module/base'
-import { GetDropdown, GetMuteDropdown } from '../choices/common.js'
+import { GetDropdown, GetMuteDropdown, GetNumberField } from '../choices/common.js'
 import { InstanceBaseExt } from '../types.js'
 import { WingConfig } from '../config.js'
 import * as ActionUtil from './utils.js'
 import { ConfigurationCommands } from '../commands/config.js'
 import { StateUtil } from '../state/index.js'
 import { getIdLabelPair } from '../choices/utils.js'
+import { getTalkbackOptions, getTalkbackModeOptions, getTalkbackIndividualOptions } from '../choices/config.js'
 
 export enum CommonActions {
 	// Solo
 	SetSoloMute = 'set-solo-mute',
 	SetSoloDim = 'set-solo-dim',
 	SetSoloMono = 'set-solo-mono',
 	SetSoloLRSwap = 'set-solo-swap',
+
+	// Talkback
+	TalkbackOn = 'talkback-on',
+	TalkbackMode = 'talkback-mode',
+	TalkbackMonitorDim = 'talkback-monitor-dim',
+	TalkbackBusDim = 'talkback-bus-dim',
+	TalkbackAssign = 'talkback-destination',
+	TalkbackIndividualLevels = 'talkback-individual-levels',
 }
 
 export function createConfigurationActions(self: InstanceBaseExt<WingConfig>): CompanionActionDefinitions {
@@ -126,6 +135,112 @@ export function createConfigurationActions(self: InstanceBaseExt<WingConfig>): C
 				ensureLoaded(cmd)
 			},
 		},
+		////////////////////////////////////////////////////////////////
+		// Talkback
+		////////////////////////////////////////////////////////////////
+		[CommonActions.TalkbackOn]: {
+			name: 'Talkback On',
+			description: 'Enable or disable the on state of a talkback.',
+			options: [
+				GetDropdown('Talkback', 'tb', getTalkbackOptions()),
+				GetDropdown('On/Off', 'on', [getIdLabelPair('1', 'On'), getIdLabelPair('0', 'Off')]),
+			],
+			callback: async (event) => {
+				const cmd = ConfigurationCommands.TalkbackOn(event.options.tb as string)
+				const val = event.options.on as number
+				send(cmd, val)
+			},
+		},
+		[CommonActions.TalkbackMode]: {
+			name: 'Talkback Mode',
+			description: 'Set the mode of a talkback channel.',
+			options: [
+				GetDropdown('Talkback', 'tb', getTalkbackOptions()),
+				GetDropdown('Mode', 'mode', getTalkbackModeOptions()),
+			],
+			callback: async (event) => {
+				const cmd = ConfigurationCommands.TalkbackMode(event.options.tb as string)
+				const val = event.options.mode as string
+				send(cmd, val)
+			},
+		},
+		[CommonActions.TalkbackMonitorDim]: {
+			name: 'Talkback Monitor Dim',
+			description: 'Set the the monitor dim amount of a talkback channel.',
+			options: [
+				GetDropdown('Talkback', 'tb', getTalkbackOptions()),
+				GetNumberField('Dim [dB]', 'dim', 0, 40, 1, 10, true),
+			],
+			callback: async (event) => {
+				const cmd = ConfigurationCommands.TalkbackMonitorDim(event.options.tb as string)
+				const val = event.options.dim as number
+				send(cmd, val, true)
+			},
+		},
+		[CommonActions.TalkbackBusDim]: {
+			name: 'Talkback Bus Dim',
+			description: 'Set the the bus dim amount of a talkback channel.',
+			options: [
+				GetDropdown('Talkback', 'tb', getTalkbackOptions()),
+				GetNumberField('Dim [dB]', 'dim', 0, 40, 1, 10, true),
+			],
+			callback: async (event) => {
+				const cmd = ConfigurationCommands.TalkbackBusDim(event.options.tb as string)
+				const val = event.options.dim as number
+				send(cmd, val, true)
+			},
+		},
+		[CommonActions.TalkbackAssign]: {
+			name: 'Talkback Assign',
+			description: 'Enable, disable or toggle the assignment of a talkback to a bus, matrix or main.',
+			options: [
+				GetDropdown('Talkback', 'tb', getTalkbackOptions()),
+				GetDropdown('Destination', 'dest', [
+					...state.namedChoices.busses,
+					...state.namedChoices.matrices,
+					...state.namedChoices.mains,
+				]),
+				GetDropdown('Assign', 'assign', [
+					getIdLabelPair('1', 'Assign'),
+					getIdLabelPair('0', 'Not Assign'),
+					getIdLabelPair('2', 'Toggle'),
+				]),
+			],
+			callback: async (event) => {
+				const talkback = event.options.tb as string
+				const destination = event.options.dest as string
+				const cmd = ActionUtil.getTalkbackAssignCommand(talkback, destination)
+				const val = event.options.assign as number
+				if (val < 2) {
+					send(cmd, val)
+				} else {
+					const currentVal = StateUtil.getBooleanFromState(cmd, state)
+					send(cmd, Number(!currentVal))
+				}
+			},
+			subscribe: (event) => {
+				const val = event.options.mode as number
+				if (val >= 2) {
+					const talkback = event.options.tb as string
+					const destination = event.options.dest as string
+					const cmd = ActionUtil.getTalkbackAssignCommand(talkback, destination)
+					ensureLoaded(cmd)
+				}
+			},
+		},
+		[CommonActions.TalkbackIndividualLevels]: {
+			name: 'Talkback Individual Levels',
+			description: 'Enable or disable individual bus and main talkback levels.',
+			options: [
+				GetDropdown('Talkback', 'tb', getTalkbackOptions()),
+				GetDropdown('Mode', 'mode', getTalkbackIndividualOptions()),
+			],
+			callback: async (event) => {
+				const cmd = ConfigurationCommands.TalkbackIndividual(event.options.tb as string)
+				const val = event.options.mode as number
+				send(cmd, val)
+			},
+		},
 	}
 	return actions
 }

src/actions/utils.ts

@@ -10,6 +10,7 @@ import { MatrixCommands } from '../commands/matrix.js'
 import { MainCommands } from '../commands/main.js'
 import { DcaCommands } from '../commands/dca.js'
 import { MuteGroupCommands } from '../commands/mutegroup.js'
+import { ConfigurationCommands } from '../commands/config.js'
 
 export function getNodeNumber(action: CompanionActionInfo | CompanionFeedbackInfo, id: string): number {
 	return action.options[id]?.toString().split('/')[2] as unknown as number
@@ -266,3 +267,16 @@ export function getScribblelightCommand(sel: string, val: number): string {
 	}
 	return cmd
 }
+
+export function getTalkbackAssignCommand(talkback: string, destination: string): string {
+	let cmd = ''
+	const num = destination.split('/')[2] as unknown as number
+	if (destination.startsWith('/bus')) {
+		cmd = ConfigurationCommands.TalkbackBusAssign(talkback, num)
+	} else if (destination.startsWith('/mtx')) {
+		cmd = ConfigurationCommands.TalkbackMatrixAssign(talkback, num)
+	} else if (destination.startsWith('/main')) {
+		cmd = ConfigurationCommands.TalkbackMainAssign(talkback, num)
+	}
+	return cmd
+}

src/choices/config.ts

@@ -0,0 +1,14 @@
+import { DropdownChoice } from '@companion-module/base'
+import { getIdLabelPair } from './utils.js'
+
+export function getTalkbackOptions(): DropdownChoice[] {
+	return [getIdLabelPair('A', 'Talkback A'), getIdLabelPair('B', 'Talkback B')]
+}
+
+export function getTalkbackModeOptions(): DropdownChoice[] {
+	return [getIdLabelPair('AUTO', 'Automatic'), getIdLabelPair('PUSH', 'Push'), getIdLabelPair('LATCH', 'Latch')]
+}
+
+export function getTalkbackIndividualOptions(): DropdownChoice[] {
+	return [getIdLabelPair('1', 'Individual'), getIdLabelPair('0', 'Linked')]
+}

src/commands/config.ts

@@ -213,4 +213,40 @@ export namespace ConfigurationCommands {
 	export function SoloLRSwap(): string {
 		return `${SoloNode()}/$flip`
 	}
+
+	export function TalkbackNode(talkback: string): string {
+		return `${ConfigNode()}/talk/${talkback}`
+	}
+
+	export function TalkbackOn(talkback: string): string {
+		return `${TalkbackNode(talkback)}/$on`
+	}
+
+	export function TalkbackMode(talkback: string): string {
+		return `${TalkbackNode(talkback)}/mode`
+	}
+
+	export function TalkbackMonitorDim(talkback: string): string {
+		return `${TalkbackNode(talkback)}/mondim`
+	}
+
+	export function TalkbackBusDim(talkback: string): string {
+		return `${TalkbackNode(talkback)}/busdim`
+	}
+
+	export function TalkbackIndividual(talkback: string): string {
+		return `${TalkbackNode(talkback)}/indiv`
+	}
+
+	export function TalkbackBusAssign(talkback: string, bus: number): string {
+		return `${TalkbackNode(talkback)}/B${bus}`
+	}
+
+	export function TalkbackMatrixAssign(talkback: string, matrix: number): string {
+		return `${TalkbackNode(talkback)}/MX${matrix}`
+	}
+
+	export function TalkbackMainAssign(talkback: string, main: number): string {
+		return `${TalkbackNode(talkback)}/M${main}`
+	}
 }

src/variables.ts

@@ -184,6 +184,19 @@ export function UpdateVariableDefinitions(self: WingInstance): void {
 		})
 	}
 
+	for (let bus = 1; bus <= model.busses; bus++) {
+		variables.push({ variableId: `talkback_a_bus${bus}_assign`, name: `Talkback A to Bus ${bus} assign` })
+		variables.push({ variableId: `talkback_b_bus${bus}_assign`, name: `Talkback B to Bus ${bus} assign` })
+	}
+	for (let mtx = 1; mtx <= model.matrices; mtx++) {
+		variables.push({ variableId: `talkback_a_mtx${mtx}_assign`, name: `Talkback A to Matrix ${mtx} assign` })
+		variables.push({ variableId: `talkback_b_mtx${mtx}_assign`, name: `Talkback B to Matrix ${mtx} assign` })
+	}
+	for (let main = 1; main <= model.mains; main++) {
+		variables.push({ variableId: `talkback_a_main${main}_assign`, name: `Talkback A to Main ${main} assign` })
+		variables.push({ variableId: `talkback_b_main${main}_assign`, name: `Talkback B to Main ${main} assign` })
+	}
+
 	self.setVariableDefinitions(variables)
 }
 
@@ -199,6 +212,7 @@ export function UpdateVariables(self: WingInstance, msgs: OscMessage[]): void {
 		UpdatePanoramaVariables(self, path, args[0]?.value as number)
 		UpdateUsbVariables(self, path, args[0])
 		UpdateSdVariables(self, path, args[0])
+		UpdateTalkbackVariables(self, path, args[0])
 	}
 }
 
@@ -368,3 +382,27 @@ function UpdateSdVariables(self: WingInstance, path: string, args: OSCMetaArgume
 		}
 	}
 }
+
+function UpdateTalkbackVariables(self: WingInstance, path: string, args: OSCMetaArgument): void {
+	const match = path.match(/^\/cfg\/talk\/(A|B)\/(B|MX|M)(\d+)$/)
+	if (!match) {
+		return
+	}
+
+	const talkback = match[1].toLowerCase()
+	let destination = ''
+	if (match[2] == 'B') {
+		destination = 'bus'
+	} else if (match[2] == 'MX') {
+		destination = 'mtx'
+	} else if (match[2] == 'M') {
+		destination = 'main'
+	} else {
+		return
+	}
+	const num = match[3]
+
+	self.setVariableValues({
+		[`talkback_${talkback}_${destination}${num}_assign`]: args.value as number,
+	})
+}