def __init__( self ):
# Set up the UI
super( LoudnessGui, self ).__init__( None )
self.audioRunning = False
self.setGeometry( 0, 0, 800, 600 )
self.layout = QtGui.QGridLayout( self )
self.startButton = QtGui.QPushButton( "Start Audio" ) # , self.centralWidget )
#self.startButton.setMinimumSize( 200, 60 )
self.stopButton = QtGui.QPushButton( "Stop Audio" ) # , self.centralWidget )
#self.stopButton.setMinimumSize( 200, 60 )
self.layout.addWidget( self.startButton, 0, 0 ) # , QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter )
self.layout.addWidget( self.stopButton, 0, 1 ) # , QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter )
self.loudnessLabel = QtGui.QLabel( '--- dB' ) # , self.centralWidget )
#self.loudnessLabel.setMinimumSize( 200, 60 )
self.layout.addWidget( self.loudnessLabel, 0, 2 ) # , QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter )
self.startButton.clicked.connect( self.startAudio )
self.stopButton.clicked.connect( self.stopAudio )
self.plotWidget = pg.PlotWidget()
self.plotWidget.setRange( xRange = (0,numPlotPoints-1), yRange = (-130.0,6.0))
self.layout.addWidget( self.plotWidget, 1, 0, 1, 4 )
self.loudnessPlot = pg.PlotCurveItem()
self.plotWidget.addItem( self.loudnessPlot )
self.loudnessHist = -120.0 * np.ones( numPlotPoints, dtype=np.float32 )
self.loudnessPlot.setData( self.loudnessHist )
# %% Setup the DSP part
self.context = visr.SignalFlowContext( period = blockSize,
samplingFrequency = samplingFrequency )
self.meter = LoudnessMeter( self.context, 'meter', None, numChannels,
measurePeriod = 0.4, audioOut = True )
audioOptions = ai.AudioInterface.Configuration( numChannels,
numChannels,
samplingFrequency,
blockSize )
self.audioInterface = ai.AudioInterfaceFactory.create( audioInterfaceName,
audioOptions,
audioBackendOptions )
self.flow = rrl.AudioSignalFlow( self.meter )
self.loudnessPort = self.flow.parameterSendPort( 'loudnessOut' )
self.readTimer = QtCore.QTimer( self )
self.readTimer.timeout.connect( self.getMeterValues )
self.readTimer.setSingleShot( False )
self.readTimer.setInterval( 100 ) # ms
updateRate = 4
ctxt = visr.SignalFlowContext(blockSize, fs)
# Instantiate the atomic flow
dl = rcl.DelayMatrix(ctxt, "DL")
dl.setup(numberOfInputs=numberOfInputs,
numberOfOutputs=numberOfOutputs,
interpolationType="lagrangeOrder0",
initialDelay=0.0001,
initialGain=0.0,
interpolationSteps=updateRate * blockSize,
methodDelayPolicy=rcl.DelayMatrix.MethodDelayPolicy.Limit,
controlInputs=rcl.DelayMatrix.ControlPortConfig.All)
flow = rrl.AudioSignalFlow(dl)
gainInputProtocol = flow.parameterReceivePort("gainInput")
delayInputProtocol = flow.parameterReceivePort("delayInput")
t = np.arange(0, numSamples, dtype=np.float32) / fs
inputSignal = np.zeros([numberOfInputs, numSamples], dtype=np.float32)
inputSignal[0, :] = 0.5 * np.sin(2.0 * 440 * np.pi * t)
inputSignal[1, :] = 0.25 * np.cos(2.0 * 880 * np.pi * t)
inputSignal[2, :] = 0.25 * np.cos(2.0 * 1760 * np.pi * t)
outputSignal = np.zeros([numberOfOutputs, numSamples], dtype=np.float32)
gainInputProtocol.data()[0, 0] = 1.0
gainInputProtocol.data()[1, 2] = 0.7
numLoudspeakers,
port,
baud,
sofaFile,
enableSerial=useTracking,
dynITD=useDynamicITD,
hrirInterp=useHRIRinterpolation,
irTruncationLength=BRIRtruncationLength,
headTrackingCalibrationPort=headTrackingCalibrationPort,
switchUdpPort=12345)
result, messages = rrl.checkConnectionIntegrity(controller)
if not result:
print(messages)
flow = rrl.AudioSignalFlow(controller)
if not useSerialPort and useTracking:
trackingInput = flow.parameterReceivePort("tracking")
aiConfig = ai.AudioInterface.Configuration(flow.numberOfCaptureChannels,
flow.numberOfPlaybackChannels, fs,
blockSize)
#if client name is too long you get an error
jackCfg = """{ "clientname": "VirtualLoudspeakerRenderer",
"autoconnect" : "false",
"portconfig":
{
"capture": [{ "basename":"in", "externalport" : {} }],
"playback": [{ "basename":"out", "externalport" : {} }]
}
numSamples = blockSize * numIterations
numChannels = 32
comp = visr_drc.Compressor(context,
"Compressor",
None,
numberOfChannels=numChannels,
averagingTimeSeconds=0.01,
attackTimeSeconds=0.001,
releaseTimeSeconds=0.005,
compressorThresholdDB=-6.02,
compressorSlope=1)
flow = rrl.AudioSignalFlow(comp)
fSig = 80
fMod = 2
t = 1.0 / fs * np.arange(numSamples)
modSig = 0.5 * (1.0 + np.cos(fMod * 2 * np.pi * t))
toneSig = np.cos(fSig * 2 * np.pi * t)
inputSignal = np.zeros((numChannels, numSamples), dtype=np.float32)
inputSignal[0, :] = toneSig * modSig
# inputSignal[1,:] = 2.5*toneSig * modSig
outputSignal = np.zeros((numChannels, numSamples), dtype=np.float32)
numberOfInputs=numberOfObjects,
numberOfOutputs=numberOfOutputs,
interpolationPeriod=1024,
diffusionFilters=diffFilters,
controlDataType=pml.UnsignedInteger)
else:
mr = RealTimeMultiRenderer(ctxt,
"MultiRenderer",
None,
loudspeakerConfigFiles=configFiles,
numberOfInputs=numberOfObjects,
numberOfOutputs=numberOfOutputs,
interpolationPeriod=1024,
diffusionFilterFile=diffFilterFile)
flow = rrl.AudioSignalFlow(mr)
objectInput = flow.parameterReceivePort('objectIn')
controlInput = flow.parameterReceivePort('controlIn')
inputSignal = np.zeros((2, signalLength), dtype=np.float32)
inputSignal[0, :] = 0.75 * np.sin(2.0 * np.pi * 440 * t)
outputSignal = np.zeros((numberOfOutputs, signalLength), dtype=np.float32)
for blockIdx in range(0, numBlocks):
if blockIdx % (parameterUpdatePeriod / blockSize) == 0:
az = 0.025 * blockIdx
el = 0.1 * np.sin(0.025 * blockIdx)
r = 1
# Determine signal size and the number of blocks
numBlocks = inputSignal.shape[1] // blockSize # Note: That truncates the signal
signalLength = blockSize * numBlocks
# Check the number of channels.
numberOfChannels = inputSignal.shape[0]
# Data structure to define basic
context = visr.SignalFlowContext( blockSize, samplingFrequency )
# Instantiate the signal flow (a component)
meter = LoudnessMeter( context, "meter", None, numberOfChannels = numberOfChannels )
# Instantiate an AudioSignalFlow object to execute the component.
flow = rrl.AudioSignalFlow( meter )
# Retrieve the component's external output port.
# This is used to retrieve the metered values generated by the LoudnessMeter.
loudnessOut = flow.parameterSendPort( 'loudnessOut' )
# Define a list to collect the computed loudness values.
loudness = []
# Execute the audio signal flow sequentially by processing the audio block-wise.
for blockIdx in range(0,numBlocks):
# Extract the next audio block
inputBlock = inputSignal[:, blockIdx*blockSize:(blockIdx+1)*blockSize]
# Execute the signal flow (one iteration)
flow.process( inputBlock )
# Or a more configurable Python adder
# pa = PythonAdder( c, "pa0", None, 3, 2 )
numBlocks = 16
numSamples = numBlocks * blockSize
t = np.arange(0, numSamples, dtype=np.float32) / fs
inputSignal = np.zeros([6, numSamples], dtype=np.float32)
inputSignal[0, :] = np.sin(2 * np.pi * 440 * t)
inputSignal[1, :] = 0.5 * np.sin(2 * np.pi * 880 * t)
inputSignal[2, :] = 0.15 * np.sin(2 * np.pi * 1340 * t)
referenceOutput = inputSignal[0:2, :] + inputSignal[2:4, :] + inputSignal[
4:6, :]
outputSignal = np.zeros((2, numSamples), dtype=np.float32)
flow = rrl.AudioSignalFlow(pa)
for blockIdx in range(0, numBlocks):
inputBlock = inputSignal[:,
blockIdx * blockSize:(blockIdx + 1) * blockSize]
outputBlock = flow.process(inputBlock)
outputSignal[:,
blockIdx * blockSize:(blockIdx + 1) * blockSize] = outputBlock
plt.figure(1)
plt.plot(t, referenceOutput[0, :], 'bo-', t, outputSignal[0, :], 'rx-')
plt.show()
numBlocks = 16
numSamples = numBlocks * blockSize
t = np.arange(0, numSamples, dtype=np.float32) / fs
inputSignal = np.zeros([4, numSamples], dtype=np.float32)
inputSignal[0, :] = np.sin(2 * np.pi * 440 * t)
inputSignal[1, :] = 0.5 * np.sin(2 * np.pi * 880 * t)
inputSignal[2, :] = 0.15 * np.sin(2 * np.pi * 1340 * t)
referenceOutput = inputSignal[0:2, :] + inputSignal[2:, :]
outputSignal = np.zeros((2, numSamples), dtype=np.float32)
c = visr.SignalFlowContext(blockSize, fs)
adder = rcl.Add(c, 'add', numInputs=2, width=2)
flow = rrl.AudioSignalFlow(adder)
for blockIdx in range(0, numBlocks):
inputBlock = inputSignal[:,
blockIdx * blockSize:(blockIdx + 1) * blockSize]
outputBlock = flow.process(inputBlock)
outputSignal[:,
blockIdx * blockSize:(blockIdx + 1) * blockSize] = outputBlock
plt.figure(1)
plt.plot(t, referenceOutput[0, :], 'bo-', t, outputSignal[0, :], 'rx-')
plt.show()
renderer1 = signalflows.BaselineRenderer(context=ctxt,
name='renderer1',
parent=None,
loudspeakerConfig=lc,
numberOfInputs=2,
numberOfOutputs=41,
interpolationPeriod=4096,
diffusionFilters=diffFilters,
trackingConfiguration='',
sceneReceiverPort=4242,
reverbConfig='',
frequencyDependentPanning=False)
print('Created renderer.')
flow1 = rrl.AudioSignalFlow(renderer1)
cc1 = visr.CompositeComponent(ctxt, 'composite1', None)
numComponents = cc1.numberOfComponents
print('Composite has %d components' % (numComponents))
add1 = rcl.Add(ctxt, 'adder1', cc1)
add1.setup(width=8, numInputs=2)
add2 = rcl.Add(ctxt, 'adder2', cc1)
add2.setup(width=8, numInputs=2)
# In C++, this is a protected method (can be done only from within.)
#r1 = range(0,8)
numChannels = 3
inputSignal = np.ones((numChannels, numSamples), dtype=np.float32)
outputSignal = np.inf * np.ones((numChannels, numSamples), dtype=np.float32)
interpolationPeriod = 64
ctxt = visr.SignalFlowContext(blockSize, samplingFrequency)
gvec = rcl.GainVector(ctxt, 'calc', None)
gvec.setup(numberOfChannels=numChannels,
interpolationSteps=88,
controlInputs=True)
flow = rrl.AudioSignalFlow(gvec)
paramInput = flow.parameterReceivePort('gainInput')
gv = paramInput.data()
gv.set(np.asarray([1.0, 1.0, 1.0]))
paramInput.swapBuffers()
# Dummy input required for the process() function
for blockIdx in range(0, numBlocks):
if blockIdx == 3:
gv = paramInput.data()
gv[0] = 0.55
gv[1] = 1.0
gv[2] = 1.0
#lc = pml.LoudspeakerArray( '/home/andi/dev/visr/config/isvr/audiolab_39speakers_1subwoofer.xml' )
lc = pml.LoudspeakerArray(
'/home/andi/dev/visr/config/generic/bs2051-9+10+3_linear.xml')
# lc = pml.LoudspeakerArray( 'c:/local/visr/config/isvr/audiolab_39speakers_1subwoofer.xml' )
reverbConfigString = '{ \"numReverbObjects\": 5, \"discreteReflectionsPerObject\": 20, \"lateReverbFilterLength\": 0.5, \"lateReverbDecorrelationFilters\": \"/home/andi/dev/visr/config/filters/random_phase_allpass_64ch_1024taps.wav\" }'
rsaoRenderer = rsao.ReverbObjectRenderer(ctxt,
'rsaoRenderer',
None,
loudspeakerConfiguration=lc,
numberOfObjectSignals=2,
reverbConfig=reverbConfigString)
flow = rrl.AudioSignalFlow(rsaoRenderer)
paramInput = flow.parameterReceivePort('objectIn')
inputSignal = np.zeros((2, signalLength), dtype=np.float32)
inputSignal[0, :] = 0.75 * np.sin(2.0 * np.pi * 440 * t)
outputSignal = np.zeros((numOutputChannels, signalLength), dtype=np.float32)
for blockIdx in range(0, numBlocks):
if blockIdx % (parameterUpdatePeriod / blockSize) == 0:
az = 0.025 * blockIdx
el = 0.1 * np.sin(0.025 * blockIdx)
r = 1
x, y, z = sph2cart(az, el, r)
ps1 = objectmodel.PointSource(0)
numObjects = 1
signalLength = bs * numBlocks
t = 1.0 / samplingFrequency * np.arange(0, signalLength)
ctxt = visr.SignalFlowContext(bs, samplingFrequency)
lc = panning.LoudspeakerArray('../data/bs2051-4+5+0.xml')
numOutputChannels = lc.numberOfRegularLoudspeakers
rendererVbap = VbapRenderer(ctxt, 'renderer', None, numObjects, lspConfig=lc)
rendererL2 = VbapL2Renderer(ctxt, 'renderer', None, numObjects, lspArray=lc)
flowVbap = rrl.AudioSignalFlow(rendererVbap)
flow = rrl.AudioSignalFlow(rendererL2)
paramInput = flow.parameterReceivePort('objects')
paramInputVbap = flowVbap.parameterReceivePort('objects')
az = np.linspace(0, 2.0 * np.pi, numBlocks)
el = 10.0 * np.pi / 180.0
r = 1.0
inSig = np.zeros((numObjects, signalLength), dtype=np.float32)
inSig[0, :] = 0.75 * np.sin(2.0 * np.pi * 88 * t)
outSigL2 = np.zeros((numOutputChannels, signalLength), dtype=np.float32)
outSigVbap = np.zeros((numOutputChannels, signalLength), dtype=np.float32)
interpolationSteps = blockSize,
headTracking = False
)
graphDyn = DynamicBinauralRenderer( context, "DynamicBinauralRenderer", None, numBinauralObjects,
headTracking = False,
dynITD = False,
dynILD = False,
hrirInterp = True )
#graphHoa = DynamicBinauralRenderer( context, "DynamicBinauralRenderer", None, numBinauralObjects,
# headTracking = False,
# dynITD = False,
# dynILD = False,
# hrirInterp = False )
flowHoa = rrl.AudioSignalFlow( graphHoa )
flowDyn = rrl.AudioSignalFlow( graphDyn )
paramInputHoa = flowHoa.parameterReceivePort('objectVector')
paramInputDyn = flowDyn.parameterReceivePort('objectVector')
for testIdx in range(0,numTestSignals):
outputSignalHoa = np.zeros( (numOutputChannels, signalLength ), dtype=np.float32 )
outputSignalDyn = np.zeros( (numOutputChannels, signalLength ), dtype=np.float32 )
x,y,z = sph2cart( azimuths[testIdx], elevations[testIdx], 1.0 )
ps1 = objectmodel.PointSource(0)
ps1.position = [x,y,z]
ps1.level = 1
ps1.groupId = 5
# Load the loudspeaker configuation
lc = panning.LoudspeakerArray('../data/bs2051-4+5+0.xml')
numLsp = lc.numberOfRegularLoudspeakers
# Create components for the two apnning algorithms
pannerVbap = rcl.PanningCalculator(ctxt,
'vbapbCalc',
None,
numObjects,
arrayConfig=lc)
pannerL2 = VbapL2Panner(ctxt, 'constSpread', None, numObjects, lspArray=lc)
# %% Create signal flow objects for the two algorithms
flowVbap = rrl.AudioSignalFlow(pannerVbap)
flowL2 = rrl.AudioSignalFlow(pannerL2)
# %% Retrieve parameter inputs and outputs for the two audio objects.
paramInputVbap = flowVbap.parameterReceivePort('objectVectorInput')
paramOutputVbap = flowVbap.parameterSendPort('vbapGains')
paramInputL2 = flowL2.parameterReceivePort('objects')
paramOutputL2 = flowL2.parameterSendPort('gains')
# %% Define a number of object positions in speherical coordinates.
# Here we define a set of positions in the horizontal plane with 1 degree distance.
az = np.linspace(0.0, 2 * np.pi, numBlocks)
el = 10.0 * np.pi / 180.0
# %% Preallocate a matrix of output gains (#numLsp x #directions)
if False:
calc = PythonPanner(ctxt,
'calc',
None,
numberOfObjects=numObjectChannels,
arrayConfig=lc)
else:
calc = rcl.PanningCalculator(ctxt,
'calc',
None,
numberOfObjects=numObjectChannels,
arrayConfig=lc,
separateLowpassPanning=True)
flow = rrl.AudioSignalFlow(calc)
paramInput = flow.parameterReceivePort('objectVectorInput')
# Dummy input required for the process() function
inputBlock = np.zeros((0, blockSize), dtype=np.float32)
lfGainOutput = flow.parameterSendPort("vbapGains")
hfGainOutput = flow.parameterSendPort("vbipGains")
hfGains = np.zeros((gridSize, numSpeakers))
lfGains = np.zeros((gridSize, numSpeakers))
for blockIdx in range(0, gridSize):
az = 50.0 * np.pi / 180.0 # azGrid[blockIdx]
el = 10.0 * np.pi / 180.0
context = visr.SignalFlowContext(period=blockSize, samplingFrequency=fs)
# The parameter hoaOrder is sensed from the data dimension in the SOFA file.
graph = HoaBinauralRenderer(context,
"HoaBinauralRenderer",
None,
sofaFile=sofaFile,
headTracking=useTracking,
headOrientation=[np.pi / 4, 0.0],
fftImplementation=fftImplementation)
result, messages = rrl.checkConnectionIntegrity(graph)
if not result:
raise RuntimeError("Error in signal flow: %s" % messages)
flow = rrl.AudioSignalFlow(graph)
if useTracking:
trackingInput = flow.parameterReceivePort('tracking')
# TODO: Provide a HOA input signal (ACN convention).
# Here we us a trivial, not very reasonable one (sine wave in the y component)
inputSignal = np.zeros((inputWidth, signalLength), dtype=np.float32)
inputSignal[1, :] = 0.75 * np.sin(2.0 * np.pi * 440 * t)
# Preallocate the binaural output signal
outputSignal = np.zeros((numOutputChannels, signalLength), dtype=np.float32)
numPos = 360 / 5
azSequence = (2.0 * np.pi) / numPos * np.arange(0, numPos)
"DynamicHrirRenderer",
None,
numberOfObjects=numBinauralObjects,
sofaFile=sofaFile,
headTracking=useTracking,
dynamicITD=useDynamicITD,
dynamicILD=useDynamicILD,
hrirInterpolation=useHRIRinterpolation,
filterCrossfading=useCrossfading,
interpolatingConvolver=useInterpolatingConvolver)
result, messages = rrl.checkConnectionIntegrity(renderer)
if not result:
print(messages)
flow = rrl.AudioSignalFlow(renderer)
paramInput = flow.parameterReceivePort('objectVector')
if useTracking:
trackingInput = flow.parameterReceivePort("tracking")
inputSignal = np.zeros((numBinauralObjects, signalLength), dtype=np.float32)
inputSignal[0, :] = 0.75 * np.sin(2.0 * np.pi * 440 * t)
outputSignal = np.zeros((numOutputChannels, signalLength), dtype=np.float32)
numPos = 360 / 5
azSequence = (2.0 * np.pi) / numPos * np.arange(0, numPos)
az = 0
el = 0
r = 1
#cc = TFProcessing( context, "top", None, numberOfChannels=numberOfChannels,
# dftLength=dftSize, window=window, hopSize=hopSize )
cc = TFProcessing(context,
"top",
None,
numberOfChannels=numberOfChannels,
dftLength=dftSize,
windowLength=windowSize,
hopSize=hopSize)
res, msg = rrl.checkConnectionIntegrity(cc)
if not res:
print("The top-level composite is inconsistent: %s" % msg)
# TODO: Abort here
flow = rrl.AudioSignalFlow(cc)
numBlocks = 16
numSamples = numBlocks * blockSize
t = np.arange(0, numSamples, dtype=np.float32) / samplingFrequency
inputSignal = np.zeros([numberOfChannels, numSamples], dtype=np.float32)
inputSignal[0, :] = np.sin(2 * np.pi * 440 * t)
inputSignal[1, :] = 0.5 * np.sin(2 * np.pi * 880 * t)
outputSignal = np.zeros([numberOfChannels, numSamples], dtype=np.float32)
for blockIdx in range(0, numBlocks):
inputBlock = inputSignal[:,
blockIdx * blockSize:(blockIdx + 1) * blockSize]
