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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2306 - (show annotations) (download)
Tue Jan 24 13:00:40 2012 UTC (12 years, 2 months ago) by iliev
File size: 18429 byte(s)
* added command line option --exec-after-init

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

  ViewVC Help
Powered by ViewVC