comparison VamPipePluginLibrary.cpp @ 110:2f621b00747e

Merge from branch jsonrpc

 	err = "invalid json: " + err;
 	return {};
     }
     if (!j.is_object()) {
 	err = "object expected at top level";
-    } else if (!j["type"].is_string()) {
-	err = "string expected for type field";
-    } else if (!j["content"].is_null() && !j["content"].is_object()) {
-	err = "object expected for content field";
     }
     return j;
 }
 
 VamPipePluginLibrary::VamPipePluginLibrary(vector<VamPipeAdapterInterface *> pp) :

 
     return response;
 }
 
 string
-VamPipePluginLibrary::processRawImpl(int pluginHandle,
+VamPipePluginLibrary::processRawImpl(int handle,
                                      const float *const *inputBuffers,
                                      int sec,
                                      int nsec)
 {
-    Vamp::Plugin *plugin = m_mapper.handleToPlugin(pluginHandle);
+    Vamp::Plugin *plugin = m_mapper.handleToPlugin(handle);
     if (!plugin) {
         return VampJson::fromError("unknown plugin handle", RRType::Process)
             .dump();
     }
     
-    if (!m_mapper.isConfigured(pluginHandle)) {
+    if (!m_mapper.isConfigured(handle)) {
         return VampJson::fromError("plugin has not been configured", RRType::Process)
             .dump();
     }
 
     Vamp::RealTime timestamp(sec, nsec);

     resp.plugin = plugin;
     resp.features = plugin->process(inputBuffers, timestamp);
     
     m_useBase64 = true;
     
-    return VampJson::fromVampResponse_Process
+    return VampJson::fromRpcResponse_Process
         (resp, m_mapper,
          VampJson::BufferSerialisation::Base64)
         .dump();
 }
 

     Json rj;
     
     switch (type) {
 
     case RRType::List:
-        rj = VampJson::fromVampResponse_List(listPluginData());
+        rj = VampJson::fromRpcResponse_List(listPluginData());
         break;
 
     case RRType::Load:
     {
-        auto req = VampJson::toVampRequest_Load(j, err);
+        auto req = VampJson::toRpcRequest_Load(j, err);
         if (err != "") {
             rj = VampJson::fromError(err, type);
         } else {
             auto resp = loadPlugin(req, err);
             if (err != "") {
                 rj = VampJson::fromError(err, type);
             } else {
                 m_mapper.addPlugin(resp.plugin);
-                rj = VampJson::fromVampResponse_Load(resp, m_mapper);
+                rj = VampJson::fromRpcResponse_Load(resp, m_mapper);
             }
         }
         break;
     }
 
     case RRType::Configure:
     {
-        auto req = VampJson::toVampRequest_Configure(j, m_mapper, err);
+        auto req = VampJson::toRpcRequest_Configure(j, m_mapper, err);
         if (err != "") {
             rj = VampJson::fromError(err, type);
         } else {
             auto h = m_mapper.pluginToHandle(req.plugin);
             if (h == m_mapper.INVALID_HANDLE) {

                     rj = VampJson::fromError(err, type);
                 } else {
                     m_mapper.markConfigured(h,
                                             req.configuration.channelCount,
                                             req.configuration.blockSize);
-                    rj = VampJson::fromVampResponse_Configure(resp, m_mapper);
+                    rj = VampJson::fromRpcResponse_Configure(resp, m_mapper);
                 }
             }
         }
         break;
     }
 
     case RRType::Process:
     {
         VampJson::BufferSerialisation serialisation;
             
-        auto req = VampJson::toVampRequest_Process(j, m_mapper,
+        auto req = VampJson::toRpcRequest_Process(j, m_mapper,
                                                    serialisation, err);
         if (err != "") {
             rj = VampJson::fromError(err, type);
         } else {
             auto h = m_mapper.pluginToHandle(req.plugin);

                 if (fbuffers) {
                     Vamp::HostExt::ProcessResponse resp;
                     resp.plugin = req.plugin;
                     resp.features = req.plugin->process(fbuffers, req.timestamp);
                     delete[] fbuffers;
-                    rj = VampJson::fromVampResponse_Process
+                    rj = VampJson::fromRpcResponse_Process
                         (resp, m_mapper, serialisation);
                 }
             }
         }
         break;
     }
 
     case RRType::Finish:
     {
-        auto req = VampJson::toVampRequest_Finish(j, m_mapper, err);
+        auto req = VampJson::toRpcRequest_Finish(j, m_mapper, err);
         if (err != "") {
             rj = VampJson::fromError(err, type);
         } else {
             auto h = m_mapper.pluginToHandle(req.plugin);
             if (h == m_mapper.INVALID_HANDLE) {

 
                 Vamp::HostExt::ProcessResponse resp;
                 resp.plugin = req.plugin;
                 resp.features = req.plugin->getRemainingFeatures();
 
-                rj = VampJson::fromVampResponse_Finish
+                rj = VampJson::fromRpcResponse_Finish
                     (resp, m_mapper, serialisation);
 	
                 m_mapper.removePlugin(h);
                 delete req.plugin;
             }