/[svn]/linuxsampler/trunk/src/linuxsampler.cpp
ViewVC logotype

Annotation of /linuxsampler/trunk/src/linuxsampler.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3354 - (hide annotations) (download)
Thu Oct 12 14:44:14 2017 UTC (6 years, 5 months ago) by schoenebeck
File size: 20193 byte(s)
* linuxsampler binary fix: option --create-instruments-db ignored
  subsequent optional argument due to glibc's implementation oddity
  which expects a "=" sign, but no space between them.
* Debian: Added build dependency to libsqlite3-dev for building
  linuxsampler with instruments DB support.
* Bumped version (2.0.0.svn76).

1 schoenebeck 9 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 persson 1644 * Copyright (C) 2003-2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 3072 * Copyright (C) 2005-2017 Christian Schoenebeck *
7 schoenebeck 9 * *
8     * This program is free software; you can redistribute it and/or modify *
9     * it under the terms of the GNU General Public License as published by *
10     * the Free Software Foundation; either version 2 of the License, or *
11     * (at your option) any later version. *
12     * *
13     * This program is distributed in the hope that it will be useful, *
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16     * GNU General Public License for more details. *
17     * *
18     * You should have received a copy of the GNU General Public License *
19     * along with this program; if not, write to the Free Software *
20     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21     * MA 02111-1307 USA *
22     ***************************************************************************/
23    
24     #include <getopt.h>
25     #include <signal.h>
26 persson 1908 #include <sys/stat.h>
27 schoenebeck 9
28 senoner 1502 #if defined(WIN32)
29     // require at least Windows 2000 for the GlobalMemoryStatusEx() call
30 persson 1895 #if _WIN32_WINNT < 0x0500
31     #ifdef _WIN32_WINNT
32     #undef _WIN32_WINNT
33     #endif
34 senoner 1502 #define _WIN32_WINNT 0x0500
35     #endif
36 persson 1895 #endif
37 senoner 1502
38 schoenebeck 53 #include "Sampler.h"
39 schoenebeck 1424 #include "common/global_private.h"
40 schoenebeck 420 #include "engines/EngineFactory.h"
41 schoenebeck 1375 #include "plugins/InstrumentEditorFactory.h"
42 schoenebeck 207 #include "drivers/midi/MidiInputDeviceFactory.h"
43 schoenebeck 203 #include "drivers/audio/AudioOutputDeviceFactory.h"
44 schoenebeck 2124 #include "effects/EffectFactory.h"
45 senkov 325 #include "engines/gig/Profiler.h"
46 schoenebeck 35 #include "network/lscpserver.h"
47 schoenebeck 271 #include "common/stacktrace.h"
48 schoenebeck 319 #include "common/Features.h"
49 persson 1534 #include "common/atomic.h"
50 schoenebeck 9
51 schoenebeck 53 using namespace LinuxSampler;
52    
53 schoenebeck 211 Sampler* pSampler = NULL;
54     LSCPServer* pLSCPServer = NULL;
55 senoner 1502 #if defined(WIN32)
56     // inet_aton seems missing under WIN32
57     #ifndef INADDR_NONE
58     #define INADDR_NONE 0xffffffff
59     #endif
60    
61 schoenebeck 3058 typedef unsigned long in_addr_t;
62    
63 senoner 1502 int inet_aton(const char *cp, struct in_addr *addr)
64     {
65     addr->s_addr = inet_addr(cp);
66     return (addr->s_addr == INADDR_NONE) ? 0 : 1;
67     }
68    
69     #else
70 wylder 816 pid_t main_pid;
71 senoner 1502 #endif
72 schoenebeck 420 bool bPrintStatistics = false;
73 senkov 325 bool profile = false;
74     bool tune = true;
75 schoenebeck 1830 static bool bShowStackTrace = false;
76 senkov 667 unsigned long int lscp_addr;
77     unsigned short int lscp_port;
78 iliev 2306 String ExecAfterInit;
79 schoenebeck 9
80     void parse_options(int argc, char **argv);
81     void signal_handler(int signal);
82 schoenebeck 271 void kill_app();
83 persson 1534 static atomic_t running = ATOMIC_INIT(1);
84 schoenebeck 9
85     int main(int argc, char **argv) {
86    
87 schoenebeck 1830 lscp_addr = htonl(LSCP_ADDR);
88     lscp_port = htons(LSCP_PORT);
89    
90     #if !defined(WIN32)
91     main_pid = getpid();
92     #endif
93    
94     // parse and assign command line options
95     parse_options(argc, argv);
96    
97     // setting signal handler for catching SIGINT (thus e.g. <CTRL><C>)
98     signal(SIGINT, signal_handler);
99    
100 schoenebeck 271 // initialize the stack trace mechanism with our binary file
101 schoenebeck 1830 // (if requested by command line option)
102     if (bShowStackTrace) {
103     #if defined(WIN32)
104     // FIXME: sigaction() not supported on WIN32, we ignore it for now
105 schoenebeck 3056 #elif AC_APPLE_UNIVERSAL_BUILD
106     // not used for Xcode
107 schoenebeck 1830 #else
108     StackTraceInit(argv[0], -1);
109     // register signal handler for all unusual signals
110     // (we will print the stack trace and exit)
111     struct sigaction sact;
112     sigemptyset(&sact.sa_mask);
113     sact.sa_flags = 0;
114     sact.sa_handler = signal_handler;
115     sigaction(SIGSEGV, &sact, NULL);
116     sigaction(SIGBUS, &sact, NULL);
117     sigaction(SIGILL, &sact, NULL);
118     sigaction(SIGFPE, &sact, NULL);
119     sigaction(SIGUSR1, &sact, NULL);
120     sigaction(SIGUSR2, &sact, NULL);
121     #endif
122     }
123 schoenebeck 271
124 schoenebeck 1830 dmsg(1,("LinuxSampler %s\n", VERSION));
125     dmsg(1,("Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck\n"));
126 schoenebeck 3072 dmsg(1,("Copyright (C) 2005-2017 Christian Schoenebeck\n"));
127 schoenebeck 2885 dmsg(1,("Binary built: " __DATE__ "\n"))
128 schoenebeck 1830
129 senoner 1502 #if defined(WIN32)
130 persson 1888 #if 0
131 senoner 1502 // some WIN32 memory info code which tries to determine the maximum lockable amount of memory (for debug purposes)
132     SYSTEM_INFO siSysInfo;
133     long physical_memory;
134     GetSystemInfo(&siSysInfo);
135 persson 1888 dmsg(2,("page size=%d\n", siSysInfo.dwPageSize));
136 senoner 1502
137     MEMORYSTATUSEX statex;
138     statex.dwLength = sizeof (statex);
139     GlobalMemoryStatusEx (&statex);
140 persson 1888 dmsg(2, ("There are %*I64d total Kbytes of physical memory.\n",
141 senoner 1502 8, statex.ullTotalPhys));
142 persson 1888 dmsg(2, ("There are %*I64d free Kbytes of physical memory.\n",
143 senoner 1502 8, statex.ullAvailPhys));
144     physical_memory = statex.ullTotalPhys;
145    
146     HANDLE hProcess = GetCurrentProcess();
147    
148     unsigned long MinimumWorkingSetSize, MaximumWorkingSetSize;
149     unsigned long DefaultMinimumWorkingSetSize, DefaultMaximumWorkingSetSize;
150     unsigned long RequestedMinimumWorkingSetSize, RequestedMaximumWorkingSetSize;
151     int res;
152    
153     res = GetProcessWorkingSetSize(hProcess, &DefaultMinimumWorkingSetSize, &DefaultMaximumWorkingSetSize);
154    
155     RequestedMaximumWorkingSetSize = physical_memory - 2*1024*1024;
156     RequestedMinimumWorkingSetSize = RequestedMaximumWorkingSetSize;
157    
158     for(;;) {
159     dmsg(2,("TRYING VALUES RequestedMinimumWorkingSetSize=%d, RequestedMaximumWorkingSetSize=%d\n", RequestedMinimumWorkingSetSize, RequestedMaximumWorkingSetSize));
160     res = SetProcessWorkingSetSize(hProcess, RequestedMinimumWorkingSetSize, RequestedMaximumWorkingSetSize);
161     dmsg(2,("AFTER SET: res = %d RequestedMinimumWorkingSetSize=%d, RequestedMaximumWorkingSetSize=%d\n", res,RequestedMinimumWorkingSetSize, RequestedMaximumWorkingSetSize));
162    
163     res = GetProcessWorkingSetSize(hProcess, &MinimumWorkingSetSize, &MaximumWorkingSetSize);
164     dmsg(2,("AFTER GET: res = %d MinimumWorkingSetSize=%d, MaximumWorkingSetSize=%d\n", res,MinimumWorkingSetSize, MaximumWorkingSetSize));
165    
166     if( RequestedMinimumWorkingSetSize == MinimumWorkingSetSize ) {
167     dmsg(2,("RequestedMinimumWorkingSetSize == MinimumWorkingSetSize. OK !\n"));
168     break;
169     }
170    
171     RequestedMinimumWorkingSetSize -= 10*1024*1024;
172     if(RequestedMinimumWorkingSetSize < DefaultMinimumWorkingSetSize) break;
173     }
174    
175 persson 1888 dmsg(2,("AFTER GetProcessWorkingSetSize: res = %d MinimumWorkingSetSize=%d, MaximumWorkingSetSize=%d\n", res,MinimumWorkingSetSize, MaximumWorkingSetSize));
176     #endif
177 schoenebeck 1830 #endif // WIN32
178 senoner 1502
179 schoenebeck 579 if (tune) {
180 persson 425 // detect and print system / CPU specific features
181     Features::detect();
182 schoenebeck 579 dmsg(1,("Detected features: %s\n", Features::featuresAsString().c_str()));
183     // prevent slow denormal FPU modes
184     Features::enableDenormalsAreZeroMode();
185 senkov 325 }
186 schoenebeck 319
187 schoenebeck 1830 dmsg(1,("Automatic Stacktrace: %s\n", (bShowStackTrace) ? "On" : "Off"));
188    
189 schoenebeck 53 // create LinuxSampler instance
190 schoenebeck 123 dmsg(1,("Creating Sampler..."));
191 schoenebeck 53 pSampler = new Sampler;
192 schoenebeck 123 dmsg(1,("OK\n"));
193 schoenebeck 53
194 schoenebeck 900 dmsg(1,("Registered sampler engines: %s\n", EngineFactory::AvailableEngineTypesAsString().c_str()));
195 schoenebeck 207 dmsg(1,("Registered MIDI input drivers: %s\n", MidiInputDeviceFactory::AvailableDriversAsString().c_str()));
196 schoenebeck 123 dmsg(1,("Registered audio output drivers: %s\n", AudioOutputDeviceFactory::AvailableDriversAsString().c_str()));
197 schoenebeck 1212 dmsg(1,("Registered instrument editors: %s\n", InstrumentEditorFactory::AvailableEditorsAsString().c_str()));
198 schoenebeck 2124 dmsg(1,("Registered internal effect systems: %s\n", EffectFactory::AvailableEffectSystemsAsString().c_str()));
199     dmsg(1,("Registered internal effects: %d\n", EffectFactory::AvailableEffectsCount()));
200 schoenebeck 123
201 schoenebeck 53 // start LSCP network server
202 senkov 667 struct in_addr addr;
203 schoenebeck 3056 addr.s_addr = (in_addr_t)lscp_addr;
204 senkov 667 dmsg(1,("Starting LSCP network server (%s:%d)...", inet_ntoa(addr), ntohs(lscp_port)));
205     pLSCPServer = new LSCPServer(pSampler, lscp_addr, lscp_port);
206 schoenebeck 53 pLSCPServer->StartThread();
207 schoenebeck 211 pLSCPServer->WaitUntilInitialized();
208 schoenebeck 12 dmsg(1,("OK\n"));
209 schoenebeck 9
210 senkov 325 if (profile)
211     {
212 persson 425 dmsg(1,("Calibrating profiler..."));
213 iliev 1161 LinuxSampler::gig::Profiler::Calibrate();
214     LinuxSampler::gig::Profiler::Reset();
215     LinuxSampler::gig::Profiler::enable();
216 persson 425 dmsg(1,("OK\n"));
217 senkov 325 }
218    
219 schoenebeck 563 printf("LinuxSampler initialization completed. :-)\n\n");
220 iliev 2306
221     if (ExecAfterInit != "") {
222     printf("Executing command: %s\n\n", ExecAfterInit.c_str());
223     if (system(ExecAfterInit.c_str()) == -1) {
224     std::cerr << "Failed to execute the command" << std::endl;
225     }
226     }
227 schoenebeck 9
228 schoenebeck 2473 //TODO: (hopefully) just a temporary nasty hack for launching gigedit on the main thread on Mac (see comments in gigedit.cpp for details)
229     #if defined(__APPLE__)
230     g_mainThreadCallbackSupported = true;
231     #endif
232    
233 persson 1534 while (atomic_read(&running)) {
234 schoenebeck 420 if (bPrintStatistics) {
235 persson 840 const std::set<Engine*>& engines = EngineFactory::EngineInstances();
236 schoenebeck 420 std::set<Engine*>::iterator itEngine = engines.begin();
237     for (int i = 0; itEngine != engines.end(); itEngine++, i++) {
238     Engine* pEngine = *itEngine;
239     printf("Engine %d) Voices: %3.3d (Max: %3.3d) Streams: %3.3d (Max: %3.3d)\n", i,
240     pEngine->VoiceCount(), pEngine->VoiceCountMax(),
241     pEngine->DiskStreamCount(), pEngine->DiskStreamCountMax()
242     );
243     fflush(stdout);
244     }
245     }
246 persson 425
247 persson 1534 sleep(1);
248     if (profile)
249     {
250     unsigned int samplingFreq = 48000; //FIXME: hardcoded for now
251     unsigned int bv = LinuxSampler::gig::Profiler::GetBogoVoices(samplingFreq);
252     if (bv != 0)
253     {
254     printf(" BogoVoices: %i \r", bv);
255     fflush(stdout);
256     }
257     }
258 persson 425
259 persson 1765 pSampler->fireStatistics();
260 schoenebeck 2473
261     //TODO: (hopefully) just a temporary nasty hack for launching gigedit on the main thread on Mac (see comments in gigedit.cpp for details)
262     #if defined(__APPLE__)
263     if (g_fireMainThreadCallback && g_mainThreadCallback) {
264     void (*fn)(void* info) = g_mainThreadCallback;
265     void* info = g_mainThreadCallbackInfo;
266     g_mainThreadCallbackInfo = NULL;
267     g_mainThreadCallback = NULL;
268     g_fireMainThreadCallback = false;
269     printf("Received main thread callback, calling now ...\n"); fflush(stdout);
270     (*fn)(info);
271     printf("Main thread callback executed.\n"); fflush(stdout);
272     }
273     #endif
274 senoner 10 }
275 schoenebeck 2473 //#endif
276 persson 1534 if (pLSCPServer) pLSCPServer->StopThread();
277     // the delete order here is important: the Sampler
278     // destructor sends notifications to the lscpserver
279     if (pSampler) delete pSampler;
280     if (pLSCPServer) delete pLSCPServer;
281     printf("LinuxSampler stopped due to SIGINT.\n");
282 schoenebeck 9 return EXIT_SUCCESS;
283     }
284    
285 schoenebeck 271 void signal_handler(int iSignal) {
286     switch (iSignal) {
287 persson 1534 case SIGINT:
288     atomic_set(&running, 0);
289 schoenebeck 271 return;
290 senoner 1502 #if defined(WIN32)
291     // FIXME: under WIN32 we ignore the signals below due to the missing sigaction call
292     #else
293 schoenebeck 271 case SIGSEGV:
294     std::cerr << ">>> FATAL ERROR: Segmentation fault (SIGSEGV) occured! <<<\n" << std::flush;
295     break;
296     case SIGBUS:
297     std::cerr << ">>> FATAL ERROR: Access to undefined portion of a memory object (SIGBUS) occured! <<<\n" << std::flush;
298     break;
299     case SIGILL:
300     std::cerr << ">>> FATAL ERROR: Illegal instruction (SIGILL) occured! <<<\n" << std::flush;
301     break;
302     case SIGFPE:
303     std::cerr << ">>> FATAL ERROR: Erroneous arithmetic operation (SIGFPE) occured! <<<\n" << std::flush;
304     break;
305     case SIGUSR1:
306     std::cerr << ">>> User defined signal 1 (SIGUSR1) received <<<\n" << std::flush;
307     break;
308     case SIGUSR2:
309     std::cerr << ">>> User defined signal 2 (SIGUSR2) received <<<\n" << std::flush;
310     break;
311 senoner 1502 #endif
312 schoenebeck 271 default: { // this should never happen, as we register for the signals we want
313     std::cerr << ">>> FATAL ERROR: Unknown signal received! <<<\n" << std::flush;
314     break;
315     }
316 schoenebeck 9 }
317 schoenebeck 271 signal(iSignal, SIG_DFL); // Reinstall default handler to prevent race conditions
318 schoenebeck 1830 if (bShowStackTrace) {
319     std::cerr << "Showing stack trace...\n" << std::flush;
320 schoenebeck 3056 #if !AC_APPLE_UNIVERSAL_BUILD
321 schoenebeck 1830 StackTrace();
322 schoenebeck 3056 #endif
323 schoenebeck 1830 sleep(2);
324     }
325 schoenebeck 271 std::cerr << "Killing LinuxSampler...\n" << std::flush;
326     kill_app(); // Use abort() if we want to generate a core dump.
327 schoenebeck 9 }
328    
329 schoenebeck 271 void kill_app() {
330 senoner 1502 #if defined(WIN32)
331     // FIXME: do we need to do anything at this point under WIN32 ? is exit(0) ok ?
332     exit(0);
333     #else
334 wylder 816 kill(main_pid, SIGKILL);
335 senoner 1502 #endif
336 schoenebeck 271 }
337    
338 senkov 325 void parse_options(int argc, char **argv) {
339 schoenebeck 9 int res;
340     int option_index = 0;
341     static struct option long_options[] =
342     {
343 schoenebeck 3091 {"help",no_argument,0,0},
344     {"version",no_argument,0,0},
345     {"profile",no_argument,0,0},
346     {"no-tune",no_argument,0,0},
347     {"statistics",no_argument,0,0},
348     {"instruments-db-location",required_argument,0,0},
349     {"create-instruments-db",optional_argument,0,0},
350     {"lscp-addr",required_argument,0,0},
351     {"lscp-port",required_argument,0,0},
352     {"stacktrace",no_argument,0,0},
353     {"exec-after-init",required_argument,0,0},
354 schoenebeck 9 {0,0,0,0}
355     };
356    
357     while (true) {
358 schoenebeck 361 /*
359     Stephane Letz : letz@grame.fr
360     getopt_long_only does not exist on OSX : replaced by getopt_long for now.
361     */
362     res = getopt_long(argc, argv, "", long_options, &option_index);
363 schoenebeck 9 if(res == -1) break;
364     if (res == 0) {
365     switch(option_index) {
366 senkov 325 case 0: // --help
367     printf("usage: linuxsampler [OPTIONS]\n\n");
368 iliev 1208 printf("--help prints this message\n");
369     printf("--version prints version information\n");
370     printf("--profile profile synthesis algorithms\n");
371     printf("--no-tune disable assembly optimization\n");
372     printf("--statistics periodically prints statistics\n");
373     printf("--lscp-addr set LSCP address (default: any)\n");
374     printf("--lscp-port set LSCP port (default: 8888)\n");
375     printf("--create-instruments-db creates an instruments DB\n");
376     printf("--instruments-db-location specifies the instruments DB file\n");
377 schoenebeck 1830 printf("--stacktrace automatically shows stacktrace if crashes\n");
378     printf(" (broken on most systems at the moment)\n");
379 iliev 2306 printf("--exec-after-init executes a command after initialization\n");
380 senkov 325 exit(EXIT_SUCCESS);
381 schoenebeck 9 break;
382 senkov 325 case 1: // --version
383 schoenebeck 328 printf("LinuxSampler %s\n", VERSION);
384     exit(EXIT_SUCCESS);
385 schoenebeck 9 break;
386 senkov 325 case 2: // --profile
387 persson 425 profile = true;
388 schoenebeck 2047 //FIXME: profiling code is currently broken!
389     std::cerr << "Option '--profile' is currently not supported, since the profiling code is currently broken!" << std::endl;
390     exit(EXIT_FAILURE);
391 schoenebeck 20 break;
392 senkov 325 case 3: // --no-tune
393 persson 425 tune = false;
394 schoenebeck 9 break;
395 schoenebeck 420 case 4: // --statistics
396     bPrintStatistics = true;
397     break;
398 iliev 1208 case 5: // --instruments-db-location
399 iliev 1187 #if HAVE_SQLITE3
400     try {
401     if (optarg) {
402 iliev 1208 struct stat statBuf;
403     int res = stat(optarg, &statBuf);
404    
405     if (res) {
406     std::stringstream ss;
407 schoenebeck 1364 ss << "Failed to stat `" << optarg << "`: " << strerror(errno);
408 iliev 1208 throw Exception(ss.str());
409     }
410    
411     if (!S_ISREG(statBuf.st_mode)) {
412     std::stringstream ss;
413     ss << "`" << optarg << "` is not a regular file";
414     throw Exception(ss.str());
415     }
416    
417     InstrumentsDb::GetInstrumentsDb()->SetDbFile(String(optarg));
418     }
419     } catch(Exception e) {
420 schoenebeck 1364 std::cerr << "Could not open instruments DB file: "
421     << e.Message() << std::endl;
422     exit(EXIT_FAILURE);
423 iliev 1208 }
424 schoenebeck 1364 break;
425 iliev 1208 #else
426     std::cerr << "LinuxSampler was not build with ";
427 schoenebeck 1364 std::cerr << "instruments database support!\n";
428     exit(EXIT_FAILURE);
429     break;
430     #endif
431 iliev 1208 case 6: // --create-instruments-db
432     #if HAVE_SQLITE3
433     try {
434 schoenebeck 3091 std::cout << "Creating instruments database..." << std::endl;
435 schoenebeck 3354 if (optarg) // with glibc this only fires with form --create-instruments-db=bla (see below)
436 schoenebeck 3091 InstrumentsDb::GetInstrumentsDb()->CreateInstrumentsDb(String(optarg));
437 schoenebeck 3354 else if (argv[optind] && argv[optind][0] != '-') // workaround: glibc actually expects form --foo=value for all optional arguments ...
438     InstrumentsDb::GetInstrumentsDb()->CreateInstrumentsDb(String(argv[optind++]));
439 schoenebeck 3091 else
440     InstrumentsDb::GetInstrumentsDb()->CreateInstrumentsDb(); // use default instruments db location
441     std::cout << "Done" << std::endl;
442 iliev 1187 } catch(Exception e) {
443     std::cerr << e.Message() << std::endl;
444     exit(EXIT_FAILURE);
445     return;
446     }
447    
448     exit(EXIT_SUCCESS);
449     return;
450     #else
451     std::cerr << "Failed to create the database. LinuxSampler was ";
452 schoenebeck 1364 std::cerr << "not build with instruments database support!\n";
453 iliev 1187 exit(EXIT_FAILURE);
454     return;
455 schoenebeck 1364 #endif
456 schoenebeck 1830 case 7: { // --lscp-addr
457 iliev 1187 struct in_addr addr;
458     if (inet_aton(optarg, &addr) == 0)
459     printf("WARNING: Failed to parse lscp-addr argument, ignoring!\n");
460     else
461     lscp_addr = addr.s_addr;
462 senkov 667 break;
463 schoenebeck 1830 }
464     case 8: {// --lscp-port
465 iliev 1187 long unsigned int port = 0;
466 persson 2837 if ((sscanf(optarg, "%lu", &port) != 1) || (port == 0) || (port > 65535))
467 iliev 1187 printf("WARNING: Failed to parse lscp-port argument, ignoring!\n");
468     else
469     lscp_port = htons(port);
470 senkov 667 break;
471 schoenebeck 1830 }
472     case 9: // --stacktrace
473     bShowStackTrace = true;
474     break;
475 iliev 2306 case 10: // --exec-after-init
476     ExecAfterInit = optarg;
477     break;
478 schoenebeck 9 }
479     }
480     }
481 senkov 325 }

  ViewVC Help
Powered by ViewVC