prepared v 0.7.0b

Author: AndreasArvidsson

.gitignore

@@ -1,7 +1,9 @@
 .vs
 x64
-*.txt
 *.iobj
 *.ipdb
 *.ipdb
-*.pdb
+*.pdb
+*.vcxproj.filters
+*.zip
+\[stuff\]/

CaptureLoop.cpp

@@ -0,0 +1,115 @@
+#include "CaptureLoop.h"
+
+CaptureLoop::CaptureLoop(Config *pConfig, const AudioDevice *pRenderDevice, IAudioRenderClient *pRenderClient, IAudioCaptureClient *pCaptureClient, const std::vector<Input*> &inputs, const std::vector<Output*> &outputs) {
+	_pConfig = pConfig;
+	_pRenderDevice = pRenderDevice;
+	_pRenderClient = pRenderClient;
+	_pCaptureClient = pCaptureClient;
+	_inputs = inputs;
+	_outputs = outputs;
+	_nChannelsIn = inputs.size();
+	_nChannelsOut = outputs.size();
+
+	//Initialize clipping detection
+	_pClippingChannels = new float[_nChannelsOut];
+	memset(_pClippingChannels, 0, _nChannelsOut * sizeof(float));
+
+	//Initialize conditions
+	_pUsedChannels = new time_t[_nChannelsIn];
+	memset(_pUsedChannels, 0, _nChannelsIn * sizeof(time_t));
+	Condition::init(_pUsedChannels);
+}
+
+CaptureLoop::~CaptureLoop() {
+	delete[] _pUsedChannels;
+	delete[] _pClippingChannels;
+}
+
+void CaptureLoop::capture() {
+	UINT32 numFramesAvailable, i, j;
+	HRESULT hr;
+	DWORD flags;
+	time_t now;
+	float *pCaptureBuffer, *pRenderBuffer;
+	size_t loopCounter = 0;
+	size_t renderBlockSize = sizeof(float) * _nChannelsOut;
+
+	//Run infinite capture loop
+	while (true) {
+		//Check for samples in capture buffer
+		hr = _pCaptureClient->GetNextPacketSize(&numFramesAvailable);
+		assertHrResult(hr);
+
+		while (numFramesAvailable != 0) {
+			//Get capture buffer pointer and number of available frames.
+			hr = _pCaptureClient->GetBuffer((BYTE**)&pCaptureBuffer, &numFramesAvailable, &flags, NULL, NULL);
+			assertHrResult(hr);
+
+			//Must read entire capture buffer at once. Wait until render buffer has enough space available.
+			while (numFramesAvailable > _pRenderDevice->getBufferFrameCountAvailable()) {
+				//Date::sleepMillis(1);
+			}
+
+			//Get render buffer
+			hr = _pRenderClient->GetBuffer(numFramesAvailable, (BYTE**)&pRenderBuffer);
+			assertHrResult(hr);
+
+			//Set default value to 0 so we can add/mix values to it later
+			memset(pRenderBuffer, 0, numFramesAvailable * renderBlockSize);
+
+			//Get current timestamp to mark playing channels with
+			now = Date::getCurrentTimeMillis();
+
+			//Iterate all capture frames
+			for (i = 0; i < numFramesAvailable; ++i) {
+				for (j = 0; j < _nChannelsIn; ++j) {
+					//Identify which channels are playing.
+					if (pCaptureBuffer[j] != 0) {
+						_pUsedChannels[j] = now;
+					}
+
+					//Route sample to outputs
+					_inputs[j]->route(pCaptureBuffer[j], pRenderBuffer);
+				}
+				
+				for (j = 0; j < _nChannelsOut; ++j) {
+					//Apply output filters
+					pRenderBuffer[j] = (float)_outputs[j]->process(pRenderBuffer[j]);
+					
+					//Check for digital clipping
+					if (abs(pRenderBuffer[j]) > 1.0) {
+						_pClippingChannels[j] = max(_pClippingChannels[j], abs(pRenderBuffer[j]));
+					}
+				}
+
+				//Move buffers to next sample
+				pCaptureBuffer += _nChannelsIn;
+				pRenderBuffer += _nChannelsOut;
+			}
+
+			//Release / flush buffers
+			hr = _pCaptureClient->ReleaseBuffer(numFramesAvailable);
+			assertHrResult(hr);
+			hr = _pRenderClient->ReleaseBuffer(numFramesAvailable, 0);
+			assertHrResult(hr);
+
+			//Check for more samples in capture buffer
+			hr = _pCaptureClient->GetNextPacketSize(&numFramesAvailable);
+			assertHrResult(hr);
+		}
+
+		if (loopCounter == 1000) {
+			loopCounter = 0;
+			//Check if config file has changed
+			checkConfig();
+			//Check for unused channels
+			checkUsedChannels();
+			//Check for clipping out channels
+			checkClippingChannels();
+		}
+		++loopCounter;
+
+		//Short sleep just to not busy wait all resources.
+		Date::sleepMillis(1);
+	}
+}

CaptureLoop.h

@@ -0,0 +1,55 @@
+#pragma once
+#include "Config.h"
+#include "ConfigChangedException.h"
+#include "Date.h"
+#include "Convert.h"
+
+class CaptureLoop {
+public:
+
+	CaptureLoop(Config *pConfig, const AudioDevice *pRenderDevice, IAudioRenderClient *pRenderClient, IAudioCaptureClient *pCaptureClient, const std::vector<Input*> &inputs, const std::vector<Output*> &outputs);
+	~CaptureLoop();
+	
+	void capture();
+
+private:
+	Config *_pConfig;
+	const AudioDevice *_pRenderDevice;
+	IAudioRenderClient *_pRenderClient;
+	IAudioCaptureClient *_pCaptureClient;
+	std::vector<Input*> _inputs;
+	std::vector<Output*> _outputs;
+	size_t _nChannelsIn, _nChannelsOut;
+	time_t *_pUsedChannels;
+	float *_pClippingChannels;
+
+	inline void checkConfig() {
+		if (_pConfig->hasChanged()) {
+			throw ConfigChangedException();
+		}
+	}
+
+	inline void checkUsedChannels() {
+		const time_t now = Date::getCurrentTimeMillis();
+		//Compare now against last used timestamp and determine active channels
+		for (size_t i = 0; i < _nChannelsIn; ++i) {
+			if (now - _pUsedChannels[i] > 1000) {
+				_pUsedChannels[i] = 0;
+			}
+		}
+		//Update conditional routing
+		for (const Input *pInut : _inputs) {
+			pInut->evalConditions();
+		}
+	}
+
+	inline void checkClippingChannels() {
+		for (size_t i = 0; i < _nChannelsOut; ++i) {
+			if (_pClippingChannels[i] != 0) {
+				printf("WARNING: Output(%s) - Clipping detected: +%0.2f dBFS\n", _pConfig->getChannelName(i).c_str(), Convert::levelToDb(_pClippingChannels[i]));
+				_pClippingChannels[i] = 0;
+			}
+		}
+	}
+
+};

Condition.cpp

@@ -0,0 +1,22 @@
+#include "Condition.h"
+
+const time_t* Condition::_pUsedChannels = nullptr;
+
+void Condition::init(const time_t *pUsedChannels) {
+	_pUsedChannels = pUsedChannels;
+}
+
+Condition::Condition(const ConditionType type, const int value) {
+	_type = type;
+	_value = value;
+}
+
+const bool Condition::eval() const {
+	switch (_type) {
+	case ConditionType::SILENT:
+		return _pUsedChannels[_value] == 0;
+		break;
+	default:
+		throw Error("Route - Unknown condition: %d", _type);
+	}
+}

Condition.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "Error.h"
+
+enum class ConditionType {
+	SILENT
+};
+
+class Condition {
+public:
+
+	static void init(const time_t *pUsedChannels);
+
+	Condition(const ConditionType type, const int value);
+
+	const bool eval() const;
+
+private:
+	static const time_t *_pUsedChannels;
+
+	ConditionType _type;
+	int _value;
+
+};
+

Config.cpp

@@ -78,7 +78,7 @@ void Config::parseMisc() {
 		}
 	}
 	else {
-		_channelNames = { "L", "R", "C", "SW", "SL", "SR","SBL", "SBR" };
+		_channelNames = { "L", "R", "C", "SW", "SBL", "SBR" ,"SL", "SR" };
 	}
 }
 
@@ -150,6 +150,18 @@ void Config::parseRoute(std::vector<Route*> &routes, const JsonNode *pRoutes, co
 		Route *pRoute = new Route(channelOut);
 		routes.push_back(pRoute);
 		parseFilters(pRoute->filters, pRouteNode, path);
+		parseConditions(pRoute, pRouteNode, path);
+	}
+}
+
+void Config::parseConditions(Route *pRoute, const JsonNode *pRouteNode, std::string path) {
+	if (pRouteNode->has("if")) {
+		const JsonNode *pIfNode = getNode(pRouteNode, "if", path);
+		if (pIfNode->has("silent")) {
+			std::string channelName = textValue(pIfNode, "silent", path);
+			size_t channel = getChannelIndex(channelName, path + "/silent");
+			pRoute->conditions.push_back(Condition(ConditionType::SILENT, (int)channel));
+		}
 	}
 }
 
@@ -207,7 +219,7 @@ void Config::validateLevels(const std::string &path) const {
 				printf("WARNING: Config(%s) - Sum of routed channel levels is above 0dBFS on output channel. CLIPPING CAN OCCUR!\n", path.c_str());
 				first = false;
 			}
-			printf("\t%s: +%.2f dBFS\n", getChannelName(i, path).c_str(), 20 * log10(levels[i]));
+			printf("\t%s: +%.2f dBFS\n", getChannelName(i, path).c_str(), Convert::levelToDb(levels[i]));
 		}
 	}
 }
@@ -664,6 +676,13 @@ const std::string Config::getChannelName(const size_t channelIndex, const std::s
 	return _channelNames[channelIndex];
 }
 
+const std::string Config::getChannelName(const size_t channelIndex) const {
+	if (channelIndex >= _channelNames.size()) {
+		throw Error("Unknown channel index: %d", channelIndex);
+	}
+	return _channelNames[channelIndex];
+}
+
 void Config::load() {
 	_pJsonNode = JsonParser::fromFile(_configFile);
 	_lastModified = _configFile.getLastModifiedTime();

Config.h

@@ -22,6 +22,7 @@ class Config {
 	const std::vector<Output*>& getOutputs() const;
 	const bool hasChanged() const;
 	const bool minimize() const;
+	const std::string getChannelName(const size_t channelIndex) const;
 
 private:
 	File _configFile;
@@ -43,6 +44,7 @@ class Config {
 	void parseInputs();
 	void parseInput(const JsonNode *pInputs, const std::string &channelName, std::string path);
 	void parseRoute(std::vector<Route*> &routes, const JsonNode *pRoutes, const size_t index, std::string path);
+	void parseConditions(Route *pRoute, const JsonNode *pRouteNode, std::string path);
 	void parseOutputs();
 	void parseOutput(const JsonNode *pOutputs, const std::string &channelName, std::string path);
 	void validateLevels(const std::string &path) const;

Input.h

@@ -17,10 +17,16 @@ class Input {
 		}
 	}
 
-	inline void process(const double data, float *pRenderBuffer) const {
+	inline void route(const double data, float *pRenderBuffer) const {
 		for (const Route *p : routes) {
 			p->process(data, pRenderBuffer);
 		}
 	}
 
+	inline void evalConditions() const {
+		for (Route *pRoute : routes) {
+			pRoute->evalConditions();
+		}
+	}
+
 };