comparison utilities/vampipe-server.cpp @ 34:ba58fe5ee2dd

Check channel count & block size

 	if (m_plugins.find(h) == m_plugins.end()) {
 	    throw NotFound();
 	}
 	Plugin *p = m_plugins[h];
 	m_plugins.erase(h);
+	if (isConfigured(h)) {
+	    m_configuredPlugins.erase(h);
+	    m_channelCounts.erase(h);
+	}
 	m_rplugins.erase(p);
     }
     
     int32_t pluginToHandle(Plugin *p) {
 	if (m_rplugins.find(p) == m_rplugins.end()) {

 
     bool isConfigured(int32_t h) {
 	return m_configuredPlugins.find(h) != m_configuredPlugins.end();
     }
 
-    void markConfigured(int32_t h) {
+    void markConfigured(int32_t h, int channelCount, int blockSize) {
 	m_configuredPlugins.insert(h);
+	m_channelCounts[h] = channelCount;
+	m_blockSizes[h] = blockSize;
+    }
+
+    int getChannelCount(int32_t h) {
+	if (m_channelCounts.find(h) == m_channelCounts.end()) {
+	    throw NotFound();
+	}
+	return m_channelCounts[h];
+    }
+
+    int getBlockSize(int32_t h) {
+	if (m_blockSizes.find(h) == m_blockSizes.end()) {
+	    throw NotFound();
+	}
+	return m_blockSizes[h];
     }
     
 private:
     int32_t m_nextHandle; // NB plugin handle type must fit in JSON number
     map<uint32_t, Plugin *> m_plugins;
     map<Plugin *, uint32_t> m_rplugins;
     set<uint32_t> m_configuredPlugins;
+    map<uint32_t, int> m_channelCounts;
+    map<uint32_t, int> m_blockSizes;
 };
 
 static Mapper mapper;
 
 RequestOrResponse

 
     writeMessageToFd(1, message);
 }
 
 RequestOrResponse
-processRequest(const RequestOrResponse &request)
+handleRequest(const RequestOrResponse &request)
 {
     RequestOrResponse response;
     response.direction = RequestOrResponse::Response;
     response.type = request.type;
 

 	}
 	break;
 	
     case RRType::Configure:
     {
-	auto h = mapper.pluginToHandle(request.configurationRequest.plugin);
+	auto &creq = request.configurationRequest;
+	auto h = mapper.pluginToHandle(creq.plugin);
 	if (mapper.isConfigured(h)) {
 	    throw runtime_error("plugin has already been configured");
 	}
 
-	response.configurationResponse =
-	    loader->configurePlugin(request.configurationRequest);
+	response.configurationResponse = loader->configurePlugin(creq);
 	
 	if (!response.configurationResponse.outputs.empty()) {
-	    mapper.markConfigured(h);
+	    mapper.markConfigured
+		(h, creq.configuration.channelCount, creq.configuration.blockSize);
 	    response.success = true;
 	}
 	break;
     }
 
     case RRType::Process:
     {
 	auto &preq = request.processRequest;
+	auto h = mapper.pluginToHandle(preq.plugin);
+	if (!mapper.isConfigured(h)) {
+	    throw runtime_error("plugin has not been configured");
+	}
+
 	int channels = int(preq.inputBuffers.size());
+	if (channels != mapper.getChannelCount(h)) {
+	    throw runtime_error("wrong number of channels supplied to process");
+	}
+		
 	const float **fbuffers = new const float *[channels];
 	for (int i = 0; i < channels; ++i) {
+	    if (int(preq.inputBuffers[i].size()) != mapper.getBlockSize(h)) {
+		delete[] fbuffers;
+		throw runtime_error("wrong block size supplied to process");
+	    }
 	    fbuffers[i] = preq.inputBuffers[i].data();
 	}
 
 	response.processResponse.features =
 	    preq.plugin->process(fbuffers, preq.timestamp);

 	    if (request.type == RRType::NotValid) {
 		cerr << "vampipe-server: eof reached" << endl;
 		break;
 	    }
 
-	    RequestOrResponse response = processRequest(request);
-
-	    cerr << "vampipe-server: request processed, writing response"
+	    RequestOrResponse response = handleRequest(request);
+
+	    cerr << "vampipe-server: request handled, writing response"
 		 << endl;
 	    
 	    writeResponseCapnp(response);
 
 	    cerr << "vampipe-server: response written" << endl;