summaryrefslogtreecommitdiff
path: root/drumgizmo/drumgizmoc.cc
diff options
context:
space:
mode:
Diffstat (limited to 'drumgizmo/drumgizmoc.cc')
-rw-r--r--drumgizmo/drumgizmoc.cc627
1 files changed, 279 insertions, 348 deletions
diff --git a/drumgizmo/drumgizmoc.cc b/drumgizmo/drumgizmoc.cc
index 6244125..6bb4d1a 100644
--- a/drumgizmo/drumgizmoc.cc
+++ b/drumgizmo/drumgizmoc.cc
@@ -27,11 +27,9 @@
#include <iostream>
#include <config.h>
-#include <getopt.h>
+#include <getoptpp.hpp>
#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
#include <sstream>
#include <chrono>
#include <thread>
@@ -46,398 +44,338 @@
#include "event.h"
-static const char version_str[] = "DrumGizmo v" VERSION "\n";
-
-static const char copyright_str[] =
- "Copyright (C) 2008-2011 Bent Bisballe Nyeng - Aasimon.org.\n"
- "This is free software. You may redistribute copies of it under the terms "
- "of\n"
- "the GNU Lesser General Public License <http://www.gnu.org/licenses/gpl.html>.\n"
- "There is NO WARRANTY, to the extent permitted by law.\n"
- "\n"
- "Written by Bent Bisballe Nyeng (deva@aasimon.org)\n";
-
-static const char usage_str[] =
- "Usage: %s [options] drumkitfile\n"
- "Options:\n"
- " -a, --async-load Load drumkit in the background and start the "
- "engine immediately.\n"
- " -i, --inputengine dummy|test|jackmidi|midifile Use said event "
- "input engine.\n"
- " -I, --inputparms parmlist Set input engine parameters.\n"
- " -o, --outputengine dummy|alsa|jackaudio|wavfile Use said audio "
- "output engine.\n"
- " -O, --outputparms parmlist Set output engine parameters.\n"
- " -e, --endpos Number of samples to process, -1: infinite.\n"
-#ifndef DISABLE_HUGIN
- " -D, --debug ddd Enable debug messages on 'ddd'; see hugin "
- "documentation for details\n"
-#endif /*DISABLE_HUGIN*/
- " -r, --no-resampling Disable resampling.\n"
- " -s, --streaming Enable streaming.\n"
- " -S, --streamingparms Streaming options.\n"
- " -v, --version Print version information and exit.\n"
- " -h, --help Print this message and exit.\n"
- "\n"
- "Input engine parameters:\n"
- " jackmidi: midimap=<midimapfile>\n"
- " midifile: file=<midifile>, speed=<tempo> (default 1.0),\n"
- " track=<miditrack> (default -1, all tracks)\n"
- " midimap=<midimapfile>, loop=<true|false>\n"
- " test: p=<hit_propability> (default 0.1)\n"
- " instr=<instrument> (default -1, random instrument)\n"
- " len=<seconds> (default -1, forever)\n"
- " dummy:\n"
- "\n"
- "Output engine parameters:\n"
- " alsa: dev=<device> (default 'default'), frames=<frames> (default "
- "32)\n"
- " srate=<samplerate> (default 441000)\n"
- " oss: dev=<device> (default '/dev/dsp'), srate=<samplerate>,\n"
- " max_fragments=<number> (default 4, see man page for more info),\n"
- " fragment_size=<selector> (default 8, see man page for more info)\n"
- " wavfile: file=<filename> (default 'output'), srate=<samplerate> "
- "(default 44100)\n"
- " jackaudio:\n"
- " dummy:\n"
- "\n"
- "Streaming parameters:\n"
- " limit: Limit the amount of preloaded drumkit data to the size\n"
- // " chunk_size: chunk size in k,M,G\n"
- "\n";
-
-int main(int argc, char* argv[])
+typedef struct parm_token
{
- int c;
- Settings settings;
- settings.disk_cache_enable = false;
- std::string hugin_filter;
- unsigned int hugin_flags = 0;
-#ifndef DISABLE_HUGIN
- hugin_flags = HUG_FLAG_DEFAULT;
-#endif /*DISABLE_HUGIN*/
+ std::string key;
+ std::string value;
+} parm_token_t;
- std::string outputengine;
- std::string inputengine;
- std::string iparms;
- std::string oparms;
- std::string sparms;
- bool async = false;
- int endpos = -1;
- EngineFactory factory;
+static std::string version()
+{
+ std::ostringstream output;
+ output << "DrumGizmo v" << VERSION << std::endl;
+ return output.str();
+}
- int option_index = 0;
- static struct option long_options[] = {
- {"async-load", no_argument, 0, 'a'},
- {"inputengine", required_argument, 0, 'i'},
- {"inputparms", required_argument, 0, 'I'},
- {"outputengine", required_argument, 0, 'o'},
- {"outputparms", required_argument, 0, 'O'},
- {"endpos", required_argument, 0, 'e'},
-#ifndef DISABLE_HUGIN
- {"debug", required_argument, 0, 'D'},
-#endif /*DISABLE_HUGIN*/
- {"streaming", no_argument, 0, 's'},
- {"streamingparams", required_argument, 0, 'S'},
- {"version", no_argument, 0, 'v'},
- {"help", no_argument, 0, 'h'},
- {"no-resample", no_argument, 0, 'r'},
- {0, 0, 0, 0}
- };
- while(1)
- {
- c = getopt_long(argc, argv, "hvpo:O:i:I:e:arsS:"
-#ifndef DISABLE_HUGIN
- "D:"
-#endif /*DISABLE_HUGIN*/
- , long_options, &option_index);
- if(c == -1)
- {
- break;
- }
+static std::string copyright()
+{
+ std::ostringstream output;
+ output << "Copyright (C) 2008-2011 Bent Bisballe Nyeng - Aasimon.org.\n";
+ output << "This is free software. You may redistribute copies of it under the terms ";
+ output << "of\n";
+ output << "the GNU Lesser General Public License <http://www.gnu.org/licenses/gpl.html>.\n";
+ output << "There is NO WARRANTY, to the extent permitted by law.\n";
+ output << "\n";
+ output << "Written by Bent Bisballe Nyeng (deva@aasimon.org)\n";
+ return output.str();
+}
- switch(c)
- {
- case 'i':
- inputengine = optarg;
- if(inputengine == "help")
- {
- std::cout << "Available Input Engines = { ";
- for(auto const& name : factory.getInputEngines())
- {
- std::cout << name << " ";
- }
- std::cout << "}\n";
- return 0;
- }
- break;
+static std::string usage(std::string name)
+{
+ std::ostringstream output;
+ output << "Usage: " << name << " [options] drumkitfile\n";
+ output << "Options:\n";
+ output << " -a, --async-load Load drumkit in the background and start the ";
+ output << "engine immediately.\n";
+ output << " -i, --inputengine dummy|test|jackmidi|midifile Use said event ";
+ output << "input engine.\n";
+ output << " -I, --inputparms parmlist Set input engine parameters.\n";
+ output << " -o, --outputengine dummy|alsa|jackaudio|wavfile Use said audio ";
+ output << "output engine.\n";
+ output << " -O, --outputparms parmlist Set output engine parameters.\n";
+ output << " -e, --endpos Number of samples to process, -1: infinite.\n";
#ifndef DISABLE_HUGIN
- case 'D':
- hugin_flags |= HUG_FLAG_USE_FILTER;
- hugin_filter = optarg;
- break;
+ output << " -D, --debug ddd Enable debug messages on 'ddd'; see hugin ";
+ output << "documentation for details\n";
#endif /*DISABLE_HUGIN*/
+ output << " -r, --no-resampling Disable resampling.\n";
+ output << " -s, --streaming Enable streaming.\n";
+ output << " -S, --streamingparms Streaming options.\n";
+ output << " -v, --version Print version information and exit.\n";
+ output << " -h, --help Print this message and exit.\n";
+ output << "\n";
+ output << "Input engine parameters:\n";
+ output << " jackmidi: midimap=<midimapfile>\n";
+ output << " midifile: file=<midifile>, speed=<tempo> (default 1.0),\n";
+ output << " track=<miditrack> (default -1, all tracks)\n";
+ output << " midimap=<midimapfile>, loop=<true|false>\n";
+ output << " test: p=<hit_propability> (default 0.1)\n";
+ output << " instr=<instrument> (default -1, random instrument)\n";
+ output << " len=<seconds> (default -1, forever)\n";
+ output << " dummy:\n";
+ output << "\n";
+ output << "Output engine parameters:\n";
+ output << " alsa: dev=<device> (default 'default'), frames=<frames> (default ";
+ output << "32)\n";
+ output << " srate=<samplerate> (default 441000)\n";
+ output << " oss: dev=<device> (default '/dev/dsp'), srate=<samplerate>,\n";
+ output << " max_fragments=<number> (default 4, see man page for more info),\n";
+ output << " fragment_size=<selector> (default 8, see man page for more info)\n";
+ output << " wavfile: file=<filename> (default 'output'), srate=<samplerate> ";
+ output << "(default 44100)\n";
+ output << " jackaudio:\n";
+ output << " dummy:\n";
+ output << "\n";
+ output << "Streaming parameters:\n";
+ output << " limit: Limit the amount of preloaded drumkit data to the size\n";
+ // output << " chunk_size: chunk size in k,M,G\n"
+ output << "\n";
+ return output.str();
+}
- case 'I':
- iparms = optarg;
- break;
- case 'o':
- outputengine = optarg;
- if(outputengine == "help")
+std::vector<parm_token_t> parse_parameters(std::string &parms)
+{
+ std::vector<parm_token_t> result;
+ std::string parm;
+ std::string val;
+ bool inval = false;
+ wordexp_t exp_result;
+ for(size_t i = 0; i < parms.size(); ++i)
+ {
+ if(parms[i] == ',')
+ {
+ int error = wordexp(val.data(), &exp_result, 0);
+ if(error)
{
- std::cout << "Available Output Engines = { ";
- for(auto const& name : factory.getOutputEngines())
- {
- std::cout << name << " ";
- }
- std::cout << "}\n";
- return 0;
+ std::cerr << "Wrong argument: ";
+ std::cerr << parm << " = " << val << std::endl;
+ exit(1);
}
- break;
-
- case 'O':
- oparms = optarg;
- break;
-
- case 'a':
- async = true;
- break;
-
- case 'e':
- endpos = atoi(optarg);
- break;
-
- case '?':
- case 'h':
- printf("%s", version_str);
- printf(usage_str, argv[0]);
- return 0;
-
- case 'v':
- printf("%s", version_str);
- printf("%s", copyright_str);
- return 0;
-
- case 'r':
- settings.enable_resampling = false;
- break;
-
- case 's':
- settings.disk_cache_enable = true;
- break;
+ result.push_back({parm, exp_result.we_wordv[0]});
+ parm = "";
+ val = "";
+ inval = false;
+ continue;
+ }
- case 'S':
- sparms = optarg;
- break;
+ if(parms[i] == '=')
+ {
+ inval = true;
+ continue;
+ }
- default:
- break;
+ if(inval)
+ {
+ val += parms[i];
+ }
+ else
+ {
+ parm += parms[i];
}
}
-
- hug_status_t status = hug_init(hugin_flags, HUG_OPTION_FILTER,
- hugin_filter.c_str(), HUG_OPTION_END);
- if(status != HUG_STATUS_OK)
+ if(parm != "")
{
- printf("Error: %d\n", status);
- return 1;
+ int error = wordexp(val.data(), &exp_result, 0);
+ if(error)
+ {
+ std::cerr << "Wrong argument: ";
+ std::cerr << parm << " = " << val << std::endl;
+ exit(1);
+ }
+ result.push_back({parm, exp_result.we_wordv[0]});
}
+ return result;
+}
- DEBUG(drumgizmo, "Debug enabled.");
-
- if(inputengine == "")
- {
- printf("Missing input engine\n");
- return 1;
- }
- auto ie = factory.createInput(inputengine);
+int main(int argc, char* argv[])
+{
+ EngineFactory factory;
+ Settings settings;
+ bool async = false;
+ dg::Options opt;
+ int endpos = -1;
+ std::string kitfile;
+ std::unique_ptr<AudioInputEngine> ie;
+ std::unique_ptr<AudioOutputEngine> oe;
+ std::string hugin_filter;
+ unsigned int hugin_flags = 0;
+#ifndef DISABLE_HUGIN
+ hugin_flags = HUG_FLAG_DEFAULT;
+#endif /*DISABLE_HUGIN*/
- if(ie == NULL)
- {
- printf("Invalid input engine: %s\n", inputengine.c_str());
- return 1;
- }
+ opt.add("async-load", no_argument, 'a', [&]() {
+ async = true;
+ });
- {
- std::string parm;
- std::string val;
- bool inval = false;
- wordexp_t exp_result;
- for(size_t i = 0; i < iparms.size(); ++i)
+ opt.add("inputengine", required_argument, 'i', [&]() {
+ std::string engine = optarg;
+ if(engine == "help")
{
- if(iparms[i] == ',')
+ std::cout << "Available Input Engines = { ";
+ for(auto const& name : factory.getInputEngines())
{
- int error = wordexp(val.data(), &exp_result, 0);
- if(error)
- {
- std::cerr << "Wrong argument: ";
- std::cerr << parm << " = " << val << std::endl;
- return 1;
- }
- ie->setParm(parm, exp_result.we_wordv[0]);
- parm = "";
- val = "";
- inval = false;
- continue;
+ std::cout << name << " ";
}
+ std::cout << "}\n";
+ exit(0);
+ }
+ if(engine == "")
+ {
+ std::cerr << "Missing input engine" << std::endl;;
+ exit(1);
+ }
+ ie = factory.createInput(engine);
+ if(ie == NULL)
+ {
+ std::cerr << "Invalid input engine: " << engine << std::endl;
+ exit(1);
+ }
+ });
- if(iparms[i] == '=')
- {
- inval = true;
- continue;
- }
+ opt.add("inputparms", required_argument, 'I', [&]() {
+ std::string parms = optarg;
+ auto tokens = parse_parameters(parms);
+ for(auto &token : tokens)
+ {
+ ie->setParm(token.key, token.value);
+ }
+ });
- if(inval)
- {
- val += iparms[i];
- }
- else
+ opt.add("outputengine", required_argument, 'o', [&]() {
+ std::string engine = optarg;
+ if(engine == "help")
+ {
+ std::cout << "Available Output Engines = { ";
+ for(auto const& name : factory.getOutputEngines())
{
- parm += iparms[i];
+ std::cout << name << " ";
}
+ std::cout << " }\n";
+ exit(0);
}
- if(parm != "")
+ if(engine == "")
{
- int error = wordexp(val.data(), &exp_result, 0);
- if(error)
- {
- std::cerr << "Wrong argument: ";
- std::cerr << parm << " = " << val << std::endl;
- return 1;
- }
- ie->setParm(parm, exp_result.we_wordv[0]);
+ std::cerr << "Missing output engine" << std::endl;
+ exit(1);
}
- }
+ oe = factory.createOutput(engine);
+ if(ie == NULL)
+ {
+ std::cerr << "Invalid output engine: " << engine << std::endl;;
+ exit(1);
+ }
+ });
- {
- if(sparms.size() != 0)
+ opt.add("outputparms", required_argument, 'O', [&]() {
+ std::string parms = optarg;
+ auto tokens = parse_parameters(parms);
+ for(auto &token : tokens)
{
- if(sparms[0] == ',' || sparms[sparms.size()-1] == ',')
+ oe->setParm(token.key, token.value);
+ }
+ });
+
+ opt.add("endpos", required_argument, 'e', [&]() {
+ try
{
- std::cerr << "Invalid streamparms" << std::endl;
- return 1;
+ endpos = std::stoi(optarg);
}
- std::string token;
- std::istringstream tokenstream(sparms);
- while(getline(tokenstream, token, ','))
+ catch(...)
{
- std::size_t index = token.find('=');
- if(index == std::string::npos || index == token.size()-1 || index == 0)
- {
- std::cerr << "Invalid streamparms" << std::endl;
- return 1;
- }
+ std::cerr << "Invalid endpos size " << optarg << std::endl;
+ }
+ });
- std::string parm = token.substr(0, index);
- std::string value = token.substr(index+1);
+#ifndef DISABLE_HUGIN
+ opt.add("debug", required_argument, 'D', [&]() {
+ hugin_flags |= HUG_FLAG_USE_FILTER;
+ hugin_filter = optarg;
+ });
+#endif /*DISABLE_HUGIN*/
- if(parm == "limit")
- {
- settings.disk_cache_upper_limit = byteSizeParser(value);
- if(settings.disk_cache_upper_limit == 0)
- {
- std::cerr << "Invalid argument for streamparms limit: " << value << std::endl;
- return 1;
- }
- }
- // else if(parm == "chunk_size")
- // {
- // settings.disk_cache_chunk_size = byteSizeParser(value);
- // if(settings.disk_cache_chunk_size == 0)
- // {
- // std::cerr << "Invalid argument for streamparms chunk_size: " << value << std::endl;
- // return 1;
- // }
- // }
- else
+ opt.add("no-resampling", no_argument, 'r', [&]() {
+ settings.enable_resampling = false;
+ });
+
+ opt.add("streaming", no_argument, 's', [&]() {
+ settings.disk_cache_enable = true;
+ });
+
+ opt.add("streamingparms", required_argument, 'S', [&]() {
+ std::string parms = optarg;
+ auto tokens = parse_parameters(parms);
+ for(auto &token : tokens)
+ {
+ if(token.key == "limit")
+ {
+ settings.disk_cache_upper_limit = byteSizeParser(token.value);
+ if(settings.disk_cache_upper_limit == 0)
{
- std::cerr << "Unknown streamingparms argument " << parm << std::endl;
- return 1;
+ std::cerr << "Invalid argument for streamparms limit: " << token.value << std::endl;
+ exit(1);
}
}
+ // else if(token.key == "chunk_size")
+ // {
+ // settings.disk_cache_chunk_size = byteSizeParser(token.value);
+ // if(settings.disk_cache_chunk_size == 0)
+ // {
+ // std::cerr << "Invalid argument for streamparms chunk_size: " << token.value << std::endl;
+ // exit(1);
+ // }
+ // }
+ else
+ {
+ std::cerr << "Unknown streamingparms argument " << token.key << std::endl;
+ exit(1);
+ }
}
- }
+ });
+
+ opt.add("version", no_argument, 'v', [&]() {
+ std::cout << version();
+ std::cout << copyright();
+ exit(0);
+ });
- if(outputengine == "")
+ opt.add("help", no_argument, 'h', [&]() {
+ std::cout << version();
+ std::cout << usage(argv[0]);
+ exit(0);
+ });
+
+ if(!opt.process(argc, argv))
{
- printf("Missing output engine\n");
return 1;
}
-
- auto oe = factory.createOutput(outputengine);
-
- if(oe == NULL)
+ hug_status_t status = hug_init(hugin_flags, HUG_OPTION_FILTER,
+ hugin_filter.data(), HUG_OPTION_END);
+ if(status != HUG_STATUS_OK)
{
- printf("Invalid output engine: %s\n", outputengine.c_str());
+ std::cerr << "Error: " << status << std::endl;
return 1;
}
+ DEBUG(drumgizmo, "Debug enabled.");
+ if(opt.arguments().empty())
{
- std::string parm;
- std::string val;
- bool inval = false;
- for(size_t i = 0; i < oparms.size(); ++i)
- {
- if(oparms[i] == ',')
- {
- oe->setParm(parm, val);
- parm = "";
- val = "";
- inval = false;
- continue;
- }
-
- if(oparms[i] == '=')
- {
- inval = true;
- continue;
- }
-
- if(inval)
- {
- val += oparms[i];
- }
- else
- {
- parm += oparms[i];
- }
- }
- if(parm != "")
- {
- oe->setParm(parm, val);
- }
+ std::cerr << "Missing kitfile." << std::endl;
+ std::cerr << usage(argv[0]) << std::endl;
+ return 1;
}
-
- std::string kitfile;
-
- if(option_index < argc)
+ else if(opt.arguments().size() > 1)
{
- while(optind < argc)
- {
- if(kitfile != "")
- {
- printf("Can only handle a single kitfile.\n");
- printf(usage_str, argv[0]);
- return 1;
- }
- kitfile = argv[optind++];
- }
- printf("\n");
+ std::cerr << "Can only handle a single kitfile." << std::endl;
+ std::cerr << usage(argv[0]) << std::endl;
+ return 1;
}
else
{
- printf("Missing kitfile.\n");
- printf(usage_str, argv[0]);
- return 1;
+ kitfile = opt.arguments()[0];
+ std::ifstream tmp_kit(kitfile);
+ if(!tmp_kit.good())
+ {
+ std::cerr << "Can not open " << kitfile << std::endl;
+ return 1;
+ }
}
-
- printf("Using kitfile: %s\n", kitfile.c_str());
+ std::cout << "Using kitfile: " << kitfile << std::endl;
DrumGizmo gizmo(settings, *oe.get(), *ie.get());
@@ -446,7 +384,7 @@ int main(int argc, char* argv[])
settings.drumkit_file.store(kitfile);
settings.reload_counter++;
- printf("Loading drumkit, this may take a while:\n");
+ std::cout << "Loading drumkit, this may take a while:" << std::endl;
if(!async)
{
@@ -457,12 +395,11 @@ int main(int argc, char* argv[])
int total = settings.number_of_files.load();
int loaded = settings.number_of_files_loaded.load();
- printf("\r%d of %d ", loaded, total);
- fflush(stdout);
+ std::cout << "\r" << loaded << " of " << total << std::flush;
if(settings.drumkit_load_status.load() == LoadStatus::Error)
{
- printf("\nFailed to load \"%s\".\n", kitfile.c_str());
+ std::cout << "\nFailed to load " << kitfile << std::endl;
return 1;
}
@@ -471,7 +408,7 @@ int main(int argc, char* argv[])
//break;
}
}
- printf("\ndone\n");
+ std::cout << "\ndone" << std::endl;
}
gizmo.setSamplerate(oe->getSamplerate());
@@ -479,11 +416,10 @@ int main(int argc, char* argv[])
if(!gizmo.init())
{
- printf("Failed init engine.\n");
+ std::cout << "Failed init engine." << std::endl;
return 1;
}
- // former drumgizmo run call
size_t pos = 0;
size_t nsamples = oe->getBufferSize();
sample_t *samples = (sample_t *)malloc(nsamples * sizeof(sample_t));
@@ -504,13 +440,8 @@ int main(int argc, char* argv[])
ie->stop();
oe->stop();
-
free(samples);
- // end former drumgizmo run call
-
- printf("Quit.\n");
- fflush(stdout);
-
+ std::cout << "Quit." << std::endl;
hug_close();
return 0;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 18:20:59 +0000