Mercurial > hg > piper-cpp

changeset 27:cc85c2851605

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Wire up Cap'n Proto reading, plus some build and arg processing fixes
author Chris Cannam <c.cannam@qmul.ac.uk>
date Tue, 24 May 2016 12:00:38 +0100
parents 13393bdfc7ef
children b5005ebc5116
files Makefile capnproto/VampnProto.h utilities/vampipe-convert.cpp
diffstat 3 files changed, 257 insertions(+), 47 deletions(-) [+]
line wrap: on
line diff
--- a/Makefile	Tue May 24 11:07:59 2016 +0100
+++ b/Makefile	Tue May 24 12:00:38 2016 +0100
@@ -1,29 +1,35 @@
 
-CXXFLAGS	:= -Wall -Werror -std=c++11
+CXXFLAGS	:= -Wall -Werror -O3 -std=c++11
 INCFLAGS	:= -Ivamp-plugin-sdk -Ijson -Icapnproto -I.
 LDFLAGS		:= -Lvamp-plugin-sdk -Wl,-Bstatic -lvamp-hostsdk -Wl,-Bdynamic -lcapnp -lkj -ldl
 
 all:	bin/vamp-json-cli bin/vamp-json-to-capnp bin/vampipe-convert
 
-bin/vampipe-convert: utilities/vampipe-convert.o json/json11/json11.o
+bin/vampipe-convert: o/vampipe-convert.o o/json11.o o/vamp.capnp.o
 	c++ $(CXXFLAGS) $^ -o $@ $(LDFLAGS)
 
-bin/vamp-json-to-capnp:	utilities/json-to-capnp.o json/json11/json11.o
+bin/vamp-json-to-capnp:	o/json-to-capnp.o o/json11.o
 	c++ $(CXXFLAGS) $^ -o $@ $(LDFLAGS)
 
-bin/vamp-json-cli:	utilities/json-cli.o json/json11/json11.o
+bin/vamp-json-cli:	o/json-cli.o o/json11.o
 	c++ $(CXXFLAGS) $^ -o $@ $(LDFLAGS)
 
 capnproto/vamp.capnp.h:	capnproto/vamp.capnp
 	capnp compile $< -oc++
 
-utilities/vampipe-convert.o:	utilities/vampipe-convert.cpp capnproto/vamp.capnp.h capnproto/VampnProto.h json/VampJson.h
+o/vamp.capnp.o:	capnproto/vamp.capnp.c++ capnproto/vamp.capnp.h
+	c++ $(CXXFLAGS) -c $< -o $@
+
+o/json11.o:	json/json11/json11.cpp
+	c++ $(CXXFLAGS) -c $< -o $@
+
+o/vampipe-convert.o:	utilities/vampipe-convert.cpp capnproto/vamp.capnp.h capnproto/VampnProto.h json/VampJson.h
 	c++ $(CXXFLAGS) $(INCFLAGS) -c $< -o $@
 
-utilities/json-to-capnp.o:	utilities/json-to-capnp.cpp capnproto/vamp.capnp.h capnproto/VampnProto.h json/VampJson.h
+o/json-to-capnp.o:	utilities/json-to-capnp.cpp capnproto/vamp.capnp.h capnproto/VampnProto.h json/VampJson.h
 	c++ $(CXXFLAGS) $(INCFLAGS) -c $< -o $@
 
-utilities/json-cli.o:	utilities/json-cli.cpp json/VampJson.h
+o/json-cli.o:	utilities/json-cli.cpp json/VampJson.h
 	c++ $(CXXFLAGS) $(INCFLAGS) -c $< -o $@
 
 test:	all
@@ -31,7 +37,7 @@
 	VAMP_PATH=./vamp-plugin-sdk/examples test/test-json-to-capnp.sh
 
 clean:
-	rm -f */*.o capnp/vamp.capnp.h capnp/vamp.capnp.c++
+	rm -f */*.o capnproto/vamp.capnp.h capnproto/vamp.capnp.c++
 
 distclean:	clean
 	rm -f bin/*
--- a/capnproto/VampnProto.h	Tue May 24 11:07:59 2016 +0100
+++ b/capnproto/VampnProto.h	Tue May 24 12:00:38 2016 +0100
@@ -748,6 +748,7 @@
         case VampRequest::Request::Which::FINISH:
             return RRType::Finish;
         }
+        return RRType::NotValid;
     }
 
     static RRType
@@ -764,12 +765,13 @@
         case VampResponse::Response::Which::FINISH:
             return RRType::Finish;
         }
+        return RRType::NotValid;
     }
     
     static void
     readVampRequest_List(const VampRequest::Reader &r) {
         if (getRequestResponseType(r) != RRType::List) {
-            throw std::runtime_error("not a list request");
+            throw std::logic_error("not a list request");
         }
     }
 
@@ -777,7 +779,7 @@
     readVampResponse_List(std::vector<Vamp::HostExt::PluginStaticData> &v,
                           const VampResponse::Reader &r) {
         if (getRequestResponseType(r) != RRType::List) {
-            throw std::runtime_error("not a list response");
+            throw std::logic_error("not a list response");
         }
         v.clear();
         if (r.getSuccess()) {
@@ -789,6 +791,94 @@
         }
     }
     
+    static void
+    readVampRequest_Load(Vamp::HostExt::LoadRequest &req,
+                         const VampRequest::Reader &r) {
+        if (getRequestResponseType(r) != RRType::Load) {
+            throw std::logic_error("not a load request");
+        }
+        readLoadRequest(req, r.getRequest().getLoad());
+    }
+
+    static void
+    readVampResponse_Load(Vamp::HostExt::LoadResponse &resp,
+                          const VampResponse::Reader &r,
+                          PluginHandleMapper &mapper) {
+        if (getRequestResponseType(r) != RRType::Load) {
+            throw std::logic_error("not a load response");
+        }
+        resp = {};
+        if (r.getSuccess()) {
+            readLoadResponse(resp, r.getResponse().getLoad(), mapper);
+        }
+    }
+    
+    static void
+    readVampRequest_Configure(Vamp::HostExt::ConfigurationRequest &req,
+                              const VampRequest::Reader &r,
+                              PluginHandleMapper &mapper) {
+        if (getRequestResponseType(r) != RRType::Configure) {
+            throw std::logic_error("not a configuration request");
+        }
+        readConfigurationRequest(req, r.getRequest().getConfigure(), mapper);
+    }
+
+    static void
+    readVampResponse_Configure(Vamp::HostExt::ConfigurationResponse &resp,
+                               const VampResponse::Reader &r) {
+        if (getRequestResponseType(r) != RRType::Configure) {
+            throw std::logic_error("not a configuration response");
+        }
+        resp = {};
+        if (r.getSuccess()) {
+            readConfigurationResponse(resp, r.getResponse().getConfigure());
+        }
+    }
+    
+    static void
+    readVampRequest_Process(Vamp::HostExt::ProcessRequest &req,
+                            const VampRequest::Reader &r,
+                            PluginHandleMapper &mapper) {
+        if (getRequestResponseType(r) != RRType::Process) {
+            throw std::logic_error("not a process request");
+        }
+        readProcessRequest(req, r.getRequest().getProcess(), mapper);
+    }
+
+    static void
+    readVampResponse_Process(Vamp::HostExt::ProcessResponse &resp,
+                             const VampResponse::Reader &r) {
+        if (getRequestResponseType(r) != RRType::Process) {
+            throw std::logic_error("not a process response");
+        }
+        resp = {};
+        if (r.getSuccess()) {
+            readProcessResponse(resp, r.getResponse().getProcess());
+        }
+    }
+    
+    static void
+    readVampRequest_Finish(Vamp::Plugin *&finishPlugin,
+                           const VampRequest::Reader &r,
+                           PluginHandleMapper &mapper) {
+        if (getRequestResponseType(r) != RRType::Finish) {
+            throw std::logic_error("not a finish request");
+        }
+        finishPlugin = mapper.handleToPlugin
+            (r.getRequest().getFinish().getPluginHandle());
+    }
+
+    static void
+    readVampResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
+                            const VampResponse::Reader &r) {
+        if (getRequestResponseType(r) != RRType::Finish) {
+            throw std::logic_error("not a finish response");
+        }
+        resp = {};
+        if (r.getSuccess()) {
+            readProcessResponse(resp, r.getResponse().getFinish());
+        }
+    }
 };
 
 }
--- a/utilities/vampipe-convert.cpp	Tue May 24 11:07:59 2016 +0100
+++ b/utilities/vampipe-convert.cpp	Tue May 24 12:00:38 2016 +0100
@@ -140,19 +140,29 @@
     }
     
     Json j = convertRequestJson(input);
+
     rr.type = VampJson::getRequestResponseType(j);
 
-    if (rr.type == RRType::Load) {
+    switch (rr.type) {
+
+    case RRType::List:
+	VampJson::toVampRequest_List(j); // type check only
+	break;
+    case RRType::Load:
 	rr.loadRequest = VampJson::toVampRequest_Load(j);
-
-    } else if (rr.type == RRType::Configure) {
-	rr.configurationRequest = VampJson::toVampRequest_Configure(j, rr.mapper);
-
-    } else if (rr.type == RRType::Process) {
+	break;
+    case RRType::Configure:
+	rr.configurationRequest =
+	    VampJson::toVampRequest_Configure(j, rr.mapper);
+	break;
+    case RRType::Process:
 	rr.processRequest = VampJson::toVampRequest_Process(j, rr.mapper);
-
-    } else if (rr.type == RRType::Finish) {
+	break;
+    case RRType::Finish:
 	rr.finishPlugin = VampJson::toVampRequest_Finish(j, rr.mapper);
+	break;
+    case RRType::NotValid:
+	break;
     }
 
     return rr;
@@ -163,20 +173,26 @@
 {
     Json j;
 
-    if (rr.type == RRType::List) {
+    switch (rr.type) {
+
+    case RRType::List:
 	j = VampJson::fromVampRequest_List();
-	
-    } else if (rr.type == RRType::Load) {
+	break;
+    case RRType::Load:
 	j = VampJson::fromVampRequest_Load(rr.loadRequest);
-	
-    } else if (rr.type == RRType::Configure) {
-	j = VampJson::fromVampRequest_Configure(rr.configurationRequest, rr.mapper);
-	
-    } else if (rr.type == RRType::Process) {
+	break;
+    case RRType::Configure:
+	j = VampJson::fromVampRequest_Configure(rr.configurationRequest,
+						rr.mapper);
+	break;
+    case RRType::Process:
 	j = VampJson::fromVampRequest_Process(rr.processRequest, rr.mapper);
-	
-    } else if (rr.type == RRType::Finish) {
+	break;
+    case RRType::Finish:
 	j = VampJson::fromVampRequest_Finish(rr.finishPlugin, rr.mapper);
+	break;
+    case RRType::NotValid:
+	break;
     }
 
     cout << j.dump() << endl;
@@ -195,22 +211,28 @@
     }
 
     Json j = convertResponseJson(input);
+
     rr.type = VampJson::getRequestResponseType(j);
 
-    if (rr.type == RRType::List) {
+    switch (rr.type) {
+
+    case RRType::List:
 	rr.listResponse = VampJson::toVampResponse_List(j);
-	
-    } else if (rr.type == RRType::Load) {
+	break;
+    case RRType::Load:
 	rr.loadResponse = VampJson::toVampResponse_Load(j, rr.mapper);
-
-    } else if (rr.type == RRType::Configure) {
+	break;
+    case RRType::Configure:
 	rr.configurationResponse = VampJson::toVampResponse_Configure(j);
-
-    } else if (rr.type == RRType::Process) {
+	break;
+    case RRType::Process: 
 	rr.processResponse = VampJson::toVampResponse_Process(j);
-
-    } else if (rr.type == RRType::Finish) {
+	break;
+    case RRType::Finish:
 	rr.finishResponse = VampJson::toVampResponse_Finish(j);
+	break;
+    case RRType::NotValid:
+	break;
     }
 
     return rr;
@@ -221,16 +243,102 @@
 {
     Json j;
 
-    if (rr.type == RRType::List) {
+    switch (rr.type) {
+
+    case RRType::List:
 	j = VampJson::fromVampResponse_List("", rr.listResponse);
-	
-    } else if (rr.type == RRType::Load) {
+	break;
+    case RRType::Load:
 	j = VampJson::fromVampResponse_Load(rr.loadResponse, rr.mapper);
+	break;
+    case RRType::Configure:
+	j = VampJson::fromVampResponse_Configure(rr.configurationResponse);
+	break;
+    case RRType::Process:
+	j = VampJson::fromVampResponse_Process(rr.processResponse);
+	break;
+    case RRType::Finish:
+	j = VampJson::fromVampResponse_Finish(rr.finishResponse);
+	break;
+    case RRType::NotValid:
+	break;
     }
 
-    //!!!
+    cout << j.dump() << endl;
+}
 
-    cout << j.dump() << endl;
+RequestOrResponse
+readRequestCapnp()
+{
+    RequestOrResponse rr;
+    rr.direction = RequestOrResponse::Request;
+
+    ::capnp::PackedFdMessageReader message(0); // stdin
+    VampRequest::Reader reader = message.getRoot<VampRequest>();
+    
+    rr.type = VampnProto::getRequestResponseType(reader);
+
+    switch (rr.type) {
+
+    case RRType::List:
+	VampnProto::readVampRequest_List(reader); // type check only
+	break;
+    case RRType::Load:
+	VampnProto::readVampRequest_Load(rr.loadRequest, reader);
+	break;
+    case RRType::Configure:
+	VampnProto::readVampRequest_Configure(rr.configurationRequest, reader,
+					      rr.mapper);
+	break;
+    case RRType::Process:
+	VampnProto::readVampRequest_Process(rr.processRequest, reader,
+					    rr.mapper);
+	break;
+    case RRType::Finish:
+	VampnProto::readVampRequest_Finish(rr.finishPlugin, reader,
+					   rr.mapper);
+	break;
+    case RRType::NotValid:
+	break;
+    }
+
+    return rr;
+}
+
+RequestOrResponse
+readResponseCapnp()
+{
+    RequestOrResponse rr;
+    rr.direction = RequestOrResponse::Response;
+
+    ::capnp::PackedFdMessageReader message(0); // stdin
+    VampResponse::Reader reader = message.getRoot<VampResponse>();
+    
+    rr.type = VampnProto::getRequestResponseType(reader);
+
+    switch (rr.type) {
+
+    case RRType::List:
+	VampnProto::readVampResponse_List(rr.listResponse, reader);
+	break;
+    case RRType::Load:
+	VampnProto::readVampResponse_Load(rr.loadResponse, reader, rr.mapper);
+	break;
+    case RRType::Configure:
+	VampnProto::readVampResponse_Configure(rr.configurationResponse,
+					       reader);
+	break;
+    case RRType::Process:
+	VampnProto::readVampResponse_Process(rr.processResponse, reader);
+	break;
+    case RRType::Finish:
+	VampnProto::readVampResponse_Finish(rr.finishResponse, reader);
+	break;
+    case RRType::NotValid:
+	break;
+    }
+
+    return rr;
 }
 
 RequestOrResponse
@@ -242,8 +350,14 @@
 	} else {
 	    return readResponseJson();
 	}
+    } else if (format == "capnp") {
+	if (direction == RequestOrResponse::Request) {
+	    return readRequestCapnp();
+	} else {
+	    return readResponseCapnp();
+	}
     } else {
-	throw runtime_error("unknown or unimplemented format \"" + format + "\"");
+	throw runtime_error("unknown input format \"" + format + "\"");
     }
 }
 
@@ -257,7 +371,7 @@
 	    writeResponseJson(rr);
 	}
     } else {
-	throw runtime_error("unknown or unimplemented format \"" + format + "\"");
+	throw runtime_error("unknown output format \"" + format + "\"");
     }
 }
 
@@ -268,7 +382,7 @@
     }
 
     string informat = "json", outformat = "json";
-    RequestOrResponse::Direction direction;
+    RequestOrResponse::Direction direction = RequestOrResponse::Request;
     bool haveDirection = false;
     
     for (int i = 1; i < argc; ++i) {
@@ -277,11 +391,11 @@
 	bool final = (i + 1 == argc);
 	
 	if (arg == "-i") {
-	    if (informat != "" || final) usage();
+	    if (final) usage();
 	    else informat = argv[++i];
 
 	} else if (arg == "-o") {
-	    if (outformat != "" || final) usage();
+	    if (final) usage();
 	    else outformat = argv[++i];
 
 	} else if (arg == "request") {