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

Contents of /linuxsampler/trunk/src/linuxsampler.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3844 - (show annotations) (download)
Sun Jan 3 18:05:57 2021 UTC (2 months ago) by schoenebeck
File size: 20234 byte(s)
Bump year for 2021

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

  ViewVC Help
Powered by ViewVC